Method and system for in-place interaction with contained objects

Abstract

A computer method and system for interacting with a containee object contained within a container object. In a preferred embodiment of the present invention, the container object has a container application with a container window environment that has container resources for interacting with the container object. The containee object has a server application with a server window environment with server resources for interacting with the containee object. The method of the present invention displays the container window environment on a display device. A user then selects the containee object. In response to selecting the containee object, the method integrates a plurality of the server resources with the displayed container window environment. When a user then selects a server resource, the method invokes the server application to process the server resource selection. Conversely, when a user selects a container resource, the method invokes the container application to process the container resource selection.

Claims

We claim:

1. A method in a computer system of activating a containee object contained within a container object, the computer system having an operating system fox scheduling execution of code, the container object having container application code with a container window environment with container resources for interacting with the container object, the cornsince object having server application code with server resources for interacting with the containee object, the method comprising the steps of:

executing the container application code as a separately scheduled entity of the operating system;

under control of rite separately executing container application code,

displaying the container window environment; and

displaying the containee object wiflfin the displayed container window enviromnent;

activating the containee object;

integrating and displaying a plurality of the server resources of the server application code with the container resources of the displayed container window enviroment, the server application code being separately schedulable by the operating system;

when a user selects a resource from among the integrated resources, determining whether to invoke the container application code or the server application code; and

when the selected resource is a server resource, executing the server application code as a separately scheduled entity to process the server resource selection.

2. The method of claim 1, the container application code having container menus allocated and managed by the container application code and the server application code having server menus allocated and managed by the server application code, and wherein the step of integrating and displaying a plurality of server resources comprises the substeps of:

generating a composite menu bar; and

storing a server menu and a container menu in the generated composite menu bar.

3. The method of claim 2 wherein the step of storing interleaves server menus and container menus in the composite menu bar.

4. The method of claim 2, the container window having a menu bar for displaying a plurality of menus and wherein the composite menu bar is displayed as the menu bar of the container window.

5. The method of claim 1 wherein the step of activating the containee object further comprises the steps of:

selecting the containee object; and

specifying an operation to be performed on the containee object.

6. A method in a computer system of interacting with a containee object contained within a container object, the computer system having an operating system for scheduling and executing code, the container object having container application code with a container window enviromnent, the containee object having server application code with server resources for interacting with the containee object, the method comprising the steps of:

executing the container application code as a separately scheduled entity of the operating system;

displaying the container window environment, the container window environment having container resources for interacting with the container object;

activating the containee object within the container window environment;

integrating and displaying a plurality of the server resources within the container window environment, the server resources being part of the server application code, the server application code being separately schedulable by the operating system;

in response to selection of a server resource from among the integrated is server resources, invoking the server application code as a separately scheduled entity to process the server resource selection; and

in response to selection of a container resource from the displayed container window environment, invoking the container application code to process the container resource selection.

7. The method of claim 6, the container application code having a window within the displayed container window environment for displaying data and further comprising the step of, under control of the server application code, negotiating with the container application code to place server resources within the window.

8. The method of claim 6 wherein the step of integrating and displaying the plurality of server resources within the container window environment is performed without the container application code knowing, in advance or at the time of displaying, what server resources are to be displayed.

9. The method of claim 6 wherein the container application code and the server application code execute as separate threads in a single computer process.

10. The method of claim 6, further comprising the step of, after integating the plurality of the server resources, displaying the containee object within the container window environment with highlighting to indicate that server resources are available for user selection.

11. The method of claim 6, the container application code having a container message handler for receiving and processing messages and the server application code having a server message handler for receiving and processing messages, the container object having a current message handler for receiving and processing messages, the current message handler initially set to the container message handler, wherein the step of integrating and displaying the plurality of server resources further comprises setting the current message handler of the container object to a special message handler that sends container resource selection messages to the container message handler when a container resource is selected and that sends server resource selection messages to the server message handler when a server resource is selected.

12. The method of claim 6, the container window environment having a window and the server application code having a server window environment with a window, and including the steps of:

designating the server window environment window as having input focus for receiving user input;

receiving a menu command from a user; and

in response to receiving the menu command,

designating the container window environment window as having input focus for receiving user input;

receiving a menu mnemonic; and

in response to receiving the menu nmemonic, redesignating the server window environment window as having input focus for receiving user input.

13. The method of claim 12 where the container window environment window is an application frame window.

14. The method of claim 6, the computer system having a keyboard for inputting keys, the container application code having a plurality of accelerator key combinations for selecting container resources, the server application code having a plurality of accelerator key combinations for selecting server resources, and further comprising the step of, upon the container application code receiving an accelerator key combination, invoking the separately scheduled server application code to determine whether a server resource is selected.

15. A method in a computer system of interacting with a containee object contained within a container object, the computer system having an operating system for scheduling execution of code, the container object having associated container application code with a plurality of container menus, the container application code having an associated menu bar for displaying a list of menus, the containee object having associated server application code with a plurality of server menus, the method comprising the steps of:

generating a composite menu list that includes a container menu and a server menu;

displaying the composite menu list in the menu bar;

in response to selection of a displayed container menu, invoking the container application code as a separately scheduled entity of the operating system to process the selected container menu; and

in response to selection of a displayed server menu, invoking the server application code as a separately scheduled entity of the operating system to process the selected server menu.

16. A method in a computer system for integrating menus from a plurality of applications executed as separately scheduled entities of an operating system, the method comprising the steps of:

executing each of the plurality of applications as a seperately scheduled entity:

specifying a set of menu groups for each executing application, each menu group having a plurality of menu items;

combining the specified menu groups from the plurality of executing applications into a composite menu;

displaying the composite menu on a display device;

selecting a menu item of a menu group of the displayed composite menu; and

invoking the executing application that defines the menu group of the selected menu item.

17. The method of claim 16 wherein the plurality of separately scheduled applications includes a container application and a server application and wherein the step of displaying the composite menu displays the composite menu as a menu of the container application.

18. A computer system for activating a coatsinee object contained within a container object, the computer system having an operating system for scheduling execution of code, the container object having container application code with a container window environment with container resources for interacting with the container object file containce object having server application code with server resources for interacting with the containee object, the system comprising:

means for displaying the container window environment;

means for displaying the containee object within the displayed container window environment;

means for activating the containee object within the displayed container window enviromnent;

means for integrating and displaying a plurality of file server resources with the container resources of the displayed container window environment;

means for determining whether to execute the container application code or the server application code when a resource is selected from among the integrated and displayed server resources; and

means for executing the server application as a separately scheduled entity of the operating system when a server resource is the selected resource, and for processing the server resource selection.

19. The system of claim 18, the container application code having container menus allocated and managed by the container application code and the server application code having server menus allocated and managed by the server application code, and wherein the integrating and displaying means includes means for generating a composite menu bar and storing a server menu and a container menu within the composite menu bar.

