|
Glossary
The process of binding an object in order to put it into its running state. Also
refers to invoking a particular operation on an object. See also Binding.
Absolute moniker
A moniker that specifies the absolute location of an object. An absolute moniker
is analogous to a full pathname. See also Moniker.
Advisory sink
An object that can receive notifications of changes in an embedded object or linked
object because it implements the IAdviseSink interface (and possibly the
IAdviseSink2 interface). Notifications originate in the object application, where
they are cached in an advise holder, which passes them to advisory sinks
implemented by object handlers. For an embedded object, the corresponding object
handler forwards the notification to the object's container. For a linked object, the
object handler forwards the notification to the link object, which in turn
passes it on to the container. See also Object handler, Embedded object, Link object, Linked object, Container
application.
Aggregate object
A component object that is made up of one or more other component objects. One
object in the aggregate is designated the control object, which controls which
interfaces in the aggregate are exposed and which are private. The control
object has a special implementation of IUnknown called the controlling unknown. All non-controlling objects in the aggregate
must pass calls to IUnknown methods through the controlling unknown.
Aggregation
A composition technique for implementing component objects. It allows you to build a
new object with one or more existing objects that support some or all of the
new object's required interfaces.
Anti-moniker
The inverse of a file, item, or pointer moniker. An anti-moniker is added to
the end of a file-, item-, or pointer moniker to nullify it. This is analogous
to the way that ".." nullifies a directory component of a pathname (that is, \work\art\.. equals \work). Anti-monikers are used in the construction of relative monikers. See also Relative Moniker.
Artificial reference counting
A technique used to safeguard an object before making a call that could result
in its premature destruction by ensuring it won't be de-allocated. A process
calls the AddRef method of IUnknown to increment the count before making the call that could otherwise free the
object prematurely, and after the function returns, calls the IUnknown::Release method to decrement the count.
Asynchronous call
A function that allows the next instruction in the process to be executed as
soon as the call is made, without waiting for the function to return. Most OLE
functions and interface methods are synchronous; that is, the function must
return before the next instruction is executed. OLE defines six asynchronous
methods, five within the IAdviseSink interface  OnDataChange, OnViewChange, OnRename, OnSave, and OnClose and one within the IAdviseSink2 interface OnLinkSourceChange.
Automation
See OLE Automation
B
Bind context
An object that implements the IBindCtx interface. Bind contexts are used in moniker operations. A bind context holds
references to the objects activated when a moniker is bound, contains
parameters that apply to all operations during the binding of a generic composite
moniker, and provides the means by which the moniker implementation should retrieve
information about its environment. See Binding, Moniker.
Binding
Generically, binding is the process of associating a name to its referent.
When referring to monikers specifically, binding is the process of locating the
object named by the moniker, activating it (loading it in memory) if it isn't
already, and returning an interface pointer to it. Binding puts an object into its
running state, allowing the operations it supports to be invoked. Objects can
be bound at run time (also called late binding or dynamic binding) or at
compile time (also called static binding). In OLE Automation, vtable-based binding is
referred to as "early binding" and IDispatch-based binding is referred to as
"late binding."
C
Cache
Generally, a cache is a (usually temporary) local store of information. In
OLE, the term cache is used in connection with linked or embedded objects, in
which the cache contains information that defines the presentation of a contained
object when the container is opened.
Cache initialization
The process of filling an embedded object's cache with data formats. The IOleCache interface provides methods that a container object can call to control the
data that gets cached for embedded objects.. The IOleCache::InitCache method fills the cache using data provided by a transfer from the Clipboard
or from a drag-and-drop operation. The IOleCache::SetData method fills the cache using data in a storage object.
Class
In object-oriented programming, a class is a set of objects whose behavior is
defined by the same set of code (they share the same implementation).
A COM class is not necessarily the same as a class in an object-oriented
language. A COM class can be identified by a CLSID, though for most COM operations,
it is not necessary to know an object's class.
Class factory
A object that you use to create one or more instances of a an object
identified by a given CLSID (class identifier). A class factory object implements the IClassFactory interface. A class factory is the most frequently used type of class object in OLE. See also CLSID.
Class identifier (CLSID)
A unique identification tag (UUID) associated with an OLE class object. A
class object that is intended to create more than one object registers its CLSID in
a task table in the registration database to enable clients to locate and load
the executable code associated with the object(s). Every OLE object
application (or container that allows linking to its embedded objects) must register a
CLSID for each supported object definition.
Class object
In COM, class objects are called class factories, and typically have no
behavior except to create new instances of the class. In object-oriented programming,
an object whose state is shared by all the objects in a class, and whose
behavior acts on that class-wide state data. See also Class factory.
Client
In referring to OLE objects, an object that requests services from another
object. See also Container.
Client site
The display site for an embedded or linked object within a compound document.
The client site is the principal means by which an object requests services
from its container.
CLSID
See Class identifier
Component object
An object that conforms to the OLE component object model (COM). Clients deal
with a component object only through a pointer to an interface (a related set
of functions called methods). With the pointer, clients can call the methods
that perform operations or manipulate the data associated with the object.
Component objects are instances of an object definition, which specifies an
implementation of the interfaces on the object.
Composite moniker
A moniker that consists of two or more monikers composed together. A composite
moniker can be non-generic, meaning that its component monikers have special
knowledge of each other, or generic, meaning that its component monikers know
nothing about each other except that they are monikers. See Generic composite moniker.
Commit
The act of persistently saving any changes made to an object since its storage
was opened or since the last time changes were saved. See also Revert.
Component object model (COM)
The OLE object-oriented programming model that defines how objects interact
within a single application or between applications. In COM, clients have access
to an OLE object through a pointer to an interface (a related set of functions
called methods) on the object.
Composite menu
A shared menu bar composed of menu groups from both an in-place container and
an in-place object application. The object application must install and remove
the menu from the container's frame window.
Compound document
A document that contains data of different formats, created by different
applications. Compound documents are created in a container application, such as
Word, and information from other applications (such as spreadsheets, sound clips,
and bitmaps) is either embedded in or linked to the container application. When
the compound document is saved, the container application saves it.
Compound file
An OLE-provided implementation of structured storage which includes the IStorage, the IStream, and the ILockBytes interfaces. You use a set of StgXxx API functions to create and use a compound file.
Container
See Container application.
Container application
An application that supports compound documents. Container applications
provide storage for the object, a site for display, access to the display site, and
an advisory sink for receiving notifications of changes in the object. See also Compound document, Client site, and Advisory sink.
Container/Object
An application that has implemented OLE interfaces such that the application
supports the features and capabilities of both a container and object
application.
Container/Server
See Container/Object.
Control object
The object within an Aggregate object that controls which interfaces within
the aggregate object are exposed and which are private.. The control object has a
special implementation of IUnknown called the controlling unknown, and all other objects in the aggregate must
pass calls to IUnknown methods through the controlling unknown. See Aggregate object.
D
Data transfer object
An object that supports the IDataObject interface and contains data to be transferred from one object to another
either through the Clipboard or drag-and-drop operations.
Default object handler
A DLL provided with the OLE SDK that provides a partial implementation of
basic interfaces. It is a surrogate in the processing space of the container
application for the real object.
With the default object handler, it is possible to look at an object's stored
data without actually activating the object. The default object handler
performs other tasks on behalf of a loaded object, such as rendering an object from
its cached state when the object is loaded into memory.
Direct access mode
One of two access modes in which a storage object can be opened. In direct
mode, all changes are immediately committed to the root storage object. See also Transacted access mode.
Drag and drop
OLE specifies a set of data transfer and drag-and drop-interface-specific
interfaces that allow applications to implement drag and drop, an operation in
which the end-user uses the mouse or other pointing device to drag data from one
window and drop it into another location in the same window or into another
window.
E
Embedded object
A compound-document object that is stored with the container application, but
when it is running, lives in the process space of the server application, which
creates and subsequently edits it. The default handler provides a surrogate in
the processing space of the container application for the real object.
Explicit caching
One of two ways an object can cache its presentation data. Explicit caching
requires the physical creation of the cache nodes needed to save the data formats
of the object. See also Implicit caching.
F
File moniker
A moniker based on a path in the file system. File monikers can be used to
identify objects that are saved in their own files. A file moniker is an object
that represents an implementation of the IMoniker interface for the file class. See also Item moniker and Generic composite moniker.
G
Global memory
See Shared application memory.
Generic composite moniker
The generic composite moniker is a sequenced collection of other types of
monikers, starting with a file moniker to provide the document-level path and
continuing with one or more item monikers. See also Item moniker and File moniker.
H
Handler
See Object handler.
Helper function
A function that encapsulates other functions and interface methods publicly
available in the OLE SDK.
HRESULT
An opaque result handle defined to be zero for a successful return from a
function and non-zero if error or status information is to be returned. To convert
an HRESULT into the more detailed SCODE, applications call GetScode(). See SCODE.
I
Implicit caching
The "implied" caching of presentation data by an object that is capable of
rendering itself using its native data. Cache nodes are not created with implicit
caching. See also Explicit caching.
In parameter
A parameter that is allocated, set, and freed by the caller of a function.
In/Out parameter
A parameter that is initially allocated by the caller of a function and set,
freed, and reallocated if necessary by that which is called.
In-process server
An object server or application implemented as a DLL that runs in the process
space of the object's container. See also Local server, Remote server.
Instance
An object for which memory is allocated or which is persistent.
Instantiate
The process of creating an activating an obnect based on its definition.
Interface
A group of related functions that provide access to OLE objects. The set of
OLE interfaces define a contract that allow objects to interact according to the
Component Object Model (COM). While OLE provides many interface
implementations, most interfaces can also be implemented by developers designing OLE
applications.
Interface identifier (IID)
A unique identification tag associated with each interface. Some functions
take IIDs as parameters to allow the callers to specify what type of interface
pointer should be returned.
Item moniker
A moniker based on a string that identifies an object in a container. Item
monikers can be used to identify objects smaller than a file, including embedded
objects in a compound document, or a pseudo-object (like a range of cells in a
spreadsheet). See also File moniker and Generic composite moniker.
L
Link object
A component object that is instantiated when a linked compound document object
is created or loaded. The link object implements the IOleLink interface and is
provided by OLE.
Linked object
A compound-document object whose source data physically resides where it was
initially created. Only a moniker that represents the source data and the
appropriate presentation data is kept with the compound document. Changes made to the
link source are automatically reflected in the linked compound-document object
in the container(s).
Link source
The data that is the source of a linked compound document object. A link
source may be a file or a portion of a file, such as an embedded object or a
selected range within a file (also called a pseudo object).
Loaded state
The state of a compound-document object after its data structures have been
loaded into container memory. The data structures are created by the object
handler. See also Passive state and Running state.
Local server
An server application implemented as an EXE running on the same machine as the
client application using it. Because the server application is an EXE, it runs
in its own process. See also In-Process server and Remote server.
Lock
OLE defines two types of locks that can be held on an object: strong and weak. A strong lock will keep an object in memory, a weak lock will not.
LRPC (Lightweight remote procedure call)
OLE's RPC-based protocol for interprocess communication. LRPC is "lightweight"
in that it handles communication between processes on one machine only.
M
Marshaling
The process of packaging and sending interface parameters across process
boundaries.
Moniker
An object that implements the IMoniker interface. A moniker acts as a name that uniquely identifies a COM object.
You can think of a moniker as a generalization of a pathname; in the same way
that a pathname identifies a file in the file system, a moniker identifies a COM
object. Monikers support an operation known as "binding," which is the process
of locating the object named by the moniker, activating it (loading it in
memory) if it isn't already, and returning an interface pointer to it.
Moniker class
An implementation of the IMoniker interface. System-supplied moniker classes
include file monikers, item monikers, generic composite monikers, anti-monikers,
and pointer monikers.
Moniker client
An application that uses monikers to acquire interface pointers to objects
managed by another application.
Moniker provider
An application that hands out monikers that identify the objects it manages,
so that they are accessible to other applications.
Multiple Document Interface (MDI) Application
An application that can support multiple documents from one application
instance. MDI object applications can simultaneously serve a user and one or more
embedding containers. See also Single Document Interface (SDI) application.
N
Native data
The data used by an OLE server application when editing an embedded object. See also Presentation data.
Nested object
An OLE object that is embedded within another OLE object through the use of a
combination container/server application. OLE objects can be arbitrarily nested
to any level.
O
Object
Generally, an instance of an entity that embodies both specific data and the
functions that manipulate it.
Specifically in object-oriented programming, an object is an entity that has
state, behavior and identity. An object's state consists of its attributes and
and the attributes' current values. An object's behavior consists of the
operations that can be performed on it and the accompanying state changes. An object's
identity is what you use to distinguish it from other objects.
In contrast, COM objects' behavior is defined by the interfaces it supports. A
COM object's state is not explicitly specified, but is implied by its
interfaces. A COM object's identity is defined by the ability to use IUnknown::QueryInterface to move between interfaces.
A COM object follows a specific model in which clients (those using an
object's services) gain access to the object's data only through a pointer to an
interface consisting of a set of methods (related functions). The client can then
call these methods to perform desired operations. There is no direct access to an
OLE object's data.
Object application
An OLE-aware application that can create compound document objects. Containers
can then embed or link to these objects.
Object handler
A piece of class-specific code that is dynamically loaded into the address
space of its container. Object handlers process requests for specific classes of
objects, so that much of the communication can be in-process. This is more
efficient because it reduces the need for remote procedure calls.
Object state
One of three relationships between a compound document object in its container
and the application responsible for the object's creation: passive, loaded, and running. Passive objects are stored (on disk or in a database), and the object is not
selected or active. In the loaded state, its data structures have been loaded
into memory, but is not yet available for operations such as editing. Running
objects are both loaded and available for all operations.
Object type name
A unique identification string that is stored as part of the information
available for an object in the registration databasefor example, Acme Drawing.
OLE Automation
A way to manipulate an application's objects from outside the application. OLE
automation is typically used to create applications that expose objects to
programming tools and macro languages, create and manipulate one application's
objects from another applications, or to create tools for accessing and
manipulating objects. For information on OLE Automation, refer to the OLE Programmer's Reference, Volume 2.
Out parameter
A function parameter that is allocated and set by whatever a function calls,
and must be freed by the caller.
P
Passive state
The state of an OLE object when it is stored (on disk or in a database). The
object is not selected or active. See also Loaded state and Running state.
Persistent storage
Storage of a file or object in a medium such as a file system or database so
that the file can be closed and then re-opened at a later time. Data can be
retrieved from the file until the underlying file is deleted.
Pointer moniker
A moniker that wraps an interface pointer to an object in memory. Whereas most
monikers identify objects that can be saved to persistent storage, pointer
monikers identify objects that cannot. They allow such objects to participate in a
moniker binding operation.
Presentation data
The data used by an OLE container applicationto display embedded or linked
objects. See also Native data.
Primary verb
The action associated with the most common, preferred operation users perform
on an object; the primary verb is always defined as verb zero in the system
registration database. An object's primary verb is executed by double-clicking on
the object.
Proxy
An interface-specific object that packages parameters for that interface in
preparation for a remote method call. A proxy runs in the address space of the
sender and communicates with a corresponding stub in the receiver's address
space. See also Stub, Marshaling, and Unmarshaling.
Proxy manager
Manages all the proxies for a single object.
Pseudo object
A selection of data within a document or embedded object that can be the
source for a compound-document object.
R
Reference counting
Keeping a count of each interface pointer instance to ensure that an object is
not destroyed before all references to it are released.
Relative moniker
A moniker that specifies the location of an object relative to the location
of another object. A relative moniker is analogous to a relative pathname (such
as "..\backup\report.old").
Remote Server
A server application, implemented as an EXE, running on a different machine
from the client application using it. See also In-process server, Local server.
Revert
The act of discarding any change(s) made to an object since the last time the
changes were committed or the object's storage was opened. See also Commit, Transacted access mode.
Root IStorage object
The outermost IStorage instance in a document; also called the root storage object.
Compound-document objects are always saved as children of a root IStorage object.
Running state
The state of an OLE object when the object application is running and it is
possible to edit the object, access its interfaces, and receive notification of
changes. See also Loaded state and Passive state.
Running object table (ROT)
A globally-accessible table on each machine that keeps track of all the OLE
objects that can be identified by a moniker and are currently running on the
machine. Monikers use the Running Object Table. Registering an object in the
running object table increments the object's reference count. Before the object can
be destroyed, its moniker must be released from the running object table.
S
SCODE
A DWORD value that is used to pass detailed information to the caller of an
interface method or function. See also HRESULT.
Server
See Object application.
Shared application memory
Memory that is primarily used between processes to optimize the data copying
that occurs in LPRC calls.
Single Document Interface (SDI) Application
An application that can support only one document at a time. Multiple
instances of an SDI application must be started to service both an embedded object and
a user. See also Multiple Document Interface (MDI) application.
Single object application
An application that is capable of creating and manipulating one class of
object. See also Multiple object application.
Stand-alone object application
An object application implemented as an executable (EXE) program, rather than
as a DLL object application.
State
See Loaded state, Passive state, and Running state.
Static object
An object that contains only a presentation, with no native data. A container
application can treat a static object as though it were a linked or embedded
object, except that it is not possible to edit a static object.
A static object can result, for example, from the breaking of a link on a
linked object; you don't want the linked object to be updated anymore.
Storage object
An object that implements the IStorage interface. A storage object contains nested storage objects or stream
objects, resulting in a directory/file system within a single file. It provides the
underlying storage for compound documents. Container applications provide a
nested storage object for each of their embedded objects. The embedded object stores
its data nested storage and stream objects within the storage object provided
by its container. See also Root IStorage object and Stream object.
Stream object
An object that implements the IStream interface. A stream object is analogous to a file in a directory/file system. See also Storage object.
Structured storage model
A specification that defines a hierarchical method of storing objects. OLE
provides an implementation of the structured storage model called Compound Files. See Compound file.
Stub
When a function's or interface method's parameters are marshaled across a
process boundary, the stub is an interface-specific object that unpackages the
marshaled parameters and calls the required method. The stub runs in the receiver's
address space and communicates with a corresponding proxy in the sender's
address space. See Proxy, Marshaling, and Unmarshaling.
Stub manager
Manages all of the stubs for a single object.
Synchronous call
A function that does not allow further instructions in the process to be
executed until the function returns. Most OLE interface methods, except some of the IAdviseSink methods, are synchronous calls. See also Asychronous call.
T
Transacted access mode
One of two access modes in which a storage object can be opened. When opened
in transacted mode, changes are stored in temporary buffers until the root IStorage object commits its changes. See also Direct access mode, Commit, Revert.
U
Uniform data transfer
A model for transferring data via the Clipboard, drag and drop, or through
automation. Objects conforming to the model implement the IDataObject interface. This model replaces DDE (dynamic data exchange). See Data transfer object.
Unmarshaling
The processing of unpackaging parameters that have been sent across process
boundaries.
V
Virtual Table (VTBL)
An array of pointers that point to interface method implementations.
Visual Editing
A term in end-user documents that refers to the user's ability to interact
with a compound-document object in the context of its container. The term most
often used by developers is in-place activation. See also In-place activation.
Related LinksSoftware for Delphi and C++ Builder developers
Software for Visual Studio .NET developers
Software for Visual Basic 6 developers
Delphi Tips&Tricks
MegaDetailed.NET
TMS Scripter Studio Pro components for Delphi/C++Builder
More Online Helps Win32 Programmer's Reference (win32.hlp)
Win32 Multimedia Programmer's Reference (mmedia.hlp)
Microsoft Windows Pen API Programmer's Reference (penapi.hlp)
Microsoft Windows Sockets 2 Reference (sock2.hlp)
Microsoft Windows Telephony API (TAPI) Programmer's Reference (sock2.hlp)
Unix Manual Pages
|
