Glossary

A

Activation: The process of loading an object in memory, which puts it into its running state. See also Binding.
Active state: A COM object that is in running state and has a visible user interface. See also Loaded state, Object state, Passive state, and Running state.
Absolute moniker: A moniker that specifies the absolute location of an object. An absolute moniker is analogous to a full path. See also Moniker.
Advisory holder: A COM object that caches, manages, and sends notifications of changes to container applications' advisory sinks. See also Advisory sink.
Advisory sink: A COM object that can receive notifications of changes in an embedded object or linked object because it implements the IAdviseSink or IAdviseSink2 interface. Containers that need to be notified of changes in objects implement an advisory sink. Notifications originate in the server, which uses an advisory holder object to cache and manage notifications to containers. See also Advisory holder, Container application, and Object handler.
Aggregate object: A COM object that is made up of one or more other COM objects. One object in the aggregate is designated the controlling object, which controls which interfaces in the aggregate are exposed and which are private. This controlling object has a special implementation of IUnknown called the controlling IUnknown. All objects in the aggregate must pass calls to IUnknown methods through the controlling IUnknown. See also Aggregation.
Aggregation: A composition technique for implementing COM objects. It allows you to build a new object by reusing one or more existing objects' interface implementations. The aggregate object chooses which interfaces to expose to clients, and the interfaces are exposed as if they were implemented by the aggregate object. Clients of the aggregate object communicate only with the aggregate object. See also Aggregate object. Contrast with Containment.
Ambient property: A run-time property that is managed and exposed by the container. Typically, an ambient property represents a characteristic of a form, such as background color, that needs to be communicated to a control so that the control can assume the look and feel of its surrounding environment. See also Run-time property.
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. 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 calling a function or method that could prematurely destroy it. A program calls IUnknown::AddRef to increment the object's reference count before making the call that could free the object. After the function returns, the program calls IUnknown::Release to decrement the count.
Asynchronous binding: A type of binding in which it is necessary for the process to occur asynchronously to avoid performance degradation for the end user. Typically, asynchronous binding is used in distributed environments such as the World Wide Web. OLE supports asynchronous moniker classes and callback mechanisms that allow the process of locating and initializing an object in a distributed environment to occur while other operations are being carried out. See also Asynchronous moniker, and Binding.
Asynchronous call: A call to a function that is executed separately so that the caller can continue processing instructions without waiting for the function to return. Contrast with Synchronous call.
Asynchronous moniker: A moniker that supports asynchronous binding. For example, instances of the system-supplied URL moniker class are asynchronous monikers. See also Asynchronous binding, Moniker, and URL moniker.
Automation: A way to manipulate an application's objects from outside the application. 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.

B

Bind context: A COM object that implements the IBindCtx interface. Bind contexts are used in moniker operations to hold references to the objects activated when a moniker is bound. The bind context contains parameters that apply to all operations during the binding of a generic composite moniker and provides the moniker implementation with access to information about its environment. See also Binding, Generic composite moniker, and Moniker.
Binding: Associating a name with its referent. Specifically, locating the object named by a moniker, putting it into its running state if it isn't already, and returning an interface pointer to it. Objects can be bound at run time (also called late binding or dynamic binding) or at compile time (also called static binding). See also Moniker and Running state.

C

