Search

A Graphical User Interface can capture the essence of an idea or a situation, often avoiding the need for a long passage of text. Such interfaces can save a user from the need to learn complex commands. They are less likely to intimidate computer users and can provide a large amount of information quickly in a form which can be easily assimilated by the user. This chapter we will first introduce what we mean by a GUI and by WIMP based UIs in particular. We will then consider the range of libraries available for Python before selecting wxPython.

The graphical user interface becomes an important element in simulation systems. The problem in this type of systems is that there is plenty of information in the environment that is not provided in the best way to the user. This information can be provided through mechanisms of awareness. However, how to incorporate these mechanisms to the graphical interface of a traffic system is not easy. This paper proposes a method that allows graphical interfaces designers to incorporate awareness mechanisms in driving simulation environments. This method allows engineers to design usable interfaces that simulate reality more adequately.

Interaction with the machines and computers is achieved using user interfaces. Nowadays, with the tremendous growth of technology, the interaction is made more simple and flexible. The study of user interfaces for human-computers and machines interaction is the main focus of this paper. In particular, an extensive overview of different user interfaces available so far is provided. The review covers text-based, graphical-based, and new class of emerging user interfaces to interact with the machines and computers. This work will be helpful for the development of new user interfaces.

User experiments are an essential tool to evaluate the user experience of intelligent user interfaces. This tutorial teaches the practical aspects of designing and setting up user experiments, as well as state-of-the-art methods to statistically evaluate the outcomes of such experiments.

This paper presents a user interface study for highly distributed system. The user interface is developed to control a multi-robot system, which is based on “component-based„ architecture using hardware abstraction. This paper present the general principles of the user interface and provides an example of Graphical User Interface for controlling a generic fleet of machines.

It is essential for developing a useful system to evaluate its user interface. The interface should be evaluated by potential users instead of experts, if unbiased results are to be obtained. It is more recommendable to observe users’ reactions to an actual working prototype of the interface than to simply ask them about what kind of interface is preferable. The observation in a laboratory room can produce more general and scientific results than that in a real-world situation does. Thus, this chapter describes how to conduct a laboratory study. It collects users’ reactions to the prototype of a user interface in a controlled situation. There are many items to consider in order to conduct a laboratory study: goals, hypotheses, factors, conditions, experimental design, tasks, subjects, data collection, and analysis. Each of these items is explained in detail. An example of system evaluation that is conducted in the past study on telepresence robots is discussed.

Many a Lisp “newbie” has been seen complaining that while Common Lisp is a cool language, it is and always was pretty weak as far as graphical user interfaces (GUIs) are concerned.

The basic aim of this paper is to checking out the on, off status of rice cooker by using fuzzy logic technique and mat lab graphical user interface technique. Then find out the trouble shooting and the solution of this by using graphical user interface technique. There are various rice cooker available in market but it has an advance technique to cooking various types of rice, according to the water level. After starting of the cooking checking out the trouble, if there is any trouble then it smartly detected it and solving it automatically.

Since the beginning of computers there have been many types of user interfaces. Early user interfaces were extremely limited because of the computers limited resources. As computing systems and computing power evolve, so have the user interfaces evolved. The current stage of evolution for graphical user interfaces (GUI) for most computer systems is the WIMP (Windows, Icons, Mice, Pointer). The WIMP graphical user interface design has been the standard since its conception in the 1970s. Progressing beyond the WIMP to the next level of graphical user interface has proven extremely difficult [1]. Animated Graphical User Interfaces (AGUI) are a significant improvement over windowed interfaces for some applications. The users perceived usefulness, perceived value, and perceived quality can be improved by applying an Animated Graphical User Interface to the application. Improving the users perceived usefulness, perceived value, and perceived quality can lead to a significant increase in revenue for some applications. Advertising in traditional windowed applications is not widely accepted by users making it difficult to use as a revenue source. The introduction of an Animated Graphical User Interface to an application also gives rise to the option of introducing animated advertising in the application. Animated advertising can present a new revenue source in addition to or in place of the purchase price of the application. Animated advertisements can be presented in an entertaining and passive format that users will find acceptable in applications where advertising is not normally tolerated. The Animated Graphical User Interface can also be used to bridge language barriers. Animations for the interface can be designed with a goal of language independence. The user interface and animations can be designed with intuitive animations and graphics that users can understand without using a language. Animated applications designed for language independence can be used by people all over the world without modifications for language considerations. Design innovative user Animated Graphical User Interfaces that are functional and entertaining. Use the Animated Graphical User Interface Model to increase the users perceived usefulness, perceived quality, and perceived value of the target application. Create an environment using the Animated Graphical User Interface Model that instills user tolerance for animated advertising embedded in applications. Design animations, graphics and functionalities using the Animated Graphical User Interface Model that allows language independent use of the application.

