US6154786A - Method for associating data bearing objects with user interface objects - Google Patents
Method for associating data bearing objects with user interface objects Download PDFInfo
- Publication number
- US6154786A US6154786A US08/939,158 US93915897A US6154786A US 6154786 A US6154786 A US 6154786A US 93915897 A US93915897 A US 93915897A US 6154786 A US6154786 A US 6154786A
- Authority
- US
- United States
- Prior art keywords
- user interface
- type
- association
- message
- interface object
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Expired - Lifetime
Links
- 238000000034 method Methods 0.000 title claims abstract description 99
- 230000004044 response Effects 0.000 claims description 13
- 238000006243 chemical reaction Methods 0.000 abstract description 3
- 238000013461 design Methods 0.000 abstract description 3
- 238000013519 translation Methods 0.000 abstract description 3
- 230000008859 change Effects 0.000 description 16
- 230000008569 process Effects 0.000 description 14
- 238000010586 diagram Methods 0.000 description 13
- 238000004891 communication Methods 0.000 description 6
- 230000003139 buffering effect Effects 0.000 description 3
- 239000004615 ingredient Substances 0.000 description 2
- 230000007246 mechanism Effects 0.000 description 2
- 238000012546 transfer Methods 0.000 description 2
- 101001022148 Homo sapiens Furin Proteins 0.000 description 1
- 101000701936 Homo sapiens Signal peptidase complex subunit 1 Proteins 0.000 description 1
- 102100030313 Signal peptidase complex subunit 1 Human genes 0.000 description 1
- 230000008901 benefit Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 230000001902 propagating effect Effects 0.000 description 1
- 230000001360 synchronised effect Effects 0.000 description 1
- 230000032258 transport Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4488—Object-oriented
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/451—Execution arrangements for user interfaces
Definitions
- the present invention relates to the field of object oriented programming languages.
- Object oriented programming languages are programming languages in which program elements are viewed as objects that can pass messages to each other.
- An object includes its own data and programming code and is internally self-reliant.
- the programming code of an object includes procedures or methods.
- the methods of an object are invoked by messages received from another object.
- Each object is an instance of an object class.
- the properties of the objects in a class are defined by a class definition.
- a class definition may utilize a hierarchical class structure in which objects in the class inherit properties of a parent class in addition to properties explicitly defined for the class. This inheritance property allows objects to be reused from one program to another, facilitating the sharing of programming code between different programs.
- a programmer To write an application program in an object oriented programming language, a programmer identifies the real-world objects of a problem, the data and processing requirements of those objects, and the communications needed between the objects, and encapsulates these in class definitions. This process is simplified by taking advantage of the inheritance property of object classes by basing the class definitions to the extent possible on preexisting object classes.
- Objects are assembled in a modular fashion to create applications. Objects communicate with one another by means of messages. In order for meaningful communications to occur, the message sent from a sending object to a receiving object must be a message to which the receiving object can respond. The sending object must therefore know the type of message to which the receiving object will respond. Similarly, if the message is one that invokes a response from the receiving object, the sending object must be prepared to accept the response.
- objects are generally internally self-reliant, and can therefore be viewed as modules that can be assembled with other objects into a variety of application programs, the simple assembling of objects does not create a functional program.
- the objects must also be able to intercommunicate with each other.
- objects represent reusable code, additional code must be written to provide for the required communication between objects. For an object to communicate with a number of different objects, each of which send and receive different messages, the object must be provided with appropriate code for each of the different objects.
- FIG. 1 shows an example of the interactions between a prior art controller object 100 managing data bearing objects 105a to 105f and a graphical user interface 110.
- Graphical user interface 110 includes three kinds of user interface objects: a table object 120, two text field objects 130 and 140, respectively, and two check box objects 150 and 160, respectively. Each of these three kinds of user interface objects operates differently and responds to and generates different messages.
- Controller 100 therefore contains separate interface code for interfacing with each kind of object. Accordingly, controller 100 contains code 170 for interfacing with table objects, code 180 for interfacing with text field objects, and code 190 for interfacing with check box objects.
- Certain prior art object oriented programming environments provide user interfaces with a predefined structure. These predefined structures do not allow developers the freedom to easily assemble custom user interfaces.
- the present invention comprises a method for allowing a controlling object to interface with any number of user interface objects without requiring separate interface code for each user interface object and without restricting the user interface to certain predetermined designs.
- the present method provides objects called association objects that are interposed between a controlling object and each user interface object.
- Each kind of user interface object has a corresponding association object.
- the association object for a particular kind of user interface object contains code that allows the association object to interact with the specific kind of user interface object with which it is associated.
- Each association object also presents a standard interface to a controlling object, regardless of the kind of user interface object with which the association object is associated.
- the association object takes care of any conversion or translation that must be performed to convert a data value sent by the controlling object into an appropriate value that can be displayed by the user interface object. Accordingly, instead of requiring different interface code for each kind of user interface object used, a controlling object requires only a single block of interface code for communicating with all association objects, which in turn provide the user interface specific code needed for each kind of user interface
- FIG. 1 is a diagram of a controller object and user interface objects of the prior art.
- FIG. 2 is a diagram of a controller object and user interface objects in one embodiment of the present invention.
- FIG. 3 is a diagram of the architecture of an Enterprise Objects Framework application.
- FIG. 4 is a diagram showing the relationship between data contained in a database and data contained in dictionary and enterprise objects in one embodiment of the present invention.
- FIG. 5 is a flow chart for one embodiment of the present invention.
- FIG. 6A is a flow diagram illustrating "takeValuesFromDictionary".
- FIG. 6B is a flow diagram illustrating "findMethod".
- FIG. 6C is a flow diagram illustrating "findInstance”.
- FIG. 7A is a flow diagram illustrating "valuesForKeys".
- FIG. 7B is a flow diagram illustrating "returnMethod".
- FIG. 7C is a flow diagram illustrating "returnInstance”.
- FIG. 2 is a block diagram showing the relationship between a controlling object and user interface objects in one embodiment of the present invention.
- FIG. 2 shows a controller object 100 that manages a number of data bearing objects 105a to 105f and a user interface 110 including a table object 120, two text field objects 130 and 140, respectively, and two check box objects 150 and 160 respectively.
- Controller 100 passes data between data bearing objects 105a to 105f and the various user interface objects 120, 130, 140, 150 and 160.
- sending and receiving messages directly to and from the user interface objects as in the prior art system of FIG. 1, in the embodiment of the present invention shown in FIG.
- controller 100 communicates indirectly with the user interface objects via "association" objects 210a, 210b, 210c, 220a, 220b, 230a and 230b that are interposed between controller 100 and each of user interface objects 205a, 205b, 205c, 130, 140, 150 and 160, respectively.
- Controller 100 sends and receives messages to and from the association objects, while the association objects send and receive messages to and from the user interface objects as well as to and from controller 100.
- the association objects present a consistent interface to controller 100. Accordingly, instead of having blocks of interface code for each of the three kinds of user interface objects contained in user interface 110 (i.e. table objects, text field objects, and check box objects), controller 100 needs only a single block of interface code with which it can communicate with any association object.
- the association objects in turn take care of any conversion or translation required between messages sent and received by controller 100 and messages sent and received by the various user interface objects.
- a separate association object is utilized for each user interface object, even if there are several user interface objects of the same kind.
- separate text field association objects 220a and 220b are used for each of text field objects 130 and 140, respectively.
- separate check box association objects 230a and 230b are used for each of check box objects 150 and 160, respectively
- separate table column association objects 210a, 210b and 210c are used for each column of table 205, which in this embodiment comprises table column objects 205a, 205b and 205c, respectively.
- table 205 may comprise a single object and be associated with a single association.
- Association objects are objects provided by the present invention that can be utilized by a programmer to tie a controlling object to a variety of different kinds of user interface objects, without requiring the programmer to provide the controlling object with the code necessary to communicate with each type of user interface object.
- the controlling object need only be provided with the means to send and respond to standard messages.
- the association objects in turn take care of the message sending and receiving requirements specific to each kind of user interface object.
- the object oriented programming environment used with the embodiment of FIG. 2 is particularly suited for the development of data base application programs. However, the method of the present invention can also be used for non-data base applications.
- the association objects of the present invention are useful particularly in a programming environment that provides a selection of user interface objects to a programmer.
- the present invention adds a pre-defined association for each user interface object provided by the programming environment.
- An application programmer wishing to display data from a controlling object can easily create an appropriate user interface by selecting the desired user interface object and linking it with the controlling object using the appropriate association object for the user interface object selected.
- a programmer may also develop custom user interface objects and corresponding association objects.
- a user interface The purpose of a user interface is to display data output to a user and to accept data input from a user.
- the basic underlying process is the same: a user interface object receives data from a controlling object and displays it, in some manner, on the user interface; if a change is made by the user on the user interface, that change is transmitted to the controlling object.
- the present invention allows the controlling object to deal with these basic underlying processes, while isolating the controlling object from any more complex control requirements of particular user interface objects.
- Enterprise Objects Framework a set of tools and resources for the NEXTSTEP (TM) object oriented programming environment from NeXT Computer, Inc.
- Enterprise Objects Framework provides tools that enable program developers to design database applications that work with relational databases, that are easy to build and maintain, that communicate with other applications, and that utilize standard interface features.
- Enterprise Objects Framework is described in detail in Enterprise Objects Framework Developer's Guide (NeXT Computer, Inc., 1994) and Enterprise Objects Framework Reference (NeXT Computer, Inc., 1994), both of which are incorporated herein by reference.
- FIG. 3 The architecture and data flow of an Enterprise Objects Framework application is shown in FIG. 3.
- data flows from a relational database 300 to a user interface 360, and vice versa, via a number of intervening modules and levels.
- the flow of data from the relational database 300 to user interface 360 proceeds as follows.
- Data in the form of rows of data from relational database 300 are retrieved from relational database 300 to an adaptor level 310, using well-known relational database access techniques.
- the raw data received from relational database 300 is packaged into "dictionary objects."
- Dictionary objects contain key-value pairs: each key typically represents the name of a database column, and the key's value corresponds to the data for the column of the particular row that was read from relational database 300.
- the key-value coding protocol used in Enterprise Objects Framework is described in Appendix A hereto. This key-value coding protocol is also described in co-pending U.S. patent application Ser. No.
- Database level 320 creates "enterprise objects" from the dictionary objects.
- Enterprise objects are like other objects used in object oriented programming languages in that they couple data with methods for operating on that data. However, an enterprise object has certain characteristics that distinguish it from other object classes.
- An enterprise object has properties that map to stored data, and an instance of an enterprise object typically corresponds to a single row or record in a database. Further, an enterprise object knows how to interact with other parts of the Enterprise Object Framework to give and receive values for its properties.
- the ingredients that make up an enterprise object are its class definition and the data values for
- FIG. 3 The architecture and data flow of an Enterprise Objects Framework application is shown in FIG. 3.
- data flows from a relational database 300 to a user interface 360, and vice versa, via a number of intervening modules and levels.
- the flow of data from the relational database 300 to user interface 360 proceeds as follows.
- Data in the form of rows of data from relational database 300 are retrieved from relational database 300 to an adaptor level 310, using well-known relational database access techniques.
- the raw data received from relational database 300 is packaged into "dictionary objects."
- Dictionary objects contain key-value pairs: each key typically represents the name of a database column, and the key's value corresponds to the data for the column of the particular row that was read from relational database 300.
- the key-value coding protocol used in Enterprise Objects Framework is described in Appendix A hereto. This key-value coding protocol is also described in co-pending U.S. patent application Ser. No.
- Database level 320 creates "enterprise objects" from the dictionary objects.
- Enterprise objects are like other objects used in object oriented programming languages in that they couple data with methods for operating on that data. However, an enterprise object has certain characteristics that distinguish it from other object classes.
- An enterprise object has properties that map to stored data, and an instance of an enterprise object typically corresponds to a single row or record in a database. Further, an enterprise object knows how to interact with other parts of the Enterprise Object Framework to give and receive values for its properties.
- the ingredients that make up an enterprise object are its class definition and the data values for the row or record to which it corresponds.
- the mechanism that enables an enterprise object to exchange its values with other objects is the Key Value Coding protocol referred to above and described in Appendix A.
- the Key Value protocol also allows an object to set its values at runtime from a dictionary, as explained below.
- the methods and instance variables of the object are examined to determine if there is a match between keys in the dictionary and the object. This is accomplished by searching for the method "set (property)" where property is the column name or key in the dictionary. For example, with property named "lastName", the system looks for a method of the form “setLastName”. If there is a match, the value of the property "lastname” can be loaded into the object using the setLastName method.
- the properties of the dictionary are provided as an array. For each property, the methods of the object are examined to determine if they are of the form "property". If there is a match, the object's value for that method is returned to the dictionary. If there is no match, the instances of the object are examined. If an instance is found that matches the property, the value is returned to the dictionary.
- the method for setting values in an object is implemented by "takeValuesFromDictionary". This method is implemented on the root object of the environment so that, in a class hierarchy system, every object inherits the method.
- the default implementations of the key-value coding methods use the class definition as follows:
- the key-value coding method looks for an accessor method based on the property name. For example, with a property named lastName, take ValuesFromDictionary: looks for a method of the form setLastName: (note that the first letter of the property name is made uppercase).
- the key-value coding method doesn't find an accessor method, it looks for an instance variable whose name is the same as the property's and sets or retrieves its value directly. In setting an instance variable, takeValuesFromDictionary: retains the new value and releases the old one.
- the takeValuesFromDictionary method may be implemented as described in the pseudo code of Appendix E.
- the operation of takeValuesFromDictionary is illustrated in the flow diagrams of FIGS. 6A, 6B, and 6C.
- step 602 the argument "All key-value pairs in dictionary processed?" is made. This step checks to see if the object has been examined for all dictionary pairs. If the argument at decision block 602 is true, the system ends at step 612. That means that all dictionary pairs have been processed for the object, and thus the method is completed. If the argument at decision block 602 is false, not all pairs have been processed.
- step 604 the class description for the object is obtained and examined.
- step 606 "findMethod" is executed to determine if the object has a set method with a name that matches a property of the key-value pair. This step is illustrated in more detail in FIG. 6B.
- step 606 After findMethod has been executed at step 606, the system proceeds to decision block 608.
- decision block 608 the argument "method found?" is made. This step is to determine whether there has been a match between the methods of the object and the property of the key-value pair. If the argument at decision block 608 is true, a match has been found and the data can be loaded into the object. The routine of FIG. 6A ends at step 612. If the argument at decision block 608 is false, no methods match the property of the key-value pair and the system must then check the instances of the object. This is accomplished by invoking "findinstance" at step 610. This step is illustrated in more detail in FIG. 6C. After findinstance has been executed, the system ends at step 612.
- Step 606 of FIG. 6A "findMethod” is illustrated in more detail in FIG. 6B.
- the process “findMethod” is used to examine the methods of the object being examined to determine if its methods match the properties of the key-value pairs being processed.
- the method to be searched for is defined as being of the type "set” plus the property of the key being processed (e.g. if the property of the key-value pair is "lastName",. then the system looks for "setLastName” ).
- the class description is examined for the method that is being searched.
- the argument "method found?" is made. This is to determine if the object contains the method that is being searched. If the argument is false, findMethod ends at step 634 and returns to decision block 626 of FIG. 6A.
- the system at 628 determines the argument type for the method.
- the value of the key-value pair is converted to the argument type if necessary.
- the method with the value as argument is called to load the data value into the object.
- findMethod ends and returns to takeValuesFromDictionary of FIG. 6A.
- Step 610 of FIG. 6A "findInstance",. is illustrated in FIG. 6C.
- the methods of an object are examined first when attempting to load data. If no suitable methods are found, the instance variables are examined using "findInstance".
- the class description of the object is examined to determine if there is an instance equal to the key property of the key-value pair being processed.
- the argument "instance found?" is made. If the argument is false, that is if no instances match the property, the findinstance process ends at step 644 and returns to step 612 of FIG. 6A.
- step 646 determines the instance type.
- step 648 the storage offset of the instance in the object is determined.
- step 650 the value of the keyvalue pair being examined is converted to the object's instance type.
- step 652 the value from the key-value pair is assigned to the instance in the object using the previously determined instance offset.
- findinstance ends and returns to step 612 of FIG. 6A.
- valuesForKeys The method for loading a dictionary with values from an object is "valuesForKeys".
- the class definitions for valuesForKeys is as described above for "takeValuesForDictionary”.
- the valuesForKeys method may be implemented as described in the pseudo code of the Appendix.
- the operation of valuesForKeys is illustrated in the flow diagrams of FIGS. 7A, 7B, and 7C.
- valuesForKeys is illustrated.
- valuesForKeys When valuesForKeys is invoked, it is to take data from an object and load it into a data destination (e.g. a relational database). The properties of the keys of the key-value dictionary of the data destination are put into a key array.
- the argument "All keys in key array processed?" is made. If the argument is true, all array entries have been processed and the method is over, the process ends at step 714. If the argument is false, the next key in the key array is processed.
- the system gets the class description for the object.
- "returnMethod" is executed to determine if the object has any methods (e.g. setValue, getvalue, etc.) that match the key property. This step is illustrated in more detail in FIG. 7B.
- step 706 After returnMethod has been executed at step 706, the system returns to decision block 708.
- decision block 708 the argument "method found?" is made. This step is to determine whether their was a match between any of the methods of the object and the key property. If the argument at decision block 708 is true, a match has been found and the data can be loaded into the data destination. The process then ends at step 714. If the argument at decision block 708 is false, no methods match the key property. The system then checks the instance variables for matches. This is accomplished by invoking "returninstance" at step 710. This step is illustrated in more detail in FIG. 7C. After returninstance has been executed, the process stores the key and returned value as a key-value pair in the key-value dictionary. At step 714, valuesForKeys ends.
- Step 706 of FIG. 7A "returnMethod",. is illustrated in FIG. 7B.
- the process "returnMethod” is used to examine the methods of the object to determine if any; of its methods match the property of the key property array value being processed.
- the method to be searched for is made defined as one having the current key property.
- the class description is examined for the defined method.
- the argument "method found?" is made. If the argument is false, there is no match, returnMethod ends at step 734 and returns to valuesForKeys of FIG. 7A.
- step 728 If the argument is true, at step 728, a match has been found.
- the value type of the method is determined.
- the method is called and returns the result as value.
- the process converts the value to value type, if necessary, and the value can be loaded into the data destination.
- the process returnMethod ends at step 734.
- Step 710 of FIG. 7A "returninstance” is illustrated in FIG. 7C.
- this process is invoked only when no matching methods have been found for a key property being processed.
- the class description is examined to determine if there is an instance variable that matches the key property.
- the argument "instance found?" is made. If the argument is false, no matches have been found, the returnInstance process ends at step 752 and returns to valuesForKeys of FIG. 6A.
- the argument at decision block 744 is true, there is a match of an instance variable and the key property.
- the type of the instance variable is determined.
- the storage offset of the instance variable in the object is determined.
- the value of the instance is converted to instance type and can be loaded into key-value pair of the dictionary of the data destination.
- returninstance ends and returns to valuesForKeys of FIG. 7A.
- Data source 330 is an object that has the ability to fetch, insert, update and delete enterprise objects. Changes made by data source 330 to an enterprise object are passed down via database level 320 and adaptor level 310 to relational database 300 so that a corresponding change is made to the database for a change made to an enterprise object.
- Data source 330 supplies enterprise objects created at database level 320 to controller 340.
- controller 340 transports data in the form of values from the enterprise objects to user interface 360 via association objects 350.
- Controller 340 coordinates the values displayed in the user interface with the corresponding enterprise object values.
- controller 340 tells data source 330, which is responsible for propagating changes to relational database 300.
- Appendix B A description of the controller object class provided by Enterprise Objects Framework is attached hereto as Appendix B.
- Movement of data in the architecture shown in FIG. 3 is bi-directional. Changes made by a user to data values displayed on user interface 360 propagate to relational database 300 in the opposite direction as data from database 300 propagates to user interface 360.
- the mechanism by which data moves through an Enterprise Object Framework application is a key-value coding informal protocol.
- objects that conform to the key-value coding protocol (such as enterprise objects) have a common characteristic: their data is accessed by other objects in the form of key-value pairs.
- Key-value coding methods enable an object to receive values for its keys and to give out its keys'values to other objects.
- FIG. 4 shows how the properties in an enterprise object 420 correspond to the key-value pairs in a dictionary 410, and how both in turn correspond to a row in a relational database 400.
- Enterprise object properties and dictionary keys (such as firstname and lastname shown in FIG. 4) map to columns in the database; the value for each key (for example "Lesly” and “Oswald", respectively) matches the column's value for the corresponding row.
- User interface 360 of FIG. 3 typically contains a number of user interface objects such as pop-up lists, forms, text fields, and tables. These user interface objects display the values of keys of enterprise objects, and, if the values are edited in the user interface, communicate the changes back to the enterprise objects.
- user interface objects such as pop-up lists, forms, text fields, and tables.
- controller object 340 and association objects 350 of FIG. 3 The interface between user interface objects and related enterprise objects is provided by controller object 340 and association objects 350 of FIG. 3, which together may be viewed as an interface layer between enterprise objects and user interface objects.
- Controller 340 uses association objects to mediate between enterprise objects and user interface 360. Each association object links a single user interface object to a class property name (key) in an enterprise object or objects managed by the controller. The property (key) value is displayed in the user interface object with which the association object is linked.
- Enterprise Objects Framework provides a number of pre-defined association objects and associated user interface objects to the developer. Appendix C contains descriptions of association objects provided by Enterprise Objects Framework.
- Specific association objects provided by Enterprise Objects Framework include EOAssociation (an abstract association object class) and the subclasses EOActionCellAssociation, EOColumnAssociation; EOControlAssociation; EOImageAssociation; EOMatrixAssociation, EOPopUpAssociation; EOQualifiedAssociation; and EOTextAssociation.
- an association object ties a single user interface object (such as a text field) to a value corresponding to a key in an enterprise object or objects managed by the controller object.
- a text field may display the value "Jun-19-1992" for the key "hireDate” of enterprise object 420 of FIG. 4.
- An association object is provided with an appropriate key to enable it to obtain data from a data bearing object using a key-value coding protocol.
- a controller can set data from data bearing objects to user interface objects and retrieve data from user interface objects into data bearing objects.
- the user interface objects, association objects, and keys can be assembled without data, and be archived for later use with an application program. By using the key-value coding protocol, these objects can be assembled and configured ahead of time and made to execute at run time with no compilation.
- association objects One of the functions performed by association objects, if needed, is to convert values extracted by the controller from an enterprise object and passed to an association object to a type that can be displayed by the corresponding user interface object.
- a data source converts edited values returned to the controller from an association object to an appropriate value class that can be applied by the data source to the corresponding enterprise object.
- a controller works closely with it's association objects to ensure that values displayed in the user interface remain synchronized with the corresponding enterprise object values.
- the controller tells its association objects.
- the association object informs its controller of the change that occurred.
- FIG. 5 shows the sequence of steps that occur when the value displayed by a user interface object has changed.
- the sequence starts when a user changes the value of a displayed user interface object at block 500.
- a user may change the hire date of "Jun-19-1992" displayed in a text field object for enterprise object 420 of FIG. 4 to a new date of "Jun-19-1991" by typing the new date in the text field object displayed on the user interface.
- the user interface object sends its association object (in this embodiment there is a one-to-one correspondence between user interface objects and association objects) a message that this user initiated change has occurred.
- the association object in turn, at block 520, notifies its controller of the change by sending the controller a "associationDidEdit" message.
- An “associationDidEdit” message informs the controller that a change has occurred, but does not include the new value.
- the controller sends the notifying association object a "value" message at block 530, upon which the association object returns the new value at block 535.
- the controller After receiving the new value, the controller sends its data source a "coerceValue:forKey;” message at block 540. This message causes the data source to convert the new value received from the association object to a value class type that can be used by the corresponding enterprise object. The controller then delivers the new, converted value to the enterprise object by means of a "takeValuesFromDictionary:” message at block 550. "takeValuesFromDictionary" is a standard message that is part of the key-value coding protocol used to transfer data between objects in the Enterprise Objects Framework.
- the controller sends "updateObject:” and "saveObjects” messages to its data source at block 560.
- the data source causes the data in the database to be updated and stored to reflect the new value.
- each user interface object has a corresponding association object, and since a user interface typically has a number of user interface objects, a controller will typically be associated with a number of association objects. Further, a number of different user interface objects may display a value for the same key of an enterprise object. As a result, if a value displayed by one user interface object is changed by a user, that change may be reflected in other user interface objects. Accordingly, after the value in an enterprise object has been changed in response to a new value entered by the user, the controller sends all of its association objects "contentsDidChange" messages at block 570.
- the controller when the change in value also causes the selected enterprise object to change (a "selected" enterprise object is the current object for which values are displayed in the user interface, or, in the case where a user interface object displays values for multiple enterprise objects simultaneously, such as a table, the selected enterprise object is the object whose values are highlighted), the controller also sends all of its association objects a "selectionDidChange" message at block 580. This enables each association object to display values for the currently selected enterprise object, or highlight the values for the selected enterprise object if the user interface object associated with the association object displays values for multiple enterprise objects.
- a "contentsDidChange" message received by an association object constitutes a signal to the association object that the value displayed by its user interface object may have changed.
- each association object sends the controller a "valuesForKeys” message to obtain the current value for the key that is displayed in the association object's user interface object.
- ValuesForKeys like "takeValuesFromDictionary", is a standard message that is part of the key-value coding protocol used to transfer data between objects in the Enterprise Objects Framework.
- an association object When an association object receives the current value for its user interface object, it compares the current value with the last value that it received (which ordinarily would also be the value being displayed by its user interface object) at block 590. If the current value is different from the last value, the association object sends a message to its user interface object to update the displayed value to the new value at block 595.
- a controller in Enterprise Objects Framework uses a "endEditing" method to order its association objects to finish editing. Before a controller can perform certain operations (such as fetching, inserting a new enterprise object, or setting an undo mark) it must collect any new edits from its association objects. When the controller sends "endEditing" messages to its association objects, they finish editing, relinquish first responder status, and notify the controller of any changes with "associationDidEdit:".
- the protocol used by a controller to send notification messages to its association objects is described in Appendix D.
- Enterprise Objects Framework allows a developer to create custom user interface objects and associated custom association objects.
- the "EOAssociation" object described in Appendix C can be used by a developer as a basis for defining a custom association object.
- association objects of the present invention may communicate directly with data bearing objects.
- an association object may be associated with more than one user interface object.
- the specific messages sent and received by association objects and data bearing and data controlling objects can vary from the specific messages described herein.
- the specific steps and sequences of steps described herein may be configured by a user and may vary from one embodiment to another. Other embodiments incorporating the inventive features of the present invention will be apparent to those skilled in the art.
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Human Computer Interaction (AREA)
- Stored Programmes (AREA)
- Machine Translation (AREA)
Priority Applications (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US08/939,158 US6154786A (en) | 1994-12-07 | 1997-09-29 | Method for associating data bearing objects with user interface objects |
US09/699,676 US6513072B1 (en) | 1994-12-07 | 2000-10-30 | Method for associating data bearing objects with user interface objects |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US35352594A | 1994-12-07 | 1994-12-07 | |
US08/939,158 US6154786A (en) | 1994-12-07 | 1997-09-29 | Method for associating data bearing objects with user interface objects |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US35352594A Continuation | 1994-12-07 | 1994-12-07 |
Related Child Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/699,676 Continuation US6513072B1 (en) | 1994-12-07 | 2000-10-30 | Method for associating data bearing objects with user interface objects |
Publications (1)
Publication Number | Publication Date |
---|---|
US6154786A true US6154786A (en) | 2000-11-28 |
Family
ID=23389493
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US08/939,158 Expired - Lifetime US6154786A (en) | 1994-12-07 | 1997-09-29 | Method for associating data bearing objects with user interface objects |
US09/699,676 Expired - Lifetime US6513072B1 (en) | 1994-12-07 | 2000-10-30 | Method for associating data bearing objects with user interface objects |
Family Applications After (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/699,676 Expired - Lifetime US6513072B1 (en) | 1994-12-07 | 2000-10-30 | Method for associating data bearing objects with user interface objects |
Country Status (6)
Country | Link |
---|---|
US (2) | US6154786A (de) |
EP (1) | EP0803093B1 (de) |
AU (1) | AU4465996A (de) |
CA (1) | CA2207331C (de) |
DE (1) | DE69522713T2 (de) |
WO (1) | WO1996018147A1 (de) |
Cited By (12)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6304922B2 (en) * | 1995-09-06 | 2001-10-16 | Seiko Epson Corporation | Control system using plural objects, a programming method therefor, and a peripheral devices control system |
US6330006B1 (en) * | 1998-05-12 | 2001-12-11 | Silverstream Software, Inc. | Method and apparatus for synchronizing an application's interface and data |
US6366921B1 (en) * | 1999-02-09 | 2002-04-02 | International Business Machines Corporation | System and method for data manipulation in a dynamic object-based format |
US20020059116A1 (en) * | 2000-07-31 | 2002-05-16 | Bulatovic Marija V. | Method and system for selectively displaying advertisements on a display device |
US20030076353A1 (en) * | 2001-10-23 | 2003-04-24 | Blackstock Michael A. | Graphical user interface for collaboration |
US20030169293A1 (en) * | 2002-02-01 | 2003-09-11 | Martin Savage | Method and apparatus for designing, rendering and programming a user interface |
US20050114863A1 (en) * | 2000-10-30 | 2005-05-26 | Next Computer, Inc. | Method for associating data bearing objects with user interface objects |
US20070067365A1 (en) * | 2000-05-12 | 2007-03-22 | John Graziano | Method and apparatus for archiving and unarchiving objects |
US20070256052A1 (en) * | 2006-04-26 | 2007-11-01 | Li Xu | Automatically binding and populating a selection control with both display labels and identification values |
US7552443B2 (en) * | 2001-10-18 | 2009-06-23 | Bea Systems, Inc. | System and method for implementing an event adapter |
US20120042232A1 (en) * | 2010-08-16 | 2012-02-16 | Perfect Sense Digital Llc | Placement of Hyperlinks in Documents |
US20180267678A1 (en) * | 2017-03-14 | 2018-09-20 | Salesforce.Com, Inc. | Techniques and architectures for managing text strings to be provided by a graphical user interface |
Families Citing this family (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5999728A (en) * | 1996-07-30 | 1999-12-07 | Sun Microsystems, Inc. | Method and apparatus for enhancing the portability of an object oriented interface among multiple platforms |
US7062773B1 (en) * | 1998-07-20 | 2006-06-13 | International Business Machines Corporation | System and method for providing graphical user interface control enhancers |
EP1286261A1 (de) * | 2001-08-13 | 2003-02-26 | Alcatel | Verfahren, Bedienoberflächenmodul, Zwischenmodule sowie damit ausgestattetes Netzwerk-Management-System zur Bedienung eines Bedienoberflächenmoduls |
US6938262B2 (en) * | 2001-09-10 | 2005-08-30 | Hewlett-Packard Development Company, L.P. | Dual data representation |
JP2003186855A (ja) * | 2001-12-20 | 2003-07-04 | Fujitsu Ltd | 型照合によるオブジェクト連携システムおよび方法 |
EP1378826A1 (de) * | 2002-07-01 | 2004-01-07 | Sun Microsystems, Inc. | Filternetzwerk zur Datenvisualisierung |
US8146027B1 (en) * | 2009-05-07 | 2012-03-27 | Xilinx, Inc. | Creating interfaces for importation of modules into a circuit design |
Citations (10)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4835685A (en) * | 1985-05-06 | 1989-05-30 | Computer X, Inc. | Virtual single machine with message-like hardware interrupts and processor exceptions |
US5119475A (en) * | 1991-03-13 | 1992-06-02 | Schlumberger Technology Corporation | Object-oriented framework for menu definition |
US5163130A (en) * | 1989-10-11 | 1992-11-10 | Next Computer, Inc. | System and method for configuring a graphic interface |
US5276816A (en) * | 1990-12-31 | 1994-01-04 | International Business Machines Corporation | Icon object interface system and method |
US5280610A (en) * | 1990-08-14 | 1994-01-18 | Digital Equipment Corporation | Methods and apparatus for implementing data bases to provide object-oriented invocation of applications |
US5327529A (en) * | 1990-09-24 | 1994-07-05 | Geoworks | Process of designing user's interfaces for application programs |
US5485617A (en) * | 1993-12-13 | 1996-01-16 | Microsoft Corporation | Method and system for dynamically generating object connections |
US5551035A (en) * | 1989-06-30 | 1996-08-27 | Lucent Technologies Inc. | Method and apparatus for inter-object communication in an object-oriented program controlled system |
US5553223A (en) * | 1990-04-03 | 1996-09-03 | U S West Advanced Technologies, Inc. | Method and system of selectively transmitting display formats and data between a host computer and an intelligent terminal |
US5574918A (en) * | 1993-08-23 | 1996-11-12 | Lucent Technologies Inc. | Method and apparatus for configuring computer program from available subprograms |
-
1995
- 1995-12-07 CA CA002207331A patent/CA2207331C/en not_active Expired - Lifetime
- 1995-12-07 DE DE69522713T patent/DE69522713T2/de not_active Expired - Lifetime
- 1995-12-07 AU AU44659/96A patent/AU4465996A/en not_active Abandoned
- 1995-12-07 WO PCT/US1995/015852 patent/WO1996018147A1/en active IP Right Grant
- 1995-12-07 EP EP95943379A patent/EP0803093B1/de not_active Expired - Lifetime
-
1997
- 1997-09-29 US US08/939,158 patent/US6154786A/en not_active Expired - Lifetime
-
2000
- 2000-10-30 US US09/699,676 patent/US6513072B1/en not_active Expired - Lifetime
Patent Citations (10)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4835685A (en) * | 1985-05-06 | 1989-05-30 | Computer X, Inc. | Virtual single machine with message-like hardware interrupts and processor exceptions |
US5551035A (en) * | 1989-06-30 | 1996-08-27 | Lucent Technologies Inc. | Method and apparatus for inter-object communication in an object-oriented program controlled system |
US5163130A (en) * | 1989-10-11 | 1992-11-10 | Next Computer, Inc. | System and method for configuring a graphic interface |
US5553223A (en) * | 1990-04-03 | 1996-09-03 | U S West Advanced Technologies, Inc. | Method and system of selectively transmitting display formats and data between a host computer and an intelligent terminal |
US5280610A (en) * | 1990-08-14 | 1994-01-18 | Digital Equipment Corporation | Methods and apparatus for implementing data bases to provide object-oriented invocation of applications |
US5327529A (en) * | 1990-09-24 | 1994-07-05 | Geoworks | Process of designing user's interfaces for application programs |
US5276816A (en) * | 1990-12-31 | 1994-01-04 | International Business Machines Corporation | Icon object interface system and method |
US5119475A (en) * | 1991-03-13 | 1992-06-02 | Schlumberger Technology Corporation | Object-oriented framework for menu definition |
US5574918A (en) * | 1993-08-23 | 1996-11-12 | Lucent Technologies Inc. | Method and apparatus for configuring computer program from available subprograms |
US5485617A (en) * | 1993-12-13 | 1996-01-16 | Microsoft Corporation | Method and system for dynamically generating object connections |
Non-Patent Citations (4)
Title |
---|
"Enterprise Object Framework: Building Reusable Business Objects," NeXT Computer Publication, Jul. 1994, Redwood City, California, U.S.A., pp. 1-13. |
Enterprise Object Framework: Building Reusable Business Objects, NeXT Computer Publication, Jul. 1994, Redwood City, California, U.S.A., pp. 1 13. * |
Steve Holzner, Burkard c Programming 2 nd Edition, 1992, Brady Publishing, * |
Steve Holzner, Burkard c++ Programming 2nd Edition, 1992, Brady Publishing, |
Cited By (18)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6304922B2 (en) * | 1995-09-06 | 2001-10-16 | Seiko Epson Corporation | Control system using plural objects, a programming method therefor, and a peripheral devices control system |
US6330006B1 (en) * | 1998-05-12 | 2001-12-11 | Silverstream Software, Inc. | Method and apparatus for synchronizing an application's interface and data |
US6366921B1 (en) * | 1999-02-09 | 2002-04-02 | International Business Machines Corporation | System and method for data manipulation in a dynamic object-based format |
US20070067365A1 (en) * | 2000-05-12 | 2007-03-22 | John Graziano | Method and apparatus for archiving and unarchiving objects |
US8024295B2 (en) * | 2000-05-12 | 2011-09-20 | Apple Inc. | Method and apparatus for archiving and unarchiving objects |
US20020059116A1 (en) * | 2000-07-31 | 2002-05-16 | Bulatovic Marija V. | Method and system for selectively displaying advertisements on a display device |
US8051429B2 (en) * | 2000-10-30 | 2011-11-01 | Next Software, Inc. | Method for associating data bearing objects with user interface objects |
US20050114863A1 (en) * | 2000-10-30 | 2005-05-26 | Next Computer, Inc. | Method for associating data bearing objects with user interface objects |
US7552443B2 (en) * | 2001-10-18 | 2009-06-23 | Bea Systems, Inc. | System and method for implementing an event adapter |
US20030076353A1 (en) * | 2001-10-23 | 2003-04-24 | Blackstock Michael A. | Graphical user interface for collaboration |
US7441200B2 (en) | 2002-02-01 | 2008-10-21 | Concepts Appsgo Inc. | Method and apparatus for designing, rendering and programming a user interface |
US20030169293A1 (en) * | 2002-02-01 | 2003-09-11 | Martin Savage | Method and apparatus for designing, rendering and programming a user interface |
US7552129B2 (en) | 2006-04-26 | 2009-06-23 | International Business Machines Corporation | Automatically binding and populating a selection control with both display labels and identification values |
US20070256052A1 (en) * | 2006-04-26 | 2007-11-01 | Li Xu | Automatically binding and populating a selection control with both display labels and identification values |
US20120042232A1 (en) * | 2010-08-16 | 2012-02-16 | Perfect Sense Digital Llc | Placement of Hyperlinks in Documents |
US9697204B2 (en) * | 2010-08-16 | 2017-07-04 | Perfect Sense, Inc. | Automatic placement of hyperlinks on words and phrases in documents |
US10963520B2 (en) | 2010-08-16 | 2021-03-30 | Perfect Sense, Inc. | Automatic placement of hyperlinks on words and phrases in documents |
US20180267678A1 (en) * | 2017-03-14 | 2018-09-20 | Salesforce.Com, Inc. | Techniques and architectures for managing text strings to be provided by a graphical user interface |
Also Published As
Publication number | Publication date |
---|---|
CA2207331A1 (en) | 1996-06-13 |
AU4465996A (en) | 1996-06-26 |
DE69522713D1 (de) | 2001-10-18 |
EP0803093A1 (de) | 1997-10-29 |
EP0803093B1 (de) | 2001-09-12 |
US6513072B1 (en) | 2003-01-28 |
WO1996018147A1 (en) | 1996-06-13 |
DE69522713T2 (de) | 2002-07-04 |
CA2207331C (en) | 2003-02-25 |
EP0803093A4 (de) | 1998-04-01 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6154786A (en) | Method for associating data bearing objects with user interface objects | |
US5950190A (en) | Dynamic, self-modifying graphical user interface for relational database applications | |
US5630126A (en) | Systems and methods for integrating computations into compound documents | |
US5832268A (en) | System and method for supporting complex objects in an object oriented computing environment | |
US5732263A (en) | Systems, methods and computer program products for generating and validating user defined object classes in an object oriented programming environment after build time | |
US6704743B1 (en) | Selective inheritance of object parameters in object-oriented computer environment | |
US6044216A (en) | Method and apparatus for implementing cursor variables for accessing data from database | |
US6158044A (en) | Proposal based architecture system | |
US6035300A (en) | Method and apparatus for generating a user interface from the entity/attribute/relationship model of a database | |
US6633869B1 (en) | Managing object relationships using an object repository | |
US7013312B2 (en) | Web-based strategic client planning system for end-user creation of queries, reports and database updates | |
US6305008B1 (en) | Automatic statement completion | |
US6820268B2 (en) | Method for associating data bearing objects with user interface objects | |
US6938041B1 (en) | Java-based data access object | |
US7334216B2 (en) | Method and apparatus for automatic generation of information system user interfaces | |
US7165073B2 (en) | Dynamic, hierarchical data exchange system | |
US5937409A (en) | Integrating relational databases in an object oriented environment | |
US6678889B1 (en) | Systems, methods and computer program products for locating resources within an XML document defining a console for managing multiple application programs | |
US7810102B2 (en) | Service adaptation of the enterprise services framework | |
US8667508B2 (en) | Method for providing stand-in objects | |
US6567819B1 (en) | Run time objects | |
CN101617292A (zh) | 面向生成器图形的编程和执行 | |
US7685155B2 (en) | System and method of providing and utilizing an object schema to facilitate mapping between disparate domains | |
US7512899B1 (en) | Method and apparatus for a unified user interface | |
Codasyl Systems Committee | Introduction to “feature analysis of generalized data base management systems” |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
FEPP | Fee payment procedure |
Free format text: PAYOR NUMBER ASSIGNED (ORIGINAL EVENT CODE: ASPN); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
FPAY | Fee payment |
Year of fee payment: 4 |
|
FPAY | Fee payment |
Year of fee payment: 8 |
|
FPAY | Fee payment |
Year of fee payment: 12 |