Cache: A (usually temporary) local store of information. In OLE, a cache contains information that defines the presentation of a linked or embedded object when the container is opened. See also Container, Embedded object, and Linked object.
Cache initialization: Filling a linked or embedded object's cache with presentation data. The IOleCache interface provides methods that a container can call to control the data that gets cached for linked or embedded objects. See also Container, Embedded object, and Linked object.
Class: The definition of an object in code. In C++, the class of an object is defined as a data type, but this is not the case in other languages. Because OLE can be coded in any language, class is used to refer to the general object definition. See also Class factory.
Class factory: A COM object that implements the IClassFactory interface and that creates one or more instances of an object identified by a given class identifier(CLSID). See also Class identifier.
Class identifier (CLSID): A globally unique identifier (GUID) associated with an OLE class object. If a class object will be used to create more than one instance of an object, the associated server application should register its CLSID in the system registry so that clients can locate and load the executable code associated with the object(s). Every OLE server or container that allows linking to its embedded objects must register a CLSID for each supported object definition. See also Class and Class factory.
Class object: In object-oriented programming, an object whose state is shared by all the objects in a class and whose behavior acts on that classwide state data. In COM, class objects are called class factories, and typically have no behavior except to create new instances of the class. See also Class factory.
Client: A COM 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. See also Compound document and Container.
CLSID: See Class identifier.
Commit: To persistently save any changes made to a storage or stream object since it was opened or changes were last saved. See also Revert.
Component: An object that encapsulates both data and code, and provides a well-specified set of publicly available services.
Component Object Model (COM): The OLE object-oriented programming model that defines how objects interact within a single process or between processes. In COM, clients have access to an object through interfaces implemented on the object. See also Interface.
Composite menu bar: A shared menu bar composed of menu groups from both a container application and an in-place-activated server application. See also In-place activation.
Composite moniker: A moniker that consists of two or more monikers that are treated as a unit. 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 also Generic composite moniker.
Compound document: A document that includes linked or embedded objects, as well as its own native data. See also Embedded object and Linked object.
Compound File: An OLE-provided Structured Storage implementation that includes the IStorage, IStream, and ILockBytes interfaces. The StgXxx helper functions create and manipulate compound files. See also Structured Storage.
COM object: An object that conforms to the OLE Component Object Model (COM). A COM object is an instance of an object definition, which specifies the object's data and one or more implementations of interfaces on the object. Clients interact with a COM object only through its interfaces. See also Component Object Model and Interface.
Connectable object: A COM object that implements, at a minimum, the IConnectionPointContainer interface, for the management of connection point objects. Connectable objects support communication from the server to the client. A connectable object creates and manages one or more connection point subobjects, which receive events from interfaces implemented on other objects and send them on to the client. See also Connection point object and Advisory sink.
Connection point object: A COM object that is managed by a connectable object and that implements the IConnectionPoint interface. One or more connection point objects can be created and managed by a connectable object. Each connection point object manages incoming events from a specific interface on another object and sends those events on to the client. See also Connectable object, Advisory sink.
Container: See Container application.
Container application: An application that supports compound documents. The container application provides storage for an embedded or linked object, a site for its display, access to the display site, and an advisory sink for receiving notifications of changes in the object. See also Advisory sink, Compound document, Client site, Embedded object, and Linked object.
Containment: A composition technique for implementing COM objects. It allows one object to reuse some or all of the interface implementations of one or more other objects. The outer object acts as a client to the other objects, delegating implementation when it wishes to use the services of one of the contained objects. Contrast with Aggregation.
Control: An embeddable, reusable COM object that supports, at a minimum, the IOleControl interface. Controls are typically associated with the user interface. They also support communication with a container and can be reused by multiple clients, depending upon licensing criteria. See also Licensing.
Control container: An application that supports embedding of controls by implementing the IOleControlSite interface. See also Control.
Control property: A run-time property that is exposed and managed by the control itself. For example, the font and text size used by the control are control properties. See also Run-time property.
Controlling object: The object within an aggregate object that controls which interfaces within the aggregate object are exposed and which are private. The IUnknown interface of the controlling object is called the controlling IUnknown. Calls to IUnknown methods of other objects in the aggregate must be passed to the controlling IUnknown. See also Aggregate object.
Control site: A structure implemented by a control container for managing the display and storage of a control. Within a given container, each control has a corresponding control site. See also Control and Control container.

D