20. The system of claim 19 wherein the generating and storing means includes means for interleaving server menus and container menus in the composite menu bar.

21. The method of claim 19 wherein the container window environment has a menu bar that displays a plurality of menus and wherein the composite menu bar is displayed as the menu bar of the container window environment.

22. The system of claim 18 wherein the means for activating selects the containee object and specified an operation to be performed on the containee object.

23. A computer system for interacting with a containee object contained within a container object, the computer system having an operating system for scheduling execution of code, the container object having container application code with a container window environment, the containee object having server application code with server resources for interacting with the containee object, the system comprising:

means for executin the container application code as a separate scheduled entity of the operating system:

means for displaying the container window environment on a display device, the container windown environment having container resources for interacting with the container object;

means for activating the containee object within the displayed container window environment;

means for integrating and displaying a plurality of the server resources of the server application code within the container window enviromnent when the containee object is activated;

means for selecting a server resource from among the integrated and displayed server resources;

means for executing the server application as a separate scheduled entity of the operating system and for invoking the executing server application to process the server resource selection when a server resource is selected;

means for selecting a container resource from among the integrated and displayed server resources; and

means for invoking the executing container application code to process the container resource selection when a container resource is selected.

24. The system of claim 23, the container application code having a window within the container window environment for displaying data and wherein the integrating and displaying means includes means for negotiating with the container application code to place server resources within the window.

25. The system of claim 23, wherein the means for integrating and displaying the plurality of the server resources within the container window environment is accomplished without the container application code knowing, in advance or at the time of displaying, what server resources are to be displayed.

26. The system of claim 23 wherein the container application code and the server application code execute as separate threads in a single computer process.

27. The system of claim 23, further comprising means for displaying the containee object within the container window environment with highlighting to indicate that server resources are available for user selection.

28. The system of claim 23, the computer system including a keyboard for inputting keys, the container application code having a plurality of accelerator key combinations for selecting container resources, the server application code having a plurality of accelerator key combinations for selecting server resources, and including means for invoking the server application code as a separate executed entity to determine if a server resource is selected upon receiving an accelerator key combination.

29. A method in a computer system for activating a containee object contained within a container object, the computer system having an operating system for scheduling execution of code and having a window system for displaying windows and for receiving user input, the computer system having an indicator for choosing an object, the container object having container application code with a container window environment with container resources for interacting with the container object, the containee object having server application code wih server resources for interacting with the containee object, the method comprising the computer-implemented steps of:

to executing the container application code as a separately scheduled entity of the operating system;

displaying fire container window environment;

executing the server application code as a separately scheduled entity of the operating system;

displaying the containee object integrated within the displayed container window environment;

in response to a user mnoving the indicator over the displayed containee object, under control of the window system, generating an input event ands, under control of the window system, sending notification of the input event directly to the executing server application code; and

in response to indicating an action to perform on the containee object, integrating the server resources of axe setvet application code into container resources of the displayed container window environment such that, when a user selects a server resource from amongst the integrated server resources, the executing server application code processes the server resource selection.

30. The method of claim 29, wherein the indicator is controlled by a computer morose, and wherein the step of integrating the server resources of the server application code occurs in response to a mouse button up event.

31. A method in a coinpater system for interacting with a non-native data object, the computer system having an operating system for scheduling execution of code and having a window system for displaying windows and for receiving user input and having an indicator for choosing a data object, the computer system having a container object for containing the non-native data object and for containing a native data object, the container object having container application code with a container window envirnment for interacting with the container object and the native data object, the non-native data object having server application code for interacting with the non-native data object, the method comprising the computer-implemented steps of:

executing the container application code and the server application code as two separately scheduled entities of the operating system;

displaying the container window environment;

displaying the native data object integrated within the displayed is container window environment;

displaying the non-native data object integrated within tile displayed container window environment wherein, from the perspective of a user, initiating interaction with the non-native data object is substantially similar to initiating interaction with the native data object;

in response to the user moving the indicator over the displayed native data object, under control of the window system, generating a first input event and, under control of the window system sending tile first input event directly to the executing nontamer application code; and

in response to the user moving the indicator over the displayed non-native data object, under control of the window system, generating a second input event and, under control of the window system, sending notification of the second input event directly to the executing server application code.

32. The method of claim 30, wherein the server application code has user interface resources for interacting with the non-native data object, and wherein the method further comprises the step of, in response to indicating an action to perform on the non-native data object, integrating the user interface resources of the server application code into the displayed container window environment such that, when a user selects a user interface resource, the scheduled and executing server application code processes the user intexface resource selection.

33. The method of claim 32, wherein the indicator is controlled by a computer mouse, and wherein the step of integrating the user interface resources of the server application code occurs in response to a single mouse click.

34. The method of claim 32, wherein the container application code has user interface resources for interacting with the native data object, and wherein the method further comprises the steps of:

in response to indicating an action to perform on the native data object, removing the integrated user interface resources of the executing server application code from the displayed container window environment; and

after removing the integrated user interface resources of the server application code, displaying the user interface resources of the executing container application code.

35. The method of claim 34, wherein the method further comprises the step of, after displaying the user interface resources of the separately scheduled and executing container application code, in response to indicating an action to perform on the non-native data object, generating a third input event and sending the third input event directly to the separately scheduled and executing server application code.

36. A method in a computer system for interacting with a containee object contained within a container object, the computer system having an operating system for scheduling execution of code and having a window system for displaying windows and for receiving user input and having an indicator for choosing an object, the container object having container application code with a container window environment with container resources for interacting with the container object, the containee object having server application code with server resources for interacting with the containee object, the method comprising the computer-implemented steps of:

executing the container application code as a separately scheduled entity of the operating system;

displaying the container window environment;

executing tim server application code as a separately scheduled entity of the operating system;

displaying the containee object integrated within the displayed container window environment;

in response to a user moving the indicator over the displayed containee object, under control of the window system, generating an input event and, under control of the window system, sending notification of the input event directly to the separately scheduled and executing server application code;

in response to indicating an action to perform on rite containee object, integrating the server resources of the server application code into the container resources of the displayed container window environment, wherein, when a user selects a server resource from amongst the integrated server resources, the separately scheduled and executing server application processes the server resource selection; and

in response to indicating an action to perform on the container object, removing the integrated server resources from being integrated inlo the container resources of the displayed container window environment.

37. A method in a computer system for activating a plurality of containee objects within a container object, the computer system having an operating system for scheduling execution of code and having a window system for displaying windows and for receiving user input, the computer system having an indicator for choosing an object, the container object having container application code with a container window environment for interacting with the container object, each of the phrality of containee objects having server application code for interacting with the containee object, the method comprising the computer-implemented steps of:

