Many computer programs use graphical user interfaces, referred to as GUIs, as an intuitive and convenient means to present information and functionality for users to interact with the computer program. A user can interact with a user interface through a myriad of user interface elements or widgets. A graphical user interface typically has some elements that display information only, such as labels and images, and other elements that receive input from a user through an input mechanism, such as menus, buttons and check boxes. Furthermore, these user interface elements can include a graphical element with a collection of input elements. For example, a tree widget may provide a hierarchy of widgets, where each widget has its own window, dialog or form for interacting with the computer program. In another example, a set of property sheets may have multiple tabs with each tab handling a portion of user input for the user interface. The display and input elements can be placed and arranged within a window, frame, property sheet or other container widget, which can be moved, resized, closed, etc. Users may interact with user interface elements to view display elements and modify input elements across multiple forms or screens.
The design and development of graphical user interfaces can be quite complex in considering the myriad of user interface components, and implementing event-driven and parallelism programming paradigms with state and control considerations. Although an event based model may follow a parallelism paradigm, the user interface also needs to have structure and data to track and manage state and control of information in accordance with the desired functionality. For example, it may be desired to have the execution of instructions related to an event behave differently based on the state of user interface components, or the currently assigned values to user interface components.
Furthermore, the design and development of a graphical user interface can increase in complexity with the increase in the number of user interface elements, the number of generated events, and the complexity of the desired functionality along with the related state and control of the user interface functionality. Moreover, some software programmers may be challenged by the complexities of implementing a design and development of a graphical user interface considering event-driven and parallelism paradigms.