The use of Natural User Interface in a real-world environment is explored by taking the example of a classroom in a government (public) school in a developing country such as India. Problems such as lack of infrastructure and inability to instill interest among students are addressed. A Microsoft Kinect based application was developed to demonstrate the use of Natural User Interface in such a classroom. The application maps Natural User Interface elements onto a Graphical User Interface and the application logic. The body gestures, distance from motion sensing device, and camera feed completely control the application, its look and feel, and the computations performed by it. The work performed, the main innovation and the salient aspects of the application, implemented as a student project, are presented.

We describe the graphical interfaces for small spaces and also deal with graphical user interfaces on restricted size screens on handheld and embedded devices, We also discuss about navigation to ensure that the user never feels lost in a maze of screens. We also discuss here some common mistakes to avoid and techniques that will help the user. How much you want to direct the user along a specific path depends on user audience.

Should you design user interfaces by giving an overview of data in the system or showing only the necessary data for each task step? Neither ensures efficient task support or ease of understanding, so the authors show an approach that balances both and allows early user validation.

User interfaces often only support one way to do a task when the physical interface or the requirements of the task would permit other ways. In contrast, a user interface that supports multiple approaches is permissive. This paper argues that permissive user interfaces are easier to use?and even when they are not applicable for particular applications, considering permissiveness is a productive design heuristic.Many user interfaces are difficult to use yet very easily demonstrated or explained by experts?with the results that users become frustrated because hindsight makes usability problems look like the user's own fault. The lack of permissiveness in such user interfaces explains this paradox.

Modern interactive services such as information and e-commerce services are becoming increasingly more flexible in the types of user interfaces they support. These interfaces incorporate automatic speech recognition and natural language understanding and include graphical user interfaces on the desktop and web-based interfaces using applets and HTML forms. To what extent can the user interface software be decoupled from the service logic software (the code that defines the essential function of a service)? Decoupling of user interface from service logic directly impacts the flexibility of services, or how easy they are to modify and extend. To explore these issues, we have developed Sisl, an architecture and domain-specific language for designing and implementing interactive services with multiple user interfaces. A key principle underlying Sisl is that all user interfaces to a service share the same service logic. Sisl provides a clean separation between the service logic and the software for a variety of interfaces, including Java applets, HTML pages, speech-based natural language dialogue, and telephone-based voice access. Sisl uses an event-based model of services that allows service providers to support interchangeable user interfaces (or add new ones) to a single consistent source of service logic and data. As part of a collaboration between research and development, Sisl is being used to prototype a new generation of call processing services for a Lucent Technologies switching product.

Graphical user interfaces are usually first sketched out manually as hand drawing pictures and then must be realized by software developers to become prototypes or usable user interfaces. This motivates our proposal of a smart CASE tool that can understand hand drawing sketches of graphical user interfaces, including forms and their navigations, then automatically transform such draft designs into real user interfaces of a prototype or an application. By using the ideas of modeling and model-transformation in model driven engineering, the authors also propose a mechanism to generate graphical user interfaces as forms targeting different platforms. Experimental results show that our sketch recognition to understand hand drawing graphical user interfaces can achieve the accuracy of 97.86% and 95% in recognizing 7 common UI controls and arrows for navigation respectively. Our model transformation engine can generate user interfaces as forms for applications on 3 different platforms of mobile devices, including Windows Phone, Android, and iOS. This approach follows the trend to develop a new generation of smart CASE tools that can understand and interpret conceptual software design models into concrete software elements and components to assist the software development process in a natural way.