Data transfer object: An object that implements the IDataObject interface and contains data to be transferred from one object to another through either the Clipboard or drag-and-drop operations.
Default object handler: A DLL provided with OLE that acts as 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, such as rendering an object from its cached state when the object is loaded into memory.
Dependent object: A COM object that is typically initialized by another object (the host object). Although the dependent object's lifetime may only make sense during the lifetime of the host object, the host object does not function as the controlling IUnknown for the dependent object. In contrast, an object is an aggregated object when its lifetime (by means of its reference count) is completely controlled by the managing object. See also Host object. Contrast with Aggregation and Containment.
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.
Document object: An OLE document that can display one or more in-place activated views of its data within a native or foreign frame, such as a browser, while retaining full control over its user interface. In addition to implementing the usual OLE document and in-place activation interfaces, a document object must implement IOleDocument, and each of its views (in the form of a document view object) must implement IOleDocumentView. See also Document view, Document view object, and Frame.
Document object container: A container application capable of displaying one or more views of one or more document objects and of managing all contained document objects within a file. Each document object is associated with a document site, and each document site contains one or more document view sites corresponding to the views supported by the document object. A document object container also includes a container frame, which handles menu and toolbar negotiation and the enumeration of contained objects. See also Document object, Document site, Document view, Document view site, and Frame.
Document object server: A server application capable of providing document objects. See also Document object and Document object container.
Document site: A client site implemented by a document object container for managing the display and storage of a document object. Each document object in a container has a corresponding document site. See also Document object and Document object container.
Document site object: A COM object that implements the IOleDocumentSite interface, in addition to the usual client-site interfaces (such as IOleClientSite). See also Document site.
Document view: A particular presentation of a document's data. A single document object can have one or more views, but a single document view can belong to one and only one document object. See also Document object.
Document view object: A COM object that implements the IOleDocumentView interface and corresponds to a particular document view. An object with multiple document views aggregates a separate document view object for each view. See also Document view.
Document view site: An object aggregated by a document site object for managing the display space for a particular view of a document object. Within a given document site, each document view has a corresponding document view site. See also Document object, Document site object, and Document view.
Document view site object: A COM object that is aggregated in a document site object and implements the IOleInPlaceSite interface and, optionally, the IContinueCallback interface. See also Document site object.
Drag and drop: An operation in which the end user uses the mouse or other pointing device to move data to another location in the same window or another window.

E

Embed: To insert an object into a compound document in such a way as to preserve the data formats native to that object, and to enable it to be edited from within its container using tools exposed by its server.
Embedded object: An object whose data is stored in a compound document, but the object runs in the process space of its server. The default object handler provides a surrogate in the processing space of the container application for the real object. See also Default object handler, Compound document, and Container application.
.EXE server: See Out-of-process server.
Extended property: A run-time property, such as a control's position and size, that a user would assume to be exposed by the control but is exposed and managed by the container. See also Run-time property.

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 a COM object that supports the system-provided implementation of the IMoniker interface for the file moniker class. See also Item moniker, Generic composite moniker, and Moniker.
Font object: A COM object that provides access to Graphics Device Interface (GDI) fonts by implementing the IFont interface.
Format identifier: A GUID that identifies a persistent property set. Also referred to as FMTID. See also Property set.
Frame: The part of a container application responsible for negotiating menus, accelerator keys, toolbars, and other shared user-interface elements with an embedded COM object or a document object. See also Document object and Embedded object.
Frame object: A COM object that implements the IOleInPlaceFrame interface and, optionally, the IOleCommandTarget interface.

G

Generic composite moniker: A sequenced collection of monikers, starting with a file moniker to provide the document-level path and continuing with one or more item monikers that, taken as a whole, uniquely identifies an object. See also Composite moniker, Item moniker, and File moniker.

H

Helper function: A function that encapsulates calls to other functions and interface methods publicly available in the OLE SDK. Helper functions are a convenient way to call frequently used sequences of function and method calls that accomplish common tasks.
Host object: A COM object that forms a hierarchical relationship with one or more other COM objects, known as the dependent objects. Typically, the host object instantiates the dependent objects, and their existence only makes sense within the lifetime of the host object. However, the host object does not act as the controlling IUnknown for the dependent objects, nor does it directly delegate to the interface implementations of those objects. See also Dependent object.
HRESULT: An opaque result handle defined to be zero for a successful return from a function and nonzero if error or status information is returned. To convert an HRESULT into the more detailed SCODE, applications call GetScode(). See also SCODE.
Hyperlink object: A COM object that implements, at a minimum, the IHlink interface and acts as a link to an object at another location (the target). A hyperlink is made up of four parts: a moniker that identifies the target's location; a string for the location within the target; a friendly, or displayable, name for the target; and a string that can contain additional parameters.
Hyperlink browse context: A COM object that implements the IHlinkBrowseContext interface and maintains the hyperlink navigation stack. The browse context object manages the hyperlink frame window and hyperlink target object's window. See also Hyperlink target.
Hyperlink container: A container application that supports hyperlinks by implementing the IHlinkSite interface and, if the container's objects can be targets of other hyperlinks, the IHlinkTarget interface. See also Container.
Hyperlink frame object: A COM object that implements the IHlinkFrame interface and controls the top-level navigation and display of hyperlinks for the frame's container and the hyperlink target's server.
Hyperlink site object: A COM object that implements the IHlinkSite interface and supplies either the moniker or interface identifier of its hyperlink container. One hyperlink site can serve multiple hyperlinks. See also Hyperlink and Hyperlink container.
Hyperlink target object: A COM object that implements the IHlinkTarget interface and supplies its moniker, friendly name, and other information that other hyperlink objects will use to navigate to it.

