Run time object layout model with object type that differs from the derived object type in the class structure at design time and the ability to store the optimized run time object layout model

• US 6,263,492 B1
• Filed: 06/06/1997
• Issued: 07/17/2001
• Est. Priority Date: 06/06/1997
• Status: Expired due to Term

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Halcoussis, Michael, Zimmerman, Christopher Alan, Hodges, C. Douglas, Burd, Gary S., Fraley, Christopher Lee, Carter, Alan W., Wiltamuth, Scott Michael
• Primary Examiner(s): Hafiz, Tariq R.
• Assistant Examiner(s): INGBERG, TODD D
• Application Number:
  US08/870,171
• Time in Patent Office: 1,502 Days
• Field of Search: 395/701, 395/702, 395/703, 395/683, 707/103, 709/303, 717/5, 717/6, 717/9
• US Class Current: 717/107
• CPC Class Codes: G06F 9/4493 Object persistence
• CPC Class Codes: G06F 9/543 User-generated data transfer, e.g. clipboards, dynamic data exchange [DDE], object linking and embedding [OLE]
• CPC Class Codes: Y10S 707/99945 Object-oriented database structure processing
• CPC Class Codes: Y10S 707/99948 Application of database or data structure, e.g. distributed, multimedia, or image

Abstract

A componentizing object designer is used to define a componentization of visual forms and other object-oriented technologies. The componentized object designer includes a set of tightly integrated protocols enabling Component Object Model (COM) objects to replace standard built-in visual form and other objects. The componentized object designer allows the design-time object and the run-time object to differ in implementation. The componentized object designer allows class identifiers for the run-time objects which are different than design-time objects. With a different class identifier, the run-time object can be saved as an object which is radically different from the design-time object. This enables the run-time object to be stored in a different object library than the design-time object. The componentized object designer allows for different persistence formats to be saved for run-time objects. The persistence formats for the run-time objects can be significantly smaller in size compared to the original design-time objects. This is important when the run-time object needs to be downloaded over a computer network like the Internet or an intranet.

Claims

1. In a computer system with an object-oriented programming environment having a componentized object designer for designing objects, a method of designing a run-time object for a software application based upon a design-time object that includes customizable dynamic type information, the method comprising:

creating with the componentized object designer a design-time object, the design-time object including dynamic type information;

creating with the design-time object a plurality of application specific objects, wherein the dynamic type information changes in response to the creation of the plurality of application specific objects;

manipulating with the design-time object the plurality of application specific objects, wherein the dynamic type information changes in response to the manipulation; and

designing a run-time object based upon the design-time object and the plurality of application specific objects, wherein the run-time object includes the changed dynamic type information.

2. A computer-readable storage medium having stored therein instructions for causing a computer to perform the method of claim 1.

3. The method of claim 1 wherein the designing a run-time object includes optimizing the layout of said run-time object to maximize the performance of said run-time object when it is executed on the computer.

4. The method of claim 3 wherein optimizing includes optimizing the layout of data used to store said run-time object in a run-time object persistence state.

5. The method of claim 1 wherein the designing a run-time object includes designing said run-time object to include a visual user interface.

6. The method of claim 1 wherein the designing a run-time object includes designing said run-time object to lack a visual user interface.

7. The method of claim 1 wherein the componentized object designer is an extended componentized object designer.

8. The method of claim 1 further comprising:

saving the design-time object in a design-time object persistence state; and

saving the run-time object in a run-time object persistence state, the run-time object persistence state including object data for only selected ones of the plurality of application specific objects created by the design-time object and less than all of the plurality of application specific objects.

9. The method of claim 1 wherein the designing a run-time object includes designing said run-time object with part of the design-time object, but less than the entire design-time object.

10. The method of claim 1 wherein the design-time object and run-time object include graphical object form data which is used to display graphical forms for a user on a display device coupled to the computer.

11. In a computer system having a first object-oriented programming environment including a first componentized object designer, and a second object-oriented programming environment including a second componentized object designer a method of creating a componentized run-time object that includes objects that are native to and objects that are non-native to the first object-oriented programming environment, the method comprising:

creating with the first object designer a first run-time object including a first set of objects, the first set of objects being native to the first object-oriented programming environment;

creating with the second object designer a second set of objects, the second set of objects being non-native to the first object-oriented programming environment;

replacing selected ones in the first set of objects in the first run-time object with objects from the second set of objects;

saving the first run-time object as a modified run-time object, the modified run-time object including one or more objects that are native to the first object-oriented programming environment, the modified run-time object further including one or more objects that are non-native to the first object-oriented programming environment.

12. A computer readable medium having stored therein instructions for causing a computer to perform the method of claim 11.

13. The method of claim 11 further comprising:

executing the modified run-time object on the computer system using either the first or second object-oriented programming environment.

14. The method of claim 11 further comprising:

creating a first design-time object with the first object designer including a third set of objects, the third set of objects being native to the first object-oriented programming environment;

creating a fourth set of objects with the second object designer, the fourth set of objects being non-native to the first object-oriented programming environment;

replacing selected ones in the third set of objects in the first design-time object with objects from the fourth set of objects;

saving the first design-time object as a modified design-time object, the modified design-time object including one or more objects that are native to the first object-oriented programming environment, the modified design-time object further including one or more objects that are non-native to the first object-oriented programming environment.

