Home
Patent Search
IMT Blog
REGISTER
|
SIGN IN
United States Patent
5581686
Koppolu , ; et al.
December 3, 1996
Title
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.
Inventors:
Koppolu; Srinivasa R.
(Redmond,
WA
)
, Hodges; C. Douglas
(Redmond,
WA
)
, MacKichan; Barry B.
(Bainbridge Island,
WA
)
, McDaniel; Richard
(Pittsburg,
PA
)
, Remala; Rao V.
(Woodinville,
WA
)
, Williams; Antony S.
(Redmond,
WA
)
Assignee:
Microsoft Corporation
(Redmond,
WA
)
Appl. No.:
468026
Filed:
June 6, 1995
Current U.S. Class:
715/784
715/802
715/804
715/516
Field of Search:
395/157,159,155
U.S. Patent Documents
5079695
January 1992
Dysart et al.
Foreign Patent Documents
0215203
Mar., 1987
EP
0304071
Feb., 1989
EP
Other References
"IBM Technical Disclosure Bulletin", vol.27, No. 10B, p. 5998, Mar. 1985. .
Andrew J. Palay et al., "The Andrew Toolkit--An Overview", USENIX Winter Conference, Dallas, Texas, Feb. 9-12, 1988. .
Terrence Crowley et al., "The Diamond Multimedia Editor", Proceedings of the Summer USENIX Conference, 1987. .
Robert H. Thomas et al., "Diamond: A Multimedia Message System Built on a Distributed Architecture" Computer, pp. 65-77, Dec. 1985. .
Harry Forsdick et al., "Initial Experience with Multimedia Documents in Diamond", Elsevier Science Publishers B. V. (North Holland), 1984. .
James Donahue et al., "Whiteboards: A Graphical Database Tool", ACM Transactions on Office Information Systems, vol. 4, No. 1, Jan. 1986. .
Thompson et al., "FullWrite Professional: A User Guide", pp. 1-286, 1988. .
Object Linking & Embedding, Microsoft Corporation, Redmond, Washington, Nov. 6, 1991. .
Marshak, R., "ClarisWorks Is a Strong Tool for the Individual", Office Computing Report 14 (9):25, 1991. .
Gore, Andrew, "Claris and Beagle Bros. shoot for the Works", MacWEEK 5(25):1 & 124, 1991. .
"LotusWorks User's Guide", Spinnaker Software Corp., pp. 2-1 - 2-11 (1991). .
Microsoft Corporation, "Microsoft.RTM. Windows.TM. User's Guide for the Windows Graphical Environment Version 3.0", pp. 19, 20, 24, 25, 80, 81, 85, Microsoft Corporation (1990). .
Microsoft Window user's Guide, Version 3.0, Microsoft Corporation, 1990, p. 25..~
Primary Examiner:
Powell; Mark R.
Assistant Examiner:
Huynh; B.
Attorney, Agent or Firm:
Seed and Berry LLP
Parent Case Text
This application is a continuation of U.S. patent application Ser. No. 08/229,264, filed Apr. 15, 1994, which is a continuation-in-part for U.S. patent application Ser. No. 07/984,868, entitled "METHOD AND SYSTEM FOR IN-PLACE INTERACTION WITH CONTAINED OBJECTS" filed on Dec. 1, 1992, which is hereby incorporated by reference abandoned.
Claims
We claim:
1. A method in a computer system for scrolling an outer application window that contains an inner application window activated within the outer application window, user input to the outer application window being processed by a first application, user input to file timer application window being processed by a second application, the first and second application being a separate executable code images that are separately scheduled by an operating system of the computer system, the computer system having a display device and a window system for managing the displaying of windows on the display device and for passing user input events to applications, the window system allowing the scrolling of data displayed within a window, the method comprising the steps of:
indicating a selection of data contained within the inner application window that is contained and activated within the outer application window;
in response to a user input to scroll the outer application window, maintaining the indicated selection of data as the selected data.
2. The method of claim 1 further comprising the steps of:
scrolling the outer application window; and
maintaining the indicated selection of data as selected when the inner application window is scrolled out of view of the user.
3. The method of claim 1 wherein the step of indicating the selection of data contained within the inner application window designates the inner application window as having keyboard input focus such that the second application will receive a next keyboard input event;
wherein the step of scrolling the outer application window is performed by the first application; and
wherein the step of maintaining the indicated selection of data as selected when the inner application window is scrolled out of view, continues to designate the inner application window as having keyboard input focus.
4. The method of claim 1 wherein the step of indicating the selection of data displays a hatched pattern border around the data and wherein the step of maintaining the indicated selection of data as the selected data preserves the hatched border displayed around the object.
5. A method in a computer system for controlling activation of a containee object activated in-place within a container object, the container object having a window environment that contains a container application window and a container menu bar with container contents, the containee object having a server window that is displayed within the window environment of the container object and having a server menu bar with server contents which are integrated with the container menu bar, such that the server contents and the container contents are displayed in combination in a joined application menu bar in the container application window instead of displaying the container menu bar, the method comprising the steps of:
indicating a selection of data in the server window of the containee object;
receiving user input within the container application window after the selected data has been indicated in the server window;
determining whether the user input indicates that the container application window is to be scrolled;
when it is determined that the user input indicates that the container application window is to be scrolled, scrolling the container application window while keeping the containee object activated in-place, with the server window being displayed within the container application window and with the joined application window menu bar being displayed in the container application window, wherein the selected data remains indicated in the server window; and
when it is determined that the user input indicates a selection within a portion of the container window that is outside the server window and that does not indicate scrolling the container application window,
deactivating the containee object such that the container menu bar is displayed in the container window instead of the joined application menu bar; and
removing the indication of the selection of data within the server window and redisplaying the containee object, wherein no data within the containee object is selectable.
6. The method of claim 5 wherein the step of scrolling the container application window while keeping the containee object activated in-place maintains the indicated selection of data as selected data when the server window is scrolled out of view of the user.
7. The method of claim 5 wherein the step of indicating a selection of data displays a hatched pattern border around the server window and wherein the step of removing the indication of the selection of data within the server window removes the hatched pattern border when the containee object is redisplayed.
8. A method in a computer system for scrolling a container object that contains a containee object, the container object having a container window, the computer system having an operating system that schedules execution of computer programs, the container object being managed by a container application program, the containee object being managed by a containee application program, each application program being a separate executable code image that is separately scheduled by the operating system, the method comprising the steps of:
under control of the container application program, selecting the containee object; and
activating, within a window environment of the container application, the selected containee object, wherein the containee application program controls displaying of contents of a containee window within the container window;
under control of the containee application program, receiving an indication of a selection of data within the displayed containee window; and
displaying an indication that the selection of data is a current selection;
under control of the container application program, receiving a scrolling indication that the container window is to be scrolled;
in response to the scrolling indication, scrolling the container window while maintaining the indication flint the selection of data is the current selection;
receiving user input other than the scrolling indication;
in response to the input other than the scrolling indication, sending a request to the containee object to deselect the selection of data, thereby changing the current selection of data; and
deselecting the containee object wherein the containee window is no longer displayed; and
under control of the containee application program, deselecting the selected data and removing the displayed indication that the selection of data is the current selection.
9. The method of claim 8 wherein the step of scrolling the container window maintains the indication that the selection of data is the current selection when the containee window is scrolled out of view of the user.
10. The method of claim 8 wherein the step displaying the indication that the selection of data is the current selection displays a hatched pattern border around the containee window and wherein the step of removing the displayed indication that the selection of data is the current selection removes the hatched pattern border.
11. A method in a computer system for controlling display of windows, the method comprising the steps of:
activating within the container window a containee window, wherein a containee application displays contents of the containee window and a container application and container application controls the container window, the container application and containee application being separately scheduled for execution by an operating system of the computer system;
under control of the containee application, highlighting a current selection of data within the displayed containee window; and
under control of the container application, scrolling the container window, wherein the current selection of data within the displayed containee window remaining highlighted and wherein the displayed containee window is moved within the container window as the container window is scrolled.
12. The method of claim 11 wherein the step of highlighting a current selection of data within the displayed containee window draws a hatched pattern border around the current selection of data.
13. A computer-readable memory device containing instructions for controlling a computer processor in a computer system to scroll a container object that contains a containee object, the container object having a container window, the computer system having an operating system that schedules execution of computer programs, the container object being managed by a container application program, the containee object being managed by a containee application program, each application program being a separate executable code image that is separately scheduled by the operating system, by performing the steps of:
under control of the container application program, selecting the containee object; and
activating, within a window environment of the container application, the selected containee object, wherein the containee application program controls displaying of contents of a containee window within the container window;
under control of the containee application program, receiving an indication of a selection of data within the displayed containee window; and
displaying an indication that the selection of data is a current selection;
under control of the containee application program, receiving a scrolling indication that the container window is to be scrolled;
in response to the scrolling indication, scrolling the container window while maintaining the indication that the selection of data is the current selection;
receiving user input other than the scrolling indication;
in response to the input other than the scrolling indication, sending a request to the containee object to deselect the selection of data, thereby changing the current selection of data; and
deselecting the containee object wherein the containee window is no longer displayed; and
under control of the containee application program, deselecting the selected data and removing the displayed indication that the selection of data is the current selection.
14. A computer-readable memory device containing instructions for controlling a computer processor in a computer system to scroll an outer application window that contains an inner application window activated within the outer application window, user input to the outer application window being processed by a first application, user input to the inner application window being processed by a second application, the first and second application being a separate executable code images that are separately scheduled by an operating system of the computer system, the computer system having a display device and a window system for managing the displaying of windows on the display device and for passing user input events to applications, the window system allowing the scrolling of data displayed within a window, by perforating the steps of:
indicating a selection of data contained within the inner application window that is contained and activated within the outer application window; and
in response to a user input to scroll the outer application window, maintaining the indicated selection of data as the selected data.
15. A computer system for scrolling a container object, the computer system having an operating system that schedules execution of computer programs, the system comprising:
a container window belonging to the container object,
a containee object;
a containee window belonging to the containee object,
a server application program, separately schedulable by the operating system, which manages the containee object and the containee window and which, in response to receiving user input,
selects data in the containee window;
indicates that the selected data is selected; and
processes an indicated operation on the selected data;
a client application program, separately schedulable by the operating system, which manages the container object and the container window and which, in response to receiving user input,
when the input indicates selection and activation of the containee object,
selects the containee object; and
causes the containee object to be activated within a window environment of the container application, wherein the containee window is displayed within the container window;
when the input indicates that the container window is to be scrolled, scrolling the container window while maintaining the indication in the containee window that the selected data is selected; and
when the input indicates an operation other than scrolling and other than selection of the containee object, deselecting the containee object, wherein the indication of the data selection within the containee window is no longer displayed; and
a window manager that sends user input to the client application when the user input occurs within the container window and that sends user input to the server application when the user input occurs within the containee window.
16. A computer system for scrolling comprising:
a display device;
a window system for managing displaying windows on the display device and for passing input events to applications;
an operating system for separately scheduling a server application and a client application;
an inner application window having input events that are processed by the server application, wherein the server application, in response to receiving a selection input event, indicates a selection of data within the inner application window; and
an outer application window that contains the inner application window activated within the outer application window, the outer application window having input events flint are processed by the client application, wherein the client application,
in response to receiving a scrolling input event, scrolls the outer application window while maintaining the indication of the selection of data within the inner application window; and
in response to receiving a selection input event outside the inner application window, removes the indication of the selection of data within the inner application window.
17. The computer system of claim 14 the indication of the selection of data being a hatched border pattern displayed around the selected data.
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 BitBit 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 conger 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::On UIDeactivate 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.
FIG. 29 is a flow diagram 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::SetActiveObject 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 IOLEInPlaceParem::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 Do InPlaceHide 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.
FIG. 51 is a flow diagram 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.
FIG. 53 is a flow diagram 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 CreateObjectToolbars
4.6.4 RemoveMenus
4.7 Object Linking and Embedding API Helper Functions
4.7.1 SetActiveObjectHwnd
4.7.2 GetActiveObjectHwnd
4.7.3 ObjectCreateSharedMenu
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 IOLEInPlaceParem::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--UIDeactivateConminedObject
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 windowing 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 functions 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 Object-Oriented 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. Refering 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 implementation 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 dam. 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 the server application for this 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 and 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 1 represents the definition for the interface for the first entry pintf.sub.1 in the object data structure 601. In Table 1, the word "interface" is defined to mean a C++ class. The definition shows three methods with their parameters. The word "virtual" indicates that the declared method can be overridden by a method of the same name and type in a derived class. (A derived class is a class that inherits the data members and methods of its base class.) The "=0" at the end of each parameter list indicates that the method has no code implementation. In the C++ programming language, these methods functions are termed "pure virtual functions". In C++, a class with at least one pure virtual function is referred to as an abstract class. In a preferred embodiment, an interface is an abstract class with no data members and whose virtual functions are all pure. Thus, an interface provides a protocol for two programs to communicate. To support an interface, a program implements a class that provides an implementation for the interface (through derivation). Thereafter, objects are created as instances of this class.
FIG. 7 is a block diagram showing a public view of an object. The public view of an object is the various interfaces that the object supports 702-706. Each interface provides methods through which container applications can access the object. Each object supports an IUnknown interface 702. Container applications use the IUnknown interface 702 to determine which other interfaces the object supports. The implementation of IUnknown interface 702 for a particular object knows what other interfaces the object supports and returns to the invoking application pointers to those interfaces. In a preferred embodiment, the method IUnknown::QueryInterface is used for this purpose. Interfaces 703 through 706 are examples of typical interfaces that can be supported by an object. These interfaces derive from the IUnknown interface. For example, the IDataObject interface 703 provides methods for storing data in and retrieving data from the object. The IOLEContainer interface 704 provides methods for listing the containee objects that are contained within the object. The IPersistStorage interface 705 provides methods for storing the object to and retrieving the object from persistent storage. The IOLEObject interface 706 provides methods through which a container application invokes the functionality of an object that corresponds to a user-selected action.
In addition to the API, the object linking and embedding facilities of the present invention provide information to container and server applications through a persistent global "registry." This registry is a database of information such as (1) for each type of object, the server application that implements the object type, (2) the actions (verbs) that each server application provides to container applications, (3) where the executable files for each server application are located, and (4) whether each server application has an associated object handler.
2. In-Place Interaction Overview
Once objects have been linked or embedded into a document, a user can select objects and request that certain actions be performed upon the selected objects. A user requests actions by first selecting the object and then selecting an action (e.g., a menu item) to be performed upon the object. The implementing server application is then invoked to perform the selected action. One skilled in the art will appreciate that there are many ways to display the choices of possible actions to a user and allow the user to select an action. In a preferred embodiment, the container application determines from the global registry what actions are supported by the server application implementing the selected object and then displays the actions in a menu.
FIG. 8 is a sample user menu provided by a container application to display and select the actions available for an object. Menu item 803 is the entry for the object on the container application Edit menu 802. The entry varies based on the currently selected object. When no embedded or linked objects are selected, menu item 803 is not displayed. Submenu 804 displays the actions supported by an "Excel Worksheet Object." In this example, the supported actions are "Edit," "Open," and "Type." The first action (e.g., "Edit") on a submenu is the default action, which is performed when a user double-clicks with a mouse pointing device on the object, or enters functionally equivalent keys.
Once a user has selected a desired action (from the menu or by double-clicking on the object), the container application can then invoke the server application passing it an indication of the action to perform on behalf of the container application. The container application does this by obtaining the IOLEObject interface for the object and then invoking the object's DoVerb method passing it the selected action. (The DoVerb method performs the object-specific actions on the object.) The server application in turn determines whether the object can be activated in place within the window environment of the container application. If so, the server application and container application merge their menus into a composite menu bar, negotiate the placement of server application tool bars, palettes, formula bars, etc., and set up merged message handling. At this point, the server application is ready to receive user input.
Continuing the example of FIG. 4, shows the user editing the spreadsheet object (the budgeting data 405) in place within the window environment of a word processing application. 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. The composite menu bar 901 comprises menus 902, 905 from the word processing application and menus 903, 904, 906 from the spreadsheet application. When the user selects a particular menu item from one of these menus, the container application through the merged message handler determines whether to dispatch the message to the word processing application or to the spreadsheet application.
In a preferred embodiment of the present invention, a composite menu bar is created based upon a set of predetermined conventions. Each application menu to be included in the composite menu bar is assigned to a menu group. The menus are then inserted into the composite menu bar according to the assigned menu group.
FIG. 10 is a diagram of the menu groups that compose a composite menu bar in a preferred embodiment of the present invention. The composite menu bar 1003 comprises menu groups 1001 from the container application and menu groups 1002 from the server application. The container application menu groups 1001 include the File group, the Container group, and the Window group. The server application menu groups 1002 include the Edit group, the Object group, and the Help group. In a preferred embodiment, the container and server application menus are interleaved in the final composite menu bar, according to the Microsoft application user interface style guidelines, which is specified in "The Windows Interface: An Application Design Guide," Microsoft Corp., 1992, which is herein incorporated by reference. Specifically, in the composite menu bar 1003, the groups are arranged left to right in the following order: File, Edit, Container, Object, Window, and Help.
3. Window Support for In-Place Interaction
In a preferred embodiment, the in-place interaction API is implemented using the capabilities of the underlying window system. The present invention is described assuming the underlying window system is similar to the Microsoft Windows 3.1
operating system ("Windows"), although one skilled in the art will appreciate that the present invention can be implemented in a different underlying window system. The Microsoft Windows 3.1 operating system is described in "Programmer's Reference, Volume 2: Functions," Microsoft Corp., 1992; "Programmer's Reference, Volume 3: Messages, Structures, and Macros," Microsoft Corp., 1992; and "Guide to Programming," Microsoft Corp., 1992, which are herein incorporated by reference.
In window environments, applications support a single document interface or a multiple document interface. A single document interface ("SDI") application interacts with one document (file) at a time. For example, a word processing application that supports SDI would display the file currently being edited in its primary window. A multiple document interface ("MDI") application interacts with multiple documents (files) by devoting at least one window to each document. For example, a word processing application that supports MDI might display each file currently being edited in a separate document window. The user selects the document window of the file the user wishes to edit either by clicking on the title bar of the desired document window or by selecting the window title from a list on the Window menu of the application.
FIG. 11 is a diagram showing the component windows of a typical Single Document Interface application. A typical SDI application provides a frame window 1101, and, depending upon the application, may additionally provide pane windows 1105 and
1106 and a parent window 1107 for an embedded object resides. In the case of an SDI application, the frame window 1101 is also the document window. Pane windows 1105, 1106 provide multiple views of a compound document. A parent window 1107 may be created by the container application to delineate the object when the object is first inserted into the compound document. In the example shown in FIG. 11, the embedded object is a spreadsheet object, which is displayed within an object window 1108, which is contained within the parent window 1107 of the container application. The object window 1108 is owned by the server application. The frame window 1101 contains a title bar 1102, a menu bar 1103, and a tool bar 1104. Typically, tool bars and other application-specific tools are attached to either the frame window or a pane window of a container application. They may also appear as floating palettes, which are windows that are independent of the windows shown in FIG. 11 and thus appear to "float" on top.
FIG. 12 is a diagram showing the component windows of a typical Multiple Document Interface application. A typical MDI application allows a user to edit multiple compound documents from within the same container application. In the example shown in FIG. 12, the user edits two separate compound documents in the two document windows 1205, 1206. Each document window can contain pane windows in a manner analogous to the SDI application. Document window 1205 contains two pane windows 1207,
1208. Also, the MDI application can provide a parent window 1209 for containing embedded objects in a manner analogous to the SDI application. FIG. 12 shows an embedded spreadsheet object presented within an object window 1210. As in the case of an SDI application, the application-specific tools may appear anywhere.
The windows managed by either an SDI or MDI application are created and maintained in a hierarchical fashion. FIG. 13 is a block diagram showing the typical window hierarchy of a container application when it is editing an embedded object in place. The window hierarchy comprises container application windows 1301 from the container application, and server application windows 1307 from the server application. The container application 1302 manages its frame window 1303, which contains a document window 1304, which may contain a pane window 1305, which may contain a parent window 1306. When an object is activated in place, the server application 1308 creates a root window 1309 for the embedded object and any child windows it requires. The object root window 1309 contains object child windows 1310, 1311, 1312.
Every application, when implemented as a separate process, contains an input queue for receiving events connected with the windows residing in the application's window hierarchy. The window hierarchy of FIG. 13 is supported by two different applications. Thus, there are separate input queues associated with the windows belonging to the container application and the windows belonging to the server application. Input queue 1313 is associated with the container application windows 1301. Input queue 1314 is associated with the server application windows 1307. In order to receive user input, a window is displayed. When a user clicks with the mouse, or inputs keystrokes to one of these windows, the underlying window system puts an appropriate message on either the container input queue 1313 or the server application queue 1314.
4. In-Place Interaction API
The object linking and embedding API provides functions and defines interfaces through which the container and server applications communicate to support in-place interaction. The methods of these interfaces and the other API functions are invoked by application code in the usual course of processing user input. In an event-driven windowing system, an application invokes the appropriate method or function in response to receiving a message indicating that a user has selected a particular menu item or object.
FIG. 14 is a flow diagram showing message processing in an event-driven windowing operating system environment. Each window has its own message handler, which is registered with the underlying window system when the window is created. Several windows may share a single message handler. When messages are received on an application input queue (for example, the input queue of the container application 1313), the application filters, translates, or dispatches the message to the window system. The window system dispatcher in turn sends the message to the message handling function (the "message handler") that was previously registered for the particular window indicated in the message. Upon receipt of the message, the message handier processes the message. The processing may include using the object linking and embedding API. Steps 1401 and 1402 compose a message pump. In step 1401, the application waits for a message on its input queue. In step 1402, the application filters or translates the message, if appropriate, or dispatches the message to the window system dispatch function. Steps 1403 and 1404 are the steps in the window system dispatch function that dispatch the message to the appropriate window message handler. In step 1403, the window system dispatcher locates the message handler for the window that is indicated in the message. In step 1404, the window system dispatcher sends the message to the located message handler (e.g., by invoking the message handler).
Steps 1405 through 1412 compose a typical message handler for a window. A message handler is also referred to as a "window procedure." In a preferred embodiment, if an application does not provide a window procedure for a particular window, the underlying window system provides a default message handler called DefWindowProc. In steps 1405 through 1408, the application decodes the message to determine what type of event has occurred. Typically, for each type of event, the application invokes a different function, as shown in steps 1409 through 1412. These functions may in turn use the object linking and embedding API. For example, when a menu event is received, the application, in step 411, invokes a function that processes menu events. If a contained object is selected before a menu event that can cause the object to be activated in place, then in step 1411 invokes the Process.sub.-- Object.sub.-- Activation function (shown as step 1413), which activates the selected containee object in place. As will be discussed further below, the Process.sub.-- Object.sub.-- Activation function uses the object linking and embedding API to activate a containee object.
The in-place interaction API defines the following interfaces: IOLEWindow, IOLEInPlaceUIWindow, IOLEInPlaceFrame, IOLEInPlaceParent, and IOLEInPlaceObject. The IOLEWindow interface provides a method for retrieving the window handle associated with one of the other interfaces. The IOLEInPlaceUIWindow interface provides methods through which a server application negotiates with a container application for placement of window tools. The IOLEInPlaceFrame interface provides methods through which a server application communicates with the frame window of a container application. The IOLEInPlaceParent interface provides methods through which a server application communicates with the parent window of a container application. The IOLEInPlaceObject interface provides methods through which a container application activates and deactivates a server application. FIG. 14B is a block diagram showing the public interfaces required to support in-place interaction. The container object
14B01 supports the IOLEUIW interface 14B02, the IOLEInPlaceParent interface 14B03, and the IOLEInPlaceFrame interface 14B04. The containee object 14B05 supports the IOLEInPlaceObject interface 14B06. Each of these interfaces is described below in detail.
4.1 IOLEWindow Interface
Table 2 lists the IOLEWindow interface. In object-oriented parlance, the IOLEWindow interface is the "base class" for the other in-place interaction interfaces. Thus, the other interfaces are derived from the IOLEWindow interface and inherit its public methods. In the IOLEWindow interface there is only one public method called GetWindow.
TABLE 2 __________________________________________________________________________ interface IOLEWindow: public IUnknown {public: virtual SCODE GetWindow (HWND FAR *phwnd) = 0; __________________________________________________________________________
4.1.1 IOLEWindow::GetWindow
The GetWindow method retrieves the window handle (unique window identifier) corresponding to the IOLEInPlaceUIWindow, IOLEInPlaceFrame, IOLEInPlaceParent, or IOLEInPlaceObject interface from which it was invoked. The retrieved window handle is typically used when invoking underlying window system functions.
4.2 IOLEInPlaceUIWindow Interface
Table 3 lists the IOLEInPlaceUIWindow interface. The IOLEInPlaceUIWindow interface methods are invoked by a server application to negotiate tool placement within the document and pane windows of a container application.
TABLE 3 __________________________________________________________________________ interface IOLEInPlaceUTWindow: public IOLEWindow {public: virtual SCODE GetBorder (RECT borderRect) = 0; virtual SCODE QueryBorderSpace (RECT widthRect) = 0; virtual SCODE SetBorderSpace (RECT widthRect) = 0; __________________________________________________________________________
4.2.1 IOLEInPlaceUIWindow::GetBorder
The GetBorder method retrieves the location where the server application is allowed to place its tools (which are implemented as child windows). This method returns a rectangle located inside the frame of either a document or pane window, depending upon whether the document or pane interface was invoked. Once the server application has retrieved this rectangle, it can determine the width of space it needs to place any tools and can then request this space using the QueryBorderSpace method. If the rectangle returned by the container application is rejected, the server application can choose not to continue with activation in place or can choose to not activate its tools.
4.2.2 IOLEInPlaceUIWindow::QueryBorderSpace
The QueryBorderSpace method retrieves the designated amount of space in a pane or document window where the server application can place its tools. The method takes one parameter, a rectangle of border space, within the rectangle retrieved from a previous call to GetBorder, that the server application needs for its tool placement. The method returns an indication as to whether the document or pane window is able to accommodate the request. If the request cannot be accommodated, the server application can invoke the method again with a different rectangle, can choose not to continue activation in place, or can choose to not activate its tools.
4.2.3 IOLEInPlaceUIWindow::SetBorderSpace
The SetBorderSpace method informs its associated container application that it is actually allocating the designated space in the pane or document window to place the server application's tools. This method is called after the space has been successfully requested from the pane or document window in a previous call to QueryBorderSpace. The server application is responsible for allocating the space it needs. The method takes one parameter, the rectangle of space the server application is allocating to its tool child window. The designated rectangle may be smaller than that successfully previously requested. The term "designated" refers to a passed in parameter and "specified" refers to the interface, class, window, or object to which a particular method belongs. The method moves or sizes, as necessary, any of the specified pane or document window user interface resources.
4.3 IOLEInPlaceFrame Interface
Table 4 lists the IOLEInPlaceFrame interface. The IOLEInPlaceFrame interface provides methods invoked by a server application to communicate with the frame window of its container application.
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 lpszStatus Text) = 0; virtual SCODE EnableModeless (BOOL fEnable) = 0; virtual SCODE TranslateAccelerator (LPMSG lpmsg, WORD WID) = 0; __________________________________________________________________________
4.3.1 IOLEInPlaceFrame::SetMenu
The SetMenu method installs and removes the designated composite menu bar as the menu bar of the container application and installs a message handler for the composite menu bar. FIG. 15 is a flow diagram of an implementation of the IOLEInPlaceFrame::SetMenu method. This method uses different mechanisms to install the composite menu bar depending upon whether the container application is an MDI or SDI application. In step 1501, the method determines whether the designated composite menu bar is NULL and, if so, continues at step 1502, else continues at step 1503. In step 1502, the method invokes the helper function ObjectSetMenuDescriptor to remove the message handler for the composite menu bar, and returns. In step
1503, the method determines whether the container application is an SDI application, and if it is, continues at step 1504, else continues at step 1505. In step 1504, the method invokes the underlying window system function SetMenu to install the composite menu bar as the menu bar of the container application frame window, and then it continues at step 1507. In step 1505, the method sends a message to the frame window telling it to perform its MDI menu setup. In step 1506, the method invokes the underlying window system function DrawMenuBar to redraw the menu bar. In step 1507, the method invokes the helper function ObjectSetMenuDescriptor to install the message handler for the composite menu bar. In step 1508, the method performs any other processing that may be required at the time of changing its menu bar and then returns.
4.3.2 IOLEInPlaceFrame::InsertMenus
CODE TABLE 1 __________________________________________________________________________ VOID IOleInPlaceFrame::InsertMenus (hmenu, ContrCounts) { 1 if there are File Groups menus present { 2 for each filegroupmenu { 3 hfilemenu = CreateMenu ( ) ; 4 InsertMenu (hmenu, MF.sub.-- APPEND,MF.sub.-- BYPOSITION.vertline.MF.s ub.-- POPUP, hfilemenu); 5 ContrCounts[0] = ContrCounts[0] + 1; 6 for each filegroupmenu.sub.-- item { 7 InsertMenu (hfilemenu, MF.sub.-- APPEND,MF.sub.-- BYPOSITION.vertline .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 = CreatMenu ( ) ; 14 InsertMenu (hmenu, MF.sub.-- APPEND,MF.sub.-- BYPOSITION.vertline.MF.s ub.-- POPUP, hcontmenu); 15 ContrCounts[1] = ContrCounts[1] + 1; 16 for each contgroupmenu.sub.-- item { 17 InsertMenu (hcontmenu, MF.sub.-- APPEND,MF.sub.-- BYPOSITION.vertline .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.MF.s ub.-- POPUP, hwndmenu); 25 ContrCounts[2] = ContrCounts[2] + 1; 26 for each wndgroupmenu.sub.-- item { 27 InsertMenu (hwndmenu, MF.sub.-- APPEND,MF.sub.-- BYPOSITION.vertline. MF.sub.-- STRING, 28 item.sub.-- id, "string to be displayed"); 29 } 30 }; 31 return ( ); __________________________________________________________________________
The InsertMenus method inserts the menus of the container application into the composite menu bar being created by the server application. Code Table 1 shows pseudo-code for an implementation of the IOLEInPlaceFrame::InsertMenus method. The method takes two parameters: a composite menu bar and an array of menu counts. For each of the menu groups represented by the menus of the container application, there is a loop which inserts the menus for that group. In lines 1-10, if there are any File group menus, then the method inserts these menus in the composite menu bar, and increments the menu count array at the index corresponding to the File group. (For example, index=0 if the menu bar presented in the example of FIG. 4 is used.) In lines 11-20, if there are any Container group menus, the method inserts these menus into the composite menu bar and increments the menu count array at the index corresponding to the Container group. Finally, in lines 21-30, if there are any Window group menus to be added, the method inserts these menus into the composite menu bar and then increments the menu count array at the index corresponding to the Window group. At the completion of this method, the value stored at each index in the menu count array indicates the number of menus that the container application inserted for that particular menu group. The method invokes standard functions from the underlying window system (CreateMenu and InsertMenu) to create the menus for the container application and to insert them in the composite menu bar.
4.3.3 IOLEInPlaceFrame::RemoveMenus
The RemoveMenus method allows the container application to remove its menus from the composite menu bar before the server application deallocates the composite menu bar. This method is invoked from the IOLEInPlaceObject::InPlaceDeactivate method. The RemoveMenus method takes one parameter: the handle of the composite menu bar where the container menus are stored. The composite menu bar is expected to be clear of all server menus before this method is invoked.
4.3.4 IOLEInPlaceFrame::SetStatusText
The SetStamsText method allows the server application to set the status window (if there is one) of the container application's frame window. Typically, the status window is located at the bottom of the frame window and contains status or hinting information corresponding to the current selection. The SetStatusText method is container application specific and will perform whatever operations the container application usually performs to set its status window. The method takes one parameter: the text string to insert in the status window.
4.3.5 IOLEInPlaceFrame::EnableModeless
The EnableModeless method enables or disables the currently displayed modeless dialog for the container application. A modeless dialog is an input window which is displayed until it is explicitly closed by the user. While this window is displayed, the user is able to interact with other windows. A modal dialog, on the other hand, is an input window which blocks out other window processing until the user enters acceptable input. This method is invoked by a server application when it wants to display a modal dialog, but and its associated container application is already displaying a modeless dialog.
FIG. 16 is a flow diagram of an implementation of the IOLEInPlaceFrame::EnableModeless method. This method hides the modeless dialog of the container application, and when called again restores the modeless dialogs. If the designated flag fEnable is true, then the hidden dialogs are displayed, otherwise any currently displayed modeless dialogs are hidden (removed from display, but in-memory data structures not deallocated). In step 1601, the method determines whether FEnable is true, and, if it is, continues at step 1602, else continues at step 1603. In step 1602, the method invokes an underlying window system function ShowWindow to restore the windows associated with the previously saved modeless dialogs, and then returns. In step
1603, the method saves the window handle of the next currently displayed modeless dialog. In step 1604, the method invokes an underlying window system function ShowWindow to hide the window associated with the modeless dialog. In step 1605, the function checks to see if there are any more modeless dialogs displayed, and, if there are, the function loops back to step 1603, otherwise the function returns.
4.3.6 IOLEInPlaceFrame::TranslateAccelerator
The TranslateAccelerator method allows a container application to process accelerator key combinations when a server application receives a keystroke it does not recognize. Accelerator key combinations are keyboard shortcuts for menu commands and are discussed further below. The TranslateAccelerator method is invoked indirectly by the function ObjectTranslateAccelerator which is called in the server application message pump. The container application should perform its normal accelerator processing and then return an indication of whether or not the accelerator was processed. This value is then passed on to the server application by the function ObjectTranslateAccelerator. Note that because the message has been transferred from the server application to the container application, the underlying window system may not have retained any additional key state or message information associated with the designated message.
4.4 IOLEInPlaceParent Interface
Table 5 lists the IOLEInPlaceParent interface. The IOLEInPlaceParent interface provides the methods invoked by the server application to communicate with the parent window. This window is also referred to as the in-place "container site" for the object.
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; __________________________________________________________________________
4.4.1 IOLEInPlaceParent::CanInPlaceActivate
The CanInPlaceActivate method is used by the server application to determine whether the container application supports in-place interaction. This method gives the container application a chance to accept or refuse the activation in place of a selected containee object. The method returns an indication of whether the container application is allowing in-place interaction.
4.4.2 IOLEInPlaceParent::OnInPlaceActivate
The OnInPlaceActivate method is invoked by a server application to give its container application a chance to perform any necessary operations before the server application creates the new composite menu bar (at activation time). FIG. 17 is a flow diagram of an implementation of the IOLEInPlaceParent::OnInPlaceActivate method. In this implementation, the only operation performed is setting a flag in step 1701 indicating that a containee object has been activated. This information is used later, whenever the specified object's parent container object is asked to activate or deactivate. This flag tells the parent container application whether it needs to activate or deactivate an object contained within it (a nested object), instead of activating or deactivating its own user interface.
4.4.3 IOLEInPlaceParent::OnUIActivate
The OnUIActivate method removes all of the container application menus and tools in preparation for activation of a containee object in place. FIG. 18 is a flow diagram of an implementation of the IOLEInPlaceParent::OnUIActivate method. The steps performed by the method depend on whether the container object is itself an object that has been activated in place. In step 1801, the method determines whether the container object has been activated in place. If it has not, the method continues at step 1802, else it continues at step 1803. In step 1802, because the container object is a top level container object (not activated in place), the method uses its normal procedure to remove the container application menus and any extraneous tools, and then returns. In step 1803, because the container object is also a containee object, the method retrieves the object's own IOLEInPlaceObject interface to access the methods that treat the container object as a containee object. In step 1804, the method invokes the activate method of the container object to deactivate itself. In step 1805, the method hides all of the container object's document and pane window level tools. In step 1806, the method invokes the shade border method of the parent container object to remove the in-place interaction user feedback from around the container object and returns. The container object's object window is actually deactivated at a later time (e.g., when the containee object deactivates).
4.4.4 IOLEInPlaceParent::OnUIDeactivate
The OnUIDeactivate method is invoked by a server application at the end of deactivating its user interface resources to allow its parent container application to either activate its own user interface or invoke its parent container application to allow the parent container application to activate its user interface. FIG. 19 is a flow diagram of an implementation of the IOLEInPlaceParent::OnUIDeactivate method. This method provides two different behaviors depending upon whether the container object is itself a containee object or is a top level container object. In the former case, if this container is to become the new object activated in place, then its own user interface is activated, otherwise the container requests its parent container application to activate its user interface. In the latter case, the container application restores its user interface using normal procedures. In step 1901, the method clears the flag indicating that the container application has activated a containee object. In step 1902, the method determines whether the specified container object is a containee object, and if it is not, continues at step 1903, else continues at step 1905. In step 1903, the method sets the container application menus and its title bar using normal procedures, and continues in step 1904 to set the input focus to the desired window, and returns. The input focus is set to a particular window when that window is to receive keyboard input. In step 1905, the method examines the flag ABOUT.sub.-- TO.sub.-- ACTIVATE to determine whether the container object is about to become the activated object, and if it is not, continues at step 1906, else continues at step 1907. (The ABOUT.sub.-- TO.sub.-- ACTIVATE flag is set when the container application is selected by the user, e.g., in the Process.sub.-- Mouse.sub.-- LButtonUp function discussed in detail below.) In step 1906, the method invokes the IOLEInPlaceParent::OnUIDeactivate method of the container object to activate the user interface of the container application of the parent container object, and returns. In step 1907, the method invokes function ActivateUI to activate the user interface of the container application, and returns.
4.4.5 IOLEInPlaceParent::OnDeactivate
The OnDeactivate method is invoked by the server application to give its associated container application a chance to free any resources or set flags associated with the activated containee object before the containee object is fully deactivated. The method is invoked from the IOLEInPlaceObject::InPlaceDeactivate method of the containee object.
4.4.6 IOLEInPlaceParem::ShadeBorder
The ShadeBorder method draws or removes a hatched pattern border from around the selected, or about to be deselected, containee object. The hatched pattern border is used to give the user feedback that the containee object has been activated in place. This method can invoke the helper object linking and embedding API function ObjectShade to create the proper shading pattern. The method takes two parameters: a rectangle surrounding the object where the border should be placed and a set of flags. The set of flags indicates whether the border should be on (SHADEBORDER.sub.-- ON=1) or off and whether the border should be drawn in the same color as the text contained in the title bar of the active window (SHADEBORDER.sub.-- ACTIVE=1) or the same color as disabled text. The active window is the window that has input focus.
4.4.7 IOLEInPlaceParent::GetWindowContext
The GetWindowContext method returns the set of container application interfaces associated with a particular containee object. Specifically, it returns the following parameters:
pFrame, which is a pointer to an IOLEInPlaceFrame interface;
pDoc, which is a pointer to an IOLEInPlaceUIWindow interface;
pPane, which is a pointer to an IOLEInPlaceUIWindow interface;
lprectChildPosn, which is a pointer to the location where the associated
IOLEInPlaceParent instance will display the object window of the object within the parent window; and
hAccelTable, which is a handle to the container application's accelerator table (described below).
These values are used by the server application to negotiate and handle activation and deactivation. This method creates and associates instances of these interfaces with the relevant frame, document, pane, and parent windows of the container application.
4.5 IOLEInPlaceObject Interface
Table 6 lists the IOLEInPlaceObject interface. The IOLEInPlaceObject interface methods are invoked by a container application to activate and deactivate a contained object. Some of these methods access contained objects in a nested fashion, through the containment hierarchy. Others access only the current active object, which is the containee object displaying the editing menus. An alternative implementation would split this interface into two others: one to access only the active object and another to access a containee object through the containment hierarchy.
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; __________________________________________________________________________
4.5.1 IOLEInPlaceObject::InPlaceDeactivate
The InPlaceDeactivate method is invoked by a container application to completely deactivate a containee object after an "undo" operation no longer needs to access the containee object and before the container application closes. This method performs the final deallocation of any resources associated with the activation of the containee object in place. FIG. 20 is a flow diagram of an implementation of the IOLEInPlaceObject::InPlaceDeactivate method. The method first determines whether it has activated a (nested) object contained within it, and if it has, it invokes the nested object's InPlaceDeactivate method. Otherwise, the object deactivates itself. In step 2001, the method determines whether the specified object is also a container object and has activated a nested containee object. If it has the method continues at step 2002, else it continues at step 2004. In step 2002, the method retrieves the IOLEInPlaceObject interface of the activated containee object (which the server application of the specified object has previously stored), and in step 2003 invokes IOLEInPlaceObject::InPlaceDeactivate method of the retrieved interface, and then returns. In step 2004, the method checks to see whether the specified object's user interface is still active, and if it is, continues at step 2005, else continues at step 2006. In step 2005, the method invokes the specified object's InPlaceUIDeactivate method to deactivate its own user interface, and then continues at step 2006. In step 2006, the method invokes a server application function Remove.sub.-- Menus to remove the server application menus from the composite menu bar. In step 2007, the method invokes the IOLEInPlaceFrame::RemoveMenus method of the specified object's container object to allow the parent container application to remove its menus from the composite menu bar. In step 2008, the method invokes the object linking and embedding API function ObjectDestroySharedMenu to deallocate the structure for the composite menu bar. The ObjectDestroySharedMenu function is window system specific and invokes whatever underlying window system functions are necessary to deallocate structures associated with a composite menu bar. In step 2009, the method invokes the underlying window system function DestroyMenu to deallocate the composite menu bar structure and to deallocate the window associated with the specified object. Finally, in step 2010, the method invokes the IOLEInPlaceParent::OnDeactivate method of the specified object's container object, and returns.
4.5.2 IOLEInPlaceObject::InPlaceUIDeactivate
The InPlaceUIDeactivate method hides all of the user interface elements associated with the specified object that has been activated in place. This method is invoked either by the container application when it processes the user selection of a different object or area within the compound document, or from the specified object's InPlaceDeactivate function if the specified object's user interface has not yet been deactivated (See FIG. 20). FIG. 21 is a flow diagram of an implementation of the IOLEInPlaceObject::InPlaceUIDeactivate method. This method first determines whether the specified object is a container object and has activated a nested object, and if so invokes the nested object's InPlaceUIDeactivate function. Otherwise, the method hides its own user interface and informs its container application that it has deactivated its user interface. In step 2101, the method determines whether the flag indicating that a nested containee object has been activated in place is true, and if so, continues at step 2102, else continues at step 2104. In step 2102, the method retrieves the IOLEInPlaceObject interface for the activated nested containee object, and in step 2103 invokes the nested containee object's InPlaceDeactivate method and returns. In step 2104, the method clears the flag ABOUT.sub.-- TO.sub.-- ACTIVATE to indicate that the user has selected a different object. In step 2105, the method invokes the specified object's Activate method sending it a parameter of false to request the method to deactivate. This method removes all of the specified object's user interface elements that were associated with the parent container application frame window. In step 2106, the method invokes the object linking and embedding API function SetActiveObjectHwnd to remove the specified object's IOLEInPlaceObject interface from its association with the parent container application document window. This means that if the container application is an MDI application, and if the user later selects this document window, the specified object will no longer be reactivated in place. In step 2107, the method uses an underlying window system function to hide any user interface elements belonging to the server application that were associated with the parent container application's pane or document window. In step 2108, the method invokes the IOLEInPlaceParent::ShadeBorder method of the specified object to remove the hatched border pattern feedback from around the deactivating object. In step 2109, the method invokes an underlying window system function to hide the window associated with the specified object. Finally, in step 2110, the method invokes the IOLEInPlaceParent::OnUIDeactivate method to allow the container application to install its own user interface, and returns.
4.5.3 IOLEInPlaceObject::TranslateAccelerator
The TranslateAccelerator method allows a server application to process accelerator key combinations before the container application has a chance to process them. Accelerator key combinations are keyboard shortcuts for menu commands and are discussed further below. In a preferred embodiment of the present invention, the object activated in place, by convention, processes accelerator key combinations first. The Translate Accelerator method is invoked by the container application in its message pump (see Code Table 9). The only operation required to be performed by this method is to invoke the underlying window system function TranslateAccelerator with the specified server application accelerator table. Such invocation is not necessary if the containee object is implemented by a separate executable process, because the separate process receives these key combinations in its own message pump and the container application never receives them. In that case, the TranslateAccelerator method will do nothing.
4.5.4 IOLEInPlaceObject::Activate
The Activate method activates or deactivates the user interface elements installed in the frame window of the parent container application depending upon whether the designated flag fActive is true or false. If called when an MDI document window is activated or deactivated, this method installs or removes the composite menu bar associated with the object activated in place and puts a hatched border pattern around the specified object if it is being activated. If called when the top level frame window is activated or deactivated, this method places a hatched border pattern around the specified object if it is being activated, otherwise removes it. In this case there is no need to activate or deactivate other user interface elements. FIG. 22
is a flow diagram of an implementation of the IOLEInPlaceObject::Activate method. In step 2201, the method determines whether it has been called as a result of activating or deactivating the top level frame window or an MDI (child) document window. If called as a result of activating or deactivating an MDI document window, the method continues at step 2202, else continues at step 2210. In step 2202, the method determines whether the specified object is to be activated, and if it is not, continues at step 2203, else it continues at step 2206. In step 2203, the method invokes the IOLEInPlaceFrame::SetMenu method of the parent container object to remove the composite menu bar associated with activation of the specified object in place. In step 2204, the method hides any user interface elements installed in the parent container application frame window. In step 2205, the method invokes the IOLEInPlaceParent::ShadeBorder method of the parent container object to remove the hatched border pattern from around the specified object, and returns. In step 2206, the method invokes the IOLEInPlaceFrame::SetMenu method of the parent container object to install the composite menu bar as the menu bar of the associated frame window. In step 2207, the method sets the title bar of the frame window of the container application to indicate that the container application has activated the specified object. In step 2208, the method invokes an underlying window system function to display any frame level user interface elements. In step 2209, the method invokes the IOLEInPlaceParent::ShadeBorder method of the parent container object to draw a hatched border pattern around the specified object, indicating that it has been activated in place, and returns. In step 2210, the method determines whether the specified object is to be activated, and if it is, continues at step 2209, else it continues at step 2211. In step 2211, the method removes the hatched border pattern from around the specified object, and returns.
4.5.5 IOLEInPlaceObject::ResizeBorder
The ResizeBorder method is called by the container application to request the server application to resize the user interface tools the server application has placed within the pane or document windows of its parent container application. In response to invocation of this method, the server application should begin another tool placement negotiation loop with the container application using the QueryBorderSpace and SetBorderSpace methods of the interface instance associated with the pane or document window.
4.5.6 IOLEInPlaceObject::EnableModeless
The EnableModeless method enables or disables the currently displayed modeless dialog for the server application. Typically, this method is implemented in a manner analogous to the IOLEInPlaceFrame::EnableModeless method, which is discussed above with reference to FIG. 16.
4.5.7 IOLEInPlaceObject::SetVisRect
The SetVisRect method is called by the innermost level container object to communicate the amount of the object actually visible. The visible (clipping) rectangle of the object may have changed, for example, due to border negotiation, scrolling, or sizing. The designated rectangle is the clipping rectangle and it is the server application's responsibility to resize the containee object window to the correct (clipped) visible size.
4.6 Other Server Application Functions
In a preferred embodiment, a server application provides the following set of functions: ActivateUI, CreateNewMenu, CreateObjectToolbars, and RemoveMenus. These functions are shared by multiple server application interfaces including IOLEInPlaceObject and IOLEObject.
4.6.1 ActivateUI
SCODE ActivateUI (IOLEInPlaceUIWindow *pDoc, IOLEInPlaceObject pObject)
The ActivateUI function is a function implemented by a server application to control activation of the designated containee object's user interface resources. This high level function activates the frame, document, and pane level user interface elements, draws the hatched border pattern around the object, and displays the composite menu bar. FIG. 23 is a flow diagram of an implementation of the ActivateUI function. The function takes two parameters: a pointer to a document interface and a pointer to a containee object. In step 2301, the function gets the window handles for the designated document window and the designated containee object. In step 2302, the function invokes the object linking and embedding API function SetActiveObjectHwnd to set the designated document window's currently active object to a pointer to the interface of the containee object. This enables a container application implemented as an MDI application to activate the proper containee object when one of its document windows is selected by the user. In step 2303, the function invokes IOLEInPlaceObject::Activate method to activate the designated object. In step 2304, the function invokes the underlying window system function ShowWindow to display any user interface elements associated with the container application pane or document windows. In step 2305, the function determines the dimensions of a border or rectangle to surround the designated containee object, and, in step 2306, the function invokes the IOLEInPlaceObject::ShadeBorder method of the designated containee object to draw a hatched border pattern around the designated containee object using this rectangle. In step 2307, the function sets the input focus to the object window of the designated containee object. Finally, in step 2308, the function invokes the underlying window system function DrawMenuBar to redisplay the composite menu bar, and returns.
4.6.2 CreateNewMenu
HANDLE CreateNewMenu (IOLEInPlaceFrame *pFrame)
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.vertli ne.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] + lpiMenuCo unt[2] 22 lpiMenuCount[3]+ 1; 23 InsertMenu (hmenu, insertion.sub.-- point, MF.sub.-- BYPOSITION.vertli ne.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); } __________________________________________________________________________
The CreateNewMenu function is a function implemented by a server application to manage the creation of a composite menu bar. This function allocates the structures associated with the composite menu bar, requests the container application to insert its menus, and inserts the server application menus. Code Table 2 represents an implementation of the CreateNewMenu function. In line 1, the function invokes an underlying window system function to create the data structure for the composite menu bar. In line 2, the function invokes the IOLEInPlaceFrame::InsertMenus method of the container application frame window to insert the container application menus into the composite menu bar. In lines 3-5, the function tracks the number of menus the container application inserted for each menu group. In lines 6-17, assuming the server application has Edit group menus, the function creates each Edit group menu and inserts it into the correct spot in the composite menu bar, keeping track of how many menus it inserted. The correct spot is calculated in line 9 by determining how many menus have already been inserted to the left. For the Edit group, this will be the number of menus the container application inserted as part of the Container Group plus the number of Edit group menus already inserted, plus one for the current insertion. In lines 18-30, 31-41, the function performs analogous steps for any menus belonging to the Object group and Help group respectively. In line 42, the function invokes the object linking and embedding API function ObjectCreateSharedMenu to create the data structure associated with message handling for the composite menu bar and, in line 43, returns a handle to this structure.
4.6.3 CreateObjectToolbars
void CreateObjectToolbars (IOLEInPlaceFrame *pFrame, IOLEInPlaceUIWindow *pDoc, IOLEInPlaceUIWindow *pPane)
The CreateObjectToolbars function is a function implemented by a server application to negotiate between the server and container applications for any space needed for server application tools. FIG. 24 is a flow diagram of an implementation of the CreateObjectToolbars function. Steps 2401 through 2408 are repeated as many times as necessary to create tools for the server application. In step 2401, the function determines whether there are more tool bars to create, and if not, returns, else continues at step 2402. In step 2402, the function invokes the IOLEInPlaceUIWindow::GetBorder method of a frame, document, or pane window of the container application (depending upon where the server application desires to place the tools) to begin the negotiation. In step 2403, the function invokes the IOLEInPlaceUIWindow::QueryBorderSpace method of the desired frame, document or pane window to request a specific width of border space inside the rectangle returned by the previous call to the GetBorder method. These methods were discussed in more detail above. In step 2404, if the specific width cannot be accommodated, then the function continues at 2405, else it returns. An implementation can choose to renegotiate for a different amount of space by calling QueryBorderSpace as many times as desired with different values. In step 2405, the function invokes the IOLEInPlaceUIWindow::SetBorderSpace method with the space previously negotiated in step 2403. In step 2406, the function creates a child window of the desired frame, document, or pane window of the parent container application. In step 2407, the function draws the tool in the child window it created earlier, and then returns to the beginning of the loop.
4.6.4 RemoveMenus
void RemoveMenus (HANDLE hSharedMenu)
CODE TABLE 3 ______________________________________ RemoveMenus(HANDLE hSharedMenu) { 1 menu = hSharedMenu --> menu; 2 descriptor = hSharedMenu --> descriptor; 3 for (i = descriptor[0] + 1, i <= descriptor[1], i++) { 4 RemoveMenu (menu, heditmenu, MF.sub.-- BYPOSITION) 5 } 6 for (i = descriptor[2] + 1, i <= descriptor[3], i++ { 7 RemoveMenu (menu, hobjmenu, MF.sub.-- BYPOSITION) 8 } 9 for (i = descriptor[4] + 1, i <= descriptor[5], i++ { 10 RemoveMenu (menu, hhelpmenu, MF.sub.-- BYPOSITION) 11 } 12 return ( ); ______________________________________
The RemoveMenus function removes the menus of the server application from the composite menu bar upon containee object deactivation. The method is invoked from the containee object's InPlaceDeactivate method. Code Table 3 shows an implementation of the RemoveMenus function. The function uses the information stored in the shared menu descriptor (see FIG. 25), which contains the number of menus within each menu group, to remove all of the server application menus by invoking the underlying window system function RemoveMenu. Lines 3-5 remove the menus belonging to the Edit group, lines 6-8 remove the menus belonging to the Object group, and lines 9-11 remove the menus belonging to the Help group.
4.7 Object Linking and Embedding API Helper Functions
In addition to interface definitions, the object linking and embedding API provides a set of helper functions to be used by container and server applications. These functions include the following: SetActiveObjectHwnd, GetActiveObjectHwnd, ObjectCreateSharedMenu, ObjectDestroySharedMenu, ObjectShade, and ObjectSetMenu.
4.7.1 SetActiveObjectHwnd
void SetActiveObjectHwnd (HWND hwndDOC, IOLEInPlaceObject *pObject)
The SetActiveObjectHwnd function sets the currently selected object in an MDI application. Each MDI (document) window in an MDI container application has associated with it an object interface corresponding to the object activated in place, which was displayed when that MDI window last had input focus. If no object had been activated in place from within the MDI window, then the associated object interface is NULL. This mechanism enables an MDI window to activate the proper containee object when the MDI window later receives input focus, for example, when the user clicks with the mouse on the title bar of the MDI window. (When the user clicks on the title bar of some other MDI window, any in-place interaction associated with the first window disappears from the display.) The SetActiveObjectHWnd function takes two parameters: the window handle of the MI)I (document) window and the IOLEInPlaceObject interface of the object currently activated in place. One skilled in the art will realize that there are many ways to associate the window handle with an object interface. In one embodiment, the function stores the object interface as a property of the document window using underlying window system functions. Note that this implementation requires storage for each MDI window active in the system. An alternative approach is to add a method to the document, pane, and frame window interfaces to keep track of the currently selected object.
4.7.2 GetActiveObjectHwnd
HWND GetActiveObjectitwnd (HWND hwndDOC)
The GetActiveObjectHwnd function retrieves the containee object to be activated in place when the MDI window receives input focus. This function returns the object interface that was previously stored using the SetActiveObjectHwnd function.
4.7.3 ObjectCreateSharedMenu
HANDLE ObjectCreateSharedMenu (HMENU hMenuCombined, UINT lpiMenuCounts)
CODE TABLE 4 __________________________________________________________________________ HANDLE ObjectCreateSharedMenu (hmenu, lpiMenuCount) { 1 hSharedMenu = AllocateSharedMenuHandle ( ); 2 hSharedMenu --> menu = hmenu; 3 for (i = 0, i < number.sub.-- menu.sub.-- groups; i ++) { 4 if (i> 0) { 5 hSharedMenu --> descriptor[i].count = 6 hSharedMenu --> descriptor[i - 1].count + lpiMenuCount[i]; 7 if i is even 8 hSharedMenu --> descriptor[i].function = Id.sub.-- Container 9 else hSharedMenu --> decriptor[i].function = Id.sub.-- Object; 10 } 11 else { 12 hSharedMenu --> descriptor[0].count = lpiMenuCount[0]; 13 hSharedMenu --> descriptor[0].function = Id.sub.-- Container; 14 }; 15 } 16 return (hSharedMenu); __________________________________________________________________________
The ObjectCreateSharedMenu function creates the shared menu data structure associated with the composite menu bar of an object activated in place. The function is invoked from the CreateNewMenu function when a containee object is activated. Code Table 4 shows an implementation of the ObjectCreateSharedMenu function. The function takes two parameters: a handle to a composite menu bar and an array of menu counts which contains the number of menus in each menu group. The function returns a handle to the newly created shared menu data structure. In line 1, the function allocates the memory required for the shared menu data structure. In line 2, the function saves the handle to the composite menu bar in this data structure. In lines 3-15, the function sets up the shared menu descriptor according to the information stored in the menu count array. This descriptor is used by the window procedure, when it receives menu commands, to determine whether to forward the menu command to the container application or to the server application.
Although one skilled in the art will recognize that there are different ways to maintain this information, in one embodiment, the descriptor stores at each index the number of the last menu contained in the menu group associated with that index. (The menus are numbered from 1 on the left.) Also, an indication of whether the menu group belongs to the container or server application is stored at each index. One skilled in the art will also recognize that any menu grouping scheme could be supported by passing additional parameters to indicate which application should be notified for which menu group. Using this descriptor arrangement, the window procedure can determine within which index a particular menu item selection falls by counting the number of menus up to and including the menu item selection and then comparing the menu number with the descriptor values to find the correct index. Once the index has been determined, the window procedure can retrieve the indicator that specifies whether a container or server application function should be invoked. This procedure is discussed further below in reference to Code Table 5.
FIG. 25 is a block diagram of the shared menu data structure corresponding to the example discussed in FIG. 4. The shared menu data structure consists of a pointer to the composite menu bar 2502 and a descriptor 2505 which contains the menu count for each menu group. The composite menu bar 2503 comprises the menus from the container and server applications 2504. Each element in the descriptor 2505 has a count field 2506 and a function field 2507. The count field 2506 indicates the number, starting from the left, of the last menu within a menu group. For example, the second menu group is the Edk group and contains only one menu. This menu 2503 is the second menu from the left in the composite menu bar; therefore, the count field
2509 contains the number 2. As another example, the fourth menu group is the Object group. This group contains five menus from the server application 2510. Therefore, the count for this menu group 2511 contains the number 7, since the seventh menu is the Macro menu which is the last menu in the Object group.
4.7.4 ObjectDestroySharedMenu
v