I

In parameter: A parameter that is allocated, set, and freed by the caller of a function or interface method. An In parameter is not modified by the called function. See also In/Out parameter and Out parameter.
In/Out parameter: A parameter that is initially allocated by the caller of a function or interface method, and set, freed, and reallocated, if necessary, by the process that is called. See also In parameter and Out parameter.
In-place activation: Editing an embedded object within the window of its container, using tools provided by the server. Linked objects do not support in-place activation; they are always edited in the window of the server. See also Embedded object and Linked object.
In-process server: A server implemented as a DLL that runs in the process space of the client. See also Out-of-process server, Local server, and Remote server.
Instance: An object for which memory is allocated or which is persistent.
Interface: A group of semantically related functions that provide access to a COM object. Each OLE interface defines a contract that allows 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. See also Component Object Model and COM object.
Interface identifier (IID): A globally unique identifier (GUID) associated with an interface. Some functions take IIDs as parameters to allow the caller to specify which interface pointer should be returned.
Item moniker: A moniker based on a string that identifies an object in a container. Item monikers can 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, Generic composite moniker, Moniker, and Pseudo-object.

L

Licensing: A feature of COM that provides control over object creation. Licensed objects can be created only by clients that are authorized to use them. Licensing is implemented in COM through the IClassFactory2 interface and by support for a license key that can be passed at run time.
Link object: A COM object that is created when a linked COM object is created or loaded. The link object is provided by OLE and implements the IOleLink interface.
Linked object: A COM object whose source data physically resides where it was initially created. Only a moniker that represents the source data and the appropriate presentation data are kept with the compound document. Changes made to the link source are automatically reflected in the linked object. See also Link source.
Link source: The data that is the source of a linked object. A link source may be a file or a portion of a file, such as a selected range of cells within a file (also called a pseudo object). See also Linked object.
Loaded state: The state of an object after its data structures have been loaded into memory and are accessible to the client process. See also Active state, Passive state, and Running state.
Local server: An out-of-process server implemented as an .EXE application running on the same machine as its client application. See also In-process server, Out-of-process server, and Remote server.
Lock: A pointer held to—and possibly, a reference count incremented on—a running object. OLE defines two types of locks that can be held on an object: strong and weak. To implement a strong lock, a server must maintain both a pointer and a reference count, so that the object will remain "locked" in memory at least until the server calls Release. To implement a weak lock, the server maintains only a pointer to the object, so that the object can be destroyed by another process.

M

Marshaling: Packaging and sending interface method calls across thread or process boundaries.
Media type: An extension of MIME that allows data format negotiation between a client and an object. See also Multipurpose Internet Mail Extension (MIME).
MIME: See Multipurpose Internet Mail Extension.
MIME content type: See Media type.
Multipurpose Internet Mail Extension (MIME): An Internet protocol originally developed to allow exchange of electronic mail messages with rich content across heterogeneous network, machine, and e-mail environments. In practice, MIME has also been adopted and extended by non-mail applications.
Moniker: An object that implements the IMoniker interface. A moniker acts as a name that uniquely identifies a COM object. In the same way that a path identifies a file in the file system, a moniker identifies a COM object in the directory namespace. See also Binding.
Moniker class: An implementation of the IMoniker interface. System-supplied moniker classes include file monikers, item monikers, generic composite monikers, anti-monikers, pointer monikers, and URL monikers.
Moniker client: An application that uses monikers to acquire interface pointers to objects managed by another application.
Moniker provider: An application that makes available monikers that identify the objects it manages, so that the objects are accessible to other applications.