executing the container application code as a separately scheduled entity of the operating system;

displaying the container window enviromnent;

displaying a first containee object integrated within the displayed container window environment;

displaying a second containee object within the displayed container window environment;

executing the server application code of the first containee object as a separately scheduled entity;

in response to a user moving the indicator over the displayed first containee object, under control of the window system, generating a first input event and, under control of the windows system, sending notification of the first input event directly to the executing server application code of the first containee object;

executing the server application code of the second containee object as a separately scheduled entity; and

in response to a user moving the indicator over axe displayed second containee object, under control of the window system, generating a second input event and, under control of the window system, sending notification of the second input event directly to the executing server application code of the second containee object.

38. The method of claim 37, wherein each of the plurality of containee objects has user interface resources for interacting with the containee object, and wherein the method further comprises the steps of:

in response to indicating an action to perform on the first eontainee object, integrating the user interface resources of the first containee object into the displayed container window environment;

in response to indicating an action to perform on the second containee object, removing the integrated user interface resources of the first containee object from the displayed container window environment; and

after removing the integrated user interface resources of the first containee object, integrating the user interface resources of the second containee object into the displayed container window environment.

39. The method of claim 38, further comprising the steps of:

after integrating the user interface resources of the first containee object, displaying the integrated user interface resources; and

after integrating the user interface resources of the second containee object, displaying the integrated user interface resources.

40. A method in a computer system for activating an inside-out activation style containee object within a container object, the container object having container application code that manages a container window environment with container resources, the inside-out activation style containee object having an inside-out window for receiving user input-and having server application code for interacting with the containee object, the server application code having user interface resources for interacting with the containee object, the computer system having an indicator for choosing an object, having an operating system for scheduling execution of code, and having a window system for displaying windows and for receiving user input, the method comprising the computer-implemented steps of:

executing the container application code as a separate executable entity of the operating system;

displaying the container window environment;

displaying the inside-out activation style containee object integrated within the container window enviromnent, wherein the inside-out window is displayed;

in response to a user moving the indicator over the displayed inside-out window, cxecutixtg the server application code as a separate executable entity of the operating system and, under control of the window system, generating an input event and sending notification of the input event directly to the separately executing server application code;

in response to selecting the displayed inside-out window, integrating the user interface resources of the server application code into the container resources of the container window environment; and

in response to selecting a user interface resource of the server application code from amongst the integrated user interface resources, under control of the separately executing the server application code processing the selected user interface resource.

41. A method in a computer system for activating an inside-out activation style containee object and an outside-in activation style containee object within a container object, the container object having a container window environment, the inside-out activation style containce objcct having an inside-out window for receiving user input and having corresponding server application code for interacting with the containee object, the outside-in activation style containee object having an outside-in window for receiving user input and having corresponding server application code for interacting with the containce object, each server application code having user interface resources for interacting with the corresponding containee object, the cornpurer system having an indicator for choosing an object, having an operating system for scheduling execution of code, and having a window system for displaying windows and for receiving user input, the method comprising the computer-implemented steps of:

executing the container application code as a separate executable entity of the operating system;

displaying the container window environment;

displaying the inside-out activation style containee object integrated within the container window environment, wherein the inside-out window is displayed;

displaying the outside-in activation sWle containee object integrated within the container window environment without displaying the outside-in window;

upon selection of the outside-in activation style containee object, displaying the outside-in window;

executing the server application code of the outside-in activation style containee object as a separate executable entity of the operating system;

executing the server application code of the inside-out activation style containee object as a separate executable entity of the operating system;

in response to a user moving the indicator over the displayed outside-in window, under control of the window system, generating a first input event and sending notification of the first input event directly to the separately executing server application code corresponding to the outside-in activation style containee object; and

in response to a user moving the indicator over the displayed inside-out window, under control of the window system, generating a second input event and sending notification of the second input event directly to the separately executing server application code corresponding to the inside-out activation style containee object.

42. The method of claim 41, the method further comprising the step of, after displaying the outside-in window, upon selection of an object other than the outside-in activation style containee object, removing the outside-in window from the display.

43. A computer system for activating a containee object contained within a container object, the container object having container application code with a container window for interacting with the container object, the containee object having server application code with user interface resources for interacting with the containee object, the computer system comprising:

an indicator for choosing an object;

an operating systems for starting execution of the container application code as a separately schedduled entity and for starting execution of the server application code as a separately scheduled entity;

a window system that displays axe container window environment and that displays the eontainee object integrated within the displayed container window environment;

an input event generating mid handling mechanism, flint in response to moving the indicator over the displayed containee object, generates an input event, directs the operating system to start execution of the container application code and the server application code, and sends notification of the input event directly to the executing server application code; and

a resource integration mechanism, that in response to indicating an action to perform on the coatsince object, integrates the user interface resources of the server application code into the displayed container window environment such that, when a user selects a user interface resource from amongst the integrarod user interface resource, the separately scheduled and executing server application code processes the user interface resource selection.

44. The computer system of claim 43, wherein the indicator is controlled by a computer mouse, and wherein the resource integration mechanism is responsive to a mouse button up event.

45. A computer system for interacting with a non-native data object and a native data object, the non-native data object having server application code for interacting with the non-native data object, the computer system comprising:

a container object that contains the non-native data object and contains the native data object, the eontainer object having container application code with a container window environment for interacting with the container object and the native data object;

an indicator for choosing an object;

an operating system for starting execution of the container application code and the server application code as separate executable entities, each separate executable entity being a process or a thread;

a window system that displays the container window environment, that displays the native data object integrated within the displayed container window environment, and that displays file non-native data object integrated within the displayed container window environment such that, from the perspective of a user, initiating interaction with the non-native data object is substantially similar to initiating interaction with the nativc data object even though the native data object and the non-native data object are managed by two separately executing application code entities;

an input event generating and handling mechtanism, that in response to moving the indicator over the displayed native data object, generates a first input event and sends notification of the first input event directly to the separately executing container application code; and

an input event generating and handling mechanism, that in response to moving the indicator over the displayed non-native data object generates a second input event and sends notification of the second input event directly to the separately executing server application code.

46. The computer system of claim 45, wherein the server application code has user interface resources for interacting with the non-native data object, the system further including a resource integration mechanism, that in response to indicating an action to perform on the containee object, integrates the user interface resources of the server application code, into the displayed container window environment such that when a user selects a user interface resource from amongst the integrated user interface resources, the separately executing server application code processes the user interface resource selection.

47. A method in a computer system of activating a containee object contained within a container object, the container object having a container application with a container window environment, the container window environment having container resources for interacting with the container object, the containee object having a server application with server resources for interacting with the containee object, the method comprising the steps of:

executing the container application as a separate executable entity of an operating system;

