Object Linking and Embedding (OLE)
Object Linking and Embedding (OLE) is a compound document standard developed by Microsoft Corporation. It enables you to create objects with one application and then link or embed them in a second application. Embedded objects retain their original formatand links to the application that created them. Support for OLE is built into the Windows and Macintosh operating systems. A competing compound document standard developed jointly by IBM, Apple Computer, and other computer firms is called OpenDoc.
History of Object Linking and Embedding (OLE)
- OLE 1.0: OLE 1.0, released in 1990, was an evolution of the original Dynamic Data Exchange (DDE) concept that Microsoft developed for earlier versions of Windows. While DDE was limited to transferring limited amounts of data between two running applications, OLE was capable of maintaining active links between two documents or even embedding one type of document within another. OLE servers and clients communicate with system libraries using virtual function tables, or VTBLs. The VTBL consists of a structure of function pointers that the system library can use to communicate with the server or client. The server and client libraries, OLESVR.DLL and OLECLI.DLL, were originally designed to communicate between themselves using the WM_DDE_EXECUTE message. OLE 1.0 later evolved to become an architecture for software components known as the Component Object Model (COM), and later DCOM. When an OLE object is placed on the clipboard or embedded in a document, both a visual representation in native Windows formats (such as a bitmap or metafile) is stored, as well as the underlying data in its own format. This allows applications to display the object without loading the application used to create the object, while also allowing the object to be edited, if the appropriate application is installed. The Object Packager, a component of OLE, shipping from Windows 3.1 up to Windows XP allows a non-OLE object to be "packaged" so it can be embedded into an OLE client.
- OLE 2.0: OLE 2.0 was the next evolution of OLE, sharing many of the same goals as version 1.0, but was re-implemented on top of the Component Object Model (COM) instead of using VTBLs directly. New features were OLE automation, drag-and-drop, in-place activation and structured storage. Monikers evolved from OLE 1 object names, and provided a hierarchical object and resource naming system similar to URLs or URIs, which were independently invented. Windows now has merged the two technologies supporting a URL Moniker type, and a Moniker URL scheme.
- OLE custom controls: OLE custom controls were introduced in 1994 as a replacement for the now deprecated Visual Basic Extension controls. Instead of upgrading these, the new architecture was based on OLE. In particular, any container that supported OLE 2.0 could already embed OLE custom controls, although these controls cannot react to events unless the container supports this. OLE custom controls are usually shipped in the form of a dynamic link library with the .ocx extension. In 1996 all interfaces for controls (except IUnknown) were made optional to keep the file size of controls down, so they would download faster; these were then called ActiveX Controls.
An OLE object may display as an icon. Double clicking the icon opens the associated object application or asks the user to select an application for object editing. Alternatively, an OLE object may display as actual contents, such as a graph or chart. For example, an external application chart, such as an Excel spreadsheet, may be inserted into a Word application. When the chart is activated in the Word document, the chart's user interface loads, and the user is able to manipulate the external chart's data inside the Word document. OLE-supported software applications include:
- Microsoft Windows applications, such as Excel, Word and PowerPoint
- Corel WordPerfect
- Adobe Acrobat
- Multimedia applications, like photos, audio/video clips and PowerPoint presentations.
Understanding Object Linking and Embedding (OLE)
A linked object is a pointer to data in a source file; when data in the source file changes, the changes are reflected in Notes®. (You can specify whether the linked data in Notes is updated automatically or manually when data in the source file changes). Because a linked object's data is stored in the source file, users who need to edit (or update) a linked object need to have the server application, have access to the source file on a file server, and maintain the directory mapping to the source file on the file server. Also, if a source file is moved or deleted, the linked object that points to it has to be re-created.
An embedded object is a copy of data from a source file; when data from the source file changes, the changes are not reflected in the embedded object. Because an embedded object's data is stored in Notes, users who need to edit an embedded object don't need access to the source file. For this reason, embedding makes it easier to share static data from other applications in Notes with other users.
Static OLE Objects
A static OLE object is a snapshot of an object that has been copied from the original application to the container application. You can place a static OLE object in a Crystal report, but after you put it there, you can’t edit it or change it in any way (except to delete it). A static OLE object doesn’t maintain any connection to the application that created it.
Control the Plot Quality of OLE Objects
OLE objects are treated as raster objects when a raster plotter is used. Because large, high-resolution, color-rich rasters can be expensive to plot, you can set the OLEQUALITY system variable to control how each OLE object is plotted. The default setting, Automatically Select, assigns a plot-quality level based on the type of object. The higher the plot-quality setting, the more time and memory are used to plot. You can also adjust OLE plot quality in the Plotter Configuration Editor. The Graphics option displays a Raster Graphics dialog box with a slider that controls OLE plot quality. Note: Nested OLE objects may cause problems. For example, an Excel spreadsheet embedded in a Word document may fail to plot. Also, an OLE object that is not in the current view plane is not plotted, but the frame is plotted based on the setting of the OLEFRAME system variable.
Disadvantages of Object Linking and Embedding (OLE)
OLE has certain disadvantages, as follows:
- Embedded objects increase the host document file size, resulting in potential storage or loading difficulties.
- Linked objects can break when a host document is moved to a location that does not have the original object application.
- Interoperability is limited. If the embedded or linked object application is unavailable, the object cannot be manipulated or edited.
- Definition of Object Linking and Embedding (OLE) Webopedia
- The History of Object Linking and Embedding (OLE) Wikipedia
- Explaining Object Linking and Embedding (OLE) Techopedia
- Understanding Object Linking and Embedding (OLE) IBM
- Static OLE Objects Dummies
- Control the Plot Quality of OLE Objects Autodesk Knowledge Network
- Disadvantages of Object Linking and Embedding (OLE) Techopedia
- Managing and composing requirements: Defining requirements in modules - OLE objects and pictures IBM
- Contrasting Linked and Embedded Objects Microsoft
- Object Linking and Embedding (OLE) Definition on Business Dictionary
- Object Linking and Embedding (OLE) Definition on Encyclopedia
- Object Linking and Embedding (OLE) Definition on TechTerms