N

Namespace extension: An in-process COM object that implements IShellFolder, IPersistFolder, and IShellView, which are sometimes referred to as the namespace extension interfaces. A namespace extension is used either to extend the shell's namespace or to create a separate namespace. Primary users are the Windows Explorer and common file dialog boxes.
Native data: The data used by an OLE server application when editing an embedded object. See also Presentation data.

O

Object: In OLE, a programming structure encapsulating both data and functionality that are defined and allocated as a single unit and for which the only public access is through the programming structure's interfaces. A COM object must support, at a minimum, the IUnknown interface, which maintains the object's existence while it is being used and provides access to the object's other interfaces. See also COM and Interface.
Object handler: See Default object handler.
Object state: The relationship between a compound document object in its container and the application responsible for the object's creation: active, passive, loaded, or running. Passive objects are stored on disk or in a database, and the object is not selected or active. In the loaded state, the object's data structures have been loaded into memory, but they are not available for operations such as editing. Running objects are both loaded and available for all operations. Active objects are running objects that have a visible user interface.
Object type name: A unique identification string that is stored as part of the information available for an object in the registration database.
OLE: Microsoft's object-based technology for sharing information and services across process and machine boundaries.
OLE Automation: See Automation.
OLE control: See Control.
Out-of-process server: A server, implemented as an .EXE application, which runs outside the process of its client, either on the same machine or a remote machine. See also Local server and Remote server.
Out parameter: A parameter that is allocated and freed by the caller, but its value is set by the function being called. See also In parameter and In/Out parameter.

P

Passive state: The state of a COM object when it is stored (on disk or in a database). The object is not selected or active. See also Active state, Loaded state, Object state, and Running state.
Persistent properties: Information that can be stored persistently as part of a storage object such as a file or directory. Persistent properties are grouped into property sets, which can be displayed and edited.
Persistent properties are different from the run-time properties of objects created with OLE Controls and Automation technologies, which can be used to affect system behavior. The PROPVARIANT structure defines all valid types of persistent properties, whereas the VARIANT structure defines all valid types of run-time properties. See also Compound files, Property, and Property sets.
Persistent storage: Storage of a file or object in a medium such as a file system or database so that the object and its data persist when the file is closed and then re-opened at a later time.
Picture object: A COM object that provides access to GDI images by implementing the IPicture interface.
Pointer moniker: A moniker that maps an interface pointer to an object in memory. Whereas most monikers identify objects that can be persistently stored, pointer monikers identify objects that cannot. They allow such objects to participate in a moniker binding operation.
Presentation data: The data used by a container to display embedded or linked objects. See also Native data.
Primary verb: The action associated with the most common or 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.
Property: Information that is associated with an object. In OLE, properties fall into two categories: run-time properties and persistent properties. Run-time properties are typically associated with control objects or their containers. For example, background color is a run-time property set by a control's container. Persistent properties are associated with stored objects. See also Persistent properties and Run-time properties.
Property frame: The user interface mechanism that displays one or more property pages for a control. The OLE Controls run-time system provides a standard implementation of a property frame that can be accessed by using the OleCreatePropertyFrame helper funtion. See also Control and Property page.
Property identifier: A four-byte signed integer that identifies a persistent property within a property set. See also Persistent property and Property set.
Property page: A COM object with its own CLSID that is part of a user interface, implemented by a control, and allows the control's properties to be viewed and set. Property page objects implement the IPropertyPage interface. See also CLSID, Control.
Property page site: The location within a property frame where a property page is displayed. The property frame implements the IPropertyPageSite interface, which contains methods to manage the sites of each of the property pages supplied by a control. See also Property frame.
Property set: A logically related group of properties that is associated with a persistently stored object. To create, open, delete, or enumerate one or more property sets, implement the IPropertySetStorage interface. If you are using compound files, you can use OLE's implementation of this interface rather than implementing your own. See also Persistent properties.
Property set storage: A COM storage object that holds a property set. A property set storage is a dependent object associated with and managed by a storage object. See also Dependent object, Property set.
Property sheet: A set of property pages for one or more objects. See also Property page.
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: In standard marshaling, a proxy that manages all the interface proxies for a single object. See also Marshaling, Proxy.
Pseudo-object: A portion of a document or embedded object, such as a range of cells in a spreadsheet, that can be the source for a COM object.

R

Redistributable files: For more information on redistributable files, see the readme file for this service pack and the file redist.txt in the license directory.
Reference counting: Keeping a count of each interface pointer held on an object to ensure that the object is not destroyed before all references to it are released. See also Lock.
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 path, such as ..\backup\report.old. See also Moniker.
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, and Out-of-process server.
Revert: To discard any changes made to an object since the last time the changes were committed or the object's storage was opened. See also Commit and Transacted access mode.
Root storage object: The outermost storage object in a document. A root storage object can contain other nested storage and stream objects. For example, a compound document is saved on disk as a series of storage and stream objects within a root storage object. See also Compound document, Storage object, and Stream object.
Running state: The state of a COM object when its server application is running and it is possible to access its interfaces and receive notification of changes. See also Active state, Loaded state, Passive state.
Running Object Table (ROT): A globally accessible table on each computer that keeps track of all COM objects in the running state that can be identified by a moniker. Moniker providers register an object in the table, which increments the object's reference count. Before the object can be destroyed, its moniker must be released from the table. See also Running state.
Run-time property: Discrete state information associated with a control object or its container. There are three types of run-time properties: ambient properties, control properties, and extended properties. See also Ambient property, Control property, and Extended property. Contrast with Persistent property.

S

SCODE: A DWORD value that is used to return detailed information to the caller of an interface method or function. See also HRESULT.
Self-registration: The process by which a server can perform its own registry operations.
Server application: An application that can create COM objects. Container applications can then embed or link to these objects. See also Container application.
Sink: See Advisory sink.
State: See Active state, Loaded state, Object state, Passive state, and Running state.
Static object: An object that contains only a presentation, with no native data. A container 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—that is, the server application is unavailable, or the user doesn't want the linked object to be updated anymore. See also Native data.
Storage object: A COM object that implements the IStorage interface. A storage object contains nested storage objects or stream objects, resulting in the equivalent of a directory/file structure within a single file. See also Root storage object and Stream object.
Stream object: A COM object that implements the IStream interface. A stream object is analogous to a file in a directory/file system. See also Storage object.
Strong lock: See Lock.
Structured Storage: OLE's technology for storing compound files in native file systems. See also Compound file, Storage object, and Stream object.
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 also Proxy, Marshaling, and Unmarshaling.
Stub manager: Manages all of the interface stubs for a single object.
Subobject: See Dependent object.
Synchronous call: A function call that does not allow further instructions in the calling process to be executed until the function returns. See also Asychronous call.
System registry: A system-wide repository of information supported by Windows, which contains information about the system and its applications, including OLE clients and servers.

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 buffers until the root storage object commits its changes. See also Direct access mode, Commit, Revert, and Root storage object.
Type information: Information about an object's class provided by a type library. To provide type information, a COM object implements the IProvideClassInfo interface.

U

Uniform data transfer: A model for transferring data via the Clipboard, drag and drop, or Automation. Objects conforming to this model implement the IDataObject interface. This model replaces DDE (dynamic data exchange). See also Data transfer object.
Unmarshaling: Unpacking parameters that have been sent to a proxy across process boundaries.
Universal resource locator (URL): The identifier used by the World Wide Web for the names and locations of objects on the Internet. OLE provides a moniker class, URL moniker, whose implementation can be used to bind a client to objects identified by a URL. See also URL moniker.
URL moniker: A moniker based on a universal resource locator (URL). A client can use URL monikers to bind to objects that reside on the Internet. The system-supplied URL moniker class supports both synchronous and asynchronous binding. See also Asynchronous binding.

V

Virtual Table (VTBL): An array of pointers to interface method implementations. See also Interface.
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.

W

Weak lock: See Lock .