under control of the container application,

displaying the container window environment;

displaying the containee object integrated within the displayed container window environment;

selecting the containee object; and

in response to selecting the containee object, executing the server application as a separate executable entity of the operating system;

under control of the separately executing server application,

indicating the server resources to the container application;

under control of the container application,

integrating the indicated server resources within the displayed container window environment; and

in response to selection of a server resource front the integrated server resources, sending to the separately executing server application all indication that the server resource is selected; and

under control of the server application, performing a behavior associated with the selected server resource.

48. A method in a computer system of activating a containee object contained witfin a container object, the computer system having an operating system for scheduling and executing code, the container object having container application code implemented as a separately schedulable and executable application program and having a container window environment with container resources, the containee object having associated server application code implemented as a loadable code module which is loadable into a memory address space of a separately schedulable and executable application program, the server application code having server resources for interacting with the containee object, the containee object having a class identifier for identifying tile server application code, the method comprising the computer implemented steps of:

executing the container application code as a separately scheduled program with a memory address space;

displaying the container window enviromnent;

displaying the containee object integrated within the displayed container window enviromnent;

selecting the containee object;

in response to selection of the containee object,

determining the class identifier of the containee object;

based upon the determined class identifier, determining from a persistent registry the associated server application code;

loading the determined server application code into the memory address space of the container application code;

under control of the loaded server application code, determining a plurality of server resources; and

integrating and displaying the plurality of the server resources of the loaded server application code into the container resources of the displayed container window environment, without the container application code knowing what server resources are being integrated and displayed; and

in response to selection of a scarer resource from among the integrated and displayed server resources, executing the server application code to process the server resource selection.

Description

TECHNICAL FIELD

This invention relates generally to a computer method and system for interacting with linked and embedded objects and, more specifically, to a method and system for editing and otherwise interacting with a contained object within the context of its container application.

BACKGROUND OF THE INVENTION

Current document processing computer systems allow a user to prepare compound documents. A compound document is a document that contains information in various formats. For example, a compound document may contain data in text format, chart format, numerical format, etc. FIG. 1 is an example of a compound document. In this example, the compound document 101 is generated as a report for a certain manufacturing project. The compound document 101 contains scheduling data 102, which is presented in chart format; budgeting data 103, which is presented in spreadsheet format; and explanatory data 104, which is presented in text format. In typical prior systems, a user generates the scheduling data 102 using a project management computer program and the budgeting data 103 using a spreadsheet computer program. After this data has been generated, the user creates the compound document 101, enters the explanatory data 104, and incorporates the scheduling data 102 and budgeting data 103 using a word processing computer program.

FIG. 2 shows how the scheduling data, budgeting data, and explanatory data can be incorporated into the compound document. The user generates scheduling data using the project management program 201 and then stores the data in the clipboard 203. The user generates budgeting data using the spreadsheet program 204 and then stores the data in the clipboard 203. The clipboard 203 is an area of storage (disk or memory) that is typically accessible by any program. The project management program 201 and the spreadsheet program 204 typically store the data into the clipboard in a presentation format. A presentation format is a format in which the data is easily displayed on an output device. For example, the presentation format may be a bitmap that can be displayed with a standard bitmap block transfer operation (BitBit). The storing of data into a clipboard is referred to as "copying" to the clipboard.

After data has been copied to the clipboard 203, the user starts up the word processing program 206 to create the compound document 101. The user enters the explanatory data 104 and specifies the locations in the compound document 101 to which the scheduling data and budgeting data that are in the clipboard 203 are to be copied. The copying of data from a clipboard to a document is referred to as "pasting" from the clipboard. The word processing program 206 then copies the scheduling data 102 and the budgeting data 103 from the clipboard 203 into the compound document 101 at the specified locations. Data that is copied from the clipboard into a compound document is referred to as "embedded" data. The word processing program 206 treats the embedded data as simple bitmaps that it displays with a BitBlt operation when rendering the compound document 101 on an output device. In some prior systems, a clipboard may only be able to store data for one copy command at a time. In such a system, the scheduling data can be copied to the clipboard and then pasted into the compound document. Then, the budgeting data can be copied to the clipboard and then pasted into the compound document.

Since word processors typically process only text data, users of the word processing program can move or delete embedded data, but cannot modify embedded data, unless the data is in text format. Thus, if a user wants to modify, for example, the budgeting data 103 that is in the compound document 101, the user starts the spreadsheet program 204, loads in the budgeting data 103 from a file, makes the modifications, copies the modifications to the clipboard 203, starts the word processing program 206, loads in the compound document 101, and pastes the modified clipboard data into the compound document 101. The spreadsheet program "implements" the spreadsheet data, that is, the spreadsheet program can be used to manipulate data that is in spreadsheet format. The format that a program implements is referred to as native format.

Some prior systems store links to the data to be included in the compound document rather than actually embedding the data. When a word processing program pastes the data from a clipboard into a compound document, a link is stored in the compound document. The link points to the data (typically residing in a file) to be included. These prior systems typically provide links to data in a format that the word processing program recognizes or treats as a presentation format. For example, when the word processing program 206 is directed by the user to paste the scheduling data and budgeting data into the compound document by linking, rather than embedding, the names of files in which the scheduling data and budgeting data reside in presentation format are inserted into the document. Several compound documents can contain links to the same data to allow one copy of the data to be shared by several compound documents.

SUMMARY OF THE INVENTION

It is an object of the present invention to provide a method and system for interacting with a contained object within a window environment of a container application of a container object.

It is another object of the present invention to provide a method and system for combining menus of the container application with menus of a server application of the contained object.

These and other objects, which will become apparent as the invention is more fully described below, are provided by a computer method and system for interacting with a containee object contained within a container object. In a preferred embodiment, the container object has a container application with a container window environment that has container resources for interacting with the container object. The containee object has a server application with a server window environment with server resources for interacting with the containee object. The method of the present invention displays the container window environment on a display device. A user then activating the containee object. In response to activating the containee object, the method integrates a plurality of the server resources with the displayed container window environment. When a user then selects a server resource, the method invokes the server application to process the server resource selection. Conversely, when a user selects a container resource, the method invokes the container application to process the container resource selection.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is an example of a compound document.

FIG. 2 is a diagram showing how the scheduling data, budgeting data, and explanatory data can be incorporated into the compound document.

FIG. 3 is a diagram of the sample compound document shown in FIG. 1 as it appears when edited within the word processing application before in-place interaction occurs.

FIG. 4 is a diagram of the embedded spreadsheet object as it appears when activated in place within the compound document.

FIG. 5 is a diagram which shows the relationship between an object handler and the container and server processes.

FIG. 6 is a block diagram of a sample instance of a linked or embedded object.

FIG. 7 is a block diagram showing a public view of an object.

