Object Linking and Embedding (OLE) - Revision history

User at 17:25, 16 January 2023

2023-01-16T17:25:04Z

User: The LinkTitles extension automatically added links to existing pages (https://github.com/bovender/LinkTitles).

2021-02-06T17:18:46Z

The LinkTitles extension automatically added links to existing pages (https://github.com/bovender/LinkTitles).

User: 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.

2019-01-04T05:52:23Z

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.

User: Created page with "'''Content coming soon'''"

2018-12-13T18:52:44Z

Created page with "'''Content coming soon'''"

New page

'''Content coming soon'''

@@ Line 1: / Line 1: @@
-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.<ref>Definition of Object Linking and Embedding (OLE) [http://www.webopedia.com/TERM/O/OLE.html Webopedia]</ref>
+'''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 format and 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 are called OpenDoc.<ref>[http://www.webopedia.com/TERM/O/OLE.html Definition of Object Linking and Embedding (OLE)]</ref>
-'''History of Object Linking and Embedding (OLE)'''<ref>The History of Object Linking and Embedding (OLE) [https://en.wikipedia.org/wiki/Object_Linking_and_Embedding Wikipedia]</ref><br />
+'''History of Object Linking and Embedding (OLE)'''<ref>[https://en.wikipedia.org/wiki/Object_Linking_and_Embedding The History of Object Linking and Embedding (OLE)]</ref><br />
-*OLE 1.0: OLE 1.0, released in 1990, was an evolution of the original [[Dynamic_Data_Exchange_(DDE)|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)|Component Object Model (COM)]], and later [[Distributed_Component_Object_Model_(DCOM)|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 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)|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 [[Uniform_Resource_Locator_(URL)|URLs]] or [[Uniform_Resource_Identifier_(URI)|URIs]], which were independently invented. Windows now has merged the two technologies supporting a URL Moniker type, and a Moniker URL scheme.
+*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 have 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_Interface_(COM)|IUnknown]]) were made optional to keep the file size of controls down, so they would download faster; these were then called [[ActiveX]] Controls.
+*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 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
+*Microsoft Windows applications, such as Excel, Word, and PowerPoint
 *Corel WordPerfect
 *Adobe Acrobat
 *AutoCAD
-*Multimedia applications, like photos, audio/video clips and PowerPoint presentations.<ref>Explaining Object Linking and Embedding (OLE) [https://www.techopedia.com/definition/4995/object-linking-and-embedding-ole Techopedia]</ref>
+*Multimedia applications, like photos, audio/video clips, and PowerPoint presentations.<ref>[https://www.techopedia.com/definition/4995/object-linking-and-embedding-ole Explaining Object Linking and Embedding (OLE)]</ref>
-'''Understanding Object Linking and Embedding (OLE)'''<ref>Understanding Object Linking and Embedding (OLE) [https://www.ibm.com/support/knowledgecenter/en/SSKTWP_9.0.0/com.ibm.notes900.help.doc/sh_object_link_embed_defined_c.html IBM]</ref><br />
+'''Understanding Object Linking and Embedding (OLE)'''<ref>[https://www.ibm.com/support/knowledgecenter/en/SSKTWP_9.0.0/com.ibm.notes900.help.doc/sh_object_link_embed_defined_c.html Understanding Object Linking and Embedding (OLE)]</ref><br />
-*Linking
+*Linking: 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 recreated.
-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.
+*Embedding: 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'''<ref>Static OLE Objects [http://www.dummies.com/software/other-software/crystal-reports-10-understanding-object-linking-and-embedding-ole/ Dummies]</ref><br />
+'''Static OLE Objects'''<ref>[http://www.dummies.com/software/other-software/crystal-reports-10-understanding-object-linking-and-embedding-ole/ Static OLE Objects]</ref><br />
 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'''<ref>Control the Plot Quality of OLE Objects [https://knowledge.autodesk.com/support/autocad/learn-explore/caas/CloudHelp/cloudhelp/2016/ENU/AutoCAD-Core/files/GUID-8D74BAD2-B564-4C7C-A732-8AB0FC271155-htm.html Autodesk Knowledge Network]</ref><br />
+'''Control the Plot Quality of OLE Objects'''<ref>[https://knowledge.autodesk.com/support/autocad/learn-explore/caas/CloudHelp/cloudhelp/2016/ENU/AutoCAD-Core/files/GUID-8D74BAD2-B564-4C7C-A732-8AB0FC271155-htm.html Control the Plot Quality of OLE Objects]</ref><br />
-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.
+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.<br />
 '''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)'''<ref>Disadvantages of Object Linking and Embedding (OLE) [https://www.techopedia.com/definition/4995/object-linking-and-embedding-ole Techopedia]</ref><br />
+'''Disadvantages of Object Linking and Embedding (OLE)'''<ref>[https://www.techopedia.com/definition/4995/object-linking-and-embedding-ole Disadvantages of Object Linking and Embedding (OLE)]</ref><br />
 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.
+*Interoperability is limited. If the embedded or linked object application is unavailable, the object cannot be manipulated or edited.
-===See Also===
+== See Also ==
-[[Component_Object_Model_(COM)|Component Object Model (COM)]]
+[[Component Object Model (COM)]]
-===References===
+== References ==
 <references/>
-===Further Reading===
+== Further Reading ==
-*Managing and composing requirements: Defining requirements in modules - OLE objects and pictures [https://www.ibm.com/support/knowledgecenter/en/SSYQBZ_9.6.1/com.ibm.doors.requirements.doc/topics/c_aboutoleobjects.html IBM]
+*[https://www.ibm.com/support/knowledgecenter/en/SSYQBZ_9.6.1/com.ibm.doors.requirements.doc/topics/c_aboutoleobjects.html Managing and composing requirements: Defining requirements in modules - OLE objects and pictures]
-*Contrasting Linked and Embedded Objects [https://msdn.microsoft.com/en-us/library/aa240861(v=vs.60).aspx Microsoft]
+*[https://msdn.microsoft.com/en-us/library/aa240861(v=vs.60).aspx Contrasting Linked and Embedded Objects]
-*Object Linking and Embedding (OLE) Definition on [http://www.businessdictionary.com/definition/object-linking-and-embedding-OLE.html Business Dictionary]
+*[http://www.businessdictionary.com/definition/object-linking-and-embedding-OLE.html Object Linking and Embedding (OLE) Definition]
-*Object Linking and Embedding (OLE) Definition on [http://www.encyclopedia.com/computing/dictionaries-thesauruses-pictures-and-press-releases/object-linking-and-embedding Encyclopedia]
+__NOTOC__

@@ Line 1: / Line 1: @@
-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.<ref>Definition of Object Linking and Embedding (OLE) [http://www.webopedia.com/TERM/O/OLE.html Webopedia]</ref>
+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.<ref>Definition of Object Linking and Embedding (OLE) [http://www.webopedia.com/TERM/O/OLE.html Webopedia]</ref>
 '''History of Object Linking and Embedding (OLE)'''<ref>The History of Object Linking and Embedding (OLE) [https://en.wikipedia.org/wiki/Object_Linking_and_Embedding Wikipedia]</ref><br />
-*OLE 1.0: OLE 1.0, released in 1990, was an evolution of the original [[Dynamic_Data_Exchange_(DDE)|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)|Component Object Model (COM)]], and later [[Distributed_Component_Object_Model_(DCOM)|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 1.0: OLE 1.0, released in 1990, was an evolution of the original [[Dynamic_Data_Exchange_(DDE)|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)|Component Object Model (COM)]], and later [[Distributed_Component_Object_Model_(DCOM)|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)|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 [[Uniform_Resource_Locator_(URL)|URLs]] or [[Uniform_Resource_Identifier_(URI)|URIs]], which were independently invented. Windows now has merged the two technologies supporting a URL Moniker type, and a Moniker URL scheme.
+*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)|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 [[Uniform_Resource_Locator_(URL)|URLs]] or [[Uniform_Resource_Identifier_(URI)|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_Interface_(COM)|IUnknown]]) were made optional to keep the file size of controls down, so they would download faster; these were then called ActiveX Controls.
+*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_Interface_(COM)|IUnknown]]) were made optional to keep the file size of controls down, so they would download faster; these were then called [[ActiveX]] Controls.
@@ Line 28: / Line 28: @@
-'''Control the Plot Quality of OLE Objects'''<ref>Control the Plot Quality of OLE Objects [https://knowledge.autodesk.com/support/autocad/learn-explore/caas/CloudHelp/cloudhelp/2016/ENU/AutoCAD-Core/files/GUID-8D74BAD2-B564-4C7C-A732-8AB0FC271155-htm.html Autodesk Knowledge Network]</ref><br />
+'''[[Control]] the Plot [[Quality]] of OLE Objects'''<ref>Control the Plot Quality of OLE Objects [https://knowledge.autodesk.com/support/autocad/learn-explore/caas/CloudHelp/cloudhelp/2016/ENU/AutoCAD-Core/files/GUID-8D74BAD2-B564-4C7C-A732-8AB0FC271155-htm.html Autodesk Knowledge Network]</ref><br />
 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.
@@ Line 37: / Line 37: @@
 *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.
+*[[Interoperability]] is limited. If the embedded or linked object application is unavailable, the object cannot be manipulated or edited.

← Older revision		Revision as of 05:52, 4 January 2019
Line 1:		Line 1:
−	'''~~Content coming soon~~'''	+	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.<ref>Definition of Object Linking and Embedding (OLE) [http://www.webopedia.com/TERM/O/OLE.html Webopedia]</ref>
		+
		+
		+	'''History of Object Linking and Embedding (OLE)'''<ref>The History of Object Linking and Embedding (OLE) [https://en.wikipedia.org/wiki/Object_Linking_and_Embedding Wikipedia]</ref><br />
		+	*OLE 1.0: OLE 1.0, released in 1990, was an evolution of the original [[Dynamic_Data_Exchange_(DDE)\|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)\|Component Object Model (COM)]], and later [[Distributed_Component_Object_Model_(DCOM)\|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)\|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 [[Uniform_Resource_Locator_(URL)\|URLs]] or [[Uniform_Resource_Identifier_(URI)\|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_Interface_(COM)\|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
		+	*AutoCAD
		+	*Multimedia applications, like photos, audio/video clips and PowerPoint presentations.<ref>Explaining Object Linking and Embedding (OLE) [https://www.techopedia.com/definition/4995/object-linking-and-embedding-ole Techopedia]</ref>
		+
		+
		+	'''Understanding Object Linking and Embedding (OLE)'''<ref>Understanding Object Linking and Embedding (OLE) [https://www.ibm.com/support/knowledgecenter/en/SSKTWP_9.0.0/com.ibm.notes900.help.doc/sh_object_link_embed_defined_c.html IBM]</ref><br />
		+	*Linking
		+	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.
		+	*Embedding
		+	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'''<ref>Static OLE Objects [http://www.dummies.com/software/other-software/crystal-reports-10-understanding-object-linking-and-embedding-ole/ Dummies]</ref><br />
		+	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'''<ref>Control the Plot Quality of OLE Objects [https://knowledge.autodesk.com/support/autocad/learn-explore/caas/CloudHelp/cloudhelp/2016/ENU/AutoCAD-Core/files/GUID-8D74BAD2-B564-4C7C-A732-8AB0FC271155-htm.html Autodesk Knowledge Network]</ref><br />
		+	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)'''<ref>Disadvantages of Object Linking and Embedding (OLE) [https://www.techopedia.com/definition/4995/object-linking-and-embedding-ole Techopedia]</ref><br />
		+	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.
		+
		+
		+	===See Also===
		+	[[Component_Object_Model_(COM)\|Component Object Model (COM)]]
		+
		+
		+	===References===
		+	<references/>
		+
		+
		+	===Further Reading===
		+	*Managing and composing requirements: Defining requirements in modules - OLE objects and pictures [https://www.ibm.com/support/knowledgecenter/en/SSYQBZ_9.6.1/com.ibm.doors.requirements.doc/topics/c_aboutoleobjects.html IBM]
		+	*Contrasting Linked and Embedded Objects [https://msdn.microsoft.com/en-us/library/aa240861(v=vs.60).aspx Microsoft]
		+	*Object Linking and Embedding (OLE) Definition on [http://www.businessdictionary.com/definition/object-linking-and-embedding-OLE.html Business Dictionary]
		+	*Object Linking and Embedding (OLE) Definition on [http://www.encyclopedia.com/computing/dictionaries-thesauruses-pictures-and-press-releases/object-linking-and-embedding Encyclopedia]
		+	*Object Linking and Embedding (OLE) Definition on [https://techterms.com/definition/ole TechTerms]