 |
Claims  |
|
|
What is claimed is:
1. A method for operating a container object to display a message item, the
message item being stored in a message store, the container object being
invoked by an email client application in response to an input, the method
comprising the steps of:
retrieving from the message store header data and body data, each
associated with the message item;
creating a server object associated with a program module, the program
module being operative for rendering the body data;
providing the body data to the program module; and
displaying a mail note associated with the message item, the message item
including a command region, a header region and a body region,
the command region including commands associated with both the container
object and the program module;
the header region including at least a portion of the header data; and
the body region including at least a portion of the body data as rendered
by the program module.
2. The method recited in claim 1, further comprising the steps of:
retrieving from the message store attachment data associated with the
message item;
providing the attachment data to the program module; and
displaying the attachment data in the body region, the attachment data
being displayed by the program module in association with the body data.
3. The method recited in claim 2, wherein the body data comprises a special
character corresponding to the attachment data, and wherein the attachment
data is displayed in the body region in a position determined by the
location of the special character in the body data.
4. The method recited in claim 1, wherein the body data comprises
formatting codes, and wherein the program module renders the body data in
accordance with the formatting codes.
5. The method recited in claim 1, wherein the header data includes
information regarding the source and destination of the message item.
6. The method recited in claim 1, wherein the commands associated with the
container object include commands associated with the disposition of the
message item.
7. The method recited in claim 1, wherein the commands associated with the
program module include options associated with the rendering of the body
data.
8. The method recited in claim 1, wherein the program module comprises a
word processing program.
9. A computer system for employing a container object to display a message
item, comprising:
a processing unit;
an input device connected to the processing unit; and
a display device coupled to the processing unit for displaying the object;
the processing unit, responsive to instructions from a program module
running on the computer system, being operative to:
invoke the container object in response to an input from the input device;
retrieve body data associated with the message item;
create a server object associated with a program module, the program module
being operative for rendering the body data in the container object;
providing the body data to the program module; and
displaying on the display a mail note including the body data, the body
data being rendered by the program module.
10. The computer system recited in claim 9, wherein the processing unit is
further operative to:
retrieve attachment data associated with the message item;
provide the attachment data to the program module; and
display the attachment data in association with the body data, the
displayed attachment data being rendered by the program module.
11. The computer system recited in claim 10, wherein the body data
comprises text data and a special character corresponding to the
attachment data, and wherein the attachment data is displayed in the body
region in a position determined by the location of the special character
in the body data.
12. The computer system recited in claim 9, wherein the program module
comprises a word processing program and the body data comprises formatting
codes, and wherein the program module renders the body data in accordance
with the formatting codes.
13. A computer-readable medium on which is stored a computer program for
operating a container object to display a message item, the computer
program comprising instructions which, when executed by a computer,
perform the steps of:
retrieving from a message store body data associated with the message item;
creating a server object associated with a program module, the program
module being operative for rendering the body data;
providing the body data to the program module;
displaying a mail note including a command region and a body region, the
command region including commands associated with both the container
object and the program module, the body region including at least a
portion of the body data as rendered by the program module;
retrieving from the message store attachment data associated with the
message item;
providing the attachment data to the program module; and
displaying the attachment data in the body region, the attachment data
being displayed by the program module in association with the body data.
14. The computer-readable medium recited in claim 13, wherein the body data
comprises text data and a special character corresponding to the
attachment data, and wherein the attachment data is displayed in the body
region in a position determined by the location of the special character
in the body data.
15. The computer-readable medium recited in claim 13, wherein the body data
comprises formatting codes, and wherein the program module renders the
body data in accordance with the formatting codes.
16. The computer-readable medium recited in claim 13, wherein the commands
associated with the container object include commands associated with the
disposition of the message item, and wherein the commands associated with
the program module include options associated with the rendering of the
body data.
17. The computer-readable medium recited in claim 13, wherein the program
module comprises a word processing program.
18. A method for operating a container object to edit a message item, the
container object being invoked by an email client application in response
to input, the method comprising the steps of:
creating a server object associated with a program module;
displaying a mail note associated with said message item, the mail note
including a command region, a header region and a body region, the command
region including commands associated with both the container object and
the program module and the body region including body data rendered by the
program module;
extracting the body data from the program module;
forming the message item, the message item including a header and a body,
the body comprising the body data; and
transmitting the message item to an intended recipient.
19. The method recited in claim 18, wherein the message item includes an
attachment list, and further comprising the steps of:
displaying attachment data in the body region, the attachment data being
displayed by the program module in association with the body data;
extracting the attachment data from the program module; and
storing the attachment data in the attachment list.
20. The method recited in claim 19, wherein the body data comprises a
special character corresponding to the position of the attachment data in
the body data.
21. The method recited in claim 18, wherein the body data comprises
formatting codes, and wherein the program module renders the body data in
accordance with the formatting codes.
22. The method recited in claim 21, wherein extracting the body data
comprises removing the formatting codes from the body data prior to
storing the body data in the message item.
23. The method recited in claim 18, further comprising the step of
providing template identification data to the program module, the template
identification data corresponding to formatting attributes applied to the
body data.
24. The method recited in claim 18, wherein the commands associated with
the container object include commands associated with the disposition of
the message item, and wherein the commands associated with the program
module include options associated with the rendering of the body data.
25. The method recited in claim 18, wherein the program module comprises a
word processing program.
26. A computer system for operating a container object to edit a message
item, comprising:
a processing unit;
an input device connected to the processing unit; and
a display device coupled to the processing unit for displaying the object;
the processing unit, responsive to instructions from a program module
running on the computer system, being operative to:
create a container object in response to input from the input device;
create a server object associated with a program module, the server object
being in communication with the container object;
display a mail note including a command region, a header region and a body
region, the command region including commands associated with both the
container object and the program module and the body region including body
data rendered by the program module;
transfer the body data from the program module to the container object;
form the message item, the message item comprising the body data; and
transmit the message item to an intended recipient.
27. The computer system recited in claim 26, wherein the message item
includes an attachment list, and further comprising the steps of:
displaying attachment data in the body region, the attachment data being
displayed by the program module in association with the body data;
receiving the attachment data from the program module; and
storing the attachment data in the attachment list.
28. The computer system recited in claim 27, wherein the body data
comprises a special character corresponding to the position of the
attachment data.
29. The computer system recited in claim 26, wherein the body data
comprises formatting codes, and wherein the program module renders the
body data in accordance with the formatting codes.
30. The computer system recited in claim 29, wherein transferring the body
data comprises removing the formatting codes from the body data prior to
storing the body data in the message item.
31. The computer system recited in claim 26, wherein the processing unit is
further operative to provide template identification data to the program
module, the template identification data corresponding to formatting
attributes applied to the body data.
32. The computer system recited in claim 26, wherein the commands
associated with the container object include commands associated with the
disposition of the message item, and wherein the commands associated with
the program module include options associated with the rendering of the
body data.
33. The computer system recited in claim 26, wherein the program module
comprises a word processing program.
34. A computer-readable medium on which is stored a computer program for
operating a container object to store a message item, the computer program
comprising instructions which, when executed by a computer, perform the
steps of:
creating a server object associated with a program module;
display a mail note including a command region and a body region, the
command region including commands associated with both the container
object and the program module, and the body region including body data,
the body data being rendered by the program module;
extracting the body data from the program module;
forming a message item including the body data and an attachment list;
displaying attachment data in the body region, the attachment data being
rendered by the program module in association with the body data;
extracting the attachment data from the program module;
storing the attachment data in an attachment list; and
transmitting the message item to an intended recipient.
35. The computer-readable medium recited in claim 34, wherein the body data
comprises a special character corresponding to the position of the
attachment data in the body data.
36. The computer-readable medium recited in claim 34, wherein the body data
comprises formatting codes, and wherein the program module renders the
body data in accordance with the formatting codes.
37. The computer-readable medium recited in claim 34, wherein extracting
the body data comprises removing the formatting codes from the body data
prior to storing the body data in the message item.
38. The computer-readable medium recited in claim 34, wherein the program
further performs the step of providing template data to the program
module, the template data corresponding to formatting applied to the body
data.
39. The computer-readable medium recited in claim 34, wherein the commands
associated with the container object include commands associated with the
disposition of the message item, and wherein the commands associated with
the program module include options associated with the rendering of the
body data.
40. The computer-readable medium recited in claim 34, wherein the program
module comprises a word processing program. |
|
 |