FIG. 8 is a sample user menu provided by a container application to display and select the actions available for an object.

FIG. 9 is a diagram showing the composite menu bar resulting from the merger of the server application menus with the container application menus of the example shown in FIG. 4.

FIG. 10 is a diagram of the menu groups that compose a composite menu bar in a preferred embodiment of the present invention.

FIG. 11 is a diagram showing the component windows of a typical Single Document Interface application.

FIG. 12 is a diagram showing the component windows of an Multiple Document Interface application.

FIG. 13 is a block diagram showing the typical window hierarchy of a container application when it is editing an embedded object in place.

FIG. 14 is a flow diagram showing message processing in an event-driven windowing operating system environment.

FIG. 14B is a block diagram showing the public interfaces required to support in place interaction.

FIG. 15 is a flow diagram of an implementation of the IOLEInPlaceFrame::SetMenu method.

FIG. 16 is a flow diagram of an implementation of the IOLEInPlaceFrame::EnableModeless method.

FIG. 17 is a flow diagram of an implementation of the IOLEInPlaceParent::OnInPlaceActivate method.

FIG. 18 is a flow diagram of an implementation of the IOLEInPlaceParent::OnUIActivate method.

FIG. 19 is a flow diagram of an implementation of the IOLEInPlaceParent::OnUIDeactivate method.

FIG. 20 is a flow diagram of an implementation of the IOLEInPlaceObject::InPlaceDeactivate method.

FIG. 21 is a flow diagram of an implementation of the IOLEInPlaceObject::InPlaceUIDeactivate method.

FIG. 22 is a flow diagram of an implementation of the IOLEInPlaceObject::Activate method.

FIG. 23 is a flow diagram of an implementation of the ActivateUI function.

FIG. 24 is a flow diagram of an implementation of the CreateObjectToolbars function.

FIG. 25 is a block diagram of the shared menu data structure corresponding to the example discussed in FIG. 4.

FIG. 26 is a flow diagram of an implementation of the ObjectSetMenu function.

FIG. 27 is a flow diagram of an implementation of the function Process.sub.-- Object.sub.-- Activation.

FIG. 28 is a flow diagram of an implementation of the object linking and embedding API function ObjectLoad.

FIGS. 29A and 29B are flow diagrams of an implementation of the IOLEObject::DoVerb method. This method is the primary method for interacting with a containee object.

FIG. 30 is a flow diagram of an implementation of the function Process.sub.-- Activation.sub.-- Message called by the window procedure of an MDI document window to process activation and deactivation messages.

FIG. 31 is a flow diagram of an implementation of the Process.sub.-- Mouse.sub.-- LButtonUp function.

FIG. 32 is an example application that uses a forms architecture as the basis for its user interface.

FIG. 33 is a block diagram of the activation states available for a container object.

FIG. 34 is a flow diagram of the message processing of a typical window procedure of a container application implementing a container object that can activate outside-in objects.

FIG. 35 is a flow diagram of a window procedure for an inside-out containee object implemented by a server application.

FIG. 36 is a block diagram showing the arrangement of objects in a containment hierarchy and typical relationships between their interfaces.

FIG. 37 is a flow diagram of a typical implementation of the IOLEInPlaceUIWindow::SetActiveObj ect method.

FIG. 38 is a flow diagram of a typical implementation of the IOLEInPlaceFrame::SetMenu method for a server application that does not wish to participate in menu merging.

FIG. 39 is a flow diagram of a typical implementation of the IOLEInPlaceParent::OnInPlaceActivate method.

FIG. 40 is a flow diagram of a typical implementation of the IOLEInPlaceParent::OnUIActivate method.

FIG. 41 is a flow diagram of a typical implementation of the IOLEInPlaceParent::OnUIDeactivate method.

FIG. 42 is a flow diagram of a typical implementation of the IOLEInPlaceParent::OnDeactivate method.

FIG. 43 is a flow diagram of a typical implementation of the IOLEInPlaceObject::InPlaceDeactivate method.

FIG. 44 is a flow diagram of a typical implementation of the DeactivateUI function implemented by a server application.

FIG. 45 is a flow diagram of a typical implementation of the UIDeactivateContainedObject function implemented by a server application.

FIG. 46 is a flow diagram of a typical implementation of the DoInPlaceHide function implemented by a server application.

FIG. 47 is a flow diagram of a typical implementation of the InPlaceDeactivateContainedObjects function implemented by a server application.

FIG. 48 is a flow diagram of a typical implementation of the IOLEInPlaceObject::UIDeactivate method.

FIG. 49 is a flow diagram of a typical implementation of the IOLEInPlaceActiveObject::Activate method.

FIG. 50 is a flow diagram of a typical implementation of the ActivateUI function implemented by a server application.

FIGS. 51A abd 51B are flow diagrams of a typical implementation of the DoInPlaceActivate function implemented by a server application.

FIG. 52 is a flow diagram of a typical implementation of the Process.sub.-- Object.sub.-- Activation function implemented by a container application.

FIGS. 53A and 53B are flow diagrams of a typical implementation of the IOLEObject::DoVerb method implemented by a server application.

FIG. 54 is a flow diagram of a typical implementation of the Process.sub.-- Activation.sub.-- Message function invoked by the window procedure of an MDI document window to process MDI activation and deactivation messages.

FIG. 55 is a flow diagram of a typical implementation of the Process.sub.-- Mouse.sub.-- LButtonDown function implemented by a container application.

FIG. 56 is a flow diagram of a typical implementation of the IOLEObject::Close method implemented by a server application.

DETAILED DESCRIPTION OF THE INVENTION

Table of Contents

1. Overview

2. In-Place Interaction Overview

3. Window Support for In-Place Interaction

4. In-Place Interaction API

4.1 IOLEWindow Interface

4.1.1 IOLEWindow::GetWindow

4.2 IOLEInPlaceUIWindow Interface

4.2.1 IOLEInPlaceUIWindow::GetBorder

4.2.2 IOLEInPlaceUIWindow::QueryBorderSpace

4.2.3 IOLEInPlaceUIWindow::SetBorderSpace

4.3 IOLEInPlaceFrame Interface

4.3.1 IOLEInPlaceFrame::SetMenu

4.3.2 IOLEInPlaceFrames:: InsertMenus

4.3.3 IOLEInPlaceFrame::RemoveMenus

4.3.4 IOLEInPlaceFrame:: SetStatusText

4.3.5 IOLEInPlaceFrame::EnableModeless

4.3.6 IOLEInPlaceFrame::TranslateAccelerator

4.4 IOLEInPlaceParent Interface

4.4.1 IOLEInPlaceParent::CanInPlaceDeactivate

4.4.2 IOLEInPlaceParent::OnInPlaceActivate

4.4.3 IOLEInPlaceParent::OnUIActivate

