TLE 4TH Q.

• Window Forms are used to create the GUIs for programs
• form is a graphical element that appears on the desktop; it can be a dialog, a window or an MDI window (multiple document interface window
• component is an instance of a class that implements the IComponent interface, which defines the behaviors that components must implement.
• A control, such as a button or label, is a component that has a graphical representation at runtime.
• A graphical user interface (GUI) allows a user to interact visually with a program.
• A GUI (pronounced “GOO-ee”) gives a program a distinctive “look” and “feel.”
• GUIs are built from GUI components (which are sometimes called controls or widgets—short for window gadgets).
• A GUI component is an object with which the user interacts via the mouse or keyboard.
• Object-oriented programming language:  Means you work with objects in building an application.
• Event-driven programming language: because you will write program code that responds to events that are controlled by the system user
• Object: A thing – like a noun in English.  Examples include forms and controls you place on forms such as buttons, text boxes, and icons.
• Objects have properties – like adjectives in English.  Properties describe object behaviors.  Examples of properties include Text, Name,BackColor, Font, and Size. 
• Method: Like a verb in English – these are the actions that objects exhibit. Examples include methods to Show and Hide forms and methods toPrint and Close forms. 
• Events are actions usually triggered by the system user such as clicking a button; however, events can also be triggered by the actions of objects. For example, closing a form can trigger an event.
• Class: This is a really abstract term – it is a sort of template for an object.  
• Objects – These are defined as data and the closely associated actions which operate on the data. This integration of data and opera-tions into a single object is called encapsulation. In GUI design, objects are abstracted as icons and menus which represent folders, files, application programs, processes, and operations.
• Messages – These are defined as the requests sent to an object to execute the actions of which it is capable. Different objects may support different messages and may respond identically or differently to the same message. In GUI design, messages may be sent by the mouse in performing actions such as selection, launching, copying, restructuring, trashing, and ejecting. Messages commanding actions of saving, duplicating, printing, cutting, copying, and pasting may be sent via either the mouse or keyboard. The
• Methods – These are the routines and algorithms for implementing messages. In GUI design, methods are implemented by high-level routines supported by the event manager, windows manager, menu manager, and so on.
• Class hierarchy – Each object belongs to a class and is called an instance of the class. Class hierarchy provides for super -classes and subclasses. All objects of a subclass inherit the data and behavior defined by the superclass of which they are members. The class without a superclass is called the root class. A given class supports certain methods common to all members of the class. In GUI design, classes exist for data files, applications programs, menu headers, and menu selection items.
• Inheritance – Membership in a class provides inheritance of data and methods for all members of the class. Members of a subclass inherit all the instance variables and methods of its superclass unless it chooses to override them with local variables and/or methods. Inheritance provides advantages of reducing data redundancy and action code duplication. In GUI design, all data icons share the method of examining their own creator slot and searching for the application program it points to when they are opened.
• Polymorphism – Literally multiple forms, this feature of OOP means that the same message may be sent to objects of different classes. The response from members of distinct classes may be identical to, similar to, or completely distinct from each other, depending on the method chosen by each class for implementing the message.
• Sensitivity – Perhaps the first principle of good GUI design is the sensitivity to good design in general. Good design involves building smooth, effective, and unobtrusive interfaces between humans and the objects with which they interact. Good design is often most evident when it is missing.
• Task Understanding – The first step in effective GUI/application program design is to achieve a thorough understanding of the task for which the program is being designed. This involves not only an analysis of the task mechanics, but a study of users, their background and skills, the environment in which the task is accomplished, the institutional setting, and communications requirements. The task analysis should be user-centered, with user interviews and interaction at every level of the development.
• Transparency – The goal of an effective GUI/application program is to make the computer "invisible" and to focus the user’s complete attention on the task to be accomplished. In a perfectly designed GUI/application program, the user should be aware only of the work in progress and totally unaware of the tools s/he is using to perform the work.
• Integration – The goal of good GUI design for application programs is the seamless integration of the GUI with the application program. There is nothing quite as obvious or awkward as a command-line program onto which a GUI has been pasted. The integration of a GUI with an application program does not involve simply replacing the command interpreter with a menu window, but rather requires a complete restructuring of the application program.
• Consistency – In the design of GUI/application programs for general users who are likely to be users of other programs, consistency of metaphor is of great value. The genius of the desktop metaphor is that, once the user has mastered a single program, it is relatively easy to master subsequent programs. The closer the designer sticks to a consistent metaphor, the greater is the transference of skills for novice users.
• Feedback – Effective feedback is an important principle in the design of any interface and particularly important in the rich environment possible with GUIs. Graphical feedback should indicate the status of the system at all times ("Wait, I’m busy computing" or "Alright, what should we do next?"), the action options available to the user, an indication of what objects are active or selected, and an indication of the progress in time-consuming tasks like file copying.
• Balance – A well-designed GUI/application program must balance simplicity against features. Feature-rich programs may appeal to "power users," the loss of simplicity may leave the average user confused and overwhelmed.
• Construct the graphical objects that make up the user interface.
• Define attributes for the objects to customize their appearance and behavior.
• Embed code in each object to define methods for implementing its messages.
• Events are actions usually triggered by the system user such as clicking a button; however, events can also be triggered by the actions of objects. For example, closing a form can trigger an event.