|Publication number||US6374308 B1|
|Application number||US 08/636,323|
|Publication date||Apr 16, 2002|
|Filing date||Apr 23, 1996|
|Priority date||Apr 23, 1996|
|Publication number||08636323, 636323, US 6374308 B1, US 6374308B1, US-B1-6374308, US6374308 B1, US6374308B1|
|Inventors||James Kempf, Malini Minasandram|
|Original Assignee||Sun Microsystems, Inc.|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (6), Non-Patent Citations (6), Referenced by (39), Classifications (12), Legal Events (6)|
|External Links: USPTO, USPTO Assignment, Espacenet|
1. Field of the Invention
This invention relates to object-oriented programming and, more specifically, to the interactive connection of distributed objects to a graphic user interface (GUI).
A software application typically includes a GUI that provides an interface between an application user and the application. In an object-oriented environment, the GUI uses GUI objects to control the fields in the GUI. To use the data input via the GUI, an application object is connected to the GUI object Data entered in a GUI field is forwarded to the application object via the connection formed between the GUI object and the application object. In a distributed environment, the GUI object and application object can reside on different computer systems.
In the prior art, it is necessary to generate customized code for use by the software application to create the connection between the GUI object and the application object. This is a disadvantage because it makes the code more complicated and increases the cost in time associated with development of an application. The following provides a background of prior art development environments and the need to generate such custom code.
A GUI is typically created using a development environment. An example of a technology that provides a development environment is OpenStep. OpenStep™ is an open, high-volume portable standard for object-oriented computing. It provides a standard application programming interface (API). The OpenStep specification is based on NeXTStep. NeXTStep™ is an object-oriented operating system of NeXT Software, Inc.
The NeXTStep environment runs in the Mach operating system (OS). The Mach OS is a microkernel-based operating systems. A microkernel-based OS provides a basic level of services with the bulk of the operating system services supplied by user-level services. For example, the Mach kernel provides process management, memory management, communication and Input/Output services. Services such as files and directories are handled by user-level processes.
Solaris™ is a UNIX operating environment that can run on multiple hardware platforms such as Intel x86, SPARC, and PowerPC processors. OpenWindows™ is a windowing system based on the X11 windowing specification that runs in Solaris. The X11/DPS is a windowing system that runs in OpenWindows. Solaris, OpenWindows, and X11/DPS are products that are available from Sun Microsystems, Inc. (Sun Microsystems, Inc., OpenWindows, X11/DPS, and Solaris are trademarks or registered trademarks of Sun Microsystems, Inc. in the U.S. and certain other countries.) An implementation of OpenStep runs in the Solaris operating environment.
A development environment such as that provided by OpenStep includes tools that can be used to develop a software application. Examples of such tools are: InterfaceBuilder (IB) and ProjectBuilder (PB).
The PB is a tool that can be used to logically group, connect, and manage the files and components of an application. A project file contains all of the information about the end product (e.g., a software application). A project can be a stand-alone application, a subproject that is contained within another project, a bundle that contains resources that can be used by other applications, for example.
The IB is a tool that can be used to build a GUI for an application. It assists in the design and definition of the presentation layer of an application. The IB provides a GUI that allows a developer to drag objects such as text fields, radio buttons, and custom views to the application window. The IB saves an application's objects in a file referred to as a pickled object file (e.g., a nib file).
The IB also allows the developer to make connections between the application's interface and other application objects. A connection can be used to send a message between an interface object and another object, for example. A connection is typically made by defining an outlet. An outlet is an instance variable in an Objective-C class that can store a pointer to another object (e.g., type “id”). The value of the instance variable is typically set to the “id” of an object in the nib file such as a GUI object. When an outlet is set to the “id” of an object, this is known as a connection.
An interface defines how an object can communicate, or interact, with another object. An interface defines an object's type, attributes, the methods it exports, and the method parameters. An object that understands another object's interface can generate a request for the other object to perform an operation.
Binding refers to the linking of the software interface to the code that implements the interface. Dynamic binding only requires that the interface be determined at the time a message is sent between the objects. In contrast, if the binding is static, the interface for the client and server is determined at compile or build time.
Typing refers to the identification of an object's type, or class. Static typing requires that an object's type be known at compile time. In contrast, it is not necessary to know the type, or class, of an object at compile-time if dynamic typing is used. Instead, an object's type may be determined at run time.
Both C++ and Objective-C support dynamic, or run time, binding. However, C++ does not support dynamic typing. A C++ object's type must be declared at compile time. In contrast, an Objective-C object's type does not need to be available at compile time. Objective-C object typing can be dynamic (i.e., determined at run time).
Software applications can take advantage of a distributed computing capability referred to as distributed objects. Using distributed objects, a first object (a client object) can send a message to a second object (a server object) regardless of the physical location of either object. That is, the client and server objects can reside on different machines.
The distributed object technology uses a name server and a local proxy to allow a client object to communicate with a server object. A name server is used to register the server object. A client accesses the name server to look up the name of the server object. Using the name information, the client object directs a message to the server object.
Instead of going directly from the client to the server, the message is actually received by a proxy object that resides on the same machine as the client object. The proxy object forwards the message to the server object on the server object's machine. A response generated by the server object is forwarded to the client object via the proxy object. The client object need not know the location of the server object. As far as the client object is concerned, the proxy object is the server object. However, the proxy object is only a vehicle for forwarding the message to the server object via the network. The details of the network communication is therefore hidden from the client object.
NEO provides a development environment and run time system for developing and deploying distributed objects on a CORBA infrastructure having an OpenStep GUI. The NEO product is intended for developing and delivering distributed object applications based on a CORBA-compliant infrastructure.
A CORBA object has an associated definition that is used to specify the object's interface. The definition is parsed at run time and stored in a repository. A server provides access to the repository at run time to determine a CORBA object's interface.
A CORBA object such as an object created using the NEO framework, a NEO object, is therefore dependent on a connection with the server. The connection to the server is not made while a developer is using the IB, but rather when a nib file is actually loaded at run time.
The applications developed using the NEO product use an OpenStep object-oriented GUI tool kit. The GUI tool kit contains Objective-C object classes. The IB provides the ability to connect an instance of a GUI tool kit Objective-C object class to another Objective-C object instance. For example, a GUI text field object that allows text entry such as an employee name is connected to an employee name Objective-C object that performs operations on the employee name.
Custom Code Generation
A developer typically uses an IB to create an object and establish a connection between the GUI object (e.g., text field object) and an application object (e.g., employee name Objective-C object). For example, a connection is formed by specifying an outlet of one object to point to another object. If the application object is an Objective-C object, it is not necessary to specify the outlet's type statically (i.e., at build time). The type can be determined dynamically at run time. If, however, the application object is a C++ object, the outlet must have a static type that matches the run time type of the C++ application object. To match, the static type of the C++ application object can be the same type as, or a subclass of, the outlet's type.
If the application object is a CORBA object, it is necessary to generate customized code that obtains the CORBA object from a name server and to form the connection between the GUI object and the CORBA object. The code generation is either performed by the application software developer or a development tool such as an IB. Customized code generation must be performed for each application which requires additional development time and expense. In addition, the use of customized code adds to the complexity of the application's code.
A connection is dynamically created between a graphic user interface (GUI) and a statically typed, distributed object using the present invention. The connection is created without requiring a developer to write customized code or using a program development tool to generate customized code. Using the present invention, the connection is established dynamically at run time using declarative information specified at build time.
A template object is generated at build time that contains type and name information for a surrogate object. The surrogate object acts as a proxy for a distributed object (e.g., CORBA distributed object). At run time, the template object is used to identify the surrogate object. The surrogate object is connected to the GUI object at run time. The surrogate can be a statically-typed object. Thus, the present invention can be used to form a dynamic connection between a GUI object and a statically-typed object The GUI object is connected to the distributed object via the surrogate object.
The name information stored in the template object at build time is used to query a name server for an untyped surrogate object of a distributed object. The untyped surrogate object is transformed into a typed surrogate object at run time using the type information of the template object. A connection is formed between the typed surrogate object and the GUI object.
FIG. 1 provides an example of a general purpose computer to be used in accordance with embodiments of the present invention.
FIG. 2 illustrates the creation of a dynamic connection to a static object according to an embodiment of the present invention.
FIG. 3 provides a diagram of a connection between a GUI object and a CORBA distributed object.
FIGS. 4A-4B provides a process flow for template and surrogate object creation according to an embodiment of the present invention.
FIG. 5 provides an example of the process flow illustrated in FIGS. 4A-4B.
A method and apparatus for interactively connecting distributed objects to a graphic user interface is described. In the following description, numerous specific details are set forth in order to provide a more thorough description of the present invention. It will be apparent, however, to one skilled in the art, that the present invention may be practiced without these specific details. In other instances, well-known features have not been described in detail so as not to obscure the invention.
The present invention can be implemented on a general purpose computer such as illustrated in FIG. 1. A keyboard 110 and mouse 111 are coupled to a bi-directional system bus 118. The keyboard and mouse are for introducing user input to the computer system and communicating that user input to CPU 113. The computer system of FIG. 1 also includes a video memory 114, main memory 115 and mass storage 112, all coupled to bidirectional system bus 118 along with keyboard 110, mouse 111 and CPU 113. The mass storage 112 may include both fixed and removable media, such as magnetic, optical or magnetic optical storage systems or any other available mass storage technology. Bus 118 may contain, for example, 32 address lines for addressing video memory 114 or main memory 115. The system bus 118 also includes, for example, a 32-bit DATA bus for transferring DATA between and among the components, such as CPU 113, main memory 115, video memory 114 and mass storage 112. Alternatively, multiplex DATA/address lines may be used instead of separate DATA and address lines.
In the preferred embodiment of this invention, the CPU 113 is a 32-bit microprocessor manufactured by Motorola, such as the 680X0 processor, a 80X86 microprocessor manufactured by Intel, or a SPARC microprocessor. However, any other suitable microprocessor or microcomputer may be utilized. Main memory 115 is comprised of dynamic random access memory (DRAM). Video memory 114 is a dual-ported video random access memory. One port of the video memory 114 is coupled to video amplifier 116. The video amplifier 116 is used to drive the cathode ray tube (CRT) raster monitor 117. Video amplifier 116 is well known in the art and may be implemented by any suitable means. This circuitry converts pixel DATA stored in video memory 114 to a raster signal suitable for use by monitor 117. Monitor 117 is a type of monitor suitable for displaying graphic images.
The computer system described above is for purposes of example only. The present invention may be implemented in any type of computer system or programming or processing environment. When a general purpose computer system such as the one described executes the processes and process flows described herein, it is configured to interactively connect distributed objects to a GUI.
The present invention can dynamically create the connection between an Objective-C object and a C++ statically-typed object, for example. FIG. 2 illustrates the creation of a dynamic connection to a static object according to an embodiment of the present invention. The Objective-C object is GUI object 200. GUI object 200 is a dynamically typed object. In the preferred embodiment, adapter object 204 is used as an intermediate object between an Objective-C object and another object such as a C++ object. Adapter object 204 performs functions such as data translation, for example. Adapter object 204 is preferably a dynamic object. However, it should be apparent that the present invention can be used without adapter object 204. As an alternative, GUI object 200 can perform the functions performed by adapter object 204, for example.
At development (or build) time, connection 206 is established between adapter object 204 and template object 210. Connection 206 is specified using an IB, for example. Connection 208 is established at run time. Connection 208 connects adapter object 204 to surrogate object 212. Surrogate object 212 is a statically typed C++ object. Surrogate object 212 can be used as a local proxy for a distributed object such as a CORBA object, for example.
Information is stored in the nib file created by the IB at development time that is used to dynamically create surrogate object 212 and dynamically establish connection 208. The nib file contains a definition for template object 210. The definition includes: 1) a service name for surrogate object 212, and 2) the type of the surrogate object 212.
When the nib file is loaded at run time, the definition of template object 210 is encountered. Template object 210 is used to determine a CORBA reference for the distributed object associated with surrogate object 212. The type information is used to identify a type narrowing function referred to as a narrowing function, for surrogate object 212. The narrowing function transforms the surrogate object 212 into an object that is a sub-type, or subclass, of a CORBA supertype. Connection 208 is established between adapter object 204 and surrogate object 212. Connection 208 is formed by setting an outlet instance variable of adapter object 204 to point to surrogate object 212, for example.
GUI object 200 and surrogate object 212 are connected via adapter object 204 and connection 208. GUI object 200 is connected to adapter object 204 via connection 202. Connection 202 is formed by assigning a value to an outlet of GUI object 200, for example. GUI object 200 can send a message to adapter object 204 via connection 202. Connection 208 is used to forward the message generated by GUI object 200 to surrogate object 212. If surrogate object 212 is acting as a proxy for another object (i.e., a CORBA object), surrogate object 212 can forward the message to the other object Using the present invention, it is unnecessary for a developer to generate customized code to create surrogate object 212 and connection 208 at run time. That is, it is unnecessary for a developer or an IB to generate code to determine the CORBA reference for surrogate object 212, initiate the creation of surrogate object 212, and establish connection 208 between adapter object 204 and surrogate object 212. Thus, the present invention can be used to automatically create a connection between a dynamically-typed GUI object and a statically-typed, C++ object at run time. Further, the present invention can be used to automatically create an interactive connection between a GUI object and a CORBA object, if the statically-typed, C++ object is a surrogate, or proxy, for the CORBA object.
FIG. 3 provides a diagram of a connection between a GUI object and a CORBA distributed object. GUI object 300 is connected to adapter object 306 via connection 304. Connection 304 can be formed by setting outlet instance variable 302 of GUI object 300 to point to adapter object 306, for example. GUI object 300 and adapter object 306 can be Objective-C, dynamically-type objects. Connection 304 is preferably set using the IB. GUI object 300 can be connected to CORBA object 320 at run time.
In the preferred embodiment, the connection between GUI object 300 and CORBA object 320 is established via adapter object 306, surrogate object 312 and CORBA server 316 at run time. At run time, surrogate object 312 is created and connection 310 is established between adapter object 306 and surrogate object 312.
Surrogate object 312 is created at run time based on a definition in an application's nib file of template object 210, for example. Preferably, a development tool such as the IB is used to define template object 210 at build time. In one example, a Make Template Object menu command of the IB can be selected. The Make Template Object command is used to indicate that an instance of template object 210 is to be included in the application's nib file definition. A result of a Make Template Object selection is the inclusion of a definition for template object 210 in the application's nib file. The GUI of the IB can be used to establish a connection between GUI object 200 and surrogate object 212. This connection is specified by graphically connecting icons that represent adapter object 204 and template object 210. The IB is also used to specify the service name for, and type (or class) of, surrogate object 212.
The information specified using the IB is stored in a nib file of the application being developed. Specifically, the nib file contains a declaration for template object 210 along with declarations for adapter object 204 and GUI object 200. The declaration for template object 210 includes declarations for the name and type values of surrogate object 212.
When the software application is invoked or run, the application is loaded into memory for execution. The application's run time environment is initialized. The application's nib file is examined and entries in the nib file are used to create instances of objects. When the declaration for template object 210 is encountered, an instance of the object class for template object 210 is created. A creation method of the template object class is used to create template object 210. In the preferred embodiment, the creation method is also used to initiate the creation of surrogate object 212. FIGS. 4A-4B provides a process flow for template and surrogate object creation according to an embodiment of the present invention.
At step 402, the nib file is loaded. At step 404, an instance of the template object class is created. At step 406, the template object's creation method is invoked. At step 408, the type value contained in the nib file is used to generate the name of an narrowing function. The narrowing function is used to narrow a supertype obtained from the CORBA server to the surrogate object's type. At step 410, a symbol lookup is performed in a dynamic link library for the surrogate's stub code to obtain a pointer to the narrowing function. At step 412, the name server is queried to obtain an untyped CORBA object reference using the service name information (e.g., a string) stored in the template object.
The untyped CORBA object reference can be a reference to an untyped surrogate object The untyped surrogate object is created when the look up operation is performed at step 412. The untyped object reference actually has the root type of the object class hierarchy. The root class is referred to as the base supertype. At step 414, the narrowing function and untyped, or supertyped, object reference are used to narrow the object reference to the surrogate object. That is, for example, the supertype is narrowed to the type specified in the type information of the template declaration using the narrowing function. At step 416, an outlet of the adapter object (e.g., adapter object 306) is set to point to the surrogate object (e.g., surrogate object 312).
An error may occur during the processing of the nib file template object entry. At step 412, for example, an object reference may not be found in the name server. Such a failure can be reported using an alert panel or by printing a message. If no errors occur, outlet 308 of adapter object 306 is pointing to a valid surrogate object (e.g., surrogate object 312) after the initialization process is finished. If an error occurred, outlet 308 is preferably a null pointer. The application can determine whether to proceed or terminate.
FIG. 5 provides an example of the flow illustrated in FIGS. 4A-4B. Template object 500 includes a type information 502A and a name information 502B. Type information 502A becomes the input for name mangling routine 504. Name mangling routine 504 is, for example, the name mangling routine provided in a C++ ABL Name mangling routine 504 constructs a narrowing function name from type information 502A. The narrowing function name is used as input to dynamic link library symbol lookup, or dlsym, function 508. Dlsym function 508 performs a symbol lookup in stub library 510 to obtain a pointer, or function symbol, to the narrowing function having the narrowing function name.
Name information 502B is used by the run time library to invoke a find operation 514 (i.e., ODF::Service::find()) on name server 516. Name server 516 obtains an untyped CORBA object reference to the surrogate object (i.e., CORBA::ObjectRef) associated with the service specified by the name information 502B. Narrowing function 520 is invoked using the function symbol, or pointer, obtained using dlsym function 508. The surrogate object containing the untyped CORBA object obtained from name server 516 is an argument of narrowing function 520. Narrowing function 520 transforms the surrogate object to a C++ subtype. An outlet of source object 522 (e.g., adapter object 306) is set to point to the surrogate object (e.g., surrogate object 312).
The present invention's functionality can be reused across applications. Software application developers can incorporate the invention's functionality in multiple applications without generating a separate instance of code for each application.
Thus, a method and apparatus for the interactively connecting distributed objects to a graphic user interface has been described in conjunction with one or more specific embodiments. The invention is defined by the claims and their full scope of equivalents.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US5530864 *||Dec 23, 1992||Jun 25, 1996||Taligent||Command object system for an object-oriented software platform|
|US5559948 *||Mar 22, 1995||Sep 24, 1996||International Business Machines Corporation||Apparatus and method for manipulating an object in a computer system graphical user interface|
|US5692183 *||Mar 31, 1995||Nov 25, 1997||Sun Microsystems, Inc.||Methods and apparatus for providing transparent persistence in a distributed object operating environment|
|US5848419 *||May 21, 1997||Dec 8, 1998||Sun Microsystems, Inc.||Methods and apparatus for providing transparent persistence in a distributed object operating environment|
|US5872973 *||Oct 26, 1995||Feb 16, 1999||Viewsoft, Inc.||Method for managing dynamic relations between objects in dynamic object-oriented languages|
|US5877966 *||Mar 18, 1996||Mar 2, 1999||Pantheon Solutions, Inc.||System and method for creating configurations using templates|
|1||*||(no author given) "IDL Objective-C Language Mapping Specification," NeXT Computer, pp(11), 1993.*|
|2||*||IBM, SOM Objects Developer Toolkit, Programmer's Guide, vol. II: Object Services, SOM Objects Version 3.0, Dec. 1996, pp. 4-26.*|
|3||*||Lozinkski, Christopher, "Why I need Objective-C," JOOP, pp. 21-26, Sep. 1991.*|
|4||*||OMG, Common Object Request Broker: Architecture and Specification, Revision 2.0, Jul. 1995, pp. 7-1-7-11, 8-1-8-10, and 11-1-11-7.*|
|5||*||SOM Objects Developer Toolkit User Guide, Version 2.0, IBM, 6-1-6-20 and 6-50-6-55, Jun. 1993.|
|6||*||Wagner, Richard, "Delphi 2.0," Delphi Informant, pp(7), Feb. 1996.*|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US6637020||Dec 3, 1998||Oct 21, 2003||International Business Machines Corporation||Creating applications within data processing systems by combining program components dynamically|
|US6735771 *||Mar 12, 1999||May 11, 2004||Perot Systems Corporation||System and method for delivering web services using common object request broker architecture|
|US6751650 *||Jun 29, 2000||Jun 15, 2004||Journyx, Inc.||Method and apparatus for monitoring contractor performance|
|US6851118 *||Jun 27, 2000||Feb 1, 2005||Sun Microsystems, Inc.||Remote object access|
|US6931455 *||Nov 30, 1999||Aug 16, 2005||Recursion Software, Inc.||System and method for communications between a CORBA object request broker and a non-CORBA object request broker|
|US6944652 *||Jun 29, 2000||Sep 13, 2005||Journyx, Inc.||Method and apparatus for providing frequent flyer miles and incentives for timely interaction with a time records system|
|US6959307||Nov 3, 2003||Oct 25, 2005||International Business Machines Corporation||Process and system for a client object to perform a remote method invocation of a method in a server object|
|US7024497 *||Sep 7, 2000||Apr 4, 2006||Adaptec, Inc.||Methods for accessing remotely located devices|
|US7143164 *||Jul 13, 2001||Nov 28, 2006||Exigen Group||Dynamic object library software architecture|
|US7287252 *||Sep 27, 2002||Oct 23, 2007||The United States Of America Represented By The Secretary Of The Navy||Universal client and consumer|
|US7380236 *||Aug 21, 2003||May 27, 2008||Sap Aktiengesellschaft||Method and computer program for rendering assemblies objects on user-interface to present data of application|
|US7418696 *||Dec 5, 2003||Aug 26, 2008||Sap Aktiengesellschaft||Method and computer program for rendering assemblies objects on user-interface to present data of application|
|US7624375||Jun 12, 2003||Nov 24, 2009||National Instruments Corporation||Automatically configuring a graphical user interface element to bind to a graphical program|
|US7779097||Dec 16, 2005||Aug 17, 2010||Sonic Solutions||Methods and systems for use in network management of content|
|US8276132 *||Nov 12, 2007||Sep 25, 2012||Nvidia Corporation||System and method for representing and managing a multi-architecture co-processor application program|
|US8281294 *||Nov 12, 2007||Oct 2, 2012||Nvidia Corporation||System and method for representing and managing a multi-architecture co-processor application program|
|US8341536 *||Jul 8, 2005||Dec 25, 2012||International Business Machines Corporation||Dynamic interface component control support|
|US8473910 *||Aug 11, 2008||Jun 25, 2013||Infonovus Technologies, Llc||Method and system for defining a software application as a complete and consistent specification in a software development process|
|US8549093||Sep 23, 2009||Oct 1, 2013||Strategic Technology Partners, LLC||Updating a user session in a mach-derived system environment|
|US8683431 *||Dec 29, 2009||Mar 25, 2014||Microgen Aptitude Limited||Applying rules to data|
|US8924502||Sep 24, 2013||Dec 30, 2014||Strategic Technology Partners Llc||System, method and computer program product for updating a user session in a mach-derived system environment|
|US8943424||Aug 8, 2012||Jan 27, 2015||International Business Machines Corporation||Dynamic interface component control support|
|US9213692 *||Mar 21, 2014||Dec 15, 2015||At&T Intellectual Property Ii, L.P.||System and method for the automatic validation of dialog run time systems|
|US20040015926 *||Jul 13, 2001||Jan 22, 2004||Vadim Antonov||Novel dynamic object library software architecture|
|US20040064820 *||Sep 27, 2002||Apr 1, 2004||Bussiere Gregory A.||Universal client and consumer|
|US20040083463 *||Aug 21, 2003||Apr 29, 2004||David Hawley||Method and computer program for rendering assemblies objects on user-interface to present data of application|
|US20040111730 *||Nov 3, 2003||Jun 10, 2004||Apte Ajay Arvind||Process and system for a client object to perform a remote method invocation of a method in a server object|
|US20040205528 *||Apr 29, 2004||Oct 14, 2004||Vlad Alexander||System and process for managing content organized in a tag-delimited template using metadata|
|US20040255269 *||Jun 12, 2003||Dec 16, 2004||Santori Michael L.||Automatically configuring a graphical user interface element to bind to a graphical program|
|US20050240945 *||Jun 22, 2005||Oct 27, 2005||Glass Graham W||System and method for dynamic generation of remote proxies|
|US20060085574 *||Dec 1, 2005||Apr 20, 2006||Sonic Solutions||Methods for accessing remotely located devices|
|US20060184538 *||Feb 16, 2005||Aug 17, 2006||Sonic Solutions||Generation, organization and/or playing back of content based on incorporated parameter identifiers|
|US20070011620 *||Jul 8, 2005||Jan 11, 2007||Gili Mendel||Dynamic interface component control support|
|US20090094573 *||Aug 11, 2008||Apr 9, 2009||Skriletz Richard A||Method and system for defining a software application as a specification|
|US20110161918 *||Jun 30, 2011||Microgen Plc||Applying rules to data|
|USRE41706||Sep 14, 2010||Glass Graham W||Moving objects in a distributed computing environment|
|USRE43375||Sep 20, 2007||May 8, 2012||Reware Asset Group, L.L.C.||System and method for communications in a distributed computing environment|
|WO2004111842A2 *||Jun 14, 2004||Dec 23, 2004||John C Limroth||Automatically configuring a graphical user interface element to bind to a graphical program|
|WO2004111842A3 *||Jun 14, 2004||Dec 29, 2005||John C Limroth||Automatically configuring a graphical user interface element to bind to a graphical program|
|U.S. Classification||719/316, 717/111, 717/105, 715/762|
|International Classification||G06F3/048, G06F3/14, G06F9/44, G06F9/46|
|Cooperative Classification||G06F9/465, G06F9/4443|
|European Classification||G06F9/46M, G06F9/44W|
|Apr 23, 1996||AS||Assignment|
Owner name: SUN MICROSYSTEMS, INC,, CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:KEMPF, JAMES;REEL/FRAME:007994/0051
Effective date: 19960412
|Jun 11, 2001||AS||Assignment|
|Sep 23, 2005||FPAY||Fee payment|
Year of fee payment: 4
|Sep 16, 2009||FPAY||Fee payment|
Year of fee payment: 8
|Sep 18, 2013||FPAY||Fee payment|
Year of fee payment: 12
|Dec 12, 2015||AS||Assignment|
Owner name: ORACLE AMERICA, INC., CALIFORNIA
Free format text: MERGER AND CHANGE OF NAME;ASSIGNORS:ORACLE USA, INC.;SUN MICROSYSTEMS, INC.;ORACLE AMERICA, INC.;REEL/FRAME:037278/0625
Effective date: 20100212