We would like to encourage you to list your keywords within Model-driven development of Graphical User Interfaces (GUIs) for multiple devices involves the transformation of the same platform-independent model to several platform-dependent GUI models. A clear definition of which characteristics comprise a platform is important, because the platform definition determines which characteristics must not be considered in platform-independent models. In this chapter we compare the notion of platform and the corresponding implications in two conceptual approaches that support multi-device GUI generation – the Model Driven Architecture (MDA) proposed by OMG and the Cameleon Reference Framework (CRF), a framework that has been developed to classify model-based user interface generation approaches. We discuss the relation between MDA and CRF in the context of multi-device GUI generation and illustrate their correspondence through classifying state-of-the-art GUI generation approaches. This classification also allows us to illustrate three different mechanisms for achieving multi-device GUI generation in practice.

Software developers face many difficult decisions when building new applications, not the least of which is the design of the graphical user interface. The answer to one question-is it better to use a GUI development tool or build it manually?-is relatively straightforward. Today's tools offer several benefits that manual coding does not. Because these tools often provide a simple graphical interface for developing displays, nonprogrammers and human factors engineers can contribute their expertise. Also, if the schedule permits, a tool can be used to build prototypes throughout the development cycle; some tools even provide a test/prototype mode for testing displays without compiling and executing the entire application. And finally, end users can evaluate each prototype and provide feedback, increasing their satisfaction with the final product.

User interfaces in mobile applications are complex since they need to provide sufficient features to variety of users in a restricted space where a small number of components are available. When user acquires expertise in the system they expect user interfaces which satisfy their unique needs. Therefore, user interfaces in mobile applications should be adapted to different users. Since this problem exists in various applications a general solution is required to make user interfaces adaptive using user context history. In this paper, we introduce a conceptual prototype framework for mobile applications to make the user interfaces adaptive to the user. This identifies a suitable experience level to a user by learning his/her history of interactions with applications and then displays adaptive user interfaces. A proof of concept application is implemented to inspect the behavior of framework. Further, a user study was conducted on the developed proof of concept application and user context data was stored. This data was used as the training data for the Inference engine. This framework introduces an abstract solution which can be used to adapt various user interfaces based on human computer interactions. We believe the suggested framework can be used in related adaptation for Web applications, desktop applications and other mobile platforms.

Evolution in the context of use requires evolutions in the user interfaces even when they are currently used by operators. This paper proposes a model-based approach to support proactive management of context of use evolutions. By proactive management we mean mechanisms in place to plan and implement evolutions and adaptations of the entire user interface (including behaviour) in a generic way. This generic model-based approach is exemplified on a safety critical system from the space domain. It presents how the new user interfaces can be generated at runtime to provide a new user interface gathering in a single place all the information required to perform the task. These user interfaces have to be generated at runtime as new rocedures (i.e. sequences of operations to be executed in a semi-autonomous way) can be defined by operators at any time in order to react to adverse events and to keep the space system in operation. Such contextual, activity-related user interfaces complement the original user interfaces designed for operating the command and control system. The resulting user interface thus corresponds to a distribution of user interfaces in a focus + context way improving usability increasing efficiency and effectiveness.

Most developers would like to avoid redesigning a system around a new interface. But turning a character-based interface into a graphical one requires significant time and resources. The authors describe how this process can be partially automated, giving the results of their own reverse-engineering effort. >

In this paper is explained one solution for automation of testing Graphical User Interface. The paper gives a description of the problem, the concept of a solution and a description of the implementation of such a solution in order to confirm the above concept. Validation of the implementation was carried out on graphical tool for the development of software for audio target platform.

We consider the class of embedded systems user interfaces (ES-UI). They differ from classical graphical user interfaces because they use only a limited but possibly multi-modal number of inputs and offer numerous different user interface modes. We propose the domain specific language ESUIL in order to improve the quality of ES-UI software.