15. The method of claim 14 wherein the modified design-time object is capable of being executed on the computer system using either the first or second object-oriented programming environment.

16. In a computer system with an object-designer capable of creating objects with one or more object-oriented programming models, an object-oriented data structure in memory of the computer system which provides access to a run-time object, the object-oriented data structure including an object-oriented interface with a plurality of object interface members usable by one or more of the objects to manipulate the run-time object, the object-oriented data structure comprising:

an object-oriented interface member for returning an extensibility object of an object designer;

an object-oriented interface member for returning an object class identifier for a run-time object;

an object-oriented interface member for returning status flags of a run-time object;

an object-oriented interface member for identifying an object persistence interface supported by an object-designer for saving data either to a pre-determined file format or to be consumed by a run-time object;

an object-oriented interface member for saving object information necessary to create a run-time object; and

an object-oriented interface member for returning dynamic object type information which describes a run-time object.

17. A componentized object designer apparatus comprising:

program storage and execution means;

object designer means for creating a design-time object, the object designer means supporting design-time object functionality;

means for creating objects with the design-time object; and

one or more run-time object class means for creating run-time objects based upon the design-time object, each of the one or more run-time object class means supporting only part of the design-time object functionality to decrease run-time object size.

18. The apparatus of claim 17 wherein the object designer means includes:

means for interfacing with object services;

means for creating new objects; and

means for interfacing with new created objects.

19. In a computer system with an object-oriented programming environment having a componentized object designer for designing objects, a method of designing run-time files for a software application, the method comprising:

creating with the componentized object designer a design-time object;

loading design-time object information from persistent storage, the design-time object information in an object designer persistence format;

creating with the design-time object a plurality of application specific objects for a software application;

manipulating with the design-time object the plurality of application specific objects; and

based upon the design time object and the plurality of application specific objects, creating a run-time file in a persistence format other than the object designer persistence format, the run-time file usable by an application program other than the componentized object designer.

20. A computer-readable storage medium having stored therein instructions for causing a computer to perform the method of claim 19.

21. The method of claim 19 further comprising:

upon receiving a selection input from an application program other than the componentized object designer, providing a run-time file based on the selection input and in a persistence format usable by the application program.

22. In a computer system, a method for designing a run-time object of a run-time object class for a software application, the method comprising:

creating a design-time object of a design-time object class, the design-time object including persistable data, the design-time object class supporting design-time object functionality;

storing the persistable data in a persistence state for loading by a run-time object;

designating a run-time object class for the run-time object, the run-time object class differing from the design-time object class, wherein the run-time object class supports only part of the design-time object functionality, thereby decreasing run-time object size.

23. The method of claim 22 further comprising:

providing an object designer that includes the design-time object class and the run-time object class.

24. The method of claim 22 wherein the persistable data includes dynamic type information, the method further comprising:

after creating the design-time object, changing the dynamic type information.

25. The method of claim 22 wherein storing the persistable data comprises:

storing the persistable data in a format that differs from a design-time object format.

26. A computer-readable storage medium having stored therein instructions for causing a computer to perform the method of claim 22.

27. A computer-readable medium having stored therein instructions for performing a method of reducing the size of a run-time object by eliminating persistently stored type information that is unnecessary at run-time, the persistently stored type information included in a design-time object upon which the run-time object is based, the method comprising:

creating a design-time object;

loading from persistent storage type information for the design-time object, the loaded type information providing a design-time object type information state;

removing type information from the loaded type information to reduce run-time object size;

storing in persistent storage remaining type information for loading by a run-time object, the remaining type information comprising a run-time object type information state.

28. In a computer system, a method of designing a run-time object for a software application based upon a design-time object that includes customizable dynamic type information, the method comprising:

instantiating a design-time object of a design-time object class, the design-time object including dynamic type information;

during the lifetime of the design-time object, changing said dynamic type information to customize for a software application said dynamic type information;

designing a run-time object for the software application, the run-time object including said changed dynamic type information.

29. A computer-readable storage medium having stored therein instructions for causing a computer to perform the method of claim 28.

30. The method of claim 28 wherein said dynamic type information includes one or more object properties.

31. The method of claim 28 wherein said dynamic type information includes one or more object methods.

32. The method of claim 28 wherein said dynamic type information includes one or more object events.

33. The method of claim 28 wherein the designing a run-time object includes altering layout of said run-time object to improve performance of said run-time object when executed.

34. The method of claim 28 further comprising:

saving portions of said dynamic type information in a run-time object persistence state, the portions consisting of part of said dynamic type information.

35. A computer-readable medium having stored thereon instructions for performing a method of designating at design time a run-time object class for a software application, the run-time object class supporting only part of a design-time object functionality, the method comprising:

providing an object designer that includes a design-time object class and one or more run-time object classes;

creating a design-time object of the design-time object class, the design-time object class supporting design-time object functionality;

designating a run-time object class from among the one or more run-time object classes, the designated run-time object class supporting only part of the design-time object functionality, thereby decreasing run-time object size for the software application.

36. The computer-readable medium of claim 35 wherein the design-time object class includes a set of methods, and wherein the designated run-time object class includes only part of the set of methods.

37. The computer-readable medium of claim 35 wherein the design-time object class includes a set of properties, and wherein the designated run-time object class includes only part of the set of properties.

38. The computer-readable medium of claim 35 wherein the design-time object class supports a visual user interface, and wherein the designated run-time object class does not support the visual user interface.