4.4.4 IOLEInPlaceParent::OnUIDeactivate

4.4.5 IOLEInPlaceParent::OnDeactivate

4.4.6 IOLEInPlaceParent::ShadeBorder

4.4.7 IOLEInPlaceParent::GetWindowContext

4.5 IOLEInPlaceObject Interface

4.5.1 IOLEInPlaceObject::InPlaceDeactivate

4.5.2 IOLEInPlaceObject::InPlaceUIDeactivate

4.5.3 IOLEInPlaceObject::TranslateAccelerator

4.5.4 IOLEInPlaceObject::Activate

4.5.5 IOLEInPlaceObject::ResizeBorder

4.5.6 IOLEInPlaceObject::EnableModeless

4.5.7 IOLEInPlaceObject::SetVisRect

4.6 Other Server Application Functions

4.6.1 ActivateUI

4.6.2 CreateNewMenu

4.6.3 CreateObject Toolbars

4.6.4 RemoveMenus

4.7 Object Linking and Embedding API Helper Functions

4.7.1 SetActiveObjectHwnd

4.7.2 GetActiveObjectHwnd

4.7.3ObjectCreateSharedMenu

4.7.4 ObjectDestroySharedMenu

4.7.5 ObjectShade

4.7.6 ObjectSetMenu

5. Use of In-Place Interaction API

5.1 Procedure for Activation in Place

5.1.1 Activation In Place Within a Multiple Document Interface Application

5.2 User Selection of Pulldown Menus Message Handling

5.3 In-Place Deactivation Procedure

5.4 Closing the Container Application

5.5 Interacting with Modeless Dialogs

5.6 Handling Accelerator Key Combinations

6.0 Alternative Embodiment for In-Place Interaction

6.1 Activation Model Support

6.2 Windows Support for the Inside-Out Activation Model

6.3 In-Place Interaction API Support for Inside-Out Activation

6.3.1 IOLEWindow Interface

6.3.2 IOLEInPlaceUIWindow Interface

6.3.2.1 IOLEInPlaceUIWindow::SetActiveObject

6.3.3 IOLEInPlaceFrame Interface

6.3.3.1 IOLEInPlaceFrame::SetMenu

6.3.4 IOLEInPlaceParent Interface

6.3.4.1 IOLEParent::OnInPlaceActivate

6.3.4.2 IOLEInPlaceParent::OnUIActivate

6.3.4.3 IOLEInPlaceParent::OnUIDeactivate

6.3.4.4 IOLEInPlaceParent::OnDeactivate

6.3.4.5 IOLEInPlaceParent::GetWindowContext

6.3.4.6 IOLEInPlaceParent::Scroll

6.3.4.7 IOLEInPlaceParent::OnPosRectChanged

6.3.5 IOLEInPlaceObject Interface

6.3.5.1 IOLEInPlaceObject::InPlaceDeactivate

6.3.5.2 Server Application Function - DeactivateUI

6.3.5.3 Server Application- UIDeactivateContainedObject

6.3.5.4 Server Application- DoInPlaceHide

6.3.5.5 Server Application- InPlaceDeactivateContainedObjects

6.3.5.6 IOLEInPlaceObject::UIDeactivate

6.3.5.7 IOLEInPlaceObject::SetVisRects

6.3.6 IOLEInPlaceActiveObject Interface

6.3.6.1 IOLEInPlaceActiveObject::Activate

6.3.6.2 IOLEInPlaceActiveObject::ResizeBorder

6.3.6.3 Server Application- ActivateUI

6.3.7 Object Linking and Embedding Facilities Helper Functions

6.4 Use of In-Place Interaction API With Inside-Out Objects

6.4.1 Determining the Activation Model of Objects

6.4.2 Activating Objects

6.4.2.1 Activating Inside-Out Objects Within a Multiple Document Interface Application

6.4.3 Deactivating Objects

6.4.4 Closing the Container Application

1. Overview

The present invention provides a generalized method, referred to as in-place interaction, for interacting with embedded or linked data in the context of a compound document. That is, the application to be used to interact with the embedded or linked data is made accessible to the user through the window environment (for example menus and windows) of the application that implements the compound document. This accessibility is referred to as activation in place. In a preferred embodiment, when embedded or linked (contained) data is activated in place, the menus of the application that implements the contained data are merged with the menus of the application that implements the compound document to create a composite menu bar. The order of the menus in the composite menu bar is determined by a set of menu groups. Each application categorizes its menus into these menu groups and places its menus in the composite menu bar in the order of the menu groups. The composite menu bar is then installed as the menu bar of the application implementing the compound document, and a message handler is installed to filter messages sent to the windows of this application. When the user selects a menu item, the message handler determines whether the menu item belongs to a menu of the application implementing the contained data or the application implementing the compound document. The message handler then sends the input message corresponding to the selected menu item to the correct application.

The present invention defines a set of abstract classes (interfaces) and thnctions through which contained data is activated in place. (In the C++ programming language, an abstract class is a class with a definition of its data and methods, but with no implementation for those methods. It is the responsibility of the application implementing the class to provide the actual code for the methods available to manipulate the class instance data.) The application implementing the compound document is responsible for implementing some of these interfaces and the application implementing the contained data is responsible for implementing others.

In a preferred embodiment of the present invention, an application program that creates a compound document controls the manipulation of linked or embedded data generated by another application. In object-oriented parlance, this data is referred to as an object. (The reference Budd, T., "An Introduction to ObjectOriented Programming," Addison-Wesley Publishing Co., Inc., 1991, provides an introduction to object-oriented concepts and terminology.) An object that is either linked or embedded into a compound document is "contained" within the document. Also, a compound document is referred to as a "container" object and the objects contained within a compound document are referred to as "contained" or "containee" objects. Referring to FIGS. 1 and 2, the scheduling data 102 and budgeting data 103 are containee objects and the compound document 101 is a container object. The user can indicate to the word processor that the user wants to edit a containee object, such as the budgeting data 103. When the user indicates that the budgeting data 103 is to be edited, the word processing program determines which application should be used to edit the budgeting data (e.g., the spreadsheet program) and launches (starts up) that application. The user can then manipulate the budgeting data using the launched application, and changes are reflected in the compound document. The same procedure is used. whether the budgeting data is stored as an embedded or linked object.

If the application used to edit the budgeting data supports in-place interaction, then, when it is launched by the word processing program, it is activated within the window environment of the word processing program. FIGS. 3 and 4 illustrate the process of activating the embedded budgeting data 103 in place.

FIG. 3 is a diagram of the sample compound document shown in FIG. 1 as it appears when edited within the word processing application before in-place interaction occurs. The main window of the container application 301 contains a title bar 302, a menu bar 303, and a client window 304. The client window 304 displays the manufacturing project report discussed in FIG. 1. The compound document contains an embedded spreadsheet object (the budgeting data 305). When the user edits the native text data of the compound document, the menu bar 303 appears as shown: it includes all of the commands necessary to interact with the word processing application.