GUI applications revolve around events, and F# provides a natural way to process events with functions. Graphical interfaces are often developed using visual editors, in particular to build GUIs by assembling controls. Applications, however, often need drawing capabilities for displaying and manipulating data, which requires custom programming to augment available controls. This chapter will discuss how to develop graphical applications with F# and why the functional traits of the language suit the event-driven programming paradigm typical of GUIs.

In this chapter we introduce the use of GUIDE, which is the MATLAB Graphical User Interface Development Environment. This tool enables the user to create Graphical User Interfaces (GUI) that can be used to facilitate interaction with your programs.

Controlling and observing complex systems is central to the study of human-machine interaction. In our understanding, there is much to be gained from integrating formal modeling and analysis, including the reconfiguration of user interfaces, with the development of user interfaces with high usability. To this end, we introduce a new approach to modeling and reconfiguration of user interfaces jointly with a newly developed set of tools for interactive and visual creation and automatic transformation of user interfaces' interaction logic to a formal language based on Petri nets. Reconfiguration will be embedded into a process for adapting user interfaces to the user's cognitive representation of the controlled system. This process involves practicing the use of a given user interface, adapting it to the user's needs through reconfiguration, and applying the resulting adaptations to the formally defined interaction logic. An evaluation study confirms that this process reduces errors in interaction.

UniECAD is an integrated electronic CAD system, the user interface development system is the key of the integration of UniECAD. This paper presents the architecture of GUIDS, a graphical user interface development system in UniECAD, and then discusses a series of new techniques and methods in the design and the implementation of this system around the following aspects: the editing environment of interface elements, the implementation of dialogue control and the automatic generation of interface code. As an example, the generation of the main interfaces of UniECAD shows the procedure of the development of user interfaces with this development system.

Intermediates (those who are neither beginners nor old hands, and who make up most of the user population) are perhaps the most neglected user segment in terms of interface design, yet there are possibly more intermediate users than beginners or experts. The author urges interface designers to take note of this segment and details a transitional interface well-suited for bridging the gap between novice and expert. >

Web pages could be understood as graphical user interfaces to domain specific data provided by the internet. The specification of HTML5 facilitates the realization of user interfaces based on open standards and thereby the easy integration of code for user-tracking in already existing web pages. This paper describes a system for the detection and analysis of patterns within the user-traces. The core component of the system is a module that provides stochastic models for capturing patterns. In contrast to the simple detection of patterns within a stream of interaction events a model based approach condenses the patterns to states. The system enables an analyst to define restrictions to the state space and facilitates the interpretation of the found states.

The application of an object-oriented approach to modeling the application and presentation layer of the human-machine interfaces in a telecommunications management network architecture is described. It is argued that a significant simplification in information interchange between human and machine occurs when the machine has a model of the user to which it can conform. Several aspects of user modeling are discussed. The development and implementation of new input devices are also discussed. >

In his keynote address to the SIGCHI'90 conference, Michael Dertouzos said:When computers first appeared, input/output commands were a minor afterthought to cohesive, often well crafted and occasionally pretentious programming languages. Today, these commands occupy over 70 percent of a programming system's instructions. Yet they, along with the user interface structures that they define, are far from cohesive, and, at least up until now, immune to standardization. We must therefore turn our thinking around and create a new breed of programming languages that are first and foremost input/output oriented and that integrate traditional processing commands into new user-oriented structures. And just as we know today that traditional commands fall into a handful of fixed categories---decision, repetition, naming, procedure definition and use---we need to search for and identify the corresponding natural classes of commands for user interfaces. [Dertouzos 90]

GUI applications revolve around events, and F# provides a natural way to process events with functions. Graphical interfaces are often developed using visual editors, in particular to build GUIs by assembling controls. Applications, however, often need drawing capabilities for displaying and manipulating data, which requires custom programming to augment available controls. This chapter discusses how to develop graphical applications with F# and why the functional traits of the language suit the event-driven programming paradigm typical of GUIs.

