internal State(AxHost ctl)
{
CreateStorage();
manualUpdate = ctl.GetAxState(AxHost.manualUpdate);
licenseKey = ctl.GetLicenseKey();
type = STG_STORAGE;
}
// create on init new w/ storage...
internal State(AxHost control)
{
CreateStorage();
_manualUpdate = control.GetAxState(s_manualUpdate);
_licenseKey = control.GetLicenseKey();
Type = STG_STORAGE;
}
public AxPerPropertyBrowsingEnum(AxPropertyDescriptor targetObject, AxHost owner, OleStrCAMarshaler names, Int32CAMarshaler values, bool allowUnknowns) : base(Array.Empty <string>(), Array.Empty <object>(), allowUnknowns)
{
target = targetObject;
nameMarshaller = names;
valueMarshaller = values;
this.owner = owner;
arraysFetched = false;
}
// create on save from ipersist stream
internal State(MemoryStream memoryStream, int storageType, AxHost control, PropertyBagStream propertyBag)
{
Type = storageType;
_propertyBag = propertyBag;
// dangerous?
_length = (int)memoryStream.Length;
_memoryStream = memoryStream;
_manualUpdate = control.GetAxState(s_manualUpdate);
_licenseKey = control.GetLicenseKey();
}
internal State(MemoryStream ms, int storageType, AxHost ctl, PropertyBagStream propBag)
{
type = storageType;
PropertyBagBinary = propBag;
// dangerous?
length = (int)ms.Length;
this.ms = ms;
manualUpdate = ctl.GetAxState(AxHost.manualUpdate);
licenseKey = ctl.GetLicenseKey();
}
public AxPerPropertyBrowsingEnum(
AxPropertyDescriptor targetObject,
AxHost owner,
string[] names,
uint[] cookies)
{
_target = targetObject;
_names = names;
_cookies = cookies;
_owner = owner;
_arraysFetched = false;
}
internal AxPropertyDescriptor(PropertyDescriptor baseProp, AxHost owner) : base(baseProp)
{
this.baseProp = baseProp;
this.owner = owner;
// Get the category for this dispid.
//
dispid = (DispIdAttribute)baseProp.Attributes[typeof(DispIdAttribute)];
if (dispid != null)
{
// Look to see if this property has a property page.
// If it does, then it needs to be Browsable(true).
//
if (!IsBrowsable && !IsReadOnly)
{
Guid g = GetPropertyPage((Ole32.DispatchID)dispid.Value);
if (!Guid.Empty.Equals(g))
{
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Making property: " + Name + " browsable because we found an property page.");
AddAttribute(new BrowsableAttribute(true));
}
}
// Use the CategoryAttribute provided by the OCX.
CategoryAttribute cat = owner.GetCategoryForDispid((Ole32.DispatchID)dispid.Value);
if (cat != null)
{
AddAttribute(cat);
}
// Check to see if this a DataSource property.
// If it is, we can always get and set the value of this property.
//
if (PropertyType.GUID.Equals(dataSource_Guid))
{
SetFlag(FlagIgnoreCanAccessProperties, true);
}
}
}
internal RdpClient(ContainerControl parent, Size size, EventHandler resizeHandler)
{
this.parent = parent;
this.size = size;
try
{
rdpControl = rdpClient6 = new MsRdpClient6();
RDPConfigure(size);
// CA-96135: Try adding rdpControl to parent.Controls list; this will throw exception when
// MsRdpClient6 control cannot be created (there is no appropriate version of dll present)
parent.Controls.Add(rdpControl);
}
catch
{
if (parent.Controls.Contains(rdpControl))
parent.Controls.Remove(rdpControl);
rdpClient6 = null;
rdpControl = rdpClient2 = new MsRdpClient2();
RDPConfigure(size);
parent.Controls.Add(rdpControl);
}
rdpControl.Resize += resizeHandler;
}
internal AxPropertyDescriptor(PropertyDescriptor baseDescriptor, AxHost owner) : base(baseDescriptor)
{
_baseDescriptor = baseDescriptor;
_owner = owner;
// Get the category for this dispid.
_dispid = baseDescriptor.GetAttribute <DispIdAttribute>();
if (_dispid is not null)
{
// Look to see if this property has a property page.
// If it does, then it needs to be Browsable(true).
if (!IsBrowsable && !IsReadOnly)
{
Guid g = GetPropertyPage((Ole32.DispatchID)_dispid.Value);
if (!Guid.Empty.Equals(g))
{
Debug.WriteLineIf(s_axPropTraceSwitch.TraceVerbose, $"Making property: {Name} browsable because we found an property page.");
AddAttribute(new BrowsableAttribute(true));
}
}
// Use the CategoryAttribute provided by the OCX.
CategoryAttribute cat = owner.GetCategoryForDispid((Ole32.DispatchID)_dispid.Value);
if (cat is not null)
{
AddAttribute(cat);
}
// Check to see if this a DataSource property.
// If it is, we can always get and set the value of this property.
if (PropertyType.GUID.Equals(s_dataSource_Guid))
{
SetFlag(FlagIgnoreCanAccessProperties, true);
}
}
}
public AxEnumConverter(AxHost.AxPropertyDescriptor target, Com2Enum com2Enum) : base(com2Enum)
{
this.target = target;
}
internal AxPropertyDescriptor(PropertyDescriptor baseProp, AxHost owner) : base(baseProp)
{
this.updateAttrs = new ArrayList();
this.baseProp = baseProp;
this.owner = owner;
this.dispid = (DispIdAttribute) baseProp.Attributes[typeof(DispIdAttribute)];
if (this.dispid != null)
{
if (!this.IsBrowsable && !this.IsReadOnly)
{
Guid propertyPage = this.GetPropertyPage(this.dispid.Value);
if (!Guid.Empty.Equals(propertyPage))
{
this.AddAttribute(new BrowsableAttribute(true));
}
}
CategoryAttribute categoryForDispid = owner.GetCategoryForDispid(this.dispid.Value);
if (categoryForDispid != null)
{
this.AddAttribute(categoryForDispid);
}
if (this.PropertyType.GUID.Equals(AxHost.dataSource_Guid))
{
this.SetFlag(8, true);
}
}
}
internal void OnUIDeactivate(AxHost site)
{
this.siteUIActive = null;
site.RemoveSelectionHandler();
site.SetSelectionStyle(1);
site.editMode = 0;
if (site.GetSiteOwnsDeactivation())
{
ContainerControl containingControl = site.ContainingControl;
}
}
int System.Windows.Forms.UnsafeNativeMethods.IOleInPlaceFrame.SetActiveObject(System.Windows.Forms.UnsafeNativeMethods.IOleInPlaceActiveObject pActiveObject, string pszObjName)
{
if ((this.siteUIActive != null) && (this.siteUIActive.iOleInPlaceActiveObjectExternal != pActiveObject))
{
if (this.siteUIActive.iOleInPlaceActiveObjectExternal != null)
{
Marshal.ReleaseComObject(this.siteUIActive.iOleInPlaceActiveObjectExternal);
}
this.siteUIActive.iOleInPlaceActiveObjectExternal = pActiveObject;
}
if (pActiveObject == null)
{
if (this.ctlInEditMode != null)
{
this.ctlInEditMode.editMode = 0;
this.ctlInEditMode = null;
}
return 0;
}
AxHost axHost = null;
if (pActiveObject is System.Windows.Forms.UnsafeNativeMethods.IOleObject)
{
System.Windows.Forms.UnsafeNativeMethods.IOleObject obj2 = (System.Windows.Forms.UnsafeNativeMethods.IOleObject) pActiveObject;
System.Windows.Forms.UnsafeNativeMethods.IOleClientSite clientSite = null;
try
{
clientSite = obj2.GetClientSite();
if (clientSite is AxHost.OleInterfaces)
{
axHost = ((AxHost.OleInterfaces) clientSite).GetAxHost();
}
}
catch (COMException)
{
}
if (this.ctlInEditMode != null)
{
this.ctlInEditMode.SetSelectionStyle(1);
this.ctlInEditMode.editMode = 0;
}
if (axHost == null)
{
this.ctlInEditMode = null;
}
else if (!axHost.IsUserMode())
{
this.ctlInEditMode = axHost;
axHost.editMode = 1;
axHost.AddSelectionHandler();
axHost.SetSelectionStyle(2);
}
}
return 0;
}
/// <summary>
/// Returns an observable sequence wrapping the DragLeave event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the DragLeave event on the AxHost instance.</returns>
public static IObservable <EventPattern <EventArgs> > DragLeaveObservable(this AxHost instance)
{
return(Observable.FromEventPattern <EventHandler, EventArgs>(
handler => instance.DragLeave += handler,
handler => instance.DragLeave -= handler));
}
/// <summary>
/// Returns an observable sequence wrapping the RightToLeftChanged event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the RightToLeftChanged event on the AxHost instance.</returns>
public static IObservable <EventPattern <EventArgs> > RightToLeftChangedObservable(this AxHost instance)
{
return(Observable.FromEventPattern <EventHandler, EventArgs>(
handler => instance.RightToLeftChanged += handler,
handler => instance.RightToLeftChanged -= handler));
}
/// <summary>
/// Returns an observable sequence wrapping the BackgroundImageLayoutChanged event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the BackgroundImageLayoutChanged event on the AxHost instance.</returns>
public static IObservable <EventPattern <EventArgs> > BackgroundImageLayoutChangedObservable(this AxHost instance)
{
return(Observable.FromEventPattern <EventHandler, EventArgs>(
handler => instance.BackgroundImageLayoutChanged += handler,
handler => instance.BackgroundImageLayoutChanged -= handler));
}
internal State(MemoryStream ms, int storageType, AxHost ctl, AxHost.PropertyBagStream propBag)
{
this.VERSION = 1;
this.type = storageType;
this.propBag = propBag;
this.length = (int) ms.Length;
this.ms = ms;
this.manualUpdate = ctl.GetAxState(AxHost.manualUpdate);
this.licenseKey = ctl.GetLicenseKey();
}
/// <summary>
/// Returns an observable sequence wrapping the MouseWheel event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the MouseWheel event on the AxHost instance.</returns>
public static IObservable <EventPattern <MouseEventArgs> > MouseWheelObservable(this AxHost instance)
{
return(Observable.FromEventPattern <MouseEventHandler, MouseEventArgs>(
handler => instance.MouseWheel += handler,
handler => instance.MouseWheel -= handler));
}
/// <summary>
/// Returns an observable sequence wrapping the ChangeUICues event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the ChangeUICues event on the AxHost instance.</returns>
public static IObservable <EventPattern <UICuesEventArgs> > ChangeUICuesObservable(this AxHost instance)
{
return(Observable.FromEventPattern <UICuesEventHandler, UICuesEventArgs>(
handler => instance.ChangeUICues += handler,
handler => instance.ChangeUICues -= handler));
}
/// <summary>
/// Returns an observable sequence wrapping the MouseHover event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the MouseHover event on the AxHost instance.</returns>
public static IObservable <EventPattern <EventArgs> > MouseHoverObservable(this AxHost instance)
{
return(Observable.FromEventPattern <EventHandler, EventArgs>(
handler => instance.MouseHover += handler,
handler => instance.MouseHover -= handler));
}
/// <summary>
/// Returns an observable sequence wrapping the Layout event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the Layout event on the AxHost instance.</returns>
public static IObservable <EventPattern <LayoutEventArgs> > LayoutObservable(this AxHost instance)
{
return(Observable.FromEventPattern <LayoutEventHandler, LayoutEventArgs>(
handler => instance.Layout += handler,
handler => instance.Layout -= handler));
}
/// <summary>
/// Returns an observable sequence wrapping the KeyUp event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the KeyUp event on the AxHost instance.</returns>
public static IObservable <EventPattern <KeyEventArgs> > KeyUpObservable(this AxHost instance)
{
return(Observable.FromEventPattern <KeyEventHandler, KeyEventArgs>(
handler => instance.KeyUp += handler,
handler => instance.KeyUp -= handler));
}
public InvalidActiveXStateException(string name, AxHost.ActiveXInvokeKind kind)
{
this.name = name;
this.kind = kind;
}
/// <summary>
/// Returns an observable sequence wrapping the ContextMenuChanged event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the ContextMenuChanged event on the AxHost instance.</returns>
public static IObservable <EventPattern <EventArgs> > ContextMenuChangedObservable(this AxHost instance)
{
return(Observable.FromEventPattern <EventHandler, EventArgs>(
handler => instance.ContextMenuChanged += handler,
handler => instance.ContextMenuChanged -= handler));
}
internal State(AxHost ctl)
{
this.VERSION = 1;
this.CreateStorage();
this.manualUpdate = ctl.GetAxState(AxHost.manualUpdate);
this.licenseKey = ctl.GetLicenseKey();
this.type = 2;
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal void OnInPlaceDeactivate(AxHost site) {
if (siteActive == site) {
siteActive = null;
if (site.GetSiteOwnsDeactivation()) {
parent.ActiveControl = null;
}
else {
// we need to tell the form to switch activation to the next thingie...
Debug.Fail("what pathological control is calling inplacedeactivate by itself?");
}
}
}
/// <summary>
/// Returns an observable sequence wrapping the HelpRequested event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the HelpRequested event on the AxHost instance.</returns>
public static IObservable <EventPattern <HelpEventArgs> > HelpRequestedObservable(this AxHost instance)
{
return(Observable.FromEventPattern <HelpEventHandler, HelpEventArgs>(
handler => instance.HelpRequested += handler,
handler => instance.HelpRequested -= handler));
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal void OnUIDeactivate(AxHost site) {
#if DEBUG
if (siteUIActive != null)
Debug.Assert(siteUIActive == site, "deactivating when not active...");
#endif // DEBUG
siteUIActive = null;
site.RemoveSelectionHandler();
site.SetSelectionStyle(1);
site.editMode = EDITM_NONE;
if (site.GetSiteOwnsDeactivation()) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, " our site owns deactivation ");
ContainerControl f = site.ContainingControl;
Debug.Assert(f != null, "a control has to be on a ContainerControl...");
if (f != null) {
// f.setActiveControl(null);
}
}
}
/// <summary>
/// Returns an observable sequence wrapping the DoubleClick event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the DoubleClick event on the AxHost instance.</returns>
public static IObservable <EventPattern <EventArgs> > DoubleClickObservable(this AxHost instance)
{
return(Observable.FromEventPattern <EventHandler, EventArgs>(
handler => instance.DoubleClick += handler,
handler => instance.DoubleClick -= handler));
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal void OnUIActivate(AxHost site) {
// The ShDocVw control repeatedly calls OnUIActivate() with the same
// site. This causes the assert below to fire.
//
if (siteUIActive == site)
return;
if (siteUIActive != null && siteUIActive != site) {
AxHost tempSite = siteUIActive;
bool ownDisposing = tempSite.GetAxState(AxHost.ownDisposing);
try {
tempSite.SetAxState(AxHost.ownDisposing, true);
tempSite.GetInPlaceObject().UIDeactivate();
}
finally {
tempSite.SetAxState(AxHost.ownDisposing, ownDisposing);
}
}
site.AddSelectionHandler();
Debug.Assert(siteUIActive == null, "Object did not call OnUIDeactivate");
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "active Object is now "+site.ToString());
siteUIActive = site;
ContainerControl f = site.ContainingControl;
Debug.Assert(f != null, "a control has to be on a ContainerControl...");
if (f != null) {
f.ActiveControl = site;
}
}
/// <summary>
/// Returns an observable sequence wrapping the QueryContinueDrag event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the QueryContinueDrag event on the AxHost instance.</returns>
public static IObservable <EventPattern <QueryContinueDragEventArgs> > QueryContinueDragObservable(this AxHost instance)
{
return(Observable.FromEventPattern <QueryContinueDragEventHandler, QueryContinueDragEventArgs>(
handler => instance.QueryContinueDrag += handler,
handler => instance.QueryContinueDrag -= handler));
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal void ControlCreated(AxHost invoker) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in controlCreated for "+invoker.ToString()+" fAC: "+formAlreadyCreated.ToString());
if (formAlreadyCreated) {
if (invoker.IsUserMode() && invoker.AwaitingDefreezing()) {
invoker.Freeze(false);
}
}
else {
// the form will be created in the future
parent.CreateAxContainer();
}
}
private bool RegisterControl(AxHost ctl)
{
ISite site = ctl.Site;
if (site != null)
{
IContainer container = site.Container;
if (container != null)
{
if (this.assocContainer != null)
{
return (container == this.assocContainer);
}
this.assocContainer = container;
IComponentChangeService service = (IComponentChangeService) site.GetService(typeof(IComponentChangeService));
if (service != null)
{
service.ComponentRemoved += new ComponentEventHandler(this.OnComponentRemoved);
}
return true;
}
}
return false;
}
internal void FormCreated() {
if (formAlreadyCreated) return;
formAlreadyCreated = true;
ArrayList l = new ArrayList();
ListAxControls(l, false);
AxHost[] axControls = new AxHost[l.Count];
l.CopyTo(axControls, 0);
for (int i = 0; i < axControls.Length; i++) {
AxHost control = axControls[i];
if (control.GetOcState() >= OC_RUNNING && control.IsUserMode() && control.AwaitingDefreezing()) {
control.Freeze(false);
}
}
}
internal ExtenderProxy(Control principal, AxHost.AxContainer container)
{
this.pRef = new WeakReference(principal);
this.pContainer = new WeakReference(container);
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal void OnExitEditMode(AxHost ctl) {
Debug.Assert(ctlInEditMode == null || ctlInEditMode == ctl, "who is exiting edit mode?");
if (ctlInEditMode == null || ctlInEditMode != ctl) return;
ctlInEditMode = null;
}
public AxPerPropertyBrowsingEnum(AxHost.AxPropertyDescriptor targetObject, AxHost owner, OleStrCAMarshaler names, Int32CAMarshaler values, bool allowUnknowns) : base(new string[0], new object[0], allowUnknowns)
{
this.target = targetObject;
this.nameMarshaller = names;
this.valueMarshaller = values;
this.owner = owner;
this.arraysFetched = false;
}
/// <include file='doc\AxHost.uex' path='docs/doc[@for="AxHost.AxContainer.SetActiveObject"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
int UnsafeNativeMethods.IOleInPlaceFrame.SetActiveObject(UnsafeNativeMethods.IOleInPlaceActiveObject pActiveObject, string pszObjName) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SetActiveObject " + ((pszObjName == null) ? "<null>" : pszObjName));
if (siteUIActive != null) {
if (siteUIActive.iOleInPlaceActiveObjectExternal != pActiveObject) {
if (siteUIActive.iOleInPlaceActiveObjectExternal != null) {
Marshal.ReleaseComObject(siteUIActive.iOleInPlaceActiveObjectExternal);
}
siteUIActive.iOleInPlaceActiveObjectExternal = pActiveObject;
}
}
if (pActiveObject == null) {
if (ctlInEditMode != null) {
ctlInEditMode.editMode = EDITM_NONE;
ctlInEditMode = null;
}
return NativeMethods.S_OK;
}
AxHost ctl = null;
if (pActiveObject is UnsafeNativeMethods.IOleObject) {
UnsafeNativeMethods.IOleObject oleObject = (UnsafeNativeMethods.IOleObject) pActiveObject;
UnsafeNativeMethods.IOleClientSite clientSite = null;
try {
clientSite = oleObject.GetClientSite();
if (clientSite is OleInterfaces) {
ctl = ((OleInterfaces)(clientSite)).GetAxHost();
}
}
catch (COMException t) {
Debug.Fail(t.ToString());
}
if (ctlInEditMode != null) {
Debug.Fail("control " + ctlInEditMode.ToString() + " did not reset its edit mode to null");
ctlInEditMode.SetSelectionStyle(1);
ctlInEditMode.editMode = EDITM_NONE;
}
if (ctl == null) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "control w/o a valid site called setactiveobject");
ctlInEditMode = null;
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "resolved to " + ctl.ToString());
if (!ctl.IsUserMode()) {
ctlInEditMode = ctl;
ctl.editMode = EDITM_OBJECT;
ctl.AddSelectionHandler();
ctl.SetSelectionStyle(2);
}
}
}
return NativeMethods.S_OK;
}
public AxPropertyTypeEditor(AxHost.AxPropertyDescriptor pd, Guid guid)
{
this.propDesc = pd;
this.guid = guid;
}
// create on init new w/ storage...
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal State(AxHost ctl) {
CreateStorage();
manualUpdate = ctl.GetAxState(AxHost.manualUpdate);
licenseKey = ctl.GetLicenseKey();
type = STG_STORAGE;
}
internal OleInterfaces(AxHost host)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
this.host = host;
}
internal AxPropertyDescriptor(PropertyDescriptor baseProp, AxHost owner) : base(baseProp) {
this.baseProp = baseProp;
this.owner = owner;
// Get the category for this dispid.
//
dispid = (DispIdAttribute)baseProp.Attributes[typeof(DispIdAttribute)];
if (dispid != null) {
// Look to see if this property has a property page.
// If it does, then it needs to be Browsable(true).
//
if (!this.IsBrowsable && !this.IsReadOnly) {
Guid g = GetPropertyPage(dispid.Value);
if (!Guid.Empty.Equals(g)) {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Making property: " + this.Name + " browsable because we found an property page.");
AddAttribute(new BrowsableAttribute(true));
}
}
// Use the CategoryAttribute provided by the OCX.
//
CategoryAttribute cat = owner.GetCategoryForDispid(dispid.Value);
if (cat != null) {
AddAttribute(cat);
}
// Check to see if this a DataSource property.
// If it is, we can always get and set the value of this property.
//
if (this.PropertyType.GUID.Equals(dataSource_Guid)) {
SetFlag(FlagIgnoreCanAccessProperties, true);
}
}
}
internal State(AxHost.PropertyBagStream propBag)
{
this.VERSION = 1;
this.propBag = propBag;
}
internal void ControlCreated(AxHost invoker)
{
if (this.formAlreadyCreated)
{
if (invoker.IsUserMode() && invoker.AwaitingDefreezing())
{
invoker.Freeze(false);
}
}
else
{
this.parent.CreateAxContainer();
}
}
protected void SetAboutBoxDelegate (AxHost.AboutBoxDelegate d)
{
throw new NotImplementedException("COM/ActiveX support is not implemented");
}
internal OleInterfaces(AxHost host)
{
_host = host.OrThrowIfNull();
}
/// <summary>
/// Returns an observable sequence wrapping the GiveFeedback event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the GiveFeedback event on the AxHost instance.</returns>
public static IObservable <EventPattern <GiveFeedbackEventArgs> > GiveFeedbackObservable(this AxHost instance)
{
return(Observable.FromEventPattern <GiveFeedbackEventHandler, GiveFeedbackEventArgs>(
handler => instance.GiveFeedback += handler,
handler => instance.GiveFeedback -= handler));
}
protected void SetAboutBoxDelegate (AxHost.AboutBoxDelegate d)
{
this.aboutDelegate = d;
}
/// <summary>
/// Returns an observable sequence wrapping the DragOver event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the DragOver event on the AxHost instance.</returns>
public static IObservable <EventPattern <DragEventArgs> > DragOverObservable(this AxHost instance)
{
return(Observable.FromEventPattern <DragEventHandler, DragEventArgs>(
handler => instance.DragOver += handler,
handler => instance.DragOver -= handler));
}
/// <summary>
/// Returns an observable sequence wrapping the QueryAccessibilityHelp event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the QueryAccessibilityHelp event on the AxHost instance.</returns>
public static IObservable <EventPattern <QueryAccessibilityHelpEventArgs> > QueryAccessibilityHelpObservable(this AxHost instance)
{
return(Observable.FromEventPattern <QueryAccessibilityHelpEventHandler, QueryAccessibilityHelpEventArgs>(
handler => instance.QueryAccessibilityHelp += handler,
handler => instance.QueryAccessibilityHelp -= handler));
}
internal void OnExitEditMode(AxHost ctl)
{
if ((this.ctlInEditMode != null) && (this.ctlInEditMode == ctl))
{
this.ctlInEditMode = null;
}
}
internal void OnInPlaceDeactivate(AxHost site)
{
if (this.siteActive == site)
{
this.siteActive = null;
if (site.GetSiteOwnsDeactivation())
{
this.parent.ActiveControl = null;
}
}
}
internal OleInterfaces(AxHost host)
{
this.host = host ?? throw new ArgumentNullException(nameof(host));
}
internal void OnUIActivate(AxHost site)
{
if (this.siteUIActive != site)
{
if ((this.siteUIActive != null) && (this.siteUIActive != site))
{
AxHost siteUIActive = this.siteUIActive;
bool axState = siteUIActive.GetAxState(AxHost.ownDisposing);
try
{
siteUIActive.SetAxState(AxHost.ownDisposing, true);
siteUIActive.GetInPlaceObject().UIDeactivate();
}
finally
{
siteUIActive.SetAxState(AxHost.ownDisposing, axState);
}
}
site.AddSelectionHandler();
this.siteUIActive = site;
ContainerControl containingControl = site.ContainingControl;
if (containingControl != null)
{
containingControl.ActiveControl = site;
}
}
}
internal void FormCreated()
{
if (!this.formAlreadyCreated)
{
this.formAlreadyCreated = true;
ArrayList list = new ArrayList();
this.ListAxControls(list, false);
AxHost[] array = new AxHost[list.Count];
list.CopyTo(array, 0);
for (int i = 0; i < array.Length; i++)
{
AxHost host = array[i];
if (((host.GetOcState() >= 2) && host.IsUserMode()) && host.AwaitingDefreezing())
{
host.Freeze(false);
}
}
}
}
/// <summary>
/// Returns an observable sequence wrapping the Paint event on the AxHost instance.
/// </summary>
/// <param name="instance">The AxHost instance to observe.</param>
/// <returns>An observable sequence wrapping the Paint event on the AxHost instance.</returns>
public static IObservable <EventPattern <PaintEventArgs> > PaintObservable(this AxHost instance)
{
return(Observable.FromEventPattern <PaintEventHandler, PaintEventArgs>(
handler => instance.Paint += handler,
handler => instance.Paint -= handler));
}