When the user decides to edit the budgeting data 305, the user selects the spreadsheet object 305 and requests the word processing application to edit the object (e.g., by double clicking on the object using the mouse). The word processing application then launches the spreadsheet application requesting that it edit the spreadsheet object 305. The spreadsheet application negotiates with the word processing application to edit the spreadsheet object 305 using windows 301 and 304 and the menu bar 303 of the word processing application.

FIG. 4 is a diagram of the embedded spreadsheet object as it appears when activated in place within the compound document. The spreadsheet object 405 is edited directly in the client window 404 of the word processing application. The title bar 402 is changed to reflect that the application implementing the compound document, in this case a word processing application, is editing a spreadsheet worksheet within the compound document "VAC1.DOC." Also, the menu bar 403 is changed to a new composite menu bar, which comprises menus from the word processing application and menus from the spreadsheet application. In addition, various aspects of the embedded spreadsheet object 405 are changed to reflect that it is being edited within its container compound document. A selection highlight 406 in the form of a hatched border pattern is placed around the object. Also, the standard tools of the spreadsheet application, in this case the row and column markers 407, are placed around the spreadsheet object. Also, the spreadsheet selection cursor 408 is placed around the currently selected cell. At this point, the user is ready to edit the spreadsheet object 405 using all of the spreadsheet application commands.

In a preferred embodiment, application programs ("applications") cooperate using object linking and embedding facilities to create and manipulate compound documents. An application that creates a compound document is referred to as a container (or client) application, and an application that creates and manipulates containee objects is referred to as a server application. An application can behave as both a container and server. That is, an application can contain objects and the objects that the application implements can be contained within other objects. Referring to FIG. 2, the project management program 201 and the spreadsheet program 204 are server applications, and the word processing program 206 is a container application. A container application is responsible for selection of the various objects within the container object and for invoking the proper server applications to manipulate the containee objects. Server applications are responsible for manipulating the contents of the containee objects.

In a preferred embodiment, applications are provided with an implementation-independent Application Programming Interface (API) that provides object linking and embedding functionality. The API is a set of functions that are invoked by container and server applications. These functions manage, among other things, the setup and initialization necessary for container applications to send and receive messages and data to and from server applications. The API provides functions to invoke server applications to manipulate containee objects.

The invoking of a server application can be relatively slow when the server application executes as a separate process from the container application. In certain situations this slowness may be particularly undesirable. For example, if a user wants to print a compound document that includes many containee objects, it may take an unacceptably long time to invoke the server process for each containee object and request each server process to print the object. To ameliorate this unacceptable performance, a server application can provide code that can be dynamically linked during runtime into the process of the container application to provide certain functionality more efficiently. This code is called an "object handler." Object handlers provide functionality on behalf of the server application so that the object linking and embedding API can avoid starting up server processes and passing messages to the server process. In the above example, an object handler could provide a print function that the object linking and embedding API could invoke to print a containee object.

FIG. 5 is a diagram which shows the relationship between an object handler and the container and server processes. The object handler 502 is linked into the container process address space 501 during runtime by the object linking and embedding API 503. Typically, the object linking and embedding API 503 invokes the object handler 502 directly, and the container application code need not be aware that a handler is providing the functionality, rather than a server process 507.

In addition to providing a set of functions, the object linking and embedding ("OLE") API defines "interfaces" through which container applications can communicate with their contained objects. An interface is a set of methods (in C++ parlance) which abide by certain input, output, and behavior rules. If a contained object supports (provides an instrumentation for) a particular interface, the container application can invoke the methods of that interface to effect the defined behavior. In a preferred embodiment, the container application does not directly access the object data. Rather, it preferably accesses the object data using the supported interfaces. A container application is bound to a contained object through a pointer to an interface instance. The container application accesses the object data by invoking the methods of the interface instance. To access the object data, the methods may send messages to the server application requesting the specified access. In a preferred embodiment, messages are sent between container and server applications when the server application is implemented as a separate process using interprocess communications mechanisms provided by the underlying operating system.