Many resource-constrained devices do not need a complex graphical display. They provide an intuitive user interface with buttons and LEDs or a simple text display. However, there is a growing demand for devices that provide a complex user interface with a detailed graphical display. The .NET Micro Framework provides built-in support for color LCD displays, if your device has one.

A domain knowledge driven user interface development approach is described. As a conceptual design of the user interface, the domain knowledge defines the user interface in terms of objects, actions and their relationships that the user would use to interact with the application system. It also serves as input to a user interface management system (UIMS) and is the kernel of the target user interface. The principal ideas and the implementation techniques of the approach is discussed. The user interface model, user interface designer oriented high-level specification notation, and the transformation algorithms on domain knowledge are presented.

This paper describes the problem of testing graphical user interfaces (GUI) in applications with commonly used methods and introduces a new approach to such applications. The idea is to separate the GUI from the rest of the application and focus on testing the correctness of the interface itself and not the whole system.

User Interfaces have been around as long as computers have existed, even well before the field of Human-Computer Interaction was established. Over the years, some papers on the history of Human-Computer Interaction and User Interfaces have appeared, primarily focusing on the graphical interface era and early visionaries such as Bush, Engelbart and Kay. With the User Interface being a decisive factor in the proliferation of computers in society and since it has become a cultural phenomenon, it is time to paint a more comprehensive picture of its history. This SIG will investigate the possibilities of launching a concerted effort towards creating a History of User Interfaces.

In a study based on a questionnaire and an empirical test three graphical user interfaces for the DOS operating system commands (GEM, Windows 1.04, Windows 2.01) are compared.

We attack the problem of user fatigue in using an interactive genetic algorithm to evolve user interfaces in the XUL interface definition language. The interactive genetic algorithm combines computable user interface design metrics with subjective user input to guide evolution. Individuals in our population represent interface specifications and we compute an individual's fitness from a weighted combination of user input and user interface design guidelines. Results from our preliminary study involving three users indicate that users are able to effectively bias evolution towards user interface designs that reflect both user preferences and computed guideline metrics. Furthermore, we can reduce fatigue, defined by the number of choices needing to be made by the human designer, by doing two things. First, asking the user to pick just two (the best and worst) user interfaces from among a subset of nine shown. Second, asking the user to make the choice once every t generations, instead of every single generation. Our goal is to provide interface designers with an interactive tool that can be used to explore innovation and creativity in the design space of user interfaces.

User Interfaces has an important role on the success of an application. Due the relevant temporal and economic cost of its development is necessary to obtain a high acceptability and effective design. To consider a user interface acceptable this must be kind to user, do its objectives and be easy for the user. In this paper an abstract model specification is presented to allow evaluate the acceptability of user interfaces. This is made in a semiautomatic way validating the three items defined before. We also present a notation for the user interface testing and a tool that allows the user executes user tasks over the graphic user interface prototyping generates by the tool.

We attack the problem of user fatigue by using an interactive genetic algorithm to evolve user interfaces in the XUL interface definition language. The interactive genetic algorithm combines a set of computable user interface design metrics with subjective user input to guide the evolution of interfaces. Our goal is to provide user interface designers with a tool that can be used to explore innovation and creativity in the design space of user interfaces and make it easier for end-users to further customize their user interface without programming knowledge. User interface specifications are encoded as individuals in an interactive genetic algorithm's population and their fitness is computed from a weighted combination of user interface design guidelines and user input. This paper shows that we can reduce human fatigue in interactive genetic algorithms (the number of choices needing to be made by the designer), by 1) only asking the user to pick two user interfaces from among ten shown on the display and 2) by asking the user to make the choice once every t generations.

This paper proposes a method for user interface development where a model for analysis (Just-UI) and a model for design (DiaMODL) are conveniently combined into an integrated method. Just-UI currently supports automatically refining analysis models, through conceptual patterns to concrete user interface designs. Integrating a dialog modelling language (DiaMODL) into the method, will let the designers take part in the refinement process, hence gaining control and allowing a greater variety of designs. The method encourages the use of code generation for rapid prototyping of the UI. The ultimate objective is to provide a suitable software engineering and user interface design method with coverage to cross through requirements to final implementation of core application code and user interface.