|
 |
Claims |
|
|
|
Description |
|
|
TECHNICAL FIELD
The present invention relates to a system and method for handling
electronic mail (email), and more particularly relates to a system and
method for utilizing a separate program to edit and display an email
message in the context of an email client.
BACKGROUND OF THE INVENTION
In the past there has been a tremendous difference between the formatting
options available for electronic mail (email) and those available for
printed documents. Email messages were generally restricted to the
transmission of simple text and relied on formatting conventions that
traced their history back to teletypes. For example, emoticons such as
:-), abbreviations such as <G>, and suggested formatting such as .sub.--
underline.sub.-- and *bold* were the only way to express emotion or to
draw emphasis within simple text messages.
While email's formatting options have remained fairly basic, the formatting
options and editing features provided by full power word processors have
dramatically increased. With a full powered word processor, tho user is
able to apply a wide variety of styles and formatting options. In addition
to the richer formatting, full powered word processors provide powerful
editing features, such as background spell checking and automatic
correction of common typographical errors. Full powered word processors
also allow users to create increasingly sophisticated and complex
documents that include drawing objects, text colored with a highlighter,
borders, shading, tables, and special bullets.
As the popularity of email has increased, three changes have taken place.
First, some software publishers have added some rich text capabilities to
the email program. Although this approach allowed a user to change the
formatting used in an email message, it required users to edit email
messages in an environment that was different than the word processor they
were accustomed to. In addition, the rich text email programs simply do
not possess the broad array of features common to sophisticated word
processors.
A second approach has been to add some email capabilities to word
processing programs. Although this simplified the process of sending a
message that was created by the word processor, it presented several
drawbacks. First, the recipient of the message needed to have a compatible
word processor in order to read the message. Second, the editing
environment is disconnected from the email environment. Third, this
approach does not make it easier to read incoming email from various
sources. Fourth, this approach does not facilitate sending file
attachments to plain text or basic rich text (downlevel) email clients.
Finally, a third approach has been one in which users have decided to use a
full power word processor for authoring sophisticated and complex
documents, and then use email for distribution. This requires the user to
work in the word processing context to create and edit the document. When
the document is complete, the user must switch to the email program,
create a new message, and include the word processor document as an
attachment. Although email is an effective mechanism for transporting
documents, handling attachments requires several additional steps on the
part of both the sender and the recipient of the message.
Therefore, there is a need in the art for an efficient, intuitive system
that allows users to create sophisticated documents for transmission via
electronic mail. Such a system should provide sophisticated formatting and
editing options in the context of the email environment and should provide
message data in a format that is compatible with downlevel email clients.
SUMMARY OF THE INVENTION
The present invention satisfies the above-described needs by employing a
container object and a server object to display an email message. The
container object provides a view port in which the server object renders
the body of the email message. This allows all of the formatting and
editing features of the server object to be applied to the body of the
email message. The container object provides controls associated with both
an email program (the email client) and the server object, and serves as
the interface between the server object and the email client. The
container object translates the message data between the format used to
store the data in the message store and the format used by the server
object. The container object ensures that formatting and attachments
rendered by the server object are properly translated so that the
resulting email message is compatible with other email clients.
For example, the present invention allows a user to edit or view an email
message item from an email client program. The email client invokes a mail
note (the container object), which provides an email-related user
interface. The container object also provides a view port or frame for
viewing and editing the contents of an email message. Instead of
implementing text editing or word processing functionality in the mail
note or email client, the mail note allows a separate, full-featured word
processor program (the server object) to display and edit the message in
the view port provided by the mail note. This allows the user to edit and
view email messages using the editing environment and formatting
capabilities of the full-featured word processing program. The mail note
provides the interface between the word processor and the data structure
(or message store) in which the message data is stored. This data
structure must be compatible with the email client, which is responsible
for sending and receiving message items.
In one aspect, the present invention provides a method for operating a
container object to display a message item, which is stored in a message
store. The container object is invoked by an email application program
(the email client) in response to input from a user. The container object
retrieves header data and body data from the message store, and creates a
server object associated with a program module, such as a word processor.
The program module is operative for rendering the body data. The container
object provides the body data to the program module and displays a mail
note that includes a command region, a header region and a body region.
The command region includes commands associated with both the container
object and the program module. The header region includes at least a
portion of the header data. The body region includes at least a portion of
the body data as rendered by the program module.
In another aspect, the container object retrieves from the message store
attachment data associated with the message item. The attachment data is
provided to the program module and is displayed in the body region. The
attachment data is displayed by the program module in association with the
body data.
In another aspect, the present invention provides a method for operating a
container object to edit a message item. The container object is invoked
by an email client application in response to input from a user. The
container object creates a server object associated with a program module
and displays a mail note that includes a command region, a header region
and a body region. The command region includes commands associated with
both the container object and the program module and the body region
includes body data rendered by the program module. The container object
extracts the body data from the program module and forms a message item
that includes a header and a body, which includes body data. The message
item is then transmitted to the intended recipient.
More particularly described, the message includes an attachment list. The
container object displays the attachment data in the body region, with the
attachment data being rendered by the program module in association with
the body data. The attachment data is extracted from the program module
and stored in the attachment list portion of the message item. In some
cases, formatting codes included in the body data are removed prior to
storing the body data in the message item. Similarly, the program module
may be provided with template identification data corresponding to
formatting to be applied to the body data.
The various aspects of the present invention may be more clearly understood
and appreciated from a review of the following detailed description of the
disclosed embodiments and by reference to the appended drawings and claims
.
BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a block diagram of a computer system that provides the operating
environment for an exemplary embodiment of the present invention.
FIG. 2 is a block diagram illustrating the interface between a computer's
input/output devices, an operating system, and an application program.
FIG. 3 illustrates a compound document in a word processing document frame.
FIG. 4 illustrates a document object container embodied in an email note.
FIGS. 5a and 5b illustrate the components that are included on server and
container sides of a Document Object (DocObject) interface in accordance
with an embodiment of the present invention.
FIG. 6 is a flow diagram illustrating a method for invoking a DocObject
server in accordance with an embodiment of the present invention.
FIG. 7 is a diagram of portions of the MAPI messaging architecture.
FIGS. 8a and 8b illustrate the features of the user interface provided by
an email client in accordance with an embodiment of the present invention.
FIG. 9 is a diagram illustrating the interaction between an email client
and a word processing program.
FIG. 10 is a diagram illustrating the interaction between an email client,
a DocObject-enabled mail note, and a DocObject server in accordance with
an embodiment of the present invention.
FIG. 11 is a diagram illustrating the MAPI format for storing email message
data.
FIG. 12 is a flow diagram illustrating a method for reading a sent mail
message in accordance with an embodiment of the present invention.
FIG. 13 is a flow diagram illustrating a method for editing and sending a
new mail message in accordance with an embodiment of the present invention
.
DETAILED DESCRIPTION
The present invention is directed to an improved system and method for
editing and viewing an email message. Generally described, an embodiment
of the present invention employs a Document Object-enabled mail note or
form to provide a Document Object container with an email-related user
interface (UI) and a view port or frame for viewing and editing the
contents of an email message. Instead of implementing text editing or word
processing functionality in the mail note itself, the mail note allows a
separate, full-featured word processing program to display and edit the
email message in the view port provided by the mail note. The mail note
then extracts the message data from the word processor and reformats the
data to comply with the format required by the email client program. This
allows the user to edit and view email messages using the editing
environment and formatting capabilities of the full-featured word
processing program, while also providing messages that are compatible with
various types of email clients.
Those skilled in the art will appreciate that an exemplary embodiment of
the present invention relies on and incorporates several common features
of modem personal computers. In order to provide a sufficient background
for an embodiment of the present invention, it is useful to first discuss
a variety of topics, including an exemplary operating system, the Object
Linking and Embedding (OLE) and Document Object (DocObject) interfaces,
and the Messaging Application Programming Interface (MAPI). An exemplary
embodiment of the present invention will be described after each of these
components is briefly discussed.
Although exemplary embodiments of the present invention will be generally
described in the context of an operating system and programs running on a
personal computer, those skilled in the art will recognize that the
present invention also can be implemented in conjunction with other
program modules for other types of computers. Furthermore, those skilled
in the art will recognize that the present invention may be implemented in
a stand-alone or in a distributed computing environment. In a distributed
computing environment, program modules may be physically located in
different local and remote memory storage devices. Execution of the
program modules may occur locally in a stand-alone manner or remotely in a
client/server manner. Examples of such distributed computing environments
include local area networks of an office, enterprise-wide computer
networks, and the global Internet.
The detailed description that follows is represented largely in terms of
processes and symbolic representations of operations by conventional
computer components, including a processing unit, memory storage devices
for the processing unit, display devices, and input devices. Furthermore,
these processes and operations may utilize conventional computer
components in a heterogeneous distributed computing environment, including
remote file servers, remote compute servers, and remote memory storage
devices. Each of these conventional distributed computing components is
accessible by the processing unit via a communications network.
The processes and operations performed by the computer include the
manipulation of signals by a processing unit or remote server and the
maintenance of these signals within data structures resident in one or
more of the local or remote memory storage devices. Such data structures
impose a physical organization upon the collection of data stored within a
memory storage device and represent specific electrical or magnetic
elements. These symbolic representations are the means used by those
skilled in the art of computer programming and computer construction to
most effectively convey teachings and discoveries to others skilled in the
art.
For the purposes of this discussion, a process is generally conceived to be
a sequence of computer-executed steps leading to a desired result. These
steps generally require physical manipulations of physical quantities.
Usually, though not necessarily, these quantities take the form of
electrical, magnetic, or optical signals capable of being stored,
transferred, combined, compared, or otherwise manipulated. It is
conventional for those skilled in the art to refer to these signals as
bits, bytes, words, data, objects, properties, tags, types, identifiers,
values, elements, symbols, characters, terms, numbers, points, records,
messages, images, files, documents, or the like. It should be kept in
mind, however, that these and similar terms should be associated with
appropriate physical quantities for computer operations, and that these
terms are merely conventional labels applied to physical quantities that
exist within and during operation of the computer.
It should also be understood that manipulations within the computer are
often referred to in terms such as adding, comparing, receiving, sending,
transmitting, replying, etc. which are often associated with manual
operations performed by a human operator. The operations described herein
are machine operations performed in conjunction with various input
provided by a human operator or user that interacts with the computer.
In addition, it should be understood that the programs, processes, methods,
etc. described herein are not related or limited to any particular
computer or apparatus, nor are they related or limited to any particular
communication network architecture. Rather, various types of general
purpose machines may be used with program modules constructed in
accordance with the teachings described herein. Similarly, it may prove
advantageous to construct a specialized apparatus to perform the method
steps described herein by way of dedicated computer systems in a specific
network architecture with hard-wired logic or programs stored in
nonvolatile memory, such as read only memory.
Referring now to the drawings, in which like numerals represent like
elements throughout the several figures, aspects of the present invention
and the an exemplary operating environment will be described.
The Operating Environment
FIGS. 1-7 illustrate various aspects of a computing environment in which
the present invention is designed to operate. Those skilled in the art
will immediately appreciate that FIGS. 1-7 and the associated discussion
are intended to provide a brief, general description of various computer
hardware, program modules, and interfaces, and that additional information
is readily available in the appropriate programming manuals, user's
guides, and similar publications.
The Computer Hardware
FIG. 1 illustrates a conventional personal computer 10 suitable for
supporting the operation of an embodiment of the present invention. As
shown in FIG. 1, the personal computer 10 operates in a networked
environment with logical connections to a remote computer 11. The logical
connections between the personal computer 10 and the remote computer 11
are represented by a local area network 12 and a wide area network 13.
Those of ordinary skill in the art will recognize that in this
client/server configuration, the remote computer 11 may function as a file
server or compute server.
The personal computer 10 includes a processing unit 14, such as the 80486
or "PENTIUM" microprocessors manufactured by Intel Corporation of Santa
Clara, Calif. The personal computer also includes system memory 15
(including read only memory (ROM) 16 and random access memory (RAM) 17),
which is connected to the processing unit 14 by a system bus 18. The
computer 10 utilizes a BIOS 19, which is stored in ROM 16. Those skilled
in the art will recognize that the BIOS 19 is a set of basic routines that
helps to transfer information between elements within the personal
computer 10. Those skilled in the art will also appreciate that the
present invention may be implemented on computers having other
architectures, such as computers that do not use a BIOS, and those that
utilize other microprocessors, such as the "MIPS" or "POWER PC" families
of microprocessors from Silicon Graphics and Motorola, respectively.
Within the personal computer 10, a local hard disk drive 20 is connected to
the system bus 18 via a hard disk drive interface 21. A floppy disk drive
22, which is used to read or write a floppy disk 23, is connected to the
system bus 18 via a floppy disk drive interface 24. A CD-ROM drive 25,
which is used to read a CD-ROM disk 26, is connected to the system bus 18
via a CD-ROM interface 27. A user enters commands and information into the
personal computer 10 by using input devices, such as a keyboard 28 and/or
pointing device, such as a mouse 29, which are connected to the system bus
18 via a serial port interface 30. Other types of pointing devices (not
shown in FIG. 1) include track pads, track balls, pens, head trackers,
data gloves and other devices suitable for positioning a cursor on a
computer monitor 31. The monitor 31 or other kind of display device is
connected to the system bus 18 via a video adapter 32.
The remote computer 11 in this networked environment is connected to a
remote memory storage device 33. This remote memory storage device 33 is
typically a large capacity device such as a hard disk drive, CD-ROM drive,
magneto-optical drive or the like. The personal computer 10 is connected
to the remote computer 11 by a network interface 34, which is used to
communicate over the local area network 12.
As shown in FIG. 1, the personal computer 10 is also connected to the
remote computer 11 by a modem 35, which is used to communicate over the
wide area network 13, such as the Internet. The modem 35 is connected to
the system bus 18 via the serial port interface 30. The modem 35 also can
be connected to the public switched telephone network (PSTN) or community
antenna television (CATV) network. Although illustrated in FIG. 1 as
external to the personal computer 10, those of ordinary skill in the art
will quickly recognize that the modem 35 may also be internal to the
personal computer 11, thus communicating directly via the system bus 18.
It is important to note that connection to the remote computer 11 via both
the local area network 12 and the wide area network 13 is not required,
but merely illustrates alternative methods of providing a communication
path between the personal computer 10 and the remote computer 11.
Although other internal components of the personal computer 10 are not
shown, those of ordinary skill in the art will appreciate that such
components and the interconnection between them are well known.
Accordingly, additional details concerning the internal construction of
the personal computer 10 need not be disclosed in connection with the
present invention.
Those skilled in the art will understand that program modules such as an
operating system 36, application programs 37, and data are provided to the
personal computer 10 via computer-readable media. In the computer 10, the
computer-readable media include the local or remote memory storage
devices, which may include the local hard disk drive 20, floppy disk 23,
CD-ROM 26, RAM 17, ROM 16, and the remote memory storage device 33. In the
personal computer 10, the local hard disk drive 20 is used to store data
and programs, including the operating system and programs. The application
programs 37 may include word processing programs and email programs, such
as those discussed in the context of an embodiment of the present
invention.
The Operating System
FIG. 2 is a simplified block diagram illustrating the interaction between
the computer hardware 200, an exemplary operating system 36, and an
application program 37a. Referring now to both FIGS. 1 and 2, when the
personal computer 10 is turned on or reset, the Basic Input/Output System
(BIOS) 19, which is stored in the ROM 16, instructs the processing unit 14
to load the operating system 36 from the hard disk drive 20 into the RAM
17. Once the operating system 36 is loaded into RAM 17, the processing
unit 14 executes the operating system 36 and causes the visual elements
associated with the user interface of the operating system 36 to be
displayed on the monitor 31.
The operating system 36, in conjunction with the BIOS 19 (FIG. 1) and
associated device drivers, provides the basic interface between the
computer's resources, the user, and the application program 37a. The
operating system 36 interprets and carries out instructions issued by the
user. For example, when the user wants to load an application program 37a,
such as a word processing program, the operating system 36 interprets the
instruction (e.g., double clicking on the application program's icon) and
causes the processing unit 14 to load the program code into RAM 17 from
either the local hard disk drive 20, floppy disk 23, CD-ROM 26, or the
remote memory storage device 33. Once the application program 37a is
loaded into the RAM 17, it is executed by the processing unit 14. In case
of large programs, the processing unit 14 loads various portions of
program modules into RAM 17 as needed.
The preferred embodiment of the present invention is represented by the
"MICROSOFT EXCHANGE" email client and the "MICROSOFT WORD" word processing
program, which forms a part of the "MICROSOFT OFFICE" suite of program
modules. The "MICROSOFT WORD" word processor and the "MICROSOFT EXCHANGE"
email client are designed to operate in conjunction with Microsoft
Corporation's "WINDOWS 95" or "WINDOWS NT" operating systems. However, it
should be understood that the invention can readily be implemented by
program modules for use with other operating systems, such as Microsoft
Corporation's "WINDOWS 3.1" operating system, IBM Corporation's "OS/2"
operating system, and the operating system used in "MACINTOSH" computers
manufactured by Apple Computer, Inc.
The operating system 36 provides a variety of functions, services, and
interfaces that allow an application program 37a to easily deal with
various types of input/output (I/O). This allows the application program
37a to issue relatively simple function calls that cause the operating
system 36 to perform the steps required to accomplish various tasks, such
as displaying text on the monitor 31 (FIG. 1) or printing text on an
attached printer (not shown). Generally described (with reference to FIG.
2), the application program 37a communicates with the operating system 36
by calling predefined functions provided by the operating system 36. The
operating system 36 responds by providing the requested information in a
message or by executing the requested task.
The OLE and DocObject Interfaces
The "WINDOWS 95" and "WINDOWS NT" operating systems support Microsoft
Corporation's Object Linking and Embedding (OLE) and Document Object
(DocObject) interfaces. Both OLE and DocObject support a variety of
application programming interfaces (APIs) that simplify the interaction
between program modules.
OLE is a technology that enables developers to create extensible
application programs that operate across multiple platforms. OLE-enabled
applications allow users to manipulate information in an intuitive manner,
using an environment that is more "document-centric" and less
"application-centric." Users can create compound documents with data, or
objects, of different formats, and focus directly on the data rather than
on the application programs responsible for the data. The data can be
embedded within the document, or linked to it, so that only a reference to
the data is stored in the document.
OLE facilitates application integration by defining a set of standard
interfaces, which are groupings of semantically-related functions through
which one program module accesses the services of another. OLE is an open
system in the sense that any application program can provide an
implementation of a defined interface and any application program can use
it. Application programs can either take advantage of built-in
functionality provided by OLE, or add to it or replace it as best suits
their needs.
The set of OLE services can be viewed as a two tier hierarchy. The lower
level contains infrastructure services. These are basic services that
provide the means by which features can be implemented and used. The
infrastructure services include interface negotiation, memory management,
error and status reporting, interprocess communication, structured
storage, and data transfer. The upper level of the OLE service hierarchy
provides application features, which are the services that benefit the end
user. These include compound document management, in-place activation,
programmability, and drag and drop operations.
OLE's interfaces provide the standard for component object interaction.
Each interface contains a set of functions that defines a contract between
the object implementing the interface and the client using it. The
contract includes the name of the interface, the function names, and the
parameter names and types. Under this contract, the object must implement
all of the functions defined for that interface and the implementations
must conform to the contract.
All interface names are prefixed with either "I" or "IOle." Interfaces that
begin with "IOle" provide services relating to compound document
management. Those that begin with "I" provide services that are more
general in nature. For example, IOleObject contains methods used by a
client of an embedded or linked compound document object. IOleObject is
implemented and used only by applications that participate in compound
document management. IDataObject, however, contains methods that are used
by all applications. These methods provide the means by which data of any
type is transferred.
OLE supports the provision of a "compound document," which is a container
object that contains a "linked" object or an "embedded" object. The
difference between linked and embedded objects has to do with where the
actual source data associated with the object is stored. This affects the
object's portability, it method of activation and the size of the compound
document.
When an object is linked, the source data continues to reside wherever it
was initially created, which may be at another point in the document or in
another, document altogether. Only a reference, or link, to the object is
kept within the compound document. Linking is efficient and minimizes the
size of the compound document. Changes made to the source are
automatically reflected in any compound document that has a link to the
source object. From the user's point of view, a linked object appears to
be wholly contained within the document.
With an embedded object, a copy of the original object is physically stored
in the compound document, along with all of the information needed to
manage that object. As a result, the object becomes a physical part of the
document. A compound document containing an embedded object will be larger
than one containing the same objects as links. However, embedding offers
advantages that offset the larger storage requirement. For example,
compound objects with embedded objects can be transferred to another
computer and edited there.
< | | |