FIG. 6 is a block diagram of a sample instance of a linked or embedded object. In a preferred embodiment, the layout of the instance conforms to the model defined in U.S. Pat. No. 5,297,284, entitled "A Method for Implementing Virtual Functions and Virtual Bases in a Compiler for an Object Oriented Programming Language" which is hereby incorporated by reference. The instance contains object data structure 601 and interface data structure 613 for each supported interface. The object data structure 601 contains pointers 602 to the interface data structures 613 and may contain private data of the instance. The private data of this sample instance includes a class identifier 603, handle 604 to the storage for the object, and data 605 for tracking the state of the object. The class identifier (CLASS.sub.-- ID) is used to access the appropriate server application for the object. It is similar to a data structure "type" used in programming languages. A method can determine this server application for the object by using its CLASS.sub.-- ID as an index into a persistent global registry. The persistent global registry is discussed further below. As shown in FIG. 6, each interface data structure 613 contains a private data structure 606 and a virtual function table 608. The private data structure 606 contains a pointer 607 to the virtual function table 608. The virtual function table 608 contains pointers 609 and 611 to the code 610, 612 that implements the methods of the interface.

                  TABLE 1
    ______________________________________
    # define interface class
    interface intf {public:
                virtual RETCODE fnc.sub.1 (arg1, arg2) = 0;
                virtual RETCODE fnc.sub.2 (arg1, arg2) = 0;
                virtual RETCODE fnc.sub.3 ( ) = 0;
                     . . .
                };
    ______________________________________

                  TABLE 2
    ______________________________________
    interface IOLEWindow: public IUnknown {public:
         virtual SCODE GetWindow (HWND FAR *phwnd) = 0;
    ______________________________________

                  TABLE 3
    ______________________________________
    interface IOLEInPlaceUIWindow: public IOLEWindow {public:
        virtual SCODE GetBorder (RECT borderRect) = 0;
        virtual SCODE QueryBorderSpace (RECT widthRect) = 0;
        virtual SCODE SetBorderSpace (RECT widthRect) = 0;
    ______________________________________

                  TABLE 4
    ______________________________________
    interface IOLEInPlaceFrame: public
    IOLEInPlaceUIWindow {public:
        virtual SCODE SetMenu (HANDLE hSharedMenu,
        HWND hwndObject) = 0;
        virtual SCODE InsertMenus (HANDLE hmenu,
        UINT FAR *lpiMenuCounts) = 0;
        virtual SCODE RemoveMenus (HANDLE hmenu) = 0;
        virtual SCODE SetStatusText (LPSTR lpszStatusText) = 0;
        virtual SCODE EnableModeless (BOOL fEnable) = 0;
        virtual SCODE TranslateAccelerator
        (LPMSG lpmsg, WORD WID) = 0;
    ______________________________________

                                      CODE TABLE 1
    __________________________________________________________________________
    VOID IOleInPlaceFrame::InsertMenus (hmenu, ContrCounts) {
    1 if there are File Group menus present {
    2   for each filegroupmenu {
    3     hfilemenu = CreateMenu ( );
    4     InsertMenu (hmenu, MF.sub.-- APPEND, MF.sub.-- BYPOSITION.vertline.M
          F.sub.-- POPUP, hfilemenu);
    5     ContrCounts[0] = ContrCounts[0] + 1;
    6     for each filegroupmenu.sub.-- item {
    7       InsertMenu (hfilemenu, MF.sub.-- APPEND, MF.sub.-- BYPOSITION.vert
            line.MF.sub.-- STRING,
    8           item.sub.-- id, "string to be displayed");
    9     }
    10  };
    11
      if there are Container Group menus present {
    12  for each containergroupmenu {
    13    hcontmenu = CreateMenu ( );
    14    InsertMenu (hmenu, MF.sub.-- APPEND, MF.sub.-- BYPOSITION.vertline.M
          F.sub.-- POPUP, hcontmenu);
    15    ContrCounts[1] = ContrCounts[1] + 1;
    16    for each contgroupmenu.sub.-- item {
    17      InsertMenu (hcontmenu, MF.sub.-- APPEND, MF.sub.-- BYPOSITION.vert
            line.MF.sub.-- STRING,
    18        item.sub.-- id, "string to be displayed");
    19    }
    20  };
    21
      if there are Window Group menus present {
    22  for each windowgroupmenu {
    23    hwndmenu = CreateMenu ( );
    24    InsertMenu (hmenu, MF.sub.-- APPEND, MF.sub.-- BYPOSITION.vertline.M
          F.sub.-- POPUP, hwndmenu);
    25    ContrCounts[2] = ContrCounts[2] + 1;
    26    for each wndgroupmenu.sub.-- item {
    27      InsertMenu (hwndmenu, MF.sub.-- APPEND, MF.sub.-- BYPOSITION.vertl
            ine.MF.sub.-- STRING,
    28        item.sub.-- id, "string to be displayed");
    29    }
    30  };
    31
      return( );
    __________________________________________________________________________

                  TABLE 5
    ______________________________________
    interface IOLEInPlaceParent:
    public IOLEWindow {public:
          virtual SCODE CanInPlaceActivate ( ) = 0;
          virtual SCODE OnInPlaceActivate ( ) = 0;
          virtual SCODE OnUIActivate ( ) = 0;
          virtual SCODE OnUIDeactivate ( ) = 0;
          virtual SCODE OnDeactivate ( ) = 0;
          virtual SCODE ShadeBorder (LPRECT lprect,
          DWORD grfState) = 0;
          virtual SCODE GetWindowContext
          (IOLEInPlaceFrame *pFrame, IOLEInPlaceUIWindow
    *pDoc, IOLEInPlaceUIWindow *pPane, LPRECT
    lprectChildPosition, HANDLE *hAccelTable) = 0;
    ______________________________________

                  TABLE 6
    ______________________________________
    interface IOLEInPlaceObject: public IOLEWindow {public:
        virtual SCODE InPlaceDeactivate ( ) = 0;
        virtual SCODE InPlaceUIDeactivate ( ) = 0;
        virtual SCODE TranslateAccelerator (LPMSG lpmsg) = 0;
        virtual SCODE Activate (BOOL fActivate,
        BOOL fDocActivate) = 0;
        virtual SCODE ResizeBorder (RECT borderRect) = 0;
        virtual SCODE EnableModeless (BOOL fEnable) = 0;
        virtual SCODE SetVisRect (LPRECT lprect) = 0;
    ______________________________________

                                      CODE TABLE 2
    __________________________________________________________________________
    HANDLE CreateNewMenu (IOLEInPlaceFrame *pFrame) {
    1 hmenu = CreateMenu ( );
    2 pframe -> InsertMenus (hmenu, ContrCounts);
    3 lpiMenuCount[0] = ContrCount[0];
    4 lpiMenuCount[2] = ContrCount[1];
    5 lpiMenuCount[4] = ContrCount[2];
    6 if there are Edit group menus present {
    7   for each editgroupmenu {
    8     heditmenu = CreateMenu ( );
    9     insertion.sub.-- point = lpiMenuCount[0] + lpiMenuCount[1] + 1;
    10    InsertMenu (hmenu, insertion.sub.-- point, MF.sub.-- BYPOSITION.vert
          line.MF.sub.-- POPUP,
    11       heditmenu, NULL);
    12    lpiMenuCount[1] = lpiMenuCount[1] + 1;
    13    for each editgroupmenu.sub.-- item {
    14      InsertMenu (heditmenu, -1, MF.sub.-- BYPOSITION.vertline.MF.sub.--
             STRING, item.sub.-- id,
    15         "string to be displayed");
    16    }
    17  };
    18
      if there are Object group menus present {
    19  for each objectgroupmenu {
    20    hobjmenu = CreateMenu ( );
    21    insertion.sub.-- point = lpiMenuCount[0]+ lpiMenuCount[1] +
          lpiMenuCount[2]
    22          lpiMenuCount[3] + 1;
    23    InsertMenu (hmenu, insertion.sub.-- point, MF.sub.-- BYPOSITION.vert
          line.MF.sub.-- POPUP,
    24          hobjmenu, NULL);
    25    lpiMenuCount[3] = lpiMenuCount[3] + 1;
    26    for each objectgroupmenu.sub.-- item {
    27      InsertMenu (hobjmenu, -1, MF.sub.-- BYPOSITION.vertline.MF.sub.--
            STRING, item.sub.-- id,
    28          "string to be displayed");
    29    }
    30  };
    31
      if there are Help group menus present {
    32  for each helpgroupmenu {
    33    hhelpmenu = CreateMenu ( );
    34    InsertMenu (hmenu, -1, MF.sub.-- BYPOSITION .vertline.MF.sub.--
          POPUP, hhelpmenu,
    35        NULL);
    36    lpiMenuCount[5] = lpiMenuCount[5] + 1;
    37    for each objectgroupmenu.sub.-- item {
    38      InsertMenu (hhelpmenu, -1, MF.sub.-- BYPOSITION.vertline.MF.sub.--
             STRING,
    item.sub.-- id,
    39          "string to be displayed");
    40    }
    41  };
    42
      hSharedMenu = ObjectCreateSharedMenu (hmenu, lpiMenuCount);
    43
      return (hSharedMenu);
    }
    __________________________________________________________________________