Patent Application
20080270919
The present invention relates in general to the field of computers and similar technologies, and in particular to software utilized in this field. Still more particularly, the present disclosure relates to software development.
A Graphical User Interface (GUI) builder utilizes a “Canvas” as a single placeholder for GUI-parts. A user drops or creates these GUI-parts on the Canvas (from a palette, a wizard, or other sources), and use various visual queues (or helper views and dialogs) to manipulate and configure these elements. GUI-parts can be placed on top of other GUI-parts to build a complete GUI.
Java Visual Editor (JVE) is one type of GUI Builder. JVE enables a user to build a Java GUI by dropping widgets on the Canvas in a hierarchy view. The JVE's GUI parts may be widgets (components) that a computer user interacts with, such as a window, a text field, or a check box. Visual components are specific to a particular widget toolkit (e.g., Microsoft Foundation Classes (MFC) on the Windows™ platform, Swing™ for Java™, and Standard Widget Toolkit (SWT) for Eclipse™). Typically these widgets are quite light in functionality and concern themselves with presentation. Thus, the logic about how the widget's data is read by an underlying component must be provided by supplemental logic. A table, for example, has a set of properties specifying features such as border, background color, scroll visibility and so forth. The developer however, having laid out the widgets and set the properties, must then write code that populates the content of the table. This code includes instructions on such topics as binding data to a widget, how data validation occurs, cell editing, column data conversion, filtering, sorting, paging logic and so forth. Thus, the widget is presented on an upper layer canvas, but the features and code that support the widget are on another lower layer canvas, which must be toggled to in order for a user to know what functionality and protocol are being used with that particular widget.
For example, consider the GUI 102 shown in
To address the condition described above, presently disclosed are a computer-implementable method, system and computer-readable medium for establishing and utilizing a widget-centric context-based layer. In a preferred embodiment, the computer-implemented method includes a computer detecting a mouse hover over a visual control that is displayed on a visual layer canvas. In response to determining that the visual control is supported by a context layer, the computer displays the visual control and component icons together on a context layer canvas, wherein the context layer includes elements from both an upper visual layer and a lower component layer, and wherein the component icons are associated with respective components from the lower component layer. The computer then receives a user input that selects one or more of the component icons. In response to the user input selecting one or more of the component icons, the computer then presents a property sheet on the context layer canvas, wherein the property sheet contains user-editable properties of a component that is associated with a selected component icon. The computer can then receive a user editing input that edits the user-editable properties.
The above, as well as additional purposes, features, and advantages of the present invention will become apparent in the following detailed written description.
The novel features believed characteristic of the invention are set forth in the appended claims. The invention itself, however, as well as a preferred mode of use, further purposes and advantages thereof, will best be understood by reference to the following detailed description of an illustrative embodiment when read in conjunction with the accompanying drawings, where:
With reference now to
Assume for exemplary purposes that widget 206 is a data input widget that accepts data for entry into an underlying database, and that the underlying database will be used to populate some or all of an underlying table. In this example, the underlying table could be a visual component (represented by component icon 210a), since it can be visually displayed according to predefined criteria and protocols. In the “table” example, an example of a non-visual component includes, but is not limited to, a database (represented by component icon 210c), which may be a database of enterprise employees that is used to populate the table; and a binder (represented by component icon 210d), which includes instructions, passwords and protocol used to bind (logically associate) the table with the database. Other types of non-visual components include, but are not limited to, software that defines or enables schema definitions; CRUD (create, retrieve, update, delete) methods for documents; search functions; data format conversion software logic; sorting operations; document manipulation and editing; event handling; etc. By dragging component icons 210a, 210c, and 210d onto the displayed widget 206, the functionality, information, protocol, etc. associated with the represented components is now associated with widget 206.
Referring then to
As described in block 306, a palette of icons associated with visual and non-visual components, which may be used with the displayed widget, is also displayed. These visual and non-visual components may be from any of the many component frameworks that augment toolkit widget functionality, such as Microsoft's™ Design Time Controls (DTC), Java Network Desktop Components (JNDC)), or Java Server Faces (JSF) controls. These frameworks make it easier for a developer to create and configure high fidelity and functionally rich controls. These frameworks work by providing wrapper or helper elements that decorate the native widgets and augment their functionality. As an example, one GUI framework provides the Standard Widget Tool (SWT) as the native widget toolkit, which provides JFace components as the logical decorators. That is, SWT is a widget set and graphics library that is integrated with a native window system, but with an Operating System (OS)-independent Application Program Interface (API). JFace is a User Interface (UI) toolkit that is implemented though SWT. JFace sits partially “on top of” SWT to simplify common UI programming tasks, but does not hide SWT. Thus, JFace components augment the functionality of the native SWT components and add support for data binding, validation and other logic required to implement complete functionality required for a typical business logic application. A JFace table-viewer component, as an example, includes both the visual widget (shown in
Returning again to
Referring now to
With reference now to
With reference now to
Client computer 702 is able to communicate with a service provider server 750 via a network 728 using a network interface 730, which is coupled to system bus 706. Network 728 may be an external network such as the Internet, or an internal network such as an Ethernet or a Virtual Private Network (VPN). Service provider server 750 may utilize a similar architecture design as that described for client computer 702.
A hard drive interface 732 is also coupled to system bus 706. Hard drive interface 732 interfaces with a hard drive 734. In a preferred embodiment, hard drive 734 populates a system memory 736, which is also coupled to system bus 706. Data that populates system memory 736 includes client computer 702's operating system (OS) 738 and application programs 744.
OS 738 includes a shell 740, for providing transparent user access to resources such as application programs 744. Generally, shell 740 is a program that provides an interpreter and an interface between the user and the operating system. More specifically, shell 740 executes commands that are entered into a command line user interface or from a file. Thus, shell 740 (as it is called in UNIX®), also called a command processor in Windows®, is generally the highest level of the operating system software hierarchy and serves as a command interpreter. The shell provides a system prompt, interprets commands entered by keyboard, mouse, or other user input media, and sends the interpreted command(s) to the appropriate lower levels of the operating system (e.g., a kernel 742) for processing. Note that while shell 740 is a text-based, line-oriented user interface, the present invention will equally well support other user interface modes, such as graphical, voice, gestural, etc.
As depicted, OS 738 also includes kernel 742, which includes lower levels of functionality for OS 738, including providing essential services required by other parts of OS 738 and application programs 744, including memory management, process and task management, disk management, and mouse and keyboard management.
Application programs 744 include a browser 746. Browser 746 includes program modules and instructions enabling a World Wide Web (WWW) client (i.e., client computer 702) to send and receive network messages to the Internet using HyperText Transfer Protocol (HTTP) messaging, thus enabling communication with service provider server 750.
Application programs 744 in client computer 702's system memory also include an Context-Based Layer Management Program (CBLMP) 748, which includes logic for implementing the steps and UI's described above in
The hardware elements depicted in client computer 702 are not intended to be exhaustive, but rather are representative to highlight essential components required by the present invention. For instance, client computer 702 may include alternate memory storage devices such as magnetic cassettes, Digital Versatile Disks (DVDs), Bernoulli cartridges, and the like. These and other variations are intended to be within the spirit and scope of the present invention.
As noted above, CBLMP 748 can be downloaded to client computer 702 from service provider server 750. This deployment may be performed in an “on demand” basis manner, in which CBLMP 748 is only deployed when needed by client computer 702. Note further that, in another preferred embodiment of the present invention, service provider server 750 performs all of the functions associated with the present invention (including execution of CBLMP 748), thus freeing client computer 702 from using its resources. In another embodiment, process software for the method so described may be deployed to service provider server 750 by another service provider server (not shown). In yet another embodiment, ICEE 748 may be implemented through the use of a browser based application such as a Rich Internet Application (RIA). This RIA may be implemented in browser 746, preferably through the use of JavaScript such as AJAX (Asynchronous JavaScript using XML).
It should be understood that at least some aspects of the present invention may alternatively be implemented in a computer-useable medium that contains a program product. Programs defining functions on the present invention can be delivered to a data storage system or a computer system via a variety of signal-bearing media, which include, without limitation, non-writable storage media (e.g., CD-ROM), writable storage media (e.g., hard disk drive, read/write CD ROM, optical media), and communication media, such as computer and telephone networks including Ethernet, the Internet, wireless networks, and like network systems. It should be understood, therefore, that such signal-bearing media when carrying or encoding computer readable instructions that direct method functions in the present invention, represent alternative embodiments of the present invention. Further, it is understood that the present invention may be implemented by a system having means in the form of hardware, software, or a combination of software and hardware as described herein or their equivalent.
Thus, presently disclosed are a computer-implementable method, system and computer-readable medium for establishing and utilizing a context-based layer. Note that the context-based layer is widget-centric, since the context-based layer can be called up by any widget that is supported by the context-based layer described herein. In a preferred embodiment, the computer-implemented method includes a computer detecting a mouse hover over a visual control that is displayed on a visual layer canvas. In response to determining that the visual control is supported by a context layer, the computer displays the visual control and component icons on a context layer canvas, wherein the context layer includes elements from both an upper visual layer and a lower component layer, and wherein the component icons are associated with respective components from the lower component layer. The computer then receives a user input that selects one or more of the component icons. In response to the user input selecting one or more of the component icons, the computer then presents a property sheet on the context layer canvas, wherein the property sheet contains user-editable properties of a component that is associated with a selected component icon. The computer can then receive a user editing input that edits the user-editable properties.
Note that the method steps described herein may be implemented in a computer system, and may further be executed by instructions that are stored in a computer-readable medium.
In another embodiment, in which the methods described herein are performed by software that is stored on a computer-readable medium, the computer-readable medium is a component of a remote server, and the computer executable instructions are deployable to a client computer and/or a supervisory computer from the remote server. This deployment may be provided by a service provider to a customer computer (e.g., the client computer and/or the supervisory computer) on an on-demand basis.
While the present invention has been particularly shown and described with reference to a preferred embodiment, it will be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the spirit and scope of the invention. Furthermore, as used in the specification and the appended claims, the term “computer” or “system” or “computer system” or “computing device” includes any data processing system including, but not limited to, personal computers, servers, workstations, network computers, main frame computers, routers, switches, Personal Digital Assistants (PDA's), telephones, and any other system capable of processing, transmitting, receiving, capturing and/or storing data.
