Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / WinForms / Managed / System / WinForms / AxHost.cs / 1 / AxHost.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms {
using Microsoft.Win32;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Configuration.Assemblies;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Design;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Remoting;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Windows.Forms.ComponentModel;
using System.Windows.Forms.ComponentModel.Com2Interop;
using System.Windows.Forms.Design;
///
///
///
/// Wraps ActiveX controls and exposes them as
/// fully featured windows forms controls.
///
///
[
ComVisible(true),
ClassInterface(ClassInterfaceType.AutoDispatch),
ToolboxItem(false),
DesignTimeVisible(false),
DefaultEvent("Enter"),
Designer("System.Windows.Forms.Design.AxHostDesigner, " + AssemblyRef.SystemDesign),
PermissionSet(SecurityAction.LinkDemand, Name="FullTrust"),
PermissionSet(SecurityAction.InheritanceDemand, Name="FullTrust")
]
public abstract class AxHost : Control, ISupportInitialize, ICustomTypeDescriptor {
private static TraceSwitch AxHTraceSwitch = new TraceSwitch("AxHTrace", "ActiveX handle tracing");
private static TraceSwitch AxPropTraceSwitch = new TraceSwitch("AxPropTrace", "ActiveX property tracing");
private static TraceSwitch AxHostSwitch = new TraceSwitch("AxHost", "ActiveX host creation");
private static BooleanSwitch AxIgnoreTMSwitch = new BooleanSwitch("AxIgnoreTM", "ActiveX switch to ignore thread models");
private static BooleanSwitch AxAlwaysSaveSwitch = new BooleanSwitch("AxAlwaysSave", "ActiveX to save all controls regardless of their IsDirty function return value");
///
/// Flags which may be passed to the AxHost constructor
///
[SuppressMessage("Microsoft.Performance", "CA1812:AvoidUninstantiatedInternalClasses")]
internal class AxFlags {
///
/// Indicates that the context menu for the control should not contain an
/// "Edit" verb unless the activeX controls itself decides to proffer it.
/// By default, all wrapped activeX controls will contain an edit verb.
///
internal const int PreventEditMode = 0x1;
///
/// Indicated that the context menu for the control should contain
/// a "Properties..." verb which may be used to show the property
/// pages for the control. Note that even if this flag is
/// specified, the verb will not appear unless the control
/// proffers a set of property pages.
/// [Since most activeX controls alreay have their own properties verb
/// on the context menu, the default is not to include one specified by
/// this flag.]
///
internal const int IncludePropertiesVerb = 0x2;
///
///
///
/// Creates a new instance of a control which wraps an activeX control given by the
/// clsid parameter and flags of 0.
///
protected AxHost(string clsid) : this(clsid, 0) {
}
///
/// Creates a new instance of a control which wraps an activeX control given by the
/// clsid and flags parameters.
///
[PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
protected AxHost(string clsid, int flags) : base() {
if (Application.OleRequired() != ApartmentState.STA) {
throw new ThreadStateException(SR.GetString(SR.AXMTAThread, clsid));
}
this.oleSite = new OleInterfaces(this);
this.selectionChangeHandler = new EventHandler(this.OnNewSelection);
this.clsid = new Guid(clsid);
this.flags = flags;
this.axState[assignUniqueID] = !this.GetType().GUID.Equals(comctlImageCombo_Clsid);
this.axState[needLicenseKey] = true;
this.axState[rejectSelection] = true;
isMaskEdit = this.clsid.Equals(AxHost.maskEdit_Clsid);
this.onContainerVisibleChanged = new EventHandler(this.OnContainerVisibleChanged);
}
private bool CanUIActivate {
get {
return IsUserMode() || editMode != EDITM_NONE;
}
}
///
/// Returns the CreateParams used to create the handle for this control.
///
protected override CreateParams CreateParams {
get {
CreateParams cp = base.CreateParams;
if (axState[fOwnWindow] && IsUserMode()) {
cp.Style = cp.Style & (~NativeMethods.WS_VISIBLE);
}
return cp;
}
}
private bool GetAxState(int mask) {
return this.axState[mask];
}
private void SetAxState(int mask, bool value) {
this.axState[mask] = value;
}
///
/// AxHost will call this when it is ready to create the underlying ActiveX object.
/// Wrappers will override this and cast the pointer obtained by calling getOcx() to
/// their own interfaces. getOcx() should not usually be called before this function.
/// Note: calling begin will result in a call to this function.
///
protected virtual void AttachInterfaces() {
}
private void RealizeStyles() {
SetStyle(ControlStyles.UserPaint, false);
int bits = 0;
int hr = GetOleObject().GetMiscStatus(NativeMethods.ActiveX.DVASPECT_CONTENT, out bits);
if (!NativeMethods.Failed(hr)) {
miscStatusBits = bits;
ParseMiscBits(miscStatusBits);
}
}
// Control overrides:
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Color BackColor {
get {
return base.BackColor;
}
set {
base.BackColor = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override Image BackgroundImage {
get {
return base.BackgroundImage;
}
set {
base.BackgroundImage = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override ImageLayout BackgroundImageLayout {
get {
return base.BackgroundImageLayout;
}
set {
base.BackgroundImageLayout = value;
}
}
///
/// Hide ImeMode: it doesn't make sense for this control
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
new public ImeMode ImeMode
{
get
{
return base.ImeMode;
}
set
{
base.ImeMode = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler MouseClick {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseClick"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler MouseDoubleClick {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseDoubleClick"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Cursor Cursor {
get {
return base.Cursor;
}
set {
base.Cursor = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override ContextMenu ContextMenu {
get {
return base.ContextMenu;
}
set {
base.ContextMenu = value;
}
}
///
/// Deriving classes can override this to configure a default size for their control.
/// This is more efficient than setting the size in the control's constructor.
///
protected override Size DefaultSize {
get {
return new Size(75, 23);
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public virtual new bool Enabled {
get {
return base.Enabled;
}
set {
base.Enabled = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Font Font {
get {
return base.Font;
}
set {
base.Font = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Color ForeColor {
get {
return base.ForeColor;
}
set {
base.ForeColor = value;
}
}
///
/// [To be supplied.]
///
[
Browsable(false),
EditorBrowsable(EditorBrowsableState.Never),
Localizable(true)
]
public new virtual bool RightToLeft {
get {
RightToLeft rtol = base.RightToLeft;
return rtol == System.Windows.Forms.RightToLeft.Yes;
}
set {
base.RightToLeft = (value) ? System.Windows.Forms.RightToLeft.Yes : System.Windows.Forms.RightToLeft.No;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override string Text {
get {
return text;
}
set {
text = value;
}
}
internal override bool CanAccessProperties {
get {
int ocState = GetOcState();
return(axState[fOwnWindow] &&
(ocState > OC_RUNNING || (IsUserMode() && ocState >= OC_RUNNING)) ||
ocState >= OC_INPLACE);
}
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void BeginInit() {
}
///
/// Signals the object that loading of all peer components and property
/// sets are complete.
/// It should be possible to invoke any property get or set after calling this method.
/// Note that a sideeffect of this method is the creation of the parent control's
/// handle, therefore, this control must be parented before begin is called
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void EndInit() {
if (ParentInternal != null) {
ParentInternal.CreateControl(true);
ContainerControl f = ContainingControl;
if (f != null) {
f.VisibleChanged += this.onContainerVisibleChanged;
}
}
}
private void OnContainerVisibleChanged(object sender, EventArgs e) {
ContainerControl f = ContainingControl;
if (f != null) {
if (f.Visible && Visible && !axState[fOwnWindow]) {
MakeVisibleWithShow();
}
else if (!f.Visible && Visible && IsHandleCreated && GetOcState() >= OC_INPLACE) {
HideAxControl();
}
else if (f.Visible && !GetState(STATE_VISIBLE) && IsHandleCreated && GetOcState() >= OC_INPLACE) {
HideAxControl();
}
}
}
//
///
/// Determines if the control is in edit mode.
///
[ Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public bool EditMode {
get {
return editMode != EDITM_NONE;
}
}
///
/// Determines if this control has an about box.
///
[ Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public bool HasAboutBox {
get {
return aboutBoxDelegate != null;
}
}
private int NoComponentChangeEvents {
get {
return noComponentChange;
}
set {
noComponentChange = value;
}
}
//
///
/// Shows the about box for this control.
///
public void ShowAboutBox() {
if (aboutBoxDelegate != null) {
aboutBoxDelegate();
}
}
//
///
/// Retrieves the OCX control flags.
///
#if false
// FxCop: Currently not used
[ Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
private int OcxFlags {
get {
return flags;
}
}
#endif
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler BackColorChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "BackColorChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler BackgroundImageChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "BackgroundImageChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler BackgroundImageLayoutChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "BackgroundImageLayoutChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler BindingContextChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "BindingContextChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler ContextMenuChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "ContextMenuChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler CursorChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "CursorChanged"));
}
remove {
}
}
///
/// Occurs when the control is enabled.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler EnabledChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "EnabledChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler FontChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "FontChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler ForeColorChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "ForeColorChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler RightToLeftChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "RightToLeftChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler TextChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "TextChanged"));
}
remove {
}
}
///
/// Occurs when the control is clicked.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler Click {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "Click"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event DragEventHandler DragDrop {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "DragDrop"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event DragEventHandler DragEnter {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "DragEnter"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event DragEventHandler DragOver {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "DragOver"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler DragLeave {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "DragLeave"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event GiveFeedbackEventHandler GiveFeedback {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "GiveFeedback"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event HelpEventHandler HelpRequested {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "HelpRequested"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event PaintEventHandler Paint {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "Paint"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event QueryContinueDragEventHandler QueryContinueDrag {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "QueryContinueDrag"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event QueryAccessibilityHelpEventHandler QueryAccessibilityHelp {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "QueryAccessibilityHelp"));
}
remove {
}
}
///
/// Occurs when the control is double clicked.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler DoubleClick {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "DoubleClick"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler ImeModeChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "ImeModeChanged"));
}
remove {
}
}
///
/// Occurs when a key is pressed down while the control has focus.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event KeyEventHandler KeyDown {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "KeyDown"));
}
remove {
}
}
///
/// Occurs when a key is pressed while the control has focus.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event KeyPressEventHandler KeyPress {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "KeyPress"));
}
remove {
}
}
///
/// Occurs when a key is released while the control has focus.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event KeyEventHandler KeyUp {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "KeyUp"));
}
remove {
}
}
///
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event LayoutEventHandler Layout {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "Layout"));
}
remove {
}
}
///
/// Occurs when the mouse pointer is over the control and a mouse button is
/// pressed.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event MouseEventHandler MouseDown {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseDown"));
}
remove {
}
}
///
/// Occurs when the mouse pointer enters the AxHost.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler MouseEnter {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseEnter"));
}
remove {
}
}
///
/// Occurs when the mouse pointer leaves the AxHost.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler MouseLeave {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseLeave"));
}
remove {
}
}
///
/// Occurs when the mouse pointer hovers over the contro.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler MouseHover {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseHover"));
}
remove {
}
}
///
/// Occurs when the mouse pointer is moved over the AxHost.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event MouseEventHandler MouseMove {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseMove"));
}
remove {
}
}
///
/// Occurs when the mouse pointer is over the control and a mouse button is released.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event MouseEventHandler MouseUp {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseUp"));
}
remove {
}
}
///
/// Occurs when the mouse wheel moves while the control has focus.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event MouseEventHandler MouseWheel {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseWheel"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event UICuesEventHandler ChangeUICues {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "ChangeUICues"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler StyleChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "StyleChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
protected override void OnFontChanged(EventArgs e) {
base.OnFontChanged(e);
AmbientChanged(NativeMethods.ActiveX.DISPID_AMBIENT_FONT);
}
///
/// [To be supplied.]
///
protected override void OnForeColorChanged(EventArgs e) {
base.OnForeColorChanged(e);
AmbientChanged(NativeMethods.ActiveX.DISPID_AMBIENT_FORECOLOR);
}
///
/// [To be supplied.]
///
protected override void OnBackColorChanged(EventArgs e) {
base.OnBackColorChanged(e);
AmbientChanged(NativeMethods.ActiveX.DISPID_AMBIENT_BACKCOLOR);
}
private void AmbientChanged(int dispid) {
if (GetOcx() != null) {
try {
Invalidate();
GetOleControl().OnAmbientPropertyChange(dispid);
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
}
}
private bool OwnWindow() {
return axState[fOwnWindow] || axState[fFakingWindow];
}
private IntPtr GetHandleNoCreate() {
if (IsHandleCreated) return Handle;
return IntPtr.Zero;
}
private ISelectionService GetSelectionService() {
return GetSelectionService(this);
}
private static ISelectionService GetSelectionService(Control ctl) {
ISite site = ctl.Site;
if (site != null) {
Object o = site.GetService(typeof(ISelectionService));
Debug.Assert(o == null || o is ISelectionService, "service must implement ISelectionService");
//Note: if o is null, we want to return null anyway. Happy day.
return o as ISelectionService;
}
return null;
}
private void AddSelectionHandler() {
if (axState[addedSelectionHandler]) return;
ISelectionService iss = GetSelectionService();
if (iss != null) {
iss.SelectionChanging += selectionChangeHandler;
}
axState[addedSelectionHandler] = true;
}
private void OnComponentRename(object sender, ComponentRenameEventArgs e)
{
// When we're notified of a rename, see if this is the componnent that is being
// renamed.
//
if (e.Component == this)
{
// if it is, call DISPID_AMBIENT_DISPLAYNAME directly on the
// control itself.
//
UnsafeNativeMethods.IOleControl oleCtl = this.GetOcx() as UnsafeNativeMethods.IOleControl;
if (oleCtl != null)
{
oleCtl.OnAmbientPropertyChange(NativeMethods.ActiveX.DISPID_AMBIENT_DISPLAYNAME);
}
}
}
private bool RemoveSelectionHandler() {
if (!axState[addedSelectionHandler]) return false;
ISelectionService iss = GetSelectionService();
if (iss != null) {
iss.SelectionChanging -= selectionChangeHandler;
}
axState[addedSelectionHandler] = false;
return true;
}
private void SyncRenameNotification(bool hook) {
if (DesignMode && hook != axState[renameEventHooked])
{
// if we're in design mode, listen to the following events from the component change service
//
IComponentChangeService changeService = (IComponentChangeService)GetService(typeof(IComponentChangeService));
if (changeService != null)
{
if (hook) {
changeService.ComponentRename += new ComponentRenameEventHandler(OnComponentRename);
}
else {
changeService.ComponentRename -= new ComponentRenameEventHandler(OnComponentRename);
}
axState[renameEventHooked] = hook;
}
}
}
///
/// Sets the site of this component. A non-null value indicates that the
/// component has been added to a container, and a null value indicates that
/// the component is being removed from a container.
///
public override ISite Site {
set {
// If we are disposed then just return.
if (axState[disposed])
{
return;
}
bool reAddHandler = RemoveSelectionHandler();
bool olduMode = IsUserMode();
// clear the old hook
//
SyncRenameNotification(false);
base.Site = value;
bool newuMode = IsUserMode();
if (!newuMode) GetOcxCreate();
if (reAddHandler) AddSelectionHandler();
SyncRenameNotification(value != null);
// For inherited forms we create the OCX first in User mode
// and then we get sited. At that time, we have to re-activate
// the OCX by transitioning down to and up to the current state.
//
if (value != null && !newuMode && olduMode != newuMode && GetOcState() > OC_LOADED) {
TransitionDownTo(OC_LOADED);
TransitionUpTo(OC_INPLACE);
ContainerControl f = ContainingControl;
if (f != null && f.Visible && Visible)
MakeVisibleWithShow();
}
if (olduMode != newuMode && !IsHandleCreated && !axState[disposed]) {
if (GetOcx() != null) {
RealizeStyles();
}
}
if (!newuMode) {
//SetupClass_Info(this);
}
}
}
///
/// Raises the
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected override void OnLostFocus(EventArgs e) {
// ASURT 93669
// Office WebControl and MS DDS control create a child window that gains
// focus in order to handle keyboard input. Since, UIDeactivate() could
// destroy that window, these controls will crash trying to process WM_CHAR.
// We now check to see if we are losing focus to a child, and if so, not call
// UIDeactivate().
//
bool uiDeactivate = (GetHandleNoCreate() != hwndFocus);
if (uiDeactivate && IsHandleCreated) {
uiDeactivate = !UnsafeNativeMethods.IsChild(new HandleRef(this, GetHandleNoCreate()), new HandleRef(null, hwndFocus));
}
base.OnLostFocus(e);
if (uiDeactivate) {
UiDeactivate();
}
}
private void OnNewSelection(Object sender, EventArgs e) {
if (IsUserMode()) return;
ISelectionService iss = GetSelectionService();
// What we care about:
// if we are uiactive and we lose selection, then we need to uideactivate ourselves...
if (iss != null) {
if (GetOcState() >= OC_UIACTIVE && !iss.GetComponentSelected(this)) {
// need to deactivate...
int hr = UiDeactivate();
if (NativeMethods.Failed(hr)) {
// not much we can do here...
Debug.Fail("Failed to UiDeactivate: " + hr.ToString(CultureInfo.InvariantCulture));
}
}
if (!iss.GetComponentSelected(this)) {
if (editMode != EDITM_NONE) {
GetParentContainer().OnExitEditMode(this);
editMode = EDITM_NONE;
}
// need to exit edit mode...
SetSelectionStyle(1);
RemoveSelectionHandler();
}
else {
// The AX Host designer will offer an extender property called "SelectionStyle"
//
PropertyDescriptor prop = TypeDescriptor.GetProperties(this)["SelectionStyle"];
if (prop != null && prop.PropertyType == typeof(int)) {
int curSelectionStyle = (int)prop.GetValue(this);
if (curSelectionStyle != this.selectionStyle) {
prop.SetValue(this, selectionStyle);
}
}
}
}
}
//DrawToBitmap doesn't work for this control, so we should hide it. We'll
//still call base so that this has a chance to work if it can.
[EditorBrowsable(EditorBrowsableState.Never)]
new public void DrawToBitmap(Bitmap bitmap, Rectangle targetBounds)
{
base.DrawToBitmap(bitmap, targetBounds);
}
///
/// Creates a handle for this control. This method is called by the .NET framework, this should
/// not be called.
///
protected override void CreateHandle() {
if (!IsHandleCreated) {
TransitionUpTo(OC_RUNNING);
if (!axState[fOwnWindow]) {
if (axState[fNeedOwnWindow]) {
Debug.Assert(!Visible, "if we were visible we would not be needing a fake window...");
axState[fNeedOwnWindow] = false;
axState[fFakingWindow] = true;
base.CreateHandle();
// note that we do not need to attach the handle because the work usually done in there
// will be done in Control's wndProc on WM_CREATE...
}
else {
TransitionUpTo(OC_INPLACE);
// it is possible that we were hidden while in place activating, in which case we don't
// really have a handle now because the act of hiding could have destroyed it
// so, just call ourselves again recursively, and if we dont't have a handle, we will
// just take the "axState[fNeedOwnWindow]" path above...
if (axState[fNeedOwnWindow]) {
Debug.Assert(!IsHandleCreated, "if we need a fake window, we can't have a real one");
CreateHandle();
return;
}
}
}
else {
SetState(STATE_VISIBLE, false);
base.CreateHandle();
}
GetParentContainer().ControlCreated(this);
}
}
private NativeMethods.COMRECT GetClipRect(NativeMethods.COMRECT clipRect) {
if (clipRect != null) {
FillInRect(clipRect, new Rectangle(0, 0, 32000, 32000));
}
return clipRect;
}
private static int SetupLogPixels(bool force) {
if (logPixelsX == -1 || force) {
IntPtr hDC = UnsafeNativeMethods.GetDC(NativeMethods.NullHandleRef);
if (hDC == IntPtr.Zero)
return NativeMethods.E_FAIL;
logPixelsX = UnsafeNativeMethods.GetDeviceCaps(new HandleRef(null, hDC), NativeMethods.LOGPIXELSX);
logPixelsY = UnsafeNativeMethods.GetDeviceCaps(new HandleRef(null, hDC), NativeMethods.LOGPIXELSY);
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "log pixels are: "+logPixelsX.ToString(CultureInfo.InvariantCulture)+" "+logPixelsY.ToString(CultureInfo.InvariantCulture));
UnsafeNativeMethods.ReleaseDC(NativeMethods.NullHandleRef, new HandleRef(null, hDC));
}
return NativeMethods.S_OK;
}
private void HiMetric2Pixel(NativeMethods.tagSIZEL sz, NativeMethods.tagSIZEL szout) {
NativeMethods._POINTL phm = new NativeMethods._POINTL();
phm.x = sz.cx;
phm.y = sz.cy;
NativeMethods.tagPOINTF pcont = new NativeMethods.tagPOINTF();
((UnsafeNativeMethods.IOleControlSite)oleSite).TransformCoords(phm, pcont, NativeMethods.ActiveX.XFORMCOORDS_SIZE | NativeMethods.ActiveX.XFORMCOORDS_HIMETRICTOCONTAINER);
szout.cx = (int)pcont.x;
szout.cy = (int)pcont.y;
}
private void Pixel2hiMetric(NativeMethods.tagSIZEL sz, NativeMethods.tagSIZEL szout) {
NativeMethods.tagPOINTF pcont = new NativeMethods.tagPOINTF();
pcont.x = (float) sz.cx;
pcont.y = (float) sz.cy;
NativeMethods._POINTL phm = new NativeMethods._POINTL();
((UnsafeNativeMethods.IOleControlSite)oleSite).TransformCoords(phm, pcont, NativeMethods.ActiveX.XFORMCOORDS_SIZE | NativeMethods.ActiveX.XFORMCOORDS_CONTAINERTOHIMETRIC);
szout.cx = phm.x;
szout.cy = phm.y;
}
private static int Pixel2Twip(int v, bool xDirection) {
SetupLogPixels(false);
int logP = xDirection ? logPixelsX : logPixelsY;
return(int) ((((double)v) / logP) * 72.0 * 20.0);
}
private static int Twip2Pixel(double v, bool xDirection) {
SetupLogPixels(false);
int logP = xDirection ? logPixelsX : logPixelsY;
return(int) (((v / 20.0) / 72.0) * logP);
}
private static int Twip2Pixel(int v, bool xDirection) {
SetupLogPixels(false);
int logP = xDirection ? logPixelsX : logPixelsY;
return(int) (((((double) v) / 20.0) / 72.0) * logP);
}
private Size SetExtent(int width, int height) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "setting extent to "+width.ToString(CultureInfo.InvariantCulture)+" "+height.ToString(CultureInfo.InvariantCulture));
NativeMethods.tagSIZEL sz = new NativeMethods.tagSIZEL();
sz.cx = width;
sz.cy = height;
bool resetExtents = !IsUserMode();
try {
Pixel2hiMetric(sz, sz);
GetOleObject().SetExtent(NativeMethods.ActiveX.DVASPECT_CONTENT, sz);
}
catch (COMException) {
resetExtents = true;
}
if (resetExtents) {
GetOleObject().GetExtent(NativeMethods.ActiveX.DVASPECT_CONTENT, sz);
try {
GetOleObject().SetExtent(NativeMethods.ActiveX.DVASPECT_CONTENT, sz);
}
catch (COMException e) {
Debug.Fail(e.ToString());
}
}
return GetExtent();
}
private Size GetExtent() {
NativeMethods.tagSIZEL sz = new NativeMethods.tagSIZEL();
GetOleObject().GetExtent(NativeMethods.ActiveX.DVASPECT_CONTENT, sz);
HiMetric2Pixel(sz, sz);
return new Size(sz.cx, sz.cy);
}
///
/// ActiveX controls scale themselves, so GetScaledBounds simply returns their
/// original unscaled bounds.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected override Rectangle GetScaledBounds(Rectangle bounds, SizeF factor, BoundsSpecified specified) {
return bounds;
}
private void SetObjectRects(Rectangle bounds) {
if (GetOcState() < OC_INPLACE) return;
GetInPlaceObject().SetObjectRects(FillInRect(new NativeMethods.COMRECT(), bounds), GetClipRect(new NativeMethods.COMRECT()));
}
///
/// Performs the work of setting the bounds of this control.
/// User code should usually not call this function.
///
protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) {
// We have already been in this Code so please avoid re-entering this CODE PATH or else the
// IOleObject will "give a Catastrophic error" in SetObjectRects( ).
// Please refer : VsWhidbey 341212.
if (GetAxState(AxHost.handlePosRectChanged))
return;
axState[handlePosRectChanged] = true;
// Provide control with an opportunity to apply self imposed constraints on its size.
Size adjustedSize = ApplySizeConstraints(width, height);
width = adjustedSize.Width;
height = adjustedSize.Height;
try {
if (axState[fFakingWindow]) {
base.SetBoundsCore(x, y, width, height, specified);
return;
}
Rectangle oldBounds = Bounds;
if (oldBounds.X == x && oldBounds.Y == y && oldBounds.Width == width &&
oldBounds.Height == height) {
return;
}
if (!IsHandleCreated) {
UpdateBounds(x, y, width, height);
return;
}
if (GetOcState() > OC_RUNNING) {
CheckSubclassing();
if (width != oldBounds.Width || height != oldBounds.Height) {
Size p = SetExtent(width, height);
width = p.Width;
height = p.Height;
}
}
if (axState[manualUpdate]) {
SetObjectRects(new Rectangle(x, y, width, height));
CheckSubclassing();
UpdateBounds();
}
else {
SetObjectRects(new Rectangle(x, y, width, height));
base.SetBoundsCore(x, y, width, height, specified);
Invalidate();
}
}
finally {
axState[handlePosRectChanged] = false;
}
}
private bool CheckSubclassing() {
if (!IsHandleCreated || wndprocAddr == IntPtr.Zero) return true;
IntPtr handle = Handle;
IntPtr currentWndproc = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, handle), NativeMethods.GWL_WNDPROC);
if (currentWndproc == wndprocAddr) return true;
if ((int)SendMessage(REGMSG_MSG, 0, 0) == REGMSG_RETVAL) {
wndprocAddr = currentWndproc;
return true;
}
// yikes, we were resubclassed...
Debug.WriteLineIf(AxHostSwitch.TraceVerbose, "The horrible control subclassed itself w/o calling the old wndproc...");
// we need to resubclass outselves now...
Debug.Assert(!OwnWindow(), "why are we here if we own our window?");
this.WindowReleaseHandle();
UnsafeNativeMethods.SetWindowLong(new HandleRef(this, handle), NativeMethods.GWL_WNDPROC, new HandleRef(this, currentWndproc));
this.WindowAssignHandle(handle, axState[assignUniqueID]);
InformOfNewHandle();
axState[manualUpdate] = true;
return false;
}
///
/// Destroys the handle associated with this control.
/// User code should in general not call this function.
///
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
// security review: this is a breaking change, but should it be fixed?
protected override void DestroyHandle() {
if (axState[fOwnWindow]) {
base.DestroyHandle();
}
else {
if (IsHandleCreated) {
TransitionDownTo(OC_RUNNING);
}
}
}
#if false
// FxCop: Currently not used
private void TransitionTo(int state) {
if (state > GetOcState()) {
TransitionUpTo(state);
}
else if (state < GetOcState()) {
TransitionDownTo(state);
}
}
#endif
private void TransitionDownTo(int state) {
if (axState[inTransition]) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Recursively entering TransitionDownTo...");
return;
}
try {
axState[inTransition] = true;
while (state < GetOcState()) {
switch (GetOcState()) {
case OC_OPEN:
Debug.Fail("how did we ever get into the open state?");
SetOcState(OC_UIACTIVE);
break;
case OC_UIACTIVE:
int hr = UiDeactivate();
Debug.Assert(NativeMethods.Succeeded(hr), "Failed in UiDeactivate: " + hr.ToString(CultureInfo.InvariantCulture));
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose && GetOcState() == OC_INPLACE, "failed transition");
SetOcState(OC_INPLACE);
break;
case OC_INPLACE:
if (axState[fFakingWindow]) {
DestroyFakeWindow();
SetOcState(OC_RUNNING);
}
else {
InPlaceDeactivate();
}
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose && GetOcState() == OC_RUNNING, "failed transition");
SetOcState(OC_RUNNING);
break;
case OC_RUNNING:
StopEvents();
DisposeAxControl();
Debug.Assert(GetOcState() == OC_LOADED," failed transition");
SetOcState(OC_LOADED);
break;
case OC_LOADED:
ReleaseAxControl();
Debug.Assert(GetOcState() == OC_PASSIVE," failed transition");
SetOcState(OC_PASSIVE);
break;
default:
Debug.Fail("bad state");
SetOcState(GetOcState() - 1);
break;
}
}
}
finally {
axState[inTransition] = false;
}
}
private void TransitionUpTo(int state) {
if (axState[inTransition]) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Recursively entering TransitionUpTo...");
return;
}
try {
axState[inTransition] = true;
while (state > GetOcState()) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Transitioning up from: " + GetOcState().ToString(CultureInfo.InvariantCulture) + " to: " + state.ToString(CultureInfo.InvariantCulture));
switch (GetOcState()) {
case OC_PASSIVE:
axState[disposed] = false;
GetOcxCreate();
Debug.Assert(GetOcState() == OC_LOADED, " failed transition");
SetOcState(OC_LOADED);
break;
case OC_LOADED:
ActivateAxControl();
Debug.Assert(GetOcState() == OC_RUNNING, " failed transition");
SetOcState(OC_RUNNING);
if (IsUserMode()) {
// start the events flowing!
//createSink();
StartEvents();
}
break;
case OC_RUNNING:
axState[ownDisposing] = false;
Debug.Assert(!axState[fOwnWindow], "If we are invis at runtime, we should never be going beynd OC_RUNNING");
if (!axState[fOwnWindow]) {
InPlaceActivate();
if (!Visible && ContainingControl != null && ContainingControl.Visible) {
HideAxControl();
}
else {
// if we do this in both codepaths, then we will force handle creation of the fake window
// even if we don't need it...
// This optimization will break, however, if:
// a) the hWnd goes away on a OLEIVERB_HIDE and
// b) this is a simple frame control
// However, if you satisfy both of these conditions then you must be REALLY
// brain dead and you don't deserve to work anyway...
CreateControl(true);
// if our default size is wrong for the control, let's resize ourselves...
// Note: some controls haven't updated their extents at this time
// (even though they got it from the DoVerb call and
// also from GetWindowContext) so we don't poke in a new value.
// The reason to do this at design time is that that's the only way we
// can find out if the control has a default which we have to obey.
if (!IsUserMode() && !axState[ocxStateSet]) {
Size p = GetExtent();
Rectangle b = Bounds;
if ((b.Size.Equals(DefaultSize)) && (!b.Size.Equals(p))) {
b.Width = p.Width;
b.Height = p.Height;
Bounds = b;
}
}
}
}
//Debug.Assert(GetOcState() == OC_INPLACE, " failed transition");
if (GetOcState() < OC_INPLACE) {
SetOcState(OC_INPLACE);
}
OnInPlaceActive();
break;
case OC_INPLACE:
DoVerb(OLEIVERB_SHOW);
Debug.Assert(GetOcState() == OC_UIACTIVE, " failed transition");
SetOcState(OC_UIACTIVE);
break;
default:
Debug.Fail("bad state");
SetOcState(GetOcState() + 1);
break;
}
}
}
finally {
axState[inTransition] = false;
}
}
///
/// [To be supplied.]
///
///
/// [To be supplied.]
///
protected override void SetVisibleCore(bool value) {
if (GetState(STATE_VISIBLE) != value) {
bool oldVisible = Visible;
if ((IsHandleCreated || value) && ParentInternal != null && ParentInternal.Created) {
if (!axState[fOwnWindow]) {
TransitionUpTo(OC_RUNNING);
if (value) {
if (axState[fFakingWindow]) {
// first we need to destroy the fake window...
DestroyFakeWindow();
}
// We want to avoid using SHOW since that may uiactivate us, and we don't
// want that...
if (!IsHandleCreated) {
// So, if we don't have a handle, we just try to create it and hope that this will make
// us appear...
try {
SetExtent(Width, Height);
InPlaceActivate();
CreateControl(true);
}
catch {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Could not make ctl visible by using INPLACE. Will try SHOW");
MakeVisibleWithShow();
}
}
else {
// if, otoh, we had a handle to begin with, we need to use show since INPLACE is just
// a noop...
MakeVisibleWithShow();
}
}
else {
Debug.Assert(!axState[fFakingWindow], "if we were visible, we could not have had a fake window...");
HideAxControl();
}
}
}
if (!value) {
axState[fNeedOwnWindow] = false;
}
if (!axState[fOwnWindow]) {
SetState(STATE_VISIBLE, value);
if (Visible != oldVisible)
OnVisibleChanged(EventArgs.Empty);
}
}
}
private void MakeVisibleWithShow() {
ContainerControl f = ContainingControl;
Control ctl = f == null ? null : f.ActiveControl;
try {
DoVerb(OLEIVERB_SHOW);
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw new TargetInvocationException(SR.GetString(SR.AXNohWnd,GetType().Name), t);
}
EnsureWindowPresent();
CreateControl(true);
if (f != null && f.ActiveControl != ctl) {
f.ActiveControl = ctl;
}
}
private void HideAxControl() {
Debug.Assert(!axState[fOwnWindow], "can't own our window when hiding");
Debug.Assert(IsHandleCreated, "gotta have a window to hide");
Debug.Assert(GetOcState() >= OC_INPLACE, "have to be in place in order to hide.");
DoVerb(OLEIVERB_HIDE);
if (GetOcState() < OC_INPLACE) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Naughty control inplace deactivated on a hide verb...");
Debug.Assert(!IsHandleCreated, "if we are inplace deactivated we should not have a window.");
// all we do here is set a flag saying that we need the window to be created if
// create handle is ever called...
axState[fNeedOwnWindow] = true;
// also, set the state to our "pretend oc_inplace state"
//
SetOcState(OC_INPLACE);
}
}
///
/// Determines if charCode is an input character that the control
/// wants. This method is called during window message pre-processing to
/// determine whether the given input character should be pre-processed or
/// sent directly to the control. If isInputChar returns true, the
/// given character is sent directly to the control. If isInputChar
/// returns false, the character is pre-processed and only sent to the
/// control if it is not consumed by the pre-processing phase. The
/// pre-processing of a character includes checking whether the character
/// is a mnemonic of another control.
///
[UIPermission(SecurityAction.InheritanceDemand, Window=UIPermissionWindow.AllWindows)]
protected override bool IsInputChar(char charCode) {
return true;
}
///
/// [To be supplied.]
///
[SuppressMessage("Microsoft.Security", "CA2114:MethodSecurityShouldBeASupersetOfType")]
[UIPermission(SecurityAction.LinkDemand, Window=UIPermissionWindow.AllWindows)]
protected override bool ProcessDialogKey(Keys keyData)
{
return ignoreDialogKeys ? false : base.ProcessDialogKey(keyData);
}
///
/// This method is called by the application's message loop to pre-process
/// input messages before they are dispatched. Possible values for the
/// msg.message field are WM_KEYDOWN, WM_SYSKEYDOWN, WM_CHAR, and WM_SYSCHAR.
/// If this method processes the message it must return true, in which case
/// the message loop will not dispatch the message.
/// This method should not be called directly by the user.
///
/// The keyboard processing of input keys to AxHost controls go in 3 steps inside AxHost.PreProcessMessage()
///
/// (1) Call the OCX's TranslateAccelarator. This may or may not call back into us using IOleControlSite::TranslateAccelarator()
///
/// (2) If the control completely processed this without calling us back:
/// -- If this returns S_OK, then it means that the control already processed this message and we return true,
/// forcing us to not do any more processing or dispatch the message.
/// -- If this returns S_FALSE, then it means that the control wants us to dispatch the message without doing any processing on our side.
///
/// (3) If the control completely processed this by calling us back:
/// -- If this returns S_OK, then it means that the control processed this message and we return true,
/// forcing us to not do any more processing or dispatch the message.
/// -- If this returns S_FALSE, then it means that the control did not process this message,
/// but we did, and so we should route it through our PreProcessMessage().
///
public override bool PreProcessMessage(ref Message msg) {
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "AxHost.PreProcessMessage " + msg.ToString());
if (IsUserMode()) {
if (axState[siteProcessedInputKey]) {
// In this case, the control called the us back through the IControlSite
// and giving us a chance to see if we want to process it. We in turn
// call the base implementation which normally would call the control's
// IsInputKey() or IsInputChar(). So, we short-circuit those to return false
// and only return true, if the container-chain wanted to process the keystroke
// (e.g. tab, accelarators etc.)
//
return base.PreProcessMessage(ref msg);
}
NativeMethods.MSG win32Message = new NativeMethods.MSG();
win32Message.message = msg.Msg;
win32Message.wParam = msg.WParam;
win32Message.lParam = msg.LParam;
win32Message.hwnd = msg.HWnd;
axState[siteProcessedInputKey] = false;
try {
UnsafeNativeMethods.IOleInPlaceActiveObject activeObj = GetInPlaceActiveObject();
if (activeObj != null)
{
int hr = activeObj.TranslateAccelerator(ref win32Message);
msg.Msg = win32Message.message;
msg.WParam = win32Message.wParam;
msg.LParam = win32Message.lParam;
msg.HWnd = win32Message.hwnd;
if (hr == NativeMethods.S_OK) {
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "\t Message translated by control to " + msg);
return true;
}
else if (hr == NativeMethods.S_FALSE) {
bool ret = false;
ignoreDialogKeys = true;
try {
ret = base.PreProcessMessage(ref msg);
}
finally {
ignoreDialogKeys = false;
}
return ret;
}
else if (axState[siteProcessedInputKey]) {
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "\t Message processed by site. Calling base.PreProcessMessage() " + msg);
return base.PreProcessMessage (ref msg);
}
else {
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "\t Message not processed by site. Returning false. " + msg);
return false;
}
}
}
finally {
axState[siteProcessedInputKey] = false;
}
}
return false;
}
///
/// Process a mnemonic character.
/// This is done by manufacturing a WM_SYSKEYDOWN message and passing it
/// to the ActiveX control.
///
[SuppressMessage("Microsoft.Security", "CA2114:MethodSecurityShouldBeASupersetOfType")]
[UIPermission(SecurityAction.LinkDemand, Window=UIPermissionWindow.AllWindows)]
protected internal override bool ProcessMnemonic(char charCode) {
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "In AxHost.ProcessMnemonic: " + (int)charCode);
if (CanSelect) {
try {
NativeMethods.tagCONTROLINFO ctlInfo = new NativeMethods.tagCONTROLINFO();
int hr = GetOleControl().GetControlInfo(ctlInfo);
if (NativeMethods.Failed(hr)) {
return false;
}
NativeMethods.MSG msg = new NativeMethods.MSG();
// Sadly, we don't have a message so we must fake one ourselves...
// A bit of ugliness here (a bit? more like a bucket...)
// The message we are faking is a WM_SYSKEYDOWN w/ the right alt key setting...
msg.hwnd = (ContainingControl == null) ? IntPtr.Zero : ContainingControl.Handle;
msg.message = NativeMethods.WM_SYSKEYDOWN;
msg.wParam = (IntPtr) Char.ToUpper(charCode, CultureInfo.CurrentCulture);
msg.lParam = (IntPtr) 0x20180001;
msg.time = SafeNativeMethods.GetTickCount();
NativeMethods.POINT p = new NativeMethods.POINT();
UnsafeNativeMethods.GetCursorPos(p);
msg.pt_x = p.x;
msg.pt_y = p.y;
if (SafeNativeMethods.IsAccelerator(new HandleRef(ctlInfo, ctlInfo.hAccel), ctlInfo.cAccel, ref msg, null)) {
GetOleControl().OnMnemonic(ref msg);
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "\t Processed mnemonic " + msg);
Focus();
return true;
}
}
catch (Exception t) {
Debug.Fail("error in processMnemonic");
Debug.Fail(t.ToString());
return false;
}
}
return false;
}
// misc methods:
///
/// Sets the delegate which will be called when the user selects the "About..."
/// entry on the context menu.
///
protected void SetAboutBoxDelegate(AboutBoxDelegate d) {
aboutBoxDelegate += d;
}
///
/// Sets the persisted state of the control.
/// This should either be null, obtained from getOcxState, or
/// read from a resource. The value of this property will
/// be used after the control is created but before it is
/// shown.
/// Computes the persisted state of the underlying ActiveX control and
/// returns it in the encapsulated State object.
/// If the control has been modified since it was last saved to a
/// persisted state, it will be asked to save itself.
///
[
DefaultValue(null),
RefreshProperties(RefreshProperties.All),
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced)
]
public State OcxState {
get {
if (IsDirty() || ocxState == null) {
Debug.Assert(!axState[disposed], "we chould not be asking for the object when we are axState[disposed]...");
ocxState = CreateNewOcxState(ocxState);
}
return ocxState;
}
set {
axState[ocxStateSet] = true;
if (value == null) return;
if (storageType != STG_UNKNOWN && storageType != value.type) {
Debug.Fail("Trying to reload with a OcxState that is of a different type.");
throw new InvalidOperationException(SR.GetString(SR.AXOcxStateLoaded));
}
if (this.ocxState == value)
return;
this.ocxState = value;
if (this.ocxState != null) {
this.axState[manualUpdate] = ocxState._GetManualUpdate();
this.licenseKey = ocxState._GetLicenseKey();
}
else {
this.axState[manualUpdate] = false;
this.licenseKey = null;
}
if (this.ocxState != null && GetOcState() >= OC_RUNNING) {
DepersistControl();
}
}
}
private State CreateNewOcxState(State oldOcxState) {
NoComponentChangeEvents++;
try {
if (GetOcState() < OC_RUNNING) {
return null;
}
try {
PropertyBagStream propBag = null;
if (iPersistPropBag != null) {
propBag = new PropertyBagStream();
iPersistPropBag.Save(propBag, true, true);
}
MemoryStream ms = null;
switch (storageType) {
case STG_STREAM:
case STG_STREAMINIT:
ms = new MemoryStream();
if (storageType == STG_STREAM) {
iPersistStream.Save(new UnsafeNativeMethods.ComStreamFromDataStream(ms), true);
}
else {
iPersistStreamInit.Save(new UnsafeNativeMethods.ComStreamFromDataStream(ms), true);
}
break;
case STG_STORAGE:
Debug.Assert(oldOcxState != null, "we got to have an old state which holds out scribble storage...");
if (oldOcxState != null) return oldOcxState.RefreshStorage(iPersistStorage);
return null;
default:
Debug.Fail("unknown storage type.");
return null;
}
if (ms != null) {
return new State(ms, storageType, this, propBag);
}
else if (propBag != null) {
return new State(propBag);
}
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Could not create new OCX State: " + e.ToString());
}
}
finally {
NoComponentChangeEvents--;
}
return null;
}
///
/// Returns this control's logicaly containing form.
/// At design time this is always the form being designed.
/// At runtime it is either the form set with setContainingForm or,
/// by default, the parent form.
/// Sets the form which is the logical container of this control.
/// By default, the parent form performs that function. It is
/// however possible for another form higher in the parent chain
/// to serve in that role. The logical container of this
/// control determines the set of logical sibling control.
/// In general this property exists only to enable some speficic
/// behaviours of ActiveX controls and should in general not be set
/// by the user.
///
[
Browsable(false),
EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public ContainerControl ContainingControl {
get {
Debug.WriteLineIf(IntSecurity.SecurityDemand.TraceVerbose, "GetParent Demanded");
IntSecurity.GetParent.Demand();
if (containingControl == null) {
containingControl = FindContainerControlInternal();
}
return containingControl;
}
set {
containingControl = value;
}
}
///
/// Determines if the Text property needs to be persisted.
///
[EditorBrowsable(EditorBrowsableState.Never)]
internal override bool ShouldSerializeText() {
bool ret = false;
try {
ret = (Text.Length != 0);
}
catch (COMException) {
}
return ret;
}
///
/// Determines whether to persist the ContainingControl property.
///
[EditorBrowsable(EditorBrowsableState.Never)]
private bool ShouldSerializeContainingControl() {
return ContainingControl != ParentInternal;
}
private ContainerControl FindContainerControlInternal() {
if (Site != null) {
IDesignerHost host = (IDesignerHost)Site.GetService(typeof(IDesignerHost));
if (host != null) {
ContainerControl rootControl = host.RootComponent as ContainerControl;
if (rootControl != null)
{
return rootControl;
}
}
}
ContainerControl cc = null;
Control control = this;
while (control != null) {
ContainerControl tempCC = control as ContainerControl;
if (tempCC != null)
{
cc = tempCC;
break;
}
control = control.ParentInternal;
}
return cc;
}
private bool IsDirty() {
if (GetOcState() < OC_RUNNING) return false;
Debug.Assert(storageType != STG_UNKNOWN, "if we are loaded, out storage type must be set!");
if (axState[valueChanged]) {
axState[valueChanged] = false;
return true;
}
#if DEBUG
if (AxAlwaysSaveSwitch.Enabled) return true;
#endif
int hr = NativeMethods.E_FAIL;
switch (storageType) {
case STG_STREAM:
hr = iPersistStream.IsDirty();
break;
case STG_STREAMINIT:
hr = iPersistStreamInit.IsDirty();
break;
case STG_STORAGE:
hr = iPersistStorage.IsDirty();
break;
default:
Debug.Fail("unknown storage type");
return true;
}
if (hr == NativeMethods.S_FALSE) {
// NOTE: This was a note from the old AxHost codebase. The problem
// with doing this is that the some controls that do not run in
// unlicensed mode (e.g. ProtoView ScheduleX pvtaskpad.ocx) will
// always return S_FALSE to disallow design-time support.
// Sadly, some controls lie and never say that they are dirty...
// SO, we don't believe them unless they told us that they were
// dirty at least once...
return false;
}
else if (NativeMethods.Failed(hr)) {
return true;
}
return true;
}
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
internal bool IsUserMode() {
ISite site = Site;
return site == null || !site.DesignMode;
}
private Object GetAmbientProperty(int dispid) {
Control richParent = ParentInternal;
switch (dispid) {
case NativeMethods.ActiveX.DISPID_AMBIENT_USERMODE:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for usermode");
return IsUserMode();
case NativeMethods.ActiveX.DISPID_AMBIENT_AUTOCLIP:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for autoclip");
return true;
case NativeMethods.ActiveX.DISPID_AMBIENT_MESSAGEREFLECT:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for message reflect");
return true;
case NativeMethods.ActiveX.DISPID_AMBIENT_UIDEAD:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for uidead");
return false;
case NativeMethods.ActiveX.DISPID_AMBIENT_DISPLAYASDEFAULT:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for displayasdefault");
return false;
case NativeMethods.ActiveX.DISPID_AMBIENT_FONT:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for font");
if (richParent != null) {
return GetIFontFromFont(richParent.Font);
}
return null;
case NativeMethods.ActiveX.DISPID_AMBIENT_SHOWGRABHANDLES:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for showGrabHandles");
return false;
case NativeMethods.ActiveX.DISPID_AMBIENT_SHOWHATCHING:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for showHatching");
return false;
case NativeMethods.ActiveX.DISPID_AMBIENT_BACKCOLOR:
if (richParent != null) {
return GetOleColorFromColor(richParent.BackColor);
}
return null;
case NativeMethods.ActiveX.DISPID_AMBIENT_FORECOLOR:
if (richParent != null) {
return GetOleColorFromColor(richParent.ForeColor);
}
return null;
case NativeMethods.ActiveX.DISPID_AMBIENT_DISPLAYNAME:
string rval = GetParentContainer().GetNameForControl(this);
if (rval == null) rval = "";
return rval;
case NativeMethods.ActiveX.DISPID_AMBIENT_LOCALEID:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for localeid");
return Thread.CurrentThread.CurrentCulture.LCID;
case NativeMethods.ActiveX.DISPID_AMBIENT_RIGHTTOLEFT:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for right to left");
Control ctl = this;
while (ctl != null) {
if (ctl.RightToLeft == System.Windows.Forms.RightToLeft.No)
return false;
if (ctl.RightToLeft == System.Windows.Forms.RightToLeft.Yes)
return true;
if (ctl.RightToLeft == System.Windows.Forms.RightToLeft.Inherit)
ctl = ctl.Parent;
}
return null;
default:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "unsupported ambient "+dispid.ToString(CultureInfo.InvariantCulture));
return null;
}
}
///
/// [To be supplied.]
///
public void DoVerb(int verb) {
Control parent = ParentInternal;
GetOleObject().DoVerb(verb, IntPtr.Zero, oleSite, -1, parent != null ? parent.Handle : IntPtr.Zero, FillInRect(new NativeMethods.COMRECT(), Bounds));
}
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
private bool AwaitingDefreezing() {
return freezeCount > 0;
}
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
private void Freeze(bool v) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "freezing "+v.ToString());
if (v) {
try {
GetOleControl().FreezeEvents(-1);
}
catch (COMException t) {
Debug.Fail(t.ToString());
}
freezeCount ++;
}
else {
try {
GetOleControl().FreezeEvents(0);
}
catch (COMException t) {
Debug.Fail(t.ToString());
}
freezeCount --;
}
Debug.Assert(freezeCount >=0, "invalid freeze count!");
}
private int UiDeactivate() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "calling uiDeactivate for "+this.ToString());
bool ownDispose = this.axState[ownDisposing];
this.axState[ownDisposing] = true;
int hr = 0;
try {
hr = GetInPlaceObject().UIDeactivate();
}
finally {
this.axState[ownDisposing] = ownDispose;
}
return hr;
}
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
private int GetOcState() {
return ocState;
}
private void SetOcState(int nv) {
ocState = nv;
}
private string GetLicenseKey() {
return GetLicenseKey(this.clsid);
}
private string GetLicenseKey(Guid clsid) {
if (licenseKey != null || !axState[needLicenseKey]) {
return licenseKey;
}
try {
UnsafeNativeMethods.IClassFactory2 icf2 = UnsafeNativeMethods.CoGetClassObject(ref clsid, INPROC_SERVER, 0, ref icf2_Guid);
NativeMethods.tagLICINFO licInfo = new NativeMethods.tagLICINFO();
icf2.GetLicInfo(licInfo);
if (licInfo.fRuntimeAvailable != 0) {
string[] rval = new string[1];
icf2.RequestLicKey(0, rval);
licenseKey = rval[0];
return licenseKey;
}
}
catch (COMException e) {
if (e.ErrorCode == E_NOINTERFACE.ErrorCode) return null;
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Failed to get the license key: " + e.ToString());
axState[needLicenseKey] = false;
}
catch (Exception t) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Failed to get the license key: " + t.ToString());
axState[needLicenseKey] = false;
}
return null;
}
private void CreateWithoutLicense(Guid clsid) {
object ret = null;
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Creating object without license: " + clsid.ToString());
ret = UnsafeNativeMethods.CoCreateInstance(ref clsid, null, INPROC_SERVER, ref NativeMethods.ActiveX.IID_IUnknown);
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t" + (ret != null).ToString());
instance = ret;
}
private void CreateWithLicense(string license, Guid clsid) {
if (license != null) {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Creating object with license: " + clsid.ToString());
UnsafeNativeMethods.IClassFactory2 icf2 = UnsafeNativeMethods.CoGetClassObject(ref clsid, INPROC_SERVER, 0, ref icf2_Guid);
if (icf2 != null) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\tClassFactory" + (icf2 != null).ToString());
icf2.CreateInstanceLic(null, null, ref NativeMethods.ActiveX.IID_IUnknown, license, out instance);
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t" + (instance != null).ToString());
}
}
catch (Exception t) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Failed to create with license: " + t.ToString());
}
}
if (instance == null) {
CreateWithoutLicense(clsid);
}
}
private void CreateInstance() {
Debug.Assert(instance == null, "instance must be null");
//Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "before created "+Windows.GetCurrentThreadId());
//Debug.WriteStackTraceIf("AxHTrace");
//checkThreadingModel();
try {
instance = CreateInstanceCore(this.clsid);
Debug.Assert(instance != null, "w/o an exception being thrown we must have an object...");
}
catch (ExternalException e) {
if (e.ErrorCode == unchecked((int)0x80040112)) { // CLASS_E_NOTLICENSED
throw new LicenseException(GetType(), this, SR.GetString(SR.AXNoLicenseToUse));
}
throw;
}
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "created");
SetOcState(OC_LOADED);
}
///
/// Called to create the ActiveX control. Override this member to perform your own creation logic
/// or call base to do the default creation logic.
///
protected virtual object CreateInstanceCore(Guid clsid) {
if (IsUserMode()) {
CreateWithLicense(licenseKey, clsid);
}
else {
CreateWithoutLicense(clsid);
}
return instance;
}
private CategoryAttribute GetCategoryForDispid(int dispid) {
NativeMethods.ICategorizeProperties icp = GetCategorizeProperties();
if (icp == null) return null;
CategoryAttribute rval = null;
int propcat = 0;
try {
icp.MapPropertyToCategory(dispid, ref propcat);
if (propcat != 0) {
int cat = -propcat;
if (cat > 0 && cat < categoryNames.Length && categoryNames[cat] != null) {
return categoryNames[cat];
}
cat = - cat;
Int32 key = cat;
if (objectDefinedCategoryNames != null) {
rval = (CategoryAttribute) objectDefinedCategoryNames[key];
if (rval != null) return rval;
}
string name = null;
int hr = icp.GetCategoryName(cat, CultureInfo.CurrentCulture.LCID, out name);
if (hr == NativeMethods.S_OK && name != null) {
rval = new CategoryAttribute(name);
if (objectDefinedCategoryNames == null) {
objectDefinedCategoryNames = new Hashtable();
}
objectDefinedCategoryNames.Add(key, rval);
return rval;
}
}
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
return null;
}
private void SetSelectionStyle(int selectionStyle) {
if (!this.IsUserMode()) {
// selectionStyle can be 0 (not selected), 1 (selected) or 2 (active)
Debug.Assert(selectionStyle >= 0 && selectionStyle <= 2, "Invalid selection style");
ISelectionService iss = GetSelectionService();
this.selectionStyle = selectionStyle;
if (iss != null && iss.GetComponentSelected(this)) {
// The AX Host designer will offer an extender property called "SelectionStyle"
//
PropertyDescriptor prop = TypeDescriptor.GetProperties(this)["SelectionStyle"];
if (prop != null && prop.PropertyType == typeof(int)) {
prop.SetValue(this, selectionStyle);
}
}
}
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void InvokeEditMode() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "invoking EditMode for "+this.ToString());
Debug.Assert((flags & AxFlags.PreventEditMode) == 0, "edit mode should have been disabled");
if (editMode != EDITM_NONE) return;
AddSelectionHandler();
editMode = EDITM_HOST;
SetSelectionStyle(2);
IntPtr hwndFocus = UnsafeNativeMethods.GetFocus();
try {
UiActivate();
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
// It so happens that some controls don't get focus in this case, so
// we have got to force it onto them...
// int hwndFocusNow = NativeMethods.GetFocus();
// Windows.SetFocus(getHandle());
// while (hwndFocusNow != getHandle()) {
// if (hwndFocusNow == 0) {
// break;
// }
// hwndFocusNow = Windows.GetParent(hwndFocusNow);
// }
}
//
// ICustomTypeDescriptor implementation.
//
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
AttributeCollection ICustomTypeDescriptor.GetAttributes() {
if (!axState[editorRefresh] && HasPropertyPages()) {
axState[editorRefresh] = true;
TypeDescriptor.Refresh(this.GetType());
}
return TypeDescriptor.GetAttributes(this, true);
}
///
/// Retrieves the class name for this object. If null is returned,
/// the type name is used.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
string ICustomTypeDescriptor.GetClassName() {
return null;
}
///
/// Retrieves the name for this object. If null is returned,
/// the default is used.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
string ICustomTypeDescriptor.GetComponentName() {
return null;
}
///
/// Retrieves the type converter for this object.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
TypeConverter ICustomTypeDescriptor.GetConverter() {
return null;
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() {
return TypeDescriptor.GetDefaultEvent(this, true);
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() {
return TypeDescriptor.GetDefaultProperty(this, true);
}
///
/// Retrieves the an editor for this object.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
Object ICustomTypeDescriptor.GetEditor(Type editorBaseType) {
if (editorBaseType != typeof(ComponentEditor))
return null;
if (editor != null)
return editor;
if (editor == null && HasPropertyPages())
editor = new AxComponentEditor();
return editor;
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
EventDescriptorCollection ICustomTypeDescriptor.GetEvents() {
return TypeDescriptor.GetEvents(this, true);
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) {
return TypeDescriptor.GetEvents(this, attributes, true);
}
private void OnIdle(object sender, EventArgs e) {
if (axState[refreshProperties]) {
TypeDescriptor.Refresh(this.GetType());
}
}
private bool RefreshAllProperties {
get {
return axState[refreshProperties];
}
set {
axState[refreshProperties] = value;
if (value && !axState[listeningToIdle]) {
Application.Idle += new EventHandler(this.OnIdle);
axState[listeningToIdle] = true;
}
else if (!value && axState[listeningToIdle]) {
Application.Idle -= new EventHandler(this.OnIdle);
axState[listeningToIdle] = false;
}
}
}
private PropertyDescriptorCollection FillProperties(Attribute[] attributes) {
if (RefreshAllProperties) {
RefreshAllProperties = false;
propsStash = null;
attribsStash = null;
}
else if (propsStash != null) {
if (attributes == null && attribsStash == null) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Returning stashed values for : " + "");
return propsStash;
}
else if (attributes != null && attribsStash != null && attributes.Length == attribsStash.Length) {
bool attribsEqual = true;
int i = 0;
foreach(Attribute attrib in attributes) {
if (!attrib.Equals(attribsStash[i++])) {
attribsEqual = false;
break;
}
}
if (attribsEqual) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Returning stashed values for : " + attributes.Length);
return propsStash;
}
}
}
ArrayList retProps = new ArrayList();
if (properties == null)
properties = new Hashtable();
if (propertyInfos == null) {
propertyInfos = new Hashtable();
PropertyInfo[] propInfos = this.GetType().GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
foreach(PropertyInfo propInfo in propInfos)
propertyInfos.Add(propInfo.Name, propInfo);
}
PropertyDescriptorCollection baseProps = TypeDescriptor.GetProperties(this, null, true);
if (baseProps != null) {
for (int i = 0; i < baseProps.Count; ++i) {
Debug.Assert(baseProps[i] != null, "Null base prop at location: " + i.ToString(CultureInfo.InvariantCulture));
if (baseProps[i].DesignTimeOnly) {
retProps.Add(baseProps[i]);
continue;
}
string propName = baseProps[i].Name;
PropertyDescriptor prop = null;
PropertyInfo propInfo = (PropertyInfo)propertyInfos[propName];
// We do not support "write-only" properties that some activex controls support.
if (propInfo != null && !propInfo.CanRead)
continue;
if (!properties.ContainsKey(propName)) {
if (propInfo != null) {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Added AxPropertyDescriptor for: " + propName);
prop = new AxPropertyDescriptor(baseProps[i], this);
((AxPropertyDescriptor)prop).UpdateAttributes();
}
else {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Added PropertyDescriptor for: " + propName);
prop = baseProps[i];
}
properties.Add(propName, prop);
retProps.Add(prop);
}
else {
PropertyDescriptor propDesc = (PropertyDescriptor)properties[propName];
Debug.Assert(propDesc != null, "Cannot find cached entry for: " + propName);
AxPropertyDescriptor axPropDesc = propDesc as AxPropertyDescriptor;
if ((propInfo == null && axPropDesc != null) || (propInfo != null && axPropDesc == null)) {
Debug.Fail("Duplicate property with same name: " + propName);
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Duplicate property with same name: " + propName);
}
else {
if (axPropDesc != null) {
axPropDesc.UpdateAttributes();
}
retProps.Add(propDesc);
}
}
}
// Filter only the Browsable attribute, since that is the only
// one we mess with.
//
if (attributes != null) {
Attribute browse = null;
foreach(Attribute attr in attributes) {
if (attr is BrowsableAttribute) {
browse = attr;
}
}
if (browse != null) {
ArrayList removeList = null;
foreach(PropertyDescriptor prop in retProps) {
if (prop is AxPropertyDescriptor) {
Attribute attr = prop.Attributes[typeof(BrowsableAttribute)];
if (attr != null && !attr.Equals(browse)) {
if (removeList == null) {
removeList = new ArrayList();
}
removeList.Add(prop);
}
}
}
if (removeList != null) {
foreach(object prop in removeList)
retProps.Remove(prop);
}
}
}
}
PropertyDescriptor[] temp = new PropertyDescriptor[retProps.Count];
retProps.CopyTo(temp, 0);
// Update our stashed values.
//
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Updating stashed values for : " + ((attributes != null) ? attributes.Length.ToString(CultureInfo.InvariantCulture) : ""));
propsStash = new PropertyDescriptorCollection(temp);
attribsStash = attributes;
return propsStash;
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() {
return FillProperties(null);
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) {
return FillProperties(attributes);
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
Object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) {
return this;
}
private AxPropertyDescriptor GetPropertyDescriptorFromDispid(int dispid) {
Debug.Assert(dispid != NativeMethods.ActiveX.DISPID_UNKNOWN, "Wrong dispid sent to GetPropertyDescriptorFromDispid");
PropertyDescriptorCollection props = FillProperties(null);
foreach (PropertyDescriptor prop in props) {
AxPropertyDescriptor axprop = prop as AxPropertyDescriptor;
if (axprop != null && axprop.Dispid == dispid) {
return axprop;
}
}
return null;
}
#if false
// FxCop: Currently not used
private void CheckThreadingModel() {
#if DEBUG
if (AxIgnoreTMSwitch.Enabled) return;
#endif
if ((flags & AxFlags.IgnoreThreadModel) != 0) return;
bool singleThreaded = true;
new RegistryPermission(PermissionState.Unrestricted).Assert();
try {
try {
using (RegistryKey rk = Registry.ClassesRoot.OpenSubKey("CLSID\\" + clsid.ToString() + "\\InprocServer32", /*writable*/false)) {
object value = rk.GetValue("ThreadingModel");
if (value != null && value is string) {
if (value.Equals("Both")
|| value.Equals("Apartment")
|| value.Equals("Free")) {
singleThreaded = false;
}
}
}
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw new InvalidOperationException(SR.GetString(SR.AXNoThreadInfo));
}
}
finally {
System.Security.CodeAccessPermission.RevertAssert();
}
if (singleThreaded) {
throw new InvalidOperationException(SR.GetString(SR.AXSingleThreaded));
}
}
#endif
private void ActivateAxControl() {
if (QuickActivate()) {
DepersistControl();
}
else {
SlowActivate();
}
SetOcState(OC_RUNNING);
}
private void DepersistFromIPropertyBag(UnsafeNativeMethods.IPropertyBag propBag) {
iPersistPropBag.Load(propBag, null);
}
private void DepersistFromIStream(UnsafeNativeMethods.IStream istream) {
storageType = STG_STREAM;
iPersistStream.Load(istream);
}
private void DepersistFromIStreamInit(UnsafeNativeMethods.IStream istream) {
storageType = STG_STREAMINIT;
iPersistStreamInit.Load(istream);
}
private void DepersistFromIStorage(UnsafeNativeMethods.IStorage storage) {
storageType = STG_STORAGE;
// ASURT 65913 Looks like MapPoint control does not create a valid IStorage
// until some property has changed. Since we end up creating a bogus (empty)
// storage, we end up not being able to re-create a valid one and this would
// fail.
//
if (storage != null) {
int hr = iPersistStorage.Load(storage);
if (hr != NativeMethods.S_OK) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Error trying load depersist from IStorage: " + hr);
}
}
}
private void DepersistControl() {
Freeze(true);
if (ocxState == null) {
// must init new:
//
if (instance is UnsafeNativeMethods.IPersistStreamInit) {
iPersistStreamInit = (UnsafeNativeMethods.IPersistStreamInit) instance;
try {
storageType = STG_STREAMINIT;
iPersistStreamInit.InitNew();
}
catch (Exception e1) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistStreamInit.InitNew(). Is this good?" + e1.ToString());
}
return;
}
if (instance is UnsafeNativeMethods.IPersistStream) {
storageType = STG_STREAM;
iPersistStream = (UnsafeNativeMethods.IPersistStream) instance;
return;
}
if (instance is UnsafeNativeMethods.IPersistStorage) {
storageType = STG_STORAGE;
ocxState = new State(this);
iPersistStorage = (UnsafeNativeMethods.IPersistStorage) instance;
try {
iPersistStorage.InitNew(ocxState.GetStorage());
}
catch (Exception e2) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistStorage.InitNew(). Is this good?" + e2.ToString());
}
return;
}
if (instance is UnsafeNativeMethods.IPersistPropertyBag) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, this + " supports IPersistPropertyBag.");
iPersistPropBag = (UnsafeNativeMethods.IPersistPropertyBag) instance;
try {
iPersistPropBag.InitNew();
}
catch (Exception e1) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistPropertyBag.InitNew(). Is this good?" + e1.ToString());
}
}
Debug.Fail("no implemented persitance interfaces on object");
throw new InvalidOperationException(SR.GetString(SR.UnableToInitComponent));
}
// Otherwise, we have state to deperist from:
switch (ocxState.Type) {
case STG_STREAM:
try {
iPersistStream = (UnsafeNativeMethods.IPersistStream) instance;
DepersistFromIStream(ocxState.GetStream());
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistStream.DepersistFromIStream(). Is this good?" + e.ToString());
}
break;
case STG_STREAMINIT:
if (instance is UnsafeNativeMethods.IPersistStreamInit) {
try {
iPersistStreamInit = (UnsafeNativeMethods.IPersistStreamInit) instance;
DepersistFromIStreamInit(ocxState.GetStream());
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistStreamInit.DepersistFromIStreamInit(). Is this good?" + e.ToString());
}
GetControlEnabled();
}
else {
ocxState.Type = STG_STREAM;
DepersistControl();
return;
}
break;
case STG_STORAGE:
try {
iPersistStorage = (UnsafeNativeMethods.IPersistStorage) instance;
DepersistFromIStorage(ocxState.GetStorage());
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistStorage.DepersistFromIStorage(). Is this good?" + e.ToString());
}
break;
default:
Debug.Fail("unknown storage type.");
throw new InvalidOperationException(SR.GetString(SR.UnableToInitComponent));
}
if (ocxState.GetPropBag() != null) {
try {
iPersistPropBag = (UnsafeNativeMethods.IPersistPropertyBag)instance;
DepersistFromIPropertyBag(ocxState.GetPropBag());
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistPropertyBag.DepersistFromIPropertyBag(). Is this good?" + e.ToString());
}
}
}
///
/// Returns the IUnknown pointer to the enclosed ActiveX control.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
public object GetOcx() {
return instance;
}
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
private Object GetOcxCreate() {
if (instance == null) {
CreateInstance();
RealizeStyles();
AttachInterfaces();
oleSite.OnOcxCreate();
}
return instance;
}
private void StartEvents() {
if (!axState[sinkAttached]) {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Creating sink for events...");
CreateSink();
oleSite.StartEvents();
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
axState[sinkAttached] = true;
}
}
private void StopEvents() {
if (axState[sinkAttached]) {
try {
DetachSink();
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
axState[sinkAttached] = false;
}
oleSite.StopEvents();
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void CreateSink() {
// nop... windows forms wrapper will override...
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void DetachSink() {
// nop... windows forms wrapper will override...
}
private bool CanShowPropertyPages() {
if (GetOcState() < OC_RUNNING) return false;
return(GetOcx() is NativeMethods.ISpecifyPropertyPages);
}
///
/// [To be supplied.]
///
public bool HasPropertyPages() {
if (!CanShowPropertyPages()) return false;
NativeMethods.ISpecifyPropertyPages ispp = (NativeMethods.ISpecifyPropertyPages) GetOcx();
try {
NativeMethods.tagCAUUID uuids = new NativeMethods.tagCAUUID();
try {
ispp.GetPages(uuids);
if (uuids.cElems > 0) return true;
}
finally {
if (uuids.pElems != IntPtr.Zero) {
Marshal.FreeCoTaskMem(uuids.pElems);
}
}
}
catch {
}
return false;
}
unsafe private void ShowPropertyPageForDispid(int dispid, Guid guid) {
try {
IntPtr pUnk = Marshal.GetIUnknownForObject(GetOcx());
NativeMethods.OCPFIPARAMS opcparams = new NativeMethods.OCPFIPARAMS();
opcparams.hwndOwner = (ContainingControl == null) ? IntPtr.Zero : ContainingControl.Handle;
opcparams.lpszCaption = Name;
opcparams.ppUnk = (IntPtr) (long) &pUnk;
opcparams.uuid = (IntPtr)(long) &guid;
opcparams.dispidInitial = dispid;
UnsafeNativeMethods.OleCreatePropertyFrameIndirect(opcparams);
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw t;
}
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void MakeDirty() {
ISite isite = Site;
if (isite == null)
return;
IComponentChangeService ccs = (IComponentChangeService)isite.GetService(typeof(IComponentChangeService));
if (ccs == null)
return;
ccs.OnComponentChanging(this, null);
ccs.OnComponentChanged(this, null, null, null);
}
///
/// [To be supplied.]
///
public void ShowPropertyPages() {
if (ParentInternal == null) return;
if (!ParentInternal.IsHandleCreated) return;
ShowPropertyPages(ParentInternal);
}
///
/// [To be supplied.]
///
public void ShowPropertyPages(Control control) {
try {
if (!CanShowPropertyPages()) return;
NativeMethods.ISpecifyPropertyPages ispp = (NativeMethods.ISpecifyPropertyPages) GetOcx();
NativeMethods.tagCAUUID uuids = new NativeMethods.tagCAUUID();
try {
ispp.GetPages(uuids);
if (uuids.cElems <= 0) return;
}
catch {
return;
}
// State oldOcxState = OcxState;
IDesignerHost host = null;
if (Site != null)
host = (IDesignerHost)Site.GetService(typeof(IDesignerHost));
DesignerTransaction trans = null;
try {
if (host != null)
trans = host.CreateTransaction(SR.GetString(SR.AXEditProperties));
string name = null;
object o = GetOcx();
IntPtr handle = (ContainingControl == null) ? IntPtr.Zero : ContainingControl.Handle;
SafeNativeMethods.OleCreatePropertyFrame(new HandleRef(this, handle), 0, 0, name, 1, ref o, uuids.cElems, new HandleRef(null, uuids.pElems), Application.CurrentCulture.LCID, 0, IntPtr.Zero);
}
finally {
if (oleSite != null)
((UnsafeNativeMethods.IPropertyNotifySink)oleSite).OnChanged(NativeMethods.MEMBERID_NIL);
if (trans != null)
trans.Commit();
if (uuids.pElems != IntPtr.Zero)
Marshal.FreeCoTaskMem(uuids.pElems);
}
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw t;
}
}
internal override IntPtr InitializeDCForWmCtlColor (IntPtr dc, int msg)
{
if (isMaskEdit) {
return base.InitializeDCForWmCtlColor(dc, msg);
}
else {
return IntPtr.Zero; // bypass Control's anti-reflect logic
}
}
///
/// AxHost wndProc. All messages are sent to wndProc after getting filtered
/// through the preProcessMessage function.
/// Certain messages are forwarder directly to the ActiveX control,
/// others are first processed by the wndProc of Control
///
protected override void WndProc(ref Message m) {
#pragma warning disable 162, 429
// Ignore the warnings generated by the following code (unreachable code, and unreachable expression)
if (false && (axState[manualUpdate] && IsUserMode())) {
DefWndProc(ref m);
return;
}
#pragma warning restore 162, 429
switch (m.Msg) {
// Things we explicitly ignore and pass to the ocx's windproc
case NativeMethods.WM_ERASEBKGND:
case NativeMethods.WM_REFLECT + NativeMethods.WM_NOTIFYFORMAT:
case NativeMethods.WM_SETCURSOR:
case NativeMethods.WM_SYSCOLORCHANGE:
// Some of the MSComCtl controls respond to this message
// to do some custom painting. So, we should just pass this message
// through.
//
case NativeMethods.WM_DRAWITEM:
case NativeMethods.WM_LBUTTONDBLCLK:
case NativeMethods.WM_LBUTTONUP:
case NativeMethods.WM_MBUTTONDBLCLK:
case NativeMethods.WM_MBUTTONUP:
case NativeMethods.WM_RBUTTONDBLCLK:
case NativeMethods.WM_RBUTTONUP:
DefWndProc(ref m);
break;
case NativeMethods.WM_LBUTTONDOWN:
case NativeMethods.WM_MBUTTONDOWN:
case NativeMethods.WM_RBUTTONDOWN:
if (IsUserMode()) {
Focus();
}
DefWndProc(ref m);
break;
case NativeMethods.WM_KILLFOCUS:
{
hwndFocus = m.WParam;
try {
base.WndProc(ref m);
}
finally {
hwndFocus = IntPtr.Zero;
}
break;
}
case NativeMethods.WM_COMMAND:
if (!ReflectMessageInternal(m.LParam, ref m))
DefWndProc(ref m);
break;
case NativeMethods.WM_CONTEXTMENU:
DefWndProc(ref m);
break;
case NativeMethods.WM_DESTROY:
#if DEBUG
if (!OwnWindow()) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "WM_DESTROY naughty control is destroying the window from under us..." + GetType().ToString());
}
#endif
//
// If we are currently in a state of InPlaceActive or above,
// we should first reparent the ActiveX control to our parking
// window before we transition to a state below InPlaceActive.
// Otherwise we face all sorts of problems when we try to
// transition back to a state >= InPlaceActive.
//
if (GetOcState() >= OC_INPLACE) {
UnsafeNativeMethods.IOleInPlaceObject ipo = GetInPlaceObject();
IntPtr hwnd;
if (NativeMethods.Succeeded(ipo.GetWindow(out hwnd))) {
Application.ParkHandle(new HandleRef(ipo, hwnd));
}
}
bool visible = GetState(STATE_VISIBLE);
TransitionDownTo(OC_RUNNING);
DetachAndForward(ref m);
if (visible != GetState(STATE_VISIBLE)) {
SetState(STATE_VISIBLE, visible);
}
break;
case NativeMethods.WM_HELP:
// We want to both fire the event, and let the ocx have the message...
base.WndProc(ref m);
DefWndProc(ref m);
break;
case NativeMethods.WM_KEYUP:
if (axState[processingKeyUp])
break;
axState[processingKeyUp] = true;
try {
if (PreProcessControlMessage(ref m) != PreProcessControlState.MessageProcessed)
DefWndProc(ref m);
}
finally {
axState[processingKeyUp] = false;
}
break;
case NativeMethods.WM_NCDESTROY:
#if DEBUG
if (!OwnWindow()) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "WM_NCDESTROY naughty control is destroying the window from under us..." + GetType().ToString());
}
#endif
// need to detach it now...
DetachAndForward(ref m);
break;
default:
if (m.Msg == REGMSG_MSG) {
m.Result = (IntPtr)REGMSG_RETVAL;
return;
}
// Other things we may care about and we will pass them to the Control's wndProc
base.WndProc(ref m);
break;
}
}
private void DetachAndForward(ref Message m) {
IntPtr handle = GetHandleNoCreate();
DetachWindow();
if (handle != IntPtr.Zero) {
IntPtr wndProc = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, handle), NativeMethods.GWL_WNDPROC);
m.Result = UnsafeNativeMethods.CallWindowProc(wndProc, handle, m.Msg, m.WParam, m.LParam);
}
}
private void DetachWindow() {
if (IsHandleCreated) {
OnHandleDestroyed(EventArgs.Empty);
for (Control c = this; c != null; c = c.ParentInternal) {
/* NOT NEEDED
if (c.GetAxState(STATE_HANDLEHOOK)) {
((IHandleHook)c.Site.GetService(IHandleHook.class)).OnDestroyHandle(GetHandle());
break;
}
*/
}
this.WindowReleaseHandle();
}
}
private void InformOfNewHandle() {
Debug.Assert(IsHandleCreated, "we got to have a handle to be here...");
for (Control c = this; c != null; c = c.ParentInternal) {
/* NOT NEEDED
if (c.GetAxState(STATE_HANDLEHOOK)) {
((IHandleHook)c.Site.GetService(IHandleHook.class)).OnCreateHandle(GetHandle());
break;
}
*/
}
wndprocAddr = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, Handle), NativeMethods.GWL_WNDPROC);
/* NOT NEEDED
SetAxState(STATE_CREATENOTIFIED, true);
*/
}
private void AttachWindow(IntPtr hwnd) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "attaching window for "+this.ToString()+" "+hwnd.ToString());
if (!axState[fFakingWindow]) {
this.WindowAssignHandle(hwnd, axState[assignUniqueID]);
}
UpdateZOrder();
// Get the latest bounds set by the user.
Size setExtent = Size;
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "SetBounds " + setExtent.ToString());
// Get the default bounds set by the ActiveX control.
UpdateBounds();
Size ocxExtent = GetExtent();
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "OcxBounds " + ocxExtent.ToString());
Point location = Location;
// Choose the setBounds unless it is smaller than the default bounds.
if (setExtent.Width < ocxExtent.Width || setExtent.Height < ocxExtent.Height)
Bounds = new Rectangle(location.X, location.Y, ocxExtent.Width, ocxExtent.Height);
else {
Size newSize = SetExtent(setExtent.Width, setExtent.Height);
if (!newSize.Equals(setExtent)) {
Bounds = new Rectangle(location.X, location.Y, newSize.Width, newSize.Height);
}
}
OnHandleCreated(EventArgs.Empty);
InformOfNewHandle();
}
///
/// Inheriting classes should override this method to find out when the
/// handle has been created.
/// Call base.OnHandleCreated first.
///
protected override void OnHandleCreated(EventArgs e) {
// ASURT 43741 This is needed to prevent some controls (for e.g. Office Web Components) from
// failing to InPlaceActivate() when they call RegisterDragDrop() but do not call
// OleInitialize(). The EE calls CoInitializeEx() on the thread, but I believe
// that is not good enough for DragDrop.
//
if (Application.OleRequired() != System.Threading.ApartmentState.STA) {
throw new ThreadStateException(SR.GetString(SR.ThreadMustBeSTA));
}
SetAcceptDrops(AllowDrop);
RaiseCreateHandleEvent(e);
}
///
/// [To be supplied.]
///
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.InheritanceDemand, Name="FullTrust")]
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.LinkDemand, Name="FullTrust")]
public class ConnectionPointCookie {
private UnsafeNativeMethods.IConnectionPoint connectionPoint;
private int cookie;
internal int threadId;
#if DEBUG
private string callStack;
#endif
///
/// Creates a connection point to of the given interface type.
/// which will call on a managed code sink that implements that interface.
///
public ConnectionPointCookie(object source, object sink, Type eventInterface)
: this(source, sink, eventInterface, true) {
}
internal ConnectionPointCookie(object source, object sink, Type eventInterface, bool throwException) {
if (source is UnsafeNativeMethods.IConnectionPointContainer) {
UnsafeNativeMethods.IConnectionPointContainer cpc = (UnsafeNativeMethods.IConnectionPointContainer)source;
try {
Guid tmp = eventInterface.GUID;
if (cpc.FindConnectionPoint(ref tmp, out connectionPoint) != NativeMethods.S_OK) {
connectionPoint = null;
}
}
catch {
connectionPoint = null;
}
if (connectionPoint == null) {
if (throwException) {
throw new ArgumentException(SR.GetString(SR.AXNoEventInterface, eventInterface.Name));
}
}
else if (sink == null || !eventInterface.IsInstanceOfType(sink)) {
if (throwException) {
throw new InvalidCastException(SR.GetString(SR.AXNoSinkImplementation, eventInterface.Name));
}
}
else {
int hr = connectionPoint.Advise(sink, ref cookie);
if (hr == NativeMethods.S_OK) {
threadId = Thread.CurrentThread.ManagedThreadId;
}
else {
cookie = 0;
Marshal.ReleaseComObject(connectionPoint);
connectionPoint = null;
if (throwException) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.AXNoSinkAdvise, eventInterface.Name), hr));
}
}
}
}
else {
if (throwException) {
throw new InvalidCastException(SR.GetString(SR.AXNoConnectionPointContainer));
}
}
if (connectionPoint == null || cookie == 0) {
if (connectionPoint != null) {
Marshal.ReleaseComObject(connectionPoint);
}
if (throwException) {
throw new ArgumentException(SR.GetString(SR.AXNoConnectionPoint, eventInterface.Name));
}
}
#if DEBUG
new EnvironmentPermission(PermissionState.Unrestricted).Assert();
try {
callStack = Environment.StackTrace;
}
finally {
System.Security.CodeAccessPermission.RevertAssert();
}
#endif
}
///
/// Disconnect the current connection point. If the object is not connected,
/// this method will do nothing.
///
public void Disconnect() {
if (connectionPoint != null && cookie != 0) {
try {
connectionPoint.Unadvise(cookie);
}
catch (Exception ex) {
if (ClientUtils.IsCriticalException(ex)) {
throw;
}
}
finally {
cookie = 0;
}
try {
Marshal.ReleaseComObject(connectionPoint);
}
catch (Exception ex) {
if (ClientUtils.IsCriticalException(ex)) {
throw;
}
}
finally {
connectionPoint = null;
}
}
}
///
///
private class OleInterfaces
: UnsafeNativeMethods.IOleControlSite, UnsafeNativeMethods.IOleClientSite, UnsafeNativeMethods.IOleInPlaceSite, UnsafeNativeMethods.ISimpleFrameSite, UnsafeNativeMethods.IVBGetControl, UnsafeNativeMethods.IGetVBAObject, UnsafeNativeMethods.IPropertyNotifySink, IReflect {
private AxHost host;
private ConnectionPointCookie connectionPoint;
internal OleInterfaces(AxHost host) {
if (host == null)
throw new ArgumentNullException("host");
this.host = host;
}
~OleInterfaces() {
if (!AppDomain.CurrentDomain.IsFinalizingForUnload()) {
SynchronizationContext context = SynchronizationContext.Current;
if (context == null) {
Debug.Fail("Attempted to disconnect ConnectionPointCookie from the finalizer with no SynchronizationContext.");
}
else {
context.Post(new SendOrPostCallback(AttemptStopEvents), null);
}
}
}
internal AxHost GetAxHost() {
return host;
}
internal void OnOcxCreate() {
StartEvents();
}
internal void StartEvents() {
if (connectionPoint != null)
return;
Object nativeObject = host.GetOcx();
try {
connectionPoint = new ConnectionPointCookie(nativeObject, this, typeof(UnsafeNativeMethods.IPropertyNotifySink));
}
catch {
}
}
void AttemptStopEvents(object trash) {
if( connectionPoint == null ){
return;
}
if (connectionPoint.threadId == Thread.CurrentThread.ManagedThreadId) {
StopEvents();
}
else {
Debug.Fail("Attempted to disconnect ConnectionPointCookie from the wrong thread (finalizer).");
}
}
internal void StopEvents() {
if (connectionPoint != null) {
connectionPoint.Disconnect();
connectionPoint = null;
}
}
// IGetVBAObject methods:
int UnsafeNativeMethods.IGetVBAObject.GetObject(ref Guid riid, UnsafeNativeMethods.IVBFormat[] rval, int dwReserved) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetObject");
if (rval == null || riid.Equals(Guid.Empty))
return NativeMethods.E_INVALIDARG;
if (riid.Equals(ivbformat_Guid)) {
rval[0] = new VBFormat();
return NativeMethods.S_OK;
}
else {
rval[0] = null;
return NativeMethods.E_NOINTERFACE;
}
}
// IVBGetControl methods:
int UnsafeNativeMethods.IVBGetControl.EnumControls(int dwOleContF, int dwWhich, out UnsafeNativeMethods.IEnumUnknown ppenum) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in EnumControls");
ppenum = null;
ppenum = host.GetParentContainer().EnumControls(host, dwOleContF, dwWhich);
return NativeMethods.S_OK;
}
// ISimpleFrameSite methods:
int UnsafeNativeMethods.ISimpleFrameSite.PreMessageFilter(IntPtr hwnd, int msg, IntPtr wp, IntPtr lp, ref IntPtr plResult, ref int pdwCookie) {
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.ISimpleFrameSite.PostMessageFilter(IntPtr hwnd, int msg, IntPtr wp, IntPtr lp, ref IntPtr plResult, int dwCookie) {
return NativeMethods.S_FALSE;
}
// IReflect methods:
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr,Binder binder, Type[] types,ParameterModifier[] modifiers) {
return null;
}
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr) {
return null;
}
MethodInfo[] IReflect.GetMethods(BindingFlags bindingAttr) {
return new MethodInfo[0];
}
FieldInfo IReflect.GetField(String name, BindingFlags bindingAttr) {
return null;
}
FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) {
return new FieldInfo[0];
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr) {
return null;
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers) {
return null;
}
PropertyInfo[] IReflect.GetProperties(BindingFlags bindingAttr) {
return new PropertyInfo[0];
}
MemberInfo[] IReflect.GetMember(String name, BindingFlags bindingAttr) {
return new MemberInfo[0];
}
MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr) {
return new MemberInfo[0];
}
Object IReflect.InvokeMember(String name, BindingFlags invokeAttr, Binder binder,
Object target, Object[] args, ParameterModifier[] modifiers, CultureInfo culture, String[] namedParameters) {
if (name.StartsWith("[DISPID=")) {
int endIndex = name.IndexOf("]");
int dispid = Int32.Parse(name.Substring(8, endIndex - 8), CultureInfo.InvariantCulture);
object ambient = host.GetAmbientProperty(dispid);
if (ambient != null) return ambient;
}
throw E_FAIL;
}
Type IReflect.UnderlyingSystemType {
get {
return null;
}
}
// IOleControlSite methods:
int UnsafeNativeMethods.IOleControlSite.OnControlInfoChanged() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnControlInfoChanged");
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleControlSite.LockInPlaceActive(int fLock) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in LockInPlaceActive");
return NativeMethods.E_NOTIMPL;
}
int UnsafeNativeMethods.IOleControlSite.GetExtendedControl(out object ppDisp) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetExtendedControl " + host.ToString());
ppDisp = host.GetParentContainer().GetProxyForControl(host);
if (ppDisp == null)
return NativeMethods.E_NOTIMPL;
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleControlSite.TransformCoords(NativeMethods._POINTL pPtlHimetric, NativeMethods.tagPOINTF pPtfContainer, int dwFlags) {
int hr = SetupLogPixels(false);
if (NativeMethods.Failed(hr))
return hr;
if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_HIMETRICTOCONTAINER) != 0) {
if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_SIZE) != 0) {
pPtfContainer.x = (float) host.HM2Pix(pPtlHimetric.x, logPixelsX);
pPtfContainer.y = (float) host.HM2Pix(pPtlHimetric.y, logPixelsY);
}
else if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_POSITION) != 0) {
pPtfContainer.x = (float) host.HM2Pix(pPtlHimetric.x, logPixelsX);
pPtfContainer.y = (float) host.HM2Pix(pPtlHimetric.y, logPixelsY);
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose,"\t dwFlags not supported: " + dwFlags);
return NativeMethods.E_INVALIDARG;
}
}
else if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_CONTAINERTOHIMETRIC) != 0) {
if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_SIZE) != 0) {
pPtlHimetric.x = host.Pix2HM((int)pPtfContainer.x, logPixelsX);
pPtlHimetric.y = host.Pix2HM((int)pPtfContainer.y, logPixelsY);
}
else if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_POSITION) != 0) {
pPtlHimetric.x = host.Pix2HM((int)pPtfContainer.x, logPixelsX);
pPtlHimetric.y = host.Pix2HM((int)pPtfContainer.y, logPixelsY);
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t dwFlags not supported: " + dwFlags);
return NativeMethods.E_INVALIDARG;
}
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t dwFlags not supported: " + dwFlags);
return NativeMethods.E_INVALIDARG;
}
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleControlSite.TranslateAccelerator(ref NativeMethods.MSG pMsg, int grfModifiers) {
Debug.Assert(!host.GetAxState(AxHost.siteProcessedInputKey), "Re-entering UnsafeNativeMethods.IOleControlSite.TranslateAccelerator!!!");
host.SetAxState(AxHost.siteProcessedInputKey, true);
Message msg = new Message();
msg.Msg = pMsg.message;
msg.WParam = pMsg.wParam;
msg.LParam = pMsg.lParam;
msg.HWnd = pMsg.hwnd;
try {
bool f = ((Control)host).PreProcessMessage(ref msg);
return f ? NativeMethods.S_OK : NativeMethods.S_FALSE;
}
finally {
host.SetAxState(AxHost.siteProcessedInputKey, false);
}
}
int UnsafeNativeMethods.IOleControlSite.OnFocus(int fGotFocus) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnFocus " + ((fGotFocus == 0) ? "lost" : "gained"));
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleControlSite.ShowPropertyFrame() {
if (host.CanShowPropertyPages()) {
host.ShowPropertyPages();
return NativeMethods.S_OK;
}
return NativeMethods.E_NOTIMPL;
}
// IOleClientSite methods:
int UnsafeNativeMethods.IOleClientSite.SaveObject() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SaveObject");
return NativeMethods.E_NOTIMPL;
}
int UnsafeNativeMethods.IOleClientSite.GetMoniker(int dwAssign, int dwWhichMoniker, out Object moniker) {
Debug.WriteLineIf(CompModSwitches.ActiveX.TraceInfo, "AxSource:GetMoniker");
moniker = null;
return NativeMethods.E_NOTIMPL;
}
int UnsafeNativeMethods.IOleClientSite.GetContainer(out UnsafeNativeMethods.IOleContainer container) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getContainer");
container = host.GetParentContainer();
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleClientSite.ShowObject() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in ShowObject");
if (host.GetAxState(AxHost.fOwnWindow)) {
Debug.Fail("we can't be in showobject if we own our window...");
return NativeMethods.S_OK;
}
if (host.GetAxState(AxHost.fFakingWindow)) {
// we really should not be here...
// this means that the ctl inplace deactivated and didn't call on inplace activate before calling showobject
// so we need to destroy our fake window first...
host.DestroyFakeWindow();
// ASURT 46393
// The fact that we have a fake window means that the OCX inplace deactivated when we hid it. It means
// that we have to bring it back from RUNNING to INPLACE so that it can re-create its handle properly.
//
host.TransitionDownTo(OC_LOADED);
host.TransitionUpTo(OC_INPLACE);
}
if (host.GetOcState() < OC_INPLACE)
return NativeMethods.S_OK;
IntPtr hwnd;
if (NativeMethods.Succeeded(host.GetInPlaceObject().GetWindow(out hwnd))) {
if (host.GetHandleNoCreate() != hwnd) {
host.DetachWindow();
if (hwnd != IntPtr.Zero) {
host.AttachWindow(hwnd);
}
}
}
else if (host.GetInPlaceObject() is UnsafeNativeMethods.IOleInPlaceObjectWindowless) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Windowless control.");
throw new InvalidOperationException(SR.GetString(SR.AXWindowlessControl));
}
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleClientSite.OnShowWindow(int fShow) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnShowWindow");
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleClientSite.RequestNewObjectLayout() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in RequestNewObjectLayout");
return NativeMethods.E_NOTIMPL;
}
// IOleInPlaceSite methods:
///
/// [To be supplied.]
///
IntPtr UnsafeNativeMethods.IOleInPlaceSite.GetWindow() {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetWindow");
Control parent = host.ParentInternal;
return parent != null ? parent.Handle : IntPtr.Zero;
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw t;
}
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceSite.ContextSensitiveHelp(int fEnterMode) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in ContextSensitiveHelp");
return NativeMethods.E_NOTIMPL;
}
int UnsafeNativeMethods.IOleInPlaceSite.CanInPlaceActivate() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in CanInPlaceActivate");
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.OnInPlaceActivate() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnInPlaceActivate");
host.SetAxState(AxHost.ownDisposing, false);
host.SetAxState(AxHost.rejectSelection, false);
host.SetOcState(OC_INPLACE);
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.OnUIActivate() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnUIActivate for " + host.ToString());
host.SetOcState(OC_UIACTIVE);
host.GetParentContainer().OnUIActivate(host);
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.GetWindowContext(out UnsafeNativeMethods.IOleInPlaceFrame ppFrame, out UnsafeNativeMethods.IOleInPlaceUIWindow ppDoc,
NativeMethods.COMRECT lprcPosRect, NativeMethods.COMRECT lprcClipRect, NativeMethods.tagOIFI lpFrameInfo) {
ppDoc = null;
ppFrame = host.GetParentContainer();
FillInRect(lprcPosRect, host.Bounds);
host.GetClipRect(lprcClipRect);
if (lpFrameInfo != null) {
lpFrameInfo.cb = Marshal.SizeOf(typeof(NativeMethods.tagOIFI));
lpFrameInfo.fMDIApp = false;
lpFrameInfo.hAccel = IntPtr.Zero;
lpFrameInfo.cAccelEntries = 0;
lpFrameInfo.hwndFrame = host.ParentInternal.Handle;
}
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.Scroll(NativeMethods.tagSIZE scrollExtant) {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in Scroll");
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw t;
}
return(NativeMethods.S_FALSE);
}
int UnsafeNativeMethods.IOleInPlaceSite.OnUIDeactivate(int fUndoable) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnUIDeactivate for " + host.ToString());
host.GetParentContainer().OnUIDeactivate(host);
if (host.GetOcState() > OC_INPLACE) {
host.SetOcState(OC_INPLACE);
}
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.OnInPlaceDeactivate() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnInPlaceDeactivate");
if (host.GetOcState() == OC_UIACTIVE) {
((UnsafeNativeMethods.IOleInPlaceSite)this).OnUIDeactivate(0);
}
host.GetParentContainer().OnInPlaceDeactivate(host);
host.DetachWindow();
host.SetOcState(OC_RUNNING);
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.DiscardUndoState() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in DiscardUndoState");
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.DeactivateAndUndo() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in DeactivateAndUndo for "+host.ToString());
return host.GetInPlaceObject().UIDeactivate();
}
int UnsafeNativeMethods.IOleInPlaceSite.OnPosRectChange(NativeMethods.COMRECT lprcPosRect) {
// ASURT 68752
// The MediaPlayer control has a AllowChangeDisplaySize property that users
// can set to control size changes at runtime, but the control itself ignores that and sets the new size.
// We prevent this by not allowing controls to call OnPosRectChange(), unless we instantiated the resize.
// visual basic6 does the same.
//
bool useRect = true;
if (AxHost.windowsMediaPlayer_Clsid.Equals(host.clsid))
useRect = host.GetAxState(AxHost.handlePosRectChanged);
if (useRect) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnPosRectChange" + lprcPosRect.ToString());
host.GetInPlaceObject().SetObjectRects(lprcPosRect, host.GetClipRect(new NativeMethods.COMRECT()));
host.MakeDirty();
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Control directly called OnPosRectChange... ignoring the new size");
}
return NativeMethods.S_OK;
}
// IPropertyNotifySink methods
void UnsafeNativeMethods.IPropertyNotifySink.OnChanged(int dispid) {
// Some controls fire OnChanged() notifications when getting values of some properties. ASURT 20190.
// To prevent this kind of recursion, we check to see if we are already inside a OnChanged() call.
//
if (host.NoComponentChangeEvents != 0)
return;
host.NoComponentChangeEvents++;
try {
AxPropertyDescriptor prop = null;
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnChanged");
if (dispid != NativeMethods.ActiveX.DISPID_UNKNOWN) {
prop = host.GetPropertyDescriptorFromDispid(dispid);
if (prop != null) {
prop.OnValueChanged(this.host);
if (!prop.SettingValue) {
prop.UpdateTypeConverterAndTypeEditor(true);
}
}
}
else {
// update them all for DISPID_UNKNOWN.
//
PropertyDescriptorCollection props = ((ICustomTypeDescriptor)host).GetProperties();
foreach(PropertyDescriptor p in props) {
prop = p as AxPropertyDescriptor;
if (prop != null && !prop.SettingValue) {
prop.UpdateTypeConverterAndTypeEditor(true);
}
}
}
ISite site = host.Site;
if (site != null) {
IComponentChangeService changeService = (IComponentChangeService)site.GetService(typeof(IComponentChangeService));
if (changeService != null) {
try {
changeService.OnComponentChanging(host, prop);
}
catch (CheckoutException coEx) {
if (coEx == CheckoutException.Canceled) {
return;
}
throw coEx;
}
// Now notify the change service that the change was successful.
//
changeService.OnComponentChanged(host, prop, null, ((prop != null) ? prop.GetValue(host) : null));
}
}
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw t;
}
finally {
host.NoComponentChangeEvents--;
}
}
int UnsafeNativeMethods.IPropertyNotifySink.OnRequestEdit(int dispid) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnRequestEdit for "+host.ToString());
return NativeMethods.S_OK;
}
}
private const int HMperInch = 2540;
private int Pix2HM(int pix, int logP) {
return(HMperInch * pix + ( logP >> 1)) / logP;
}
private int HM2Pix(int hm, int logP) {
return(logP * hm + HMperInch / 2) / HMperInch;
}
private bool QuickActivate() {
if (!(instance is UnsafeNativeMethods.IQuickActivate)) return false;
UnsafeNativeMethods.IQuickActivate iqa = (UnsafeNativeMethods.IQuickActivate) instance;
UnsafeNativeMethods.tagQACONTAINER qaContainer = new UnsafeNativeMethods.tagQACONTAINER();
UnsafeNativeMethods.tagQACONTROL qaControl = new UnsafeNativeMethods.tagQACONTROL();
qaContainer.pClientSite = oleSite;
qaContainer.pPropertyNotifySink = oleSite;
// qaContainer.pControlSite = oleSite;
// qaContainer.pAdviseSink = null;
// qaContainer.pUnkEventSink = null;
// qaContainer.pUndoMgr = null;
// qaContainer.pBindHost = null;
// qaContainer.pServiveProvider = null;
// qaContainer.hpal = 0;
qaContainer.pFont = GetIFontFromFont(GetParentContainer().parent.Font);
qaContainer.dwAppearance = 0;
qaContainer.lcid = Application.CurrentCulture.LCID;
Control p = ParentInternal;
if (p != null) {
qaContainer.colorFore = GetOleColorFromColor(p.ForeColor);
qaContainer.colorBack = GetOleColorFromColor(p.BackColor);
}
else {
qaContainer.colorFore = GetOleColorFromColor(SystemColors.WindowText);
qaContainer.colorBack = GetOleColorFromColor(SystemColors.Window);
}
qaContainer.dwAmbientFlags = NativeMethods.ActiveX.QACONTAINER_AUTOCLIP | NativeMethods.ActiveX.QACONTAINER_MESSAGEREFLECT |
NativeMethods.ActiveX.QACONTAINER_SUPPORTSMNEMONICS;
if (IsUserMode()) {
qaContainer.dwAmbientFlags |= NativeMethods.ActiveX.QACONTAINER_USERMODE;
}
else {
// Can't set ui dead becuase MFC controls return NOWHERE on NCHITTEST which
// messes up the designer...
// But, without this the FarPoint SpreadSheet and the Office SpreadSheet
// controls take keyboard input at design time.
//qaContainer.dwAmbientFlags |= NativeMethods.ActiveX.QACONTAINER_UIDEAD;
// qaContainer.dwAmbientFlags |= ActiveX.QACONTAINER_SHOWHATCHING;
}
try {
iqa.QuickActivate(qaContainer, qaControl);
}
catch (Exception t) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Failed to QuickActivate: " + t.ToString());
DisposeAxControl();
return false;
}
miscStatusBits = qaControl.dwMiscStatus;
ParseMiscBits(miscStatusBits);
return true;
}
internal override void DisposeAxControls() {
axState[rejectSelection] = true;
base.DisposeAxControls();
TransitionDownTo(OC_PASSIVE);
}
private bool GetControlEnabled() {
try {
return IsHandleCreated;
}
catch (Exception t) {
Debug.Fail(t.ToString());
return true;
}
}
internal override bool CanSelectCore() {
if (!GetControlEnabled() || axState[rejectSelection]) return false;
return base.CanSelectCore();
}
///
/// Frees all resources assocaited with this control. This method may not be
/// called at runtime. Any resources used by the control should be setup to
/// be released when the control is garbage collected. Inheriting classes should always
/// call base.dispose.
///
protected override void Dispose(bool disposing) {
if (disposing) {
TransitionDownTo(OC_PASSIVE);
if (newParent != null)
{
newParent.Dispose();
}
}
base.Dispose(disposing);
}
private bool GetSiteOwnsDeactivation() {
return axState[ownDisposing];
}
private void DisposeAxControl() {
if (GetParentContainer() != null) {
GetParentContainer().RemoveControl(this);
}
TransitionDownTo(OC_RUNNING);
if (GetOcState() == OC_RUNNING) {
GetOleObject().SetClientSite(null);
SetOcState(OC_LOADED);
}
}
private void ReleaseAxControl() {
// This line is like a bit of magic...
// sometimes, we crash with it on,
// sometimes, with it off...
// Lately, I have decided to leave it on...
// (oh, yes, and the crashes seemed to disappear...)
//cpr: ComLib.Release(instance);
this.NoComponentChangeEvents++;
ContainerControl f = ContainingControl;
if (f != null) {
f.VisibleChanged -= this.onContainerVisibleChanged;
}
try {
if (instance != null) {
Marshal.FinalReleaseComObject(instance);
instance = null;
iOleInPlaceObject = null;
iOleObject = null;
iOleControl = null;
iOleInPlaceActiveObject = null;
iOleInPlaceActiveObjectExternal = null;
iPerPropertyBrowsing = null;
iCategorizeProperties = null;
iPersistStream = null;
iPersistStreamInit = null;
iPersistStorage = null;
}
axState[checkedIppb] = false;
axState[checkedCP] = false;
axState[disposed] = true;
freezeCount = 0;
axState[sinkAttached] = false;
wndprocAddr = IntPtr.Zero;
SetOcState(OC_PASSIVE);
}
finally {
this.NoComponentChangeEvents--;
}
}
private void ParseMiscBits(int bits) {
axState[fOwnWindow] = ((bits & NativeMethods.ActiveX.OLEMISC_INVISIBLEATRUNTIME) != 0) && IsUserMode();
axState[fSimpleFrame] = ((bits & NativeMethods.ActiveX.OLEMISC_SIMPLEFRAME) != 0);
}
private void SlowActivate() {
bool setClientSite = false;
if ((miscStatusBits & NativeMethods.ActiveX.OLEMISC_SETCLIENTSITEFIRST) != 0) {
GetOleObject().SetClientSite(oleSite);
setClientSite = true;
}
DepersistControl();
if (!setClientSite) {
GetOleObject().SetClientSite(oleSite);
}
}
private static NativeMethods.COMRECT FillInRect(NativeMethods.COMRECT dest, Rectangle source) {
dest.left = source.X;
dest.top = source.Y;
dest.right = source.Width + source.X;
dest.bottom = source.Height + source.Y;
return dest;
}
private AxContainer GetParentContainer() {
Debug.WriteLineIf(IntSecurity.SecurityDemand.TraceVerbose, "GetParent Demanded");
IntSecurity.GetParent.Demand();
if (container == null) {
container = AxContainer.FindContainerForControl(this);
}
if (container == null) {
ContainerControl f = ContainingControl;
if (f == null) {
// ContainingCointrol can be null if the AxHost is still not parented to a containerControl
// In everett we used to return a parking window.
// now we just set the containingControl to a dummyValue.
if (newParent == null)
{
newParent = new ContainerControl();
axContainer = newParent.CreateAxContainer();
axContainer.AddControl(this);
}
return axContainer;
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "calling upon "+f.ToString()+" to create a container");
container = f.CreateAxContainer();
container.AddControl(this);
containingControl = f;
}
}
return container;
}
private UnsafeNativeMethods.IOleControl GetOleControl() {
if (iOleControl == null) {
Debug.Assert(instance != null, "must have the ocx");
iOleControl = (UnsafeNativeMethods.IOleControl) instance;
}
return iOleControl;
}
private UnsafeNativeMethods.IOleInPlaceActiveObject GetInPlaceActiveObject() {
// if our AxContainer was set an external active object then use it.
if(iOleInPlaceActiveObjectExternal != null) {
return iOleInPlaceActiveObjectExternal;
}
// otherwise use our instance.
if (iOleInPlaceActiveObject == null) {
Debug.Assert(instance != null, "must have the ocx");
try {
iOleInPlaceActiveObject = (UnsafeNativeMethods.IOleInPlaceActiveObject)instance;
}
catch (InvalidCastException e) {
Debug.Fail("Invalid cast in GetInPlaceActiveObject: " + e.ToString());
}
}
return iOleInPlaceActiveObject;
}
private UnsafeNativeMethods.IOleObject GetOleObject() {
if (iOleObject == null) {
Debug.Assert(instance != null, "must have the ocx");
iOleObject = (UnsafeNativeMethods.IOleObject) instance;
}
return iOleObject;
}
private UnsafeNativeMethods.IOleInPlaceObject GetInPlaceObject() {
if (iOleInPlaceObject == null) {
Debug.Assert(instance != null, "must have the ocx");
iOleInPlaceObject = (UnsafeNativeMethods.IOleInPlaceObject) instance;
#if DEBUG
if (iOleInPlaceObject is UnsafeNativeMethods.IOleInPlaceObjectWindowless)
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, GetType().FullName + " Can also be a Windowless control.");
#endif //DEBUG
}
return iOleInPlaceObject;
}
private NativeMethods.ICategorizeProperties GetCategorizeProperties() {
if (iCategorizeProperties == null && !axState[checkedCP] && instance != null) {
axState[checkedCP] = true;
if (instance is NativeMethods.ICategorizeProperties) {
iCategorizeProperties = (NativeMethods.ICategorizeProperties) instance;
}
}
return iCategorizeProperties;
}
private NativeMethods.IPerPropertyBrowsing GetPerPropertyBrowsing() {
if (iPerPropertyBrowsing == null && !axState[checkedIppb] && instance != null) {
axState[checkedIppb] = true;
if (instance is NativeMethods.IPerPropertyBrowsing) {
iPerPropertyBrowsing = (NativeMethods.IPerPropertyBrowsing) instance;
}
}
return iPerPropertyBrowsing;
}
// Mapping functions:
#if false
// FxCop: Currently not used
private static IntPtr CopyPalette(IntPtr hPal) {
if (hPal == IntPtr.Zero) return IntPtr.Zero;
int[] nEntries = new int[1];
UnsafeNativeMethods.GetObject(new HandleRef(null, hPal), 4, nEntries);
IntPtr memory = Marshal.AllocHGlobal(nEntries[0] * 4 + 8);
IntPtr ret = IntPtr.Zero;
try {
Marshal.WriteInt32(memory, 0, 0x300);
Marshal.WriteInt32(memory, 4, nEntries[0]);
SafeNativeMethods.GetPaletteEntries(new HandleRef(null, hPal), 0, nEntries[0], (IntPtr)((long)memory + 8));
ret = SafeNativeMethods.CreatePalette(new HandleRef(null, memory));
}
finally {
Marshal.FreeHGlobal(memory);
}
return ret;
}
#endif
private static Object GetPICTDESCFromPicture(Image image) {
Bitmap bmp = image as Bitmap;
if (bmp != null) {
return new NativeMethods.PICTDESCbmp(bmp);
}
Metafile mf = image as Metafile;
if (mf != null)
{
return new NativeMethods.PICTDESCemf(mf);
}
throw new ArgumentException(SR.GetString(SR.AXUnknownImage), "image");
}
///
/// Maps from a System.Drawing.Image to an OLE IPicture
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static object GetIPictureFromPicture(Image image) {
if (image == null) return null;
Object pictdesc = GetPICTDESCFromPicture(image);
return UnsafeNativeMethods.OleCreateIPictureIndirect(pictdesc, ref ipicture_Guid, true);
}
///
/// Maps from a System.Drawing.Cursor to an OLE IPicture
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static object GetIPictureFromCursor(Cursor cursor) {
if (cursor == null) return null;
NativeMethods.PICTDESCicon pictdesc = new NativeMethods.PICTDESCicon(Icon.FromHandle(cursor.Handle));
return UnsafeNativeMethods.OleCreateIPictureIndirect(pictdesc, ref ipicture_Guid, true);
}
///
/// Maps from a System.Drawing.Image to an OLE IPictureDisp
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static object GetIPictureDispFromPicture(Image image) {
if (image == null) return null;
Object pictdesc = GetPICTDESCFromPicture(image);
return UnsafeNativeMethods.OleCreateIPictureDispIndirect(pictdesc, ref ipictureDisp_Guid, true);
}
///
/// Maps from an OLE IPicture to a System.Drawing.Image
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static Image GetPictureFromIPicture(object picture) {
if (picture == null) return null;
IntPtr hPal = IntPtr.Zero;
UnsafeNativeMethods.IPicture pict = (UnsafeNativeMethods.IPicture)picture;
int type = pict.GetPictureType();
if (type == NativeMethods.Ole.PICTYPE_BITMAP) {
try {
hPal = pict.GetHPal();
}
catch (COMException) {
}
}
return GetPictureFromParams(pict, pict.GetHandle(), type, hPal, pict.GetWidth(), pict.GetHeight());
}
///
/// Maps from an OLE IPictureDisp to a System.Drawing.Image
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static Image GetPictureFromIPictureDisp(object picture) {
if (picture == null) return null;
IntPtr hPal = IntPtr.Zero;
UnsafeNativeMethods.IPictureDisp pict = (UnsafeNativeMethods.IPictureDisp)picture;
int type = pict.PictureType;
if (type == NativeMethods.Ole.PICTYPE_BITMAP) {
try {
hPal = pict.HPal;
}
catch (COMException) {
}
}
return GetPictureFromParams(pict, pict.Handle, type, hPal, pict.Width, pict.Height);
}
private static Image GetPictureFromParams(object pict, IntPtr handle, int type, IntPtr paletteHandle, int width, int height) {
switch (type) {
case NativeMethods.Ole.PICTYPE_ICON:
return(Image)(Icon.FromHandle(handle)).Clone();
case NativeMethods.Ole.PICTYPE_METAFILE:
WmfPlaceableFileHeader header = new WmfPlaceableFileHeader();
header.BboxRight = (short)width;
header.BboxBottom = (short)height;
return(Image)(new Metafile(handle, header, false)).Clone();
case NativeMethods.Ole.PICTYPE_ENHMETAFILE:
return(Image)(new Metafile(handle, false)).Clone();
case NativeMethods.Ole.PICTYPE_BITMAP:
return Image.FromHbitmap(handle, paletteHandle);
case NativeMethods.Ole.PICTYPE_NONE:
// MSDN sez this should not be a valid value, but comctl32 returns it...
return null;
case NativeMethods.Ole.PICTYPE_UNINITIALIZED:
return null;
default:
Debug.Fail("Invalid image type "+ type.ToString(CultureInfo.InvariantCulture));
throw new ArgumentException(SR.GetString(SR.AXUnknownImage), "type");
}
}
private static NativeMethods.FONTDESC GetFONTDESCFromFont(Font font) {
NativeMethods.FONTDESC fdesc = null;
if (fontTable == null) {
fontTable = new Hashtable();
}
else {
fdesc = (NativeMethods.FONTDESC)fontTable[font];
}
if (fdesc == null) {
fdesc = new NativeMethods.FONTDESC();
fdesc.lpstrName = font.Name;
fdesc.cySize = (long)(font.SizeInPoints * 10000);
NativeMethods.LOGFONT logfont = new NativeMethods.LOGFONT();
font.ToLogFont(logfont);
fdesc.sWeight = (short) logfont.lfWeight;
fdesc.sCharset = logfont.lfCharSet;
fdesc.fItalic = font.Italic;
fdesc.fUnderline = font.Underline;
fdesc.fStrikethrough = font.Strikeout;
fontTable[font] = fdesc;
}
return fdesc;
}
///
/// Maps from an OLE COLOR to a System.Drawing.Color
///
[CLSCompliantAttribute(false)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static Color GetColorFromOleColor(uint color) {
return ColorTranslator.FromOle((int)color);
}
///
/// Maps from an System.Drawing.Color to an OLE COLOR
///
[CLSCompliantAttribute(false)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static uint GetOleColorFromColor(Color color) {
return (uint)ColorTranslator.ToOle(color);
}
///
/// Maps from a System.Drawing.Font object to an OLE IFont
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static object GetIFontFromFont(Font font) {
if (font == null) return null;
if (font.Unit != GraphicsUnit.Point)
throw new ArgumentException(SR.GetString(SR.AXFontUnitNotPoint), "font");
try {
return (UnsafeNativeMethods.IFont)UnsafeNativeMethods.OleCreateIFontIndirect(GetFONTDESCFromFont(font), ref ifont_Guid);
}
catch {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Failed to create IFrom from font: " + font.ToString());
return null;
}
}
///
/// Maps from an OLE IFont to a System.Drawing.Font object
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static Font GetFontFromIFont(object font) {
if (font == null) return null;
UnsafeNativeMethods.IFont oleFont = (UnsafeNativeMethods.IFont)font;
try {
Font f = Font.FromHfont(oleFont.GetHFont());
if (f.Unit != GraphicsUnit.Point)
f = new Font(f.Name, f.SizeInPoints, f.Style, GraphicsUnit.Point, f.GdiCharSet, f.GdiVerticalFont);
return f;
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Could not create font." + e.Message);
return DefaultFont;
}
}
///
/// Maps from a System.Drawing.Font object to an OLE IFontDisp
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static object GetIFontDispFromFont(Font font) {
if (font == null) return null;
if (font.Unit != GraphicsUnit.Point)
throw new ArgumentException(SR.GetString(SR.AXFontUnitNotPoint), "font");
SafeNativeMethods.IFontDisp rval = SafeNativeMethods.OleCreateIFontDispIndirect(GetFONTDESCFromFont(font), ref ifontDisp_Guid);
return rval;
}
///
/// Maps from an IFontDisp to a System.Drawing.Font object
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static Font GetFontFromIFontDisp(object font) {
if (font == null)
{
return null;
}
UnsafeNativeMethods.IFont ifont = font as UnsafeNativeMethods.IFont;
if (ifont != null)
{
return GetFontFromIFont(ifont);
}
SafeNativeMethods.IFontDisp oleFont = (SafeNativeMethods.IFontDisp)font;
FontStyle style = FontStyle.Regular;
Font f = null;
try {
if (oleFont.Bold)
style |= FontStyle.Bold;
if (oleFont.Italic)
style |= FontStyle.Italic;
if (oleFont.Underline)
style |= FontStyle.Underline;
if (oleFont.Strikethrough)
style |= FontStyle.Strikeout;
if ((int) oleFont.Weight >= 700) // bold
style |= FontStyle.Bold;
f = new Font(oleFont.Name, (float)oleFont.Size/(float)10000, style, GraphicsUnit.Point, (byte)oleFont.Charset);
return f;
}
catch(Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Could not create font from: " + oleFont.Name + ". " + e.Message);
return DefaultFont;
}
}
///
/// Maps from a DateTime object to an OLE DATE (expressed as a double)
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static double GetOADateFromTime(DateTime time) {
return time.ToOADate();
}
///
/// Maps from an OLE DATE (expressed as a double) to a DateTime object
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static DateTime GetTimeFromOADate(double date) {
return DateTime.FromOADate(date);
}
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
private class VBFormat : UnsafeNativeMethods.IVBFormat {
// IVBFormat methods:
//
int UnsafeNativeMethods.IVBFormat.Format(ref Object var, IntPtr pszFormat, IntPtr lpBuffer, short cpBuffer, int lcid, short firstD, short firstW, short[] result) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in Format");
if (result == null)
return NativeMethods.E_INVALIDARG;
result[0] = 0;
if (lpBuffer == IntPtr.Zero || cpBuffer < 2)
return NativeMethods.E_INVALIDARG;
IntPtr pbstr = IntPtr.Zero;
int hr = UnsafeNativeMethods.VarFormat(ref var, new HandleRef(null, pszFormat), firstD, firstW, 32 /* VAR_FORMAT_NOSUBSTITUTE */, ref pbstr);
try {
int i = 0;
if (pbstr != IntPtr.Zero) {
short ch = 0;
cpBuffer --;
for (;i < cpBuffer && (ch = Marshal.ReadInt16(pbstr, i * 2)) != 0; i++) {
Marshal.WriteInt16(lpBuffer, i * 2, ch);
}
}
Marshal.WriteInt16(lpBuffer, i * 2, (short) 0);
result[0] = (short) i;
}
finally {
SafeNativeMethods.SysFreeString(new HandleRef(null, pbstr));
}
return NativeMethods.S_OK;
}
}
///
///
internal class EnumUnknown : UnsafeNativeMethods.IEnumUnknown {
private Object[] arr;
private int loc;
private int size;
internal EnumUnknown(Object[] arr) {
//if (AxHTraceSwitch.TraceVerbose) Debug.WriteObject(arr);
this.arr = arr;
loc = 0;
size = (arr == null) ? 0 : arr.Length;
}
private EnumUnknown(Object[] arr, int loc) : this(arr) {
this.loc = loc;
}
unsafe int UnsafeNativeMethods.IEnumUnknown.Next(int celt, IntPtr rgelt, IntPtr pceltFetched) {
if (pceltFetched != IntPtr.Zero)
Marshal.WriteInt32(pceltFetched, 0, 0);
if (celt < 0) {
return NativeMethods.E_INVALIDARG;
}
int fetched = 0;
if (loc >= size) {
fetched = 0;
}
else {
for (; loc < size && fetched < celt; ++loc) {
if (arr[loc] != null) {
Marshal.WriteIntPtr(rgelt, Marshal.GetIUnknownForObject(arr[loc]));
rgelt = (IntPtr)((long)rgelt + (long)sizeof(IntPtr));
++fetched;
}
}
}
if (pceltFetched != IntPtr.Zero)
Marshal.WriteInt32(pceltFetched, 0, fetched);
if (fetched != celt) {
return(NativeMethods.S_FALSE);
}
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IEnumUnknown.Skip(int celt) {
loc += celt;
if (loc >= size) {
return(NativeMethods.S_FALSE);
}
return NativeMethods.S_OK;
}
void UnsafeNativeMethods.IEnumUnknown.Reset() {
loc = 0;
}
void UnsafeNativeMethods.IEnumUnknown.Clone(out UnsafeNativeMethods.IEnumUnknown ppenum) {
ppenum = new EnumUnknown(arr, loc);
}
}
///
///
internal class AxContainer : UnsafeNativeMethods.IOleContainer, UnsafeNativeMethods.IOleInPlaceFrame, IReflect {
internal ContainerControl parent;
private IContainer assocContainer; // associated IContainer...
// the assocContainer may be null, in which case all this container does is
// forward [de]activation messages to the requisite container...
private AxHost siteUIActive;
private AxHost siteActive;
private bool formAlreadyCreated = false;
private Hashtable containerCache = new Hashtable(); // name -> Control
private int lockCount = 0;
private Hashtable components = null; // Control -> any
private Hashtable proxyCache = null;
private AxHost ctlInEditMode = null;
private const int GC_CHILD = 0x1;
private const int GC_LASTSIBLING = 0x2;
private const int GC_FIRSTSIBLING = 0x4;
private const int GC_CONTAINER = 0x20;
private const int GC_PREVSIBLING = 0x40;
private const int GC_NEXTSIBLING = 0x80;
internal AxContainer(ContainerControl parent) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in constructor. Parent created : "+parent.Created.ToString());
this.parent = parent;
if (parent.Created) FormCreated();
}
// IReflect methods:
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr,Binder binder, Type[] types,ParameterModifier[] modifiers) {
return null;
}
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr) {
return null;
}
MethodInfo[] IReflect.GetMethods(BindingFlags bindingAttr) {
return new MethodInfo[0];
}
FieldInfo IReflect.GetField(String name, BindingFlags bindingAttr) {
return null;
}
FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) {
return new FieldInfo[0];
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr) {
return null;
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers) {
return null;
}
PropertyInfo[] IReflect.GetProperties(BindingFlags bindingAttr) {
return new PropertyInfo[0];
}
MemberInfo[] IReflect.GetMember(String name, BindingFlags bindingAttr) {
return new MemberInfo[0];
}
MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr) {
return new MemberInfo[0];
}
Object IReflect.InvokeMember(String name, BindingFlags invokeAttr, Binder binder,
Object target, Object[] args, ParameterModifier[] modifiers, CultureInfo culture, String[] namedParameters) {
foreach(DictionaryEntry e in containerCache) {
string ctlName = GetNameForControl((Control)e.Key);
if (ctlName.Equals(name)) {
return GetProxyForControl((Control)e.Value);
}
}
throw E_FAIL;
}
Type IReflect.UnderlyingSystemType {
get {
return null;
}
}
///
/// [To be supplied.]
///
internal UnsafeNativeMethods.IExtender GetProxyForControl(Control ctl) {
UnsafeNativeMethods.IExtender rval = null;
if (proxyCache == null) {
proxyCache = new Hashtable();
}
else {
rval = (UnsafeNativeMethods.IExtender) proxyCache[ctl];
}
if (rval == null) {
if (ctl != parent && !GetControlBelongs(ctl)) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "!parent || !belongs NYI");
AxContainer c = FindContainerForControl(ctl);
if (c != null) {
rval = new ExtenderProxy(ctl, c);
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "unable to find proxy, returning null");
return null;
}
}
else {
rval = new ExtenderProxy(ctl, this);
}
proxyCache.Add(ctl, rval);
}
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "found proxy "+rval.ToString());
return rval;
}
///
/// [To be supplied.]
///
internal string GetNameForControl(Control ctl) {
string name = (ctl.Site != null) ? ctl.Site.Name : ctl.Name;
return (name == null) ? "" : name;
}
///
/// [To be supplied.]
///
internal Object GetProxyForContainer() {
return this;
}
///
/// [To be supplied.]
///
internal void AddControl(Control ctl) {
//
lock(this) {
if (containerCache.Contains(ctl))
throw new ArgumentException(SR.GetString(SR.AXDuplicateControl, GetNameForControl(ctl)), "ctl");
containerCache.Add(ctl, ctl);
if (assocContainer == null) {
ISite site = ctl.Site;
if (site != null) {
assocContainer = site.Container;
IComponentChangeService ccs = (IComponentChangeService)site.GetService(typeof(IComponentChangeService));
if (ccs != null) {
ccs.ComponentRemoved += new ComponentEventHandler(this.OnComponentRemoved);
}
}
}
else {
#if DEBUG
ISite site = ctl.Site;
if (site != null && assocContainer != site.Container) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "mismatch between assoc container & added control");
}
#endif
}
}
}
internal void RemoveControl(Control ctl) {
//
lock(this) {
if (containerCache.Contains(ctl)) {
containerCache.Remove(ctl);
}
}
}
///
/// [To be supplied.]
///
private void LockComponents() {
lockCount++;
}
///
/// [To be supplied.]
///
private void UnlockComponents() {
lockCount--;
if (lockCount == 0) {
components = null;
}
}
///
/// [To be supplied.]
///
internal UnsafeNativeMethods.IEnumUnknown EnumControls(Control ctl, int dwOleContF, int dwWhich) {
GetComponents();
LockComponents();
try {
ArrayList l = null;
bool selected = (dwWhich & NativeMethods.ActiveX.GC_WCH_FSELECTED) != 0;
bool reverse = (dwWhich & NativeMethods.ActiveX.GC_WCH_FREVERSEDIR) != 0;
// Note that visual basic actually ignores the next/prev flags... we will not
bool onlyNext = (dwWhich & NativeMethods.ActiveX.GC_WCH_FONLYNEXT) != 0;
bool onlyPrev = (dwWhich & NativeMethods.ActiveX.GC_WCH_FONLYPREV) != 0;
dwWhich = dwWhich & ~(NativeMethods.ActiveX.GC_WCH_FSELECTED | NativeMethods.ActiveX.GC_WCH_FREVERSEDIR |
NativeMethods.ActiveX.GC_WCH_FONLYNEXT | NativeMethods.ActiveX.GC_WCH_FONLYPREV);
if (onlyNext && onlyPrev) {
Debug.Fail("onlyNext && onlyPrev are both set!");
throw E_INVALIDARG;
}
if (dwWhich == NativeMethods.ActiveX.GC_WCH_CONTAINER || dwWhich == NativeMethods.ActiveX.GC_WCH_CONTAINED) {
if (onlyNext || onlyPrev) {
Debug.Fail("GC_WCH_FONLYNEXT or FONLYPREV used with CONTANER or CONATINED");
throw E_INVALIDARG;
}
}
int first = 0;
int last = -1; // meaning all
Control[] ctls = null;
switch (dwWhich) {
default:
Debug.Fail("Bad GC_WCH");
throw E_INVALIDARG;
case NativeMethods.ActiveX.GC_WCH_CONTAINED:
ctls = ctl.GetChildControlsInTabOrder(false);
ctl = null;
break;
case NativeMethods.ActiveX.GC_WCH_SIBLING:
Control p = ctl.ParentInternal;
if (p != null) {
ctls = p.GetChildControlsInTabOrder(false);
if (onlyPrev) {
last = ctl.TabIndex;
}
else if (onlyNext) {
first = ctl.TabIndex + 1;
}
}
else {
ctls = new Control[0];
}
ctl = null;
break;
case NativeMethods.ActiveX.GC_WCH_CONTAINER:
l = new ArrayList();
MaybeAdd(l, ctl, selected, dwOleContF, false);
while (ctl != null) {
AxContainer cont = FindContainerForControl(ctl);
if (cont != null) {
MaybeAdd(l, cont.parent, selected, dwOleContF, true);
ctl = cont.parent;
}
else {
break;
}
}
break;
case NativeMethods.ActiveX.GC_WCH_ALL:
Hashtable htbl = GetComponents();
ctls = new Control[htbl.Keys.Count];
htbl.Keys.CopyTo(ctls, 0);
ctl = parent;
break;
}
if (l == null) {
l = new ArrayList();
if (last == -1 && ctls != null) last = ctls.Length;
if (ctl != null) MaybeAdd(l, ctl, selected, dwOleContF, false);
for (int i = first; i < last; i++) {
MaybeAdd(l, ctls[i], selected, dwOleContF, false);
}
}
Object[] rval = new Object[l.Count];
l.CopyTo(rval, 0);
if (reverse) {
for (int i = 0, j = rval.Length - 1; i < j; i++, j--) {
Object temp = rval[i];
rval[i] = rval[j];
rval[j] = temp;
}
}
return new EnumUnknown(rval);
}
finally {
UnlockComponents();
}
}
///
/// [To be supplied.]
///
private void MaybeAdd(ArrayList l, Control ctl, bool selected, int dwOleContF, bool ignoreBelong) {
if (!ignoreBelong && ctl != parent && !GetControlBelongs(ctl)) return;
if (selected) {
ISelectionService iss = GetSelectionService(ctl);
if (iss == null || !iss.GetComponentSelected(this)) return;
}
AxHost hostctl = ctl as AxHost;
if (hostctl != null && (dwOleContF & NativeMethods.ActiveX.OLECONTF_EMBEDDINGS) != 0) {
l.Add(hostctl.GetOcx());
}
else if ((dwOleContF & NativeMethods.ActiveX.OLECONTF_OTHERS) != 0) {
Object item = GetProxyForControl(ctl);
if (item != null) l.Add(item);
}
}
///
/// [To be supplied.]
///
private void FillComponentsTable(IContainer container) {
if (container != null) {
ComponentCollection comps = container.Components;
if (comps != null) {
components = new Hashtable();
foreach (IComponent comp in comps) {
if (comp is Control && comp != parent && comp.Site != null) {
components.Add(comp, comp);
}
}
return;
}
}
Debug.Assert(parent.Site == null, "Parent is sited but we could not find IContainer!!!");
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Did not find a container in FillComponentsTable!!!");
bool checkHashTable = true;
Control[] ctls = new Control[containerCache.Values.Count];
containerCache.Values.CopyTo(ctls, 0);
if (ctls != null) {
if (ctls.Length > 0 && components == null) {
components = new Hashtable();
checkHashTable = false;
}
for (int i = 0; i < ctls.Length; i ++) {
if (checkHashTable && !components.Contains(ctls[i])) {
components.Add(ctls[i], ctls[i]);
}
}
}
GetAllChildren(this.parent);
}
private void GetAllChildren(Control ctl) {
if (ctl == null)
return;
if (components == null) {
components = new Hashtable();
}
if (ctl != this.parent && !components.Contains(ctl))
components.Add(ctl, ctl);
foreach(Control c in ctl.Controls) {
GetAllChildren(c);
}
}
///
/// [To be supplied.]
///
private Hashtable GetComponents() {
return GetComponents(GetParentsContainer());
}
///
/// [To be supplied.]
///
private Hashtable GetComponents(IContainer cont) {
if (lockCount == 0) {
FillComponentsTable(cont);
}
return components;
}
///
/// [To be supplied.]
///
private bool GetControlBelongs(Control ctl) {
Hashtable comps = GetComponents();
return comps[ctl] != null;
}
///
/// [To be supplied.]
///
private IContainer GetParentIsDesigned() {
ISite site = parent.Site;
if (site != null && site.DesignMode) return site.Container;
return null;
}
///
/// [To be supplied.]
///
private IContainer GetParentsContainer() {
IContainer rval = GetParentIsDesigned();
Debug.Assert(rval == null || assocContainer == null || (rval == assocContainer),
"mismatch between getIPD & aContainer");
return rval == null ? assocContainer : rval;
}
///
/// [To be supplied.]
///
private bool RegisterControl(AxHost ctl) {
ISite site = ctl.Site;
if (site != null) {
IContainer cont = site.Container;
if (cont != null) {
if (assocContainer != null) {
return cont == assocContainer;
}
else {
assocContainer = cont;
IComponentChangeService ccs = (IComponentChangeService)site.GetService(typeof(IComponentChangeService));
if (ccs != null) {
ccs.ComponentRemoved += new ComponentEventHandler(this.OnComponentRemoved);
}
return true;
}
}
}
return false;
}
private void OnComponentRemoved(object sender, ComponentEventArgs e) {
Control c = e.Component as Control;
if (sender == assocContainer && c != null) {
RemoveControl(c);
}
}
///
/// [To be supplied.]
///
internal static AxContainer FindContainerForControl(Control ctl) {
AxHost axctl = ctl as AxHost;
if (axctl != null)
{
if (axctl.container != null) return axctl.container;
ContainerControl f = axctl.ContainingControl;
if (f != null) {
AxContainer container = f.CreateAxContainer();
if (container.RegisterControl(axctl)) {
container.AddControl(axctl);
return container;
}
}
}
return null;
}
#if false
// FxCop: Currently not used
private void OnOldActiveControl(Control valueOld, Control valueNew) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "onOAC called with old: "+valueOld.ToString()+" new: "+valueNew.ToString());
if (!(valueOld is AxHost)) return;
AxContainer c = FindContainerForControl(valueOld);
if (c != null) {
c.OnOldActiveControlInternal(valueOld);
}
else {
Debug.Fail("control w/o a container... pretty bad..."+valueOld.ToString());
}
}
///
/// [To be supplied.]
///
// FxCop: Currently not used
private void OnOldActiveControlInternal(Control valueOld) {
if (siteUIActive == valueOld) siteUIActive.UiDeactivate();
}
// FxCop: Currently not used
private void OnNewActiveControl(Control value) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "onNAC called with new: "+value.ToString());
if (!(value is AxHost)) return;
AxContainer c = FindContainerForControl(value);
if (c != null) {
c.OnNewActiveControlInternal((AxHost)value);
}
else {
Debug.Fail("control w/o a container... pretty bad..."+value.ToString());
}
}
///
/// [To be supplied.]
///
// FxCop: Currently not used
private void OnNewActiveControlInternal(AxHost value) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "New active control. siteUIActive is" +siteUIActive.ToString()+" Control is "+value.ToString());
if (siteUIActive != null && siteUIActive != value) {
Debug.Fail("we should not have an ui active site on this container!"+parent.ToString());
siteUIActive.UiDeactivate();
}
#if DEBUG
if (siteUIActive != null && siteUIActive != value) Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Why is "+siteUIActive.ToString()+" still active?");
if (!value.CanUIActivate) Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "why can't "+value.ToString()+" be uiactivated?");
#endif
if (siteUIActive == null && value.CanUIActivate) {
// we need to uiactivate it ourselves...
try {
((AxHost)value).UiActivate();
}
catch (Exception e) {
Debug.Fail(e.ToString());
}
}
#if DEBUG
if (siteUIActive != parent.ActiveControl && value.CanUIActivate) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "form's active control is "+parent.ActiveControl.ToString());
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "could not reconcile active controls... bad things loom on the horizon...");
}
#endif
if (siteUIActive == null) {
// so now the form thinks that value is the active control but it's not ui active...
// this can often lead to bad things unless we are carefull...
siteActive = value;
// basically, when siteActive goes inplacedeactivate, we need to treat it the same as a
// siteuiactive going uiactivedeactivate...
}
}
#endif
///
/// [To be supplied.]
///
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?");
}
}
}
///
/// [To be supplied.]
///
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);
}
}
}
///
/// [To be supplied.]
///
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;
}
}
///
/// [To be supplied.]
///
private void ListAxControls(ArrayList list, bool fuseOcx) {
Hashtable components = GetComponents();
if (components == null) return;
Control[] ctls = new Control[components.Keys.Count];
components.Keys.CopyTo(ctls, 0);
if (ctls != null) {
for (int i = 0; i < ctls.Length; i++) {
Control ctl = ctls[i];
AxHost hostctl = ctl as AxHost;
if (hostctl != null) {
if (fuseOcx) {
list.Add(hostctl.GetOcx());
}
else {
list.Add(ctl);
}
}
}
}
}
///
/// [To be supplied.]
///
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();
}
}
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);
}
}
}
// IOleContainer methods:
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleContainer.ParseDisplayName(Object pbc, string pszDisplayName, int[] pchEaten, Object[] ppmkOut) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in ParseDisplayName");
if (ppmkOut != null)
ppmkOut[0] = null;
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleContainer.EnumObjects(int grfFlags, out UnsafeNativeMethods.IEnumUnknown ppenum) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in EnumObjects");
ppenum = null;
if ((grfFlags & 1) != 0) { // 1 == OLECONTF_EMBEDDINGS
Debug.Assert(parent != null, "gotta have it...");
ArrayList list = new ArrayList();
ListAxControls(list, true);
if (list.Count > 0) {
Object[] temp = new Object[list.Count];
list.CopyTo(temp, 0);
ppenum = new EnumUnknown(temp);
return NativeMethods.S_OK;
}
}
ppenum = new EnumUnknown(null);
return NativeMethods.S_OK;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleContainer.LockContainer(bool fLock) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in LockContainer");
return NativeMethods.E_NOTIMPL;
}
// IOleInPlaceFrame methods:
IntPtr UnsafeNativeMethods.IOleInPlaceFrame.GetWindow() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetWindow");
return parent.Handle;
}
int UnsafeNativeMethods.IOleInPlaceFrame.ContextSensitiveHelp(int fEnterMode) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in ContextSensitiveHelp");
return NativeMethods.S_OK;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.GetBorder(NativeMethods.COMRECT lprectBorder) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetBorder");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.RequestBorderSpace(NativeMethods.COMRECT pborderwidths) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in RequestBorderSpace");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.SetBorderSpace(NativeMethods.COMRECT pborderwidths) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SetBorderSpace");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
internal void OnExitEditMode(AxHost ctl) {
Debug.Assert(ctlInEditMode == null || ctlInEditMode == ctl, "who is exiting edit mode?");
if (ctlInEditMode == null || ctlInEditMode != ctl) return;
ctlInEditMode = null;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.SetActiveObject(UnsafeNativeMethods.IOleInPlaceActiveObject pActiveObject, string pszObjName) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SetActiveObject " + ((pszObjName == 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;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.InsertMenus(IntPtr hmenuShared, NativeMethods.tagOleMenuGroupWidths lpMenuWidths) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in InsertMenus");
return NativeMethods.S_OK;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.SetMenu(IntPtr hmenuShared, IntPtr holemenu, IntPtr hwndActiveObject) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SetMenu");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.RemoveMenus(IntPtr hmenuShared) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in RemoveMenus");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.SetStatusText(string pszStatusText) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SetStatusText");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.EnableModeless(bool fEnable) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in EnableModeless");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.TranslateAccelerator(ref NativeMethods.MSG lpmsg, short wID) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in IOleInPlaceFrame.TranslateAccelerator");
return NativeMethods.S_FALSE;
}
// EXPOSED
///
///
private class ExtenderProxy : UnsafeNativeMethods.IExtender, UnsafeNativeMethods.IVBGetControl, UnsafeNativeMethods.IGetVBAObject, UnsafeNativeMethods.IGetOleObject, IReflect {
private WeakReference pRef;
private WeakReference pContainer;
internal ExtenderProxy(Control principal, AxContainer container) {
pRef = new WeakReference(principal);
pContainer = new WeakReference(container);
}
private Control GetP() {
return(Control) pRef.Target;
}
private AxContainer GetC() {
return(AxContainer) pContainer.Target;
}
int UnsafeNativeMethods.IVBGetControl.EnumControls(int dwOleContF, int dwWhich, out UnsafeNativeMethods.IEnumUnknown ppenum) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in EnumControls for proxy");
ppenum = GetC().EnumControls(GetP(), dwOleContF, dwWhich);
return NativeMethods.S_OK;
}
object UnsafeNativeMethods.IGetOleObject.GetOleObject(ref Guid riid) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetOleObject for proxy");
if (!riid.Equals(ioleobject_Guid))
throw E_INVALIDARG;
Control ctl = GetP();
if (ctl != null && ctl is AxHost) {
return ((AxHost)ctl).GetOcx();
}
throw E_FAIL;
}
int UnsafeNativeMethods.IGetVBAObject.GetObject(ref Guid riid, UnsafeNativeMethods.IVBFormat[] rval, int dwReserved) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetObject for proxy");
if (rval == null || riid.Equals(Guid.Empty))
return NativeMethods.E_INVALIDARG;
if (riid.Equals(ivbformat_Guid)) {
rval[0] = new VBFormat();
return NativeMethods.S_OK;
}
else {
rval[0] = null;
return NativeMethods.E_NOINTERFACE;
}
}
public int Align {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getAlign for proxy for "+ GetP().ToString());
int rval = (int)((Control)GetP()).Dock;
if (rval < NativeMethods.ActiveX.ALIGN_MIN || rval > NativeMethods.ActiveX.ALIGN_MAX) {
rval = NativeMethods.ActiveX.ALIGN_NO_CHANGE;
}
return rval;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setAlign for proxy for "+ GetP().ToString()+" "+
value.ToString(CultureInfo.InvariantCulture));
GetP().Dock = (DockStyle)value;
}
}
public UInt32 BackColor {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getBackColor for proxy for "+ GetP().ToString());
return AxHost.GetOleColorFromColor(((Control)GetP()).BackColor);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setBackColor for proxy for "+ GetP().ToString()+" "+
value.ToString(CultureInfo.InvariantCulture));
GetP().BackColor = AxHost.GetColorFromOleColor(value);
}
}
public bool Enabled {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getEnabled for proxy for "+ GetP().ToString());
return GetP().Enabled;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setEnabled for proxy for "+ GetP().ToString()+" "+value.ToString());
GetP().Enabled = value;
}
}
public UInt32 ForeColor {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getForeColor for proxy for "+ GetP().ToString());
return AxHost.GetOleColorFromColor(((Control)GetP()).ForeColor);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setForeColor for proxy for "+ GetP().ToString()+" "+
value.ToString(CultureInfo.InvariantCulture));
GetP().ForeColor = AxHost.GetColorFromOleColor(value);
}
}
public int Height {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getHeight for proxy for "+ GetP().ToString());
return Pixel2Twip(GetP().Height, false);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setHeight for proxy for "+ GetP().ToString()+" "+
Twip2Pixel(value,false).ToString(CultureInfo.InvariantCulture));
GetP().Height = Twip2Pixel(value, false);
}
}
public int Left {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getLeft for proxy for "+ GetP().ToString());
return Pixel2Twip(GetP().Left, true);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setLeft for proxy for "+ GetP().ToString()+" "+
Twip2Pixel(value, true).ToString(CultureInfo.InvariantCulture));
GetP().Left = Twip2Pixel(value, true);
}
}
public object Parent {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getParent for proxy for "+ GetP().ToString());
return GetC().GetProxyForControl(GetC().parent);
}
}
public short TabIndex {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getTabIndex for proxy for "+ GetP().ToString());
return (short)GetP().TabIndex;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setTabIndex for proxy for "+ GetP().ToString()+" "+
value.ToString(CultureInfo.InvariantCulture));
GetP().TabIndex = (int)value;
}
}
public bool TabStop {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getTabStop for proxy for "+ GetP().ToString());
return GetP().TabStop;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setTabStop for proxy for "+ GetP().ToString()+" "+value.ToString());
GetP().TabStop = value;
}
}
public int Top {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getTop for proxy for "+ GetP().ToString());
return Pixel2Twip(GetP().Top, false);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setTop for proxy for "+ GetP().ToString()+" "+
Twip2Pixel(value, false).ToString(CultureInfo.InvariantCulture));
GetP().Top = Twip2Pixel(value, false);
}
}
public bool Visible {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getVisible for proxy for "+ GetP().ToString());
return GetP().Visible;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setVisible for proxy for "+ GetP().ToString()+" "+value.ToString());
GetP().Visible = value;
}
}
public int Width {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getWidth for proxy for "+ GetP().ToString());
return Pixel2Twip(GetP().Width,true);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setWidth for proxy for "+ GetP().ToString()+" "+
Twip2Pixel(value, true).ToString(CultureInfo.InvariantCulture));
GetP().Width = Twip2Pixel(value, true);
}
}
public string Name {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getName for proxy for "+ GetP().ToString());
return GetC().GetNameForControl(GetP());
}
}
public IntPtr Hwnd {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getHwnd for proxy for "+ GetP().ToString());
return GetP().Handle;
}
}
public object Container {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getContainer for proxy for "+ GetP().ToString());
return GetC().GetProxyForContainer();
}
}
public string Text {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getText for proxy for "+ GetP().ToString());
return GetP().Text;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setText for proxy for "+ GetP().ToString());
GetP().Text = value;
}
}
public void Move(Object left, Object top, Object width, Object height) {
}
// IReflect methods:
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr,Binder binder, Type[] types,ParameterModifier[] modifiers) {
return null;
}
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr) {
return null;
}
MethodInfo[] IReflect.GetMethods(BindingFlags bindingAttr) {
return new MethodInfo[] {this.GetType().GetMethod("Move")};
}
FieldInfo IReflect.GetField(String name, BindingFlags bindingAttr) {
return null;
}
FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) {
return new FieldInfo[0];
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr) {
PropertyInfo prop = GetP().GetType().GetProperty(name, bindingAttr);
if (prop == null) {
prop = this.GetType().GetProperty(name, bindingAttr);
}
return prop;
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr, Binder binder,Type returnType, Type[] types, ParameterModifier[] modifiers) {
PropertyInfo prop = GetP().GetType().GetProperty(name, bindingAttr, binder, returnType, types, modifiers);
if (prop == null) {
prop = this.GetType().GetProperty(name, bindingAttr, binder, returnType, types, modifiers);
}
return prop;
}
PropertyInfo[] IReflect.GetProperties(BindingFlags bindingAttr) {
PropertyInfo[] extenderProps = this.GetType().GetProperties(bindingAttr);
PropertyInfo[] ctlProps = GetP().GetType().GetProperties(bindingAttr);
if (extenderProps == null) {
return ctlProps;
}
else if (ctlProps == null) {
return extenderProps;
}
else {
int iProp = 0;
PropertyInfo[] props = new PropertyInfo[extenderProps.Length + ctlProps.Length];
foreach(PropertyInfo prop in extenderProps) {
props[iProp++] = prop;
}
foreach(PropertyInfo prop in ctlProps) {
props[iProp++] = prop;
}
return props;
}
}
MemberInfo[] IReflect.GetMember(String name, BindingFlags bindingAttr) {
MemberInfo[] memb = GetP().GetType().GetMember(name, bindingAttr);
if (memb == null) {
memb = this.GetType().GetMember(name, bindingAttr);
}
return memb;
}
MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr) {
MemberInfo[] extenderMembs = this.GetType().GetMembers(bindingAttr);
MemberInfo[] ctlMembs = GetP().GetType().GetMembers(bindingAttr);
if (extenderMembs == null) {
return ctlMembs;
}
else if (ctlMembs == null) {
return extenderMembs;
}
else {
MemberInfo[] membs = new MemberInfo[extenderMembs.Length + ctlMembs.Length];
Array.Copy(extenderMembs, 0, membs, 0, extenderMembs.Length);
Array.Copy(ctlMembs, 0, membs, extenderMembs.Length, ctlMembs.Length);
return membs;
}
}
Object IReflect.InvokeMember(String name, BindingFlags invokeAttr, Binder binder,
Object target, Object[] args, ParameterModifier[] modifiers, CultureInfo culture, String[] namedParameters) {
try {
return this.GetType().InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
}
catch(MissingMethodException) {
return this.GetP().GetType().InvokeMember(name, invokeAttr, binder, GetP(), args, modifiers, culture, namedParameters);
}
}
Type IReflect.UnderlyingSystemType {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "In UnderlyingSystemType");
return null;
}
}
}
}
///
/// StateConverter is a class that can be used to convert
/// State from one data type to another. Access this
/// class through the TypeDescriptor.
///
///
/// Gets a value indicating whether this converter can
/// convert an object in the given source type to the native type of the converter
/// using the context.
///
///
/// Gets a value indicating whether this converter can
/// convert an object to the given destination type using the context.
///
///
/// Converts the given object to the converter's native type.
///
///
/// Converts the given object to another type. The most common types to convert
/// are to and from a string object. The default implementation will make a call
/// to ToString on the object if the object is valid and if the destination
/// type is string. If this cannot convert to the desitnation type, this will
/// throw a NotSupportedException.
///
///
/// The class which encapsulates the persisted state of the underlying activeX control
/// An instance of this class my be obtained either by calling getOcxState on an
/// AxHost object, or by reading in from a stream.
///
[
TypeConverterAttribute(typeof(TypeConverter)),
Serializable
]
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.InheritanceDemand, Name="FullTrust")]
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.LinkDemand, Name="FullTrust")]
[SuppressMessage("Microsoft.Usage", "CA2240:ImplementISerializableCorrectly")]
public class State : ISerializable {
private int VERSION = 1;
private int length;
private byte[] buffer;
internal int type;
private MemoryStream ms;
private UnsafeNativeMethods.IStorage storage;
private UnsafeNativeMethods.ILockBytes iLockBytes;
private bool manualUpdate = false;
private string licenseKey = null;
private PropertyBagStream propBag;
// create on save from ipersist stream
///
/// [To be supplied.]
///
internal State(MemoryStream ms, int storageType, AxHost ctl, PropertyBagStream propBag) {
type = storageType;
this.propBag = propBag;
// dangerous?
length = (int)ms.Length;
this.ms = ms;
this.manualUpdate = ctl.GetAxState(AxHost.manualUpdate);
this.licenseKey = ctl.GetLicenseKey();
}
internal State(PropertyBagStream propBag) {
this.propBag = propBag;
}
internal State(MemoryStream ms) {
this.ms = ms;
this.length = (int)ms.Length;
InitializeFromStream(ms);
}
// create on init new w/ storage...
///
/// [To be supplied.]
///
internal State(AxHost ctl) {
CreateStorage();
manualUpdate = ctl.GetAxState(AxHost.manualUpdate);
licenseKey = ctl.GetLicenseKey();
type = STG_STORAGE;
}
///
/// [To be supplied.]
///
public State(Stream ms, int storageType, bool manualUpdate, string licKey) {
type = storageType;
// dangerous?
length = (int)ms.Length;
this.manualUpdate = manualUpdate;
this.licenseKey = licKey;
InitializeBufferFromStream(ms);
}
/**
* Constructor used in deserialization
*/
protected State(SerializationInfo info, StreamingContext context) {
SerializationInfoEnumerator sie = info.GetEnumerator();
if (sie == null) {
return;
}
for (; sie.MoveNext();) {
if (String.Compare(sie.Name, "Data", true, CultureInfo.InvariantCulture) == 0) {
try {
byte[] dat = (byte[])sie.Value;
if (dat != null) {
InitializeFromStream(new MemoryStream(dat));
}
}
catch (Exception e) {
Debug.Fail("failure: " + e.ToString());
}
}
else if (String.Compare(sie.Name, "PropertyBagBinary", true, CultureInfo.InvariantCulture) == 0) {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Loading up property bag from stream...");
byte[] dat = (byte[])sie.Value;
if (dat != null) {
this.propBag = new PropertyBagStream();
propBag.Read(new MemoryStream(dat));
}
}
catch (Exception e) {
Debug.Fail("failure: " + e.ToString());
}
}
}
}
///
/// [To be supplied.]
///
internal int Type {
get {
return type;
}
set {
type = value;
}
}
internal bool _GetManualUpdate() {
return manualUpdate;
}
internal string _GetLicenseKey() {
return licenseKey;
}
///
/// [To be supplied.]
///
private void CreateStorage() {
Debug.Assert(storage == null, "but we already have a storage!!!");
IntPtr hglobal = IntPtr.Zero;
if (buffer != null) {
hglobal = UnsafeNativeMethods.GlobalAlloc(NativeMethods.GMEM_MOVEABLE, length);
IntPtr pointer = UnsafeNativeMethods.GlobalLock(new HandleRef(null, hglobal));
try {
if (pointer != IntPtr.Zero) {
Marshal.Copy(buffer, 0, pointer, length);
}
}
finally {
UnsafeNativeMethods.GlobalUnlock(new HandleRef(null, hglobal));
}
}
bool failed = false;
try {
iLockBytes = UnsafeNativeMethods.CreateILockBytesOnHGlobal(new HandleRef(null, hglobal), true);
if (buffer == null) {
storage = UnsafeNativeMethods.StgCreateDocfileOnILockBytes(iLockBytes,
NativeMethods.STGM_CREATE | NativeMethods.STGM_READWRITE | NativeMethods.STGM_SHARE_EXCLUSIVE, 0);
}
else {
storage = UnsafeNativeMethods.StgOpenStorageOnILockBytes(iLockBytes,
null, NativeMethods.STGM_READWRITE | NativeMethods.STGM_SHARE_EXCLUSIVE, 0, 0);
}
}
catch (Exception t) {
Debug.Fail(t.ToString());
failed = true;
}
if (failed) {
if (iLockBytes == null && hglobal != IntPtr.Zero) {
UnsafeNativeMethods.GlobalFree(new HandleRef(null, hglobal));
}
else {
iLockBytes = null;
}
storage = null;
}
}
internal UnsafeNativeMethods.IPropertyBag GetPropBag() {
return propBag;
}
internal UnsafeNativeMethods.IStorage GetStorage() {
if (storage == null)
CreateStorage();
return storage;
}
internal UnsafeNativeMethods.IStream GetStream() {
if (ms == null) {
Debug.Assert(buffer != null, "gotta have the buffer already...");
if (buffer == null) return null;
ms = new MemoryStream(buffer);
}
else {
ms.Seek(0, SeekOrigin.Begin);
}
return new UnsafeNativeMethods.ComStreamFromDataStream(ms);
}
private void InitializeFromStream(Stream ids) {
BinaryReader br = new BinaryReader(ids);
type = br.ReadInt32();
int version = br.ReadInt32();
manualUpdate = br.ReadBoolean();
int cc = br.ReadInt32();
if (cc != 0) {
licenseKey = new string(br.ReadChars(cc));
}
for (int skipUnits = br.ReadInt32(); skipUnits > 0; skipUnits --) {
int len = br.ReadInt32();
ids.Position = ids.Position + len;
}
length = br.ReadInt32();
if (length > 0)
buffer = br.ReadBytes(length);
}
private void InitializeBufferFromStream(Stream ids) {
BinaryReader br = new BinaryReader(ids);
length = br.ReadInt32();
if (length > 0)
buffer = br.ReadBytes(length);
}
internal State RefreshStorage(UnsafeNativeMethods.IPersistStorage iPersistStorage) {
Debug.Assert(storage != null, "how can we not have a storage object?");
Debug.Assert(iLockBytes != null, "how can we have a storage w/o ILockBytes?");
if (storage == null || iLockBytes == null) return null;
iPersistStorage.Save(storage, true);
storage.Commit(0);
iPersistStorage.HandsOffStorage();
try {
buffer = null;
ms = null;
NativeMethods.STATSTG stat = new NativeMethods.STATSTG();
iLockBytes.Stat(stat, NativeMethods.Ole.STATFLAG_NONAME);
length = (int) stat.cbSize;
buffer = new byte[length];
IntPtr hglobal = UnsafeNativeMethods.GetHGlobalFromILockBytes(iLockBytes);
IntPtr pointer = UnsafeNativeMethods.GlobalLock(new HandleRef(null, hglobal));
try {
if (pointer != IntPtr.Zero) {
Marshal.Copy(pointer, buffer, 0, length);
}
else {
length = 0;
buffer = null;
}
}
finally {
UnsafeNativeMethods.GlobalUnlock(new HandleRef(null, hglobal));
}
}
finally {
iPersistStorage.SaveCompleted(storage);
}
return this;
}
internal void Save(MemoryStream stream) {
BinaryWriter bw = new BinaryWriter(stream);
bw.Write(type);
bw.Write(VERSION);
bw.Write(manualUpdate);
if (licenseKey != null) {
bw.Write(licenseKey.Length);
bw.Write(licenseKey.ToCharArray());
}
else {
bw.Write((int)0);
}
bw.Write((int)0); // skip units
bw.Write(length);
if (buffer != null) {
bw.Write(buffer);
}
else if (ms != null) {
ms.Position = 0;
ms.WriteTo(stream);
}
else {
Debug.Assert(length == 0, "if we have no data, then our length has to be 0");
}
}
///
/// ISerializable private implementation
///
/// " : pVar.ToString()));
// The EE returns a VT_EMPTY for a null. The problem is that visual basic6 expects the caller to respect the
// "hint" it gives in the VariantType. For eg., for a VT_BSTR, it expects that the callee will null
// out the BSTR field of the variant. Since, the EE or us cannot do anything about this, we will return
// a E_INVALIDARG rather than let visual basic6 crash.
//
return (pVar == null) ? NativeMethods.E_INVALIDARG : NativeMethods.S_OK;
}
int UnsafeNativeMethods.IPropertyBag.Write(string pszPropName, ref object pVar) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Writing property " + pszPropName + " [" + pVar + "] into OCXState propertybag.");
if (pVar != null && !pVar.GetType().IsSerializable) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t " + pVar.GetType().FullName + " is not serializable.");
return NativeMethods.S_OK;
}
bag[pszPropName] = pVar;
return NativeMethods.S_OK;
}
internal void Write(Stream stream) {
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, bag);
}
}
///
/// [To be supplied.]
///
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.InheritanceDemand, Name="FullTrust")]
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.LinkDemand, Name="FullTrust")]
[ComVisible(false)]
public class AxComponentEditor : WindowsFormsComponentEditor {
///
/// [To be supplied.]
///
public override bool EditComponent(ITypeDescriptorContext context, object obj, IWin32Window parent) {
AxHost host = obj as AxHost;
if (host != null)
{
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in AxComponentEditor.EditComponent");
((UnsafeNativeMethods.IOleControlSite)host.oleSite).ShowPropertyFrame();
return true;
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw;
}
}
return false;
}
}
///
///
internal class AxPropertyDescriptor : PropertyDescriptor {
private PropertyDescriptor baseProp;
internal AxHost owner;
private DispIdAttribute dispid;
private TypeConverter converter;
private UITypeEditor editor;
private ArrayList updateAttrs = new ArrayList();
private int flags = 0;
private const int FlagUpdatedEditorAndConverter = 0x00000001;
private const int FlagCheckGetter = 0x00000002;
private const int FlagGettterThrew = 0x00000004;
private const int FlagIgnoreCanAccessProperties = 0x00000008;
private const int FlagSettingValue = 0x00000010;
[
SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors") // Shipped in Everett
]
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);
}
}
}
public override Type ComponentType {
get {
return baseProp.ComponentType;
}
}
public override TypeConverter Converter {
get {
if (dispid != null) {
UpdateTypeConverterAndTypeEditorInternal(false, Dispid);
}
return (converter != null) ? converter : base.Converter;
}
}
internal int Dispid {
get {
DispIdAttribute dispid = (DispIdAttribute)baseProp.Attributes[typeof(DispIdAttribute)];
if (dispid != null) {
return dispid.Value;
}
return NativeMethods.ActiveX.DISPID_UNKNOWN;
}
}
public override bool IsReadOnly {
get {
return baseProp.IsReadOnly;
}
}
public override Type PropertyType {
get {
return baseProp.PropertyType;
}
}
internal bool SettingValue {
get {
return GetFlag(FlagSettingValue);
}
}
private void AddAttribute(Attribute attr) {
updateAttrs.Add(attr);
}
public override bool CanResetValue(object o) {
return baseProp.CanResetValue(o);
}
public override object GetEditor(Type editorBaseType) {
UpdateTypeConverterAndTypeEditorInternal(false, dispid.Value);
if (editorBaseType.Equals(typeof(UITypeEditor)) && editor != null) {
return editor;
}
return base.GetEditor(editorBaseType);
}
private bool GetFlag(int flagValue) {
return ((flags & flagValue) == flagValue);
}
private Guid GetPropertyPage(int dispid) {
try {
NativeMethods.IPerPropertyBrowsing ippb = owner.GetPerPropertyBrowsing();
if (ippb == null) return Guid.Empty;
Guid rval;
if (NativeMethods.Succeeded(ippb.MapPropertyToPage(dispid, out rval))) {
return rval;
}
}
catch (COMException) {
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
return Guid.Empty;
}
public override object GetValue(object component) {
if ((!GetFlag(FlagIgnoreCanAccessProperties) && !owner.CanAccessProperties) || GetFlag(FlagGettterThrew)) {
return null;
}
try {
// Some controls fire OnChanged() notifications when getting values of some properties. ASURT 20190.
// To prevent this kind of recursion, we check to see if we are already inside a OnChanged() call.
//
owner.NoComponentChangeEvents++;
return baseProp.GetValue(component);
}
catch (Exception e) {
if (!GetFlag(FlagCheckGetter)) {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Get failed for : " + Name + " with exception: " + e.Message + " .Making property non-browsable.");
SetFlag(FlagCheckGetter, true);
AddAttribute(new BrowsableAttribute(false));
owner.RefreshAllProperties = true;
SetFlag(FlagGettterThrew, true);
}
throw e;
}
finally {
owner.NoComponentChangeEvents--;
}
}
public void OnValueChanged(object component) {
this.OnValueChanged(component, EventArgs.Empty);
}
public override void ResetValue(object o) {
baseProp.ResetValue(o);
}
private void SetFlag(int flagValue, bool value) {
if (value) {
flags |= flagValue;
}
else {
flags &= ~flagValue;
}
}
public override void SetValue(Object component, Object value) {
if (!GetFlag(FlagIgnoreCanAccessProperties) && !owner.CanAccessProperties) {
return;
}
// State oldOcxState = owner.OcxState;
try {
SetFlag(FlagSettingValue, true);
if (this.PropertyType.IsEnum && (value.GetType() != this.PropertyType)) {
baseProp.SetValue(component, Enum.ToObject(this.PropertyType, value));
}
else {
baseProp.SetValue(component, value);
}
}
finally {
SetFlag(FlagSettingValue, false);
}
OnValueChanged(component);
if (owner == component) {
owner.SetAxState(AxHost.valueChanged, true);
}
}
public override bool ShouldSerializeValue(object o) {
return baseProp.ShouldSerializeValue(o);
}
internal void UpdateAttributes() {
if (updateAttrs.Count == 0)
return;
ArrayList attributes = new ArrayList(AttributeArray);
foreach(Attribute attr in updateAttrs) {
attributes.Add(attr);
}
Attribute[] temp = new Attribute[attributes.Count];
attributes.CopyTo(temp, 0);
AttributeArray = temp;
updateAttrs.Clear();
}
///
/// Called externally to update the editor or type converter.
/// This simply sets flags so this will happen, it doesn't actually to the update...
/// we wait and do that on-demand for perf.
///
internal void UpdateTypeConverterAndTypeEditor(bool force) {
// if this is an external request, flip the flag to false so we do the update on demand.
//
if (GetFlag(FlagUpdatedEditorAndConverter) && force) {
SetFlag(FlagUpdatedEditorAndConverter, false);
}
}
///
/// Called externally to update the editor or type converter.
/// This simply sets flags so this will happen, it doesn't actually to the update...
/// we wait and do that on-demand for perf.
///
internal void UpdateTypeConverterAndTypeEditorInternal(bool force, int dispid) {
// check to see if we're being forced here or if the work really
// needs to be done.
//
if (GetFlag(FlagUpdatedEditorAndConverter) && !force) {
return;
}
if (owner.GetOcx() == null) {
return;
}
try {
NativeMethods.IPerPropertyBrowsing ppb = owner.GetPerPropertyBrowsing();
if (ppb != null) {
bool hasStrings = false;
// check for enums
NativeMethods.CA_STRUCT caStrings = new NativeMethods.CA_STRUCT();
NativeMethods.CA_STRUCT caCookies = new NativeMethods.CA_STRUCT();
int hr = NativeMethods.S_OK;
try {
hr = ppb.GetPredefinedStrings(dispid, caStrings, caCookies);
}
catch(ExternalException ex) {
hr = ex.ErrorCode;
Debug.Fail("An exception occurred inside IPerPropertyBrowsing::GetPredefinedStrings(dispid=" +
dispid + "), object type=" + new ComNativeDescriptor().GetClassName(ppb));
}
if (hr != NativeMethods.S_OK) {
hasStrings = false;
// Destroy the existing editor if we created the current one
// so if the items have disappeared, we don't hold onto the old
// items.
if (converter is Com2EnumConverter) {
converter = null;
}
}
else {
hasStrings = true;
}
if (hasStrings) {
OleStrCAMarshaler stringMarshaler = new OleStrCAMarshaler(caStrings);
Int32CAMarshaler intMarshaler = new Int32CAMarshaler(caCookies);
if (stringMarshaler.Count > 0 && intMarshaler.Count > 0) {
if (converter == null) {
converter = new AxEnumConverter(this, new AxPerPropertyBrowsingEnum(this, owner, stringMarshaler, intMarshaler, true));
}
else if (converter is AxEnumConverter){
((AxEnumConverter)converter).RefreshValues();
AxPerPropertyBrowsingEnum axEnum = ((AxEnumConverter)converter).com2Enum as AxPerPropertyBrowsingEnum;
if (axEnum != null) {
axEnum.RefreshArrays(stringMarshaler, intMarshaler);
}
}
}
else {
//hasStrings = false;
}
}
else {
// if we didn't get any strings, try the proppage edtior
//
// Check to see if this is a property that we have already massaged to be a
// .Net type. If it is, don't bother with custom property pages. We already
// have a .Net Editor for this type.
//
ComAliasNameAttribute comAlias = (ComAliasNameAttribute)baseProp.Attributes[typeof(ComAliasNameAttribute)];
if (comAlias == null) {
Guid g = GetPropertyPage(dispid);
if (!Guid.Empty.Equals(g)) {
editor = new AxPropertyTypeEditor(this, g);
// Show any non-browsable property that has an editor through a
// property page.
//
if (!this.IsBrowsable) {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Making property: " + this.Name + " browsable because we found an editor.");
AddAttribute(new BrowsableAttribute(true));
}
}
}
}
}
SetFlag(FlagUpdatedEditorAndConverter, true);
}
catch (Exception e) {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "could not get the type editor for property: " + this.Name + " Exception: " + e);
}
}
}
private class AxPropertyTypeEditor : UITypeEditor {
private AxPropertyDescriptor propDesc;
private Guid guid;
public AxPropertyTypeEditor(AxPropertyDescriptor pd, Guid guid) {
propDesc = pd;
this.guid = guid;
}
///
/// Takes the value returned from valueAccess.getValue() and modifies or replaces
/// the value, passing the result into valueAccess.setValue(). This is where
/// an editor can launch a modal dialog or create a drop down editor to allow
/// the user to modify the value. Host assistance in presenting UI to the user
/// can be found through the valueAccess.getService function.
///
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) {
try {
object instance = context.Instance;
propDesc.owner.ShowPropertyPageForDispid(propDesc.Dispid, this.guid);
}
catch (Exception ex1) {
if (provider != null) {
IUIService uiSvc = (IUIService)provider.GetService(typeof(IUIService));
if (uiSvc != null){
uiSvc.ShowError(ex1, SR.GetString(SR.ErrorTypeConverterFailed));
}
}
}
return value;
}
///
/// Retrieves the editing style of the Edit method. If the method
/// is not supported, this will return None.
///
public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context) {
return UITypeEditorEditStyle.Modal;
}
}
///
/// simple derivation of the com2enumconverter that allows us to intercept
/// the call to GetStandardValues so we can on-demand update the enum values.
///
private class AxEnumConverter : Com2EnumConverter {
private AxPropertyDescriptor target;
public AxEnumConverter(AxPropertyDescriptor target, Com2Enum com2Enum) : base(com2Enum) {
this.target = target;
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) {
// make sure the converter has been properly refreshed -- calling
// the Converter property does this.
//
TypeConverter tc = this;
tc = target.Converter;
return base.GetStandardValues(context);
}
}
// This exists for perf reasons. We delay doing this until we
// are actually asked for the array of values.
//
private class AxPerPropertyBrowsingEnum : Com2Enum {
private AxPropertyDescriptor target;
private AxHost owner;
private OleStrCAMarshaler nameMarshaller;
private Int32CAMarshaler valueMarshaller;
private bool arraysFetched;
public AxPerPropertyBrowsingEnum(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;
}
///
/// Retrieve a copy of the value array
///
public override object[] Values {
get {
EnsureArrays();
return base.Values;
}
}
///
/// Retrieve a copy of the nme array.
///
public override string[] Names {
get {
EnsureArrays();
return base.Names;
}
}
// ensure that we have processed the caStructs into arrays
// of values and strings
//
private void EnsureArrays() {
if (this.arraysFetched) {
return;
}
this.arraysFetched = true;
try {
// marshal the items.
object[] nameItems = nameMarshaller.Items;
object[] cookieItems= valueMarshaller.Items;
NativeMethods.IPerPropertyBrowsing ppb = (NativeMethods.IPerPropertyBrowsing)owner.GetPerPropertyBrowsing();
int itemCount = 0;
Debug.Assert(cookieItems != null && nameItems != null, "An item array is null");
if (nameItems.Length > 0) {
object[] valueItems = new object[cookieItems.Length];
NativeMethods.VARIANT var = new NativeMethods.VARIANT();
int cookie;
Debug.Assert(cookieItems.Length == nameItems.Length, "Got uneven names and cookies");
// for each name item, we ask the object for it's corresponding value.
//
for (int i = 0; i < nameItems.Length; i++) {
cookie = (int)cookieItems[i];
if (nameItems[i] == null || !(nameItems[i] is string)) {
Debug.Fail("Bad IPerPropertyBrowsing item [" + i.ToString(CultureInfo.InvariantCulture) + "], name=" + (nameItems == null ? "(unknown)" : nameItems[i].ToString()));
continue;
}
var.vt = (short)NativeMethods.tagVT.VT_EMPTY;
int hr = ppb.GetPredefinedValue(target.Dispid, cookie, var);
if (hr == NativeMethods.S_OK && var.vt != (short)NativeMethods.tagVT.VT_EMPTY) {
valueItems[i] = var.ToObject();
}
var.Clear();
itemCount++;
}
// pass this data down to the base Com2Enum object...
if (itemCount > 0) {
string[] strings = new string[itemCount];
Array.Copy(nameItems, 0, strings, 0, itemCount);
base.PopulateArrays(strings, valueItems);
}
}
}
catch (Exception ex) {
Debug.Fail("Failed to build IPerPropertyBrowsing editor. " + ex.GetType().Name + ", " + ex.Message);
}
}
internal void RefreshArrays( OleStrCAMarshaler names, Int32CAMarshaler values) {
this.nameMarshaller = names;
this.valueMarshaller = values;
this.arraysFetched = false;
}
#if false
// FxCop: Currently not used
private string GetDisplayString(int dispid, ref bool success) {
NativeMethods.IPerPropertyBrowsing ppb = (NativeMethods.IPerPropertyBrowsing)owner.GetPerPropertyBrowsing();
string[] strVal = new string[1];
int hr = ppb.GetDisplayString(dispid, strVal);
if (hr == NativeMethods.S_OK) {
success = (strVal[0] != null);
//Debug.Assert(success, "IPerPropertyBrowsing::GetDisplayString returned NULL and S_OK -- this is not a valid state. This component does not property implement IPerPropertyBrowsing. (component class=" + TypeDescriptor.GetClassName(ppb) + ")");
return strVal[0];
}
else {
success = false;
}
return null;
}
#endif
protected override void PopulateArrays(string[] names, object[] values) {
// we call base.PopulateArrays directly when we actually want to do this.
}
public override object FromString(string s) {
EnsureArrays();
return base.FromString(s);
}
public override string ToString(object v) {
EnsureArrays();
return base.ToString(v);
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms {
using Microsoft.Win32;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Configuration.Assemblies;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Design;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Remoting;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Windows.Forms.ComponentModel;
using System.Windows.Forms.ComponentModel.Com2Interop;
using System.Windows.Forms.Design;
///
///
///
/// Wraps ActiveX controls and exposes them as
/// fully featured windows forms controls.
///
///
[
ComVisible(true),
ClassInterface(ClassInterfaceType.AutoDispatch),
ToolboxItem(false),
DesignTimeVisible(false),
DefaultEvent("Enter"),
Designer("System.Windows.Forms.Design.AxHostDesigner, " + AssemblyRef.SystemDesign),
PermissionSet(SecurityAction.LinkDemand, Name="FullTrust"),
PermissionSet(SecurityAction.InheritanceDemand, Name="FullTrust")
]
public abstract class AxHost : Control, ISupportInitialize, ICustomTypeDescriptor {
private static TraceSwitch AxHTraceSwitch = new TraceSwitch("AxHTrace", "ActiveX handle tracing");
private static TraceSwitch AxPropTraceSwitch = new TraceSwitch("AxPropTrace", "ActiveX property tracing");
private static TraceSwitch AxHostSwitch = new TraceSwitch("AxHost", "ActiveX host creation");
private static BooleanSwitch AxIgnoreTMSwitch = new BooleanSwitch("AxIgnoreTM", "ActiveX switch to ignore thread models");
private static BooleanSwitch AxAlwaysSaveSwitch = new BooleanSwitch("AxAlwaysSave", "ActiveX to save all controls regardless of their IsDirty function return value");
///
/// Flags which may be passed to the AxHost constructor
///
[SuppressMessage("Microsoft.Performance", "CA1812:AvoidUninstantiatedInternalClasses")]
internal class AxFlags {
///
/// Indicates that the context menu for the control should not contain an
/// "Edit" verb unless the activeX controls itself decides to proffer it.
/// By default, all wrapped activeX controls will contain an edit verb.
///
internal const int PreventEditMode = 0x1;
///
/// Indicated that the context menu for the control should contain
/// a "Properties..." verb which may be used to show the property
/// pages for the control. Note that even if this flag is
/// specified, the verb will not appear unless the control
/// proffers a set of property pages.
/// [Since most activeX controls alreay have their own properties verb
/// on the context menu, the default is not to include one specified by
/// this flag.]
///
internal const int IncludePropertiesVerb = 0x2;
///
///
///
/// Creates a new instance of a control which wraps an activeX control given by the
/// clsid parameter and flags of 0.
///
protected AxHost(string clsid) : this(clsid, 0) {
}
///
/// Creates a new instance of a control which wraps an activeX control given by the
/// clsid and flags parameters.
///
[PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
protected AxHost(string clsid, int flags) : base() {
if (Application.OleRequired() != ApartmentState.STA) {
throw new ThreadStateException(SR.GetString(SR.AXMTAThread, clsid));
}
this.oleSite = new OleInterfaces(this);
this.selectionChangeHandler = new EventHandler(this.OnNewSelection);
this.clsid = new Guid(clsid);
this.flags = flags;
this.axState[assignUniqueID] = !this.GetType().GUID.Equals(comctlImageCombo_Clsid);
this.axState[needLicenseKey] = true;
this.axState[rejectSelection] = true;
isMaskEdit = this.clsid.Equals(AxHost.maskEdit_Clsid);
this.onContainerVisibleChanged = new EventHandler(this.OnContainerVisibleChanged);
}
private bool CanUIActivate {
get {
return IsUserMode() || editMode != EDITM_NONE;
}
}
///
/// Returns the CreateParams used to create the handle for this control.
///
protected override CreateParams CreateParams {
get {
CreateParams cp = base.CreateParams;
if (axState[fOwnWindow] && IsUserMode()) {
cp.Style = cp.Style & (~NativeMethods.WS_VISIBLE);
}
return cp;
}
}
private bool GetAxState(int mask) {
return this.axState[mask];
}
private void SetAxState(int mask, bool value) {
this.axState[mask] = value;
}
///
/// AxHost will call this when it is ready to create the underlying ActiveX object.
/// Wrappers will override this and cast the pointer obtained by calling getOcx() to
/// their own interfaces. getOcx() should not usually be called before this function.
/// Note: calling begin will result in a call to this function.
///
protected virtual void AttachInterfaces() {
}
private void RealizeStyles() {
SetStyle(ControlStyles.UserPaint, false);
int bits = 0;
int hr = GetOleObject().GetMiscStatus(NativeMethods.ActiveX.DVASPECT_CONTENT, out bits);
if (!NativeMethods.Failed(hr)) {
miscStatusBits = bits;
ParseMiscBits(miscStatusBits);
}
}
// Control overrides:
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Color BackColor {
get {
return base.BackColor;
}
set {
base.BackColor = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override Image BackgroundImage {
get {
return base.BackgroundImage;
}
set {
base.BackgroundImage = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override ImageLayout BackgroundImageLayout {
get {
return base.BackgroundImageLayout;
}
set {
base.BackgroundImageLayout = value;
}
}
///
/// Hide ImeMode: it doesn't make sense for this control
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
new public ImeMode ImeMode
{
get
{
return base.ImeMode;
}
set
{
base.ImeMode = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler MouseClick {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseClick"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler MouseDoubleClick {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseDoubleClick"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Cursor Cursor {
get {
return base.Cursor;
}
set {
base.Cursor = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override ContextMenu ContextMenu {
get {
return base.ContextMenu;
}
set {
base.ContextMenu = value;
}
}
///
/// Deriving classes can override this to configure a default size for their control.
/// This is more efficient than setting the size in the control's constructor.
///
protected override Size DefaultSize {
get {
return new Size(75, 23);
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public virtual new bool Enabled {
get {
return base.Enabled;
}
set {
base.Enabled = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Font Font {
get {
return base.Font;
}
set {
base.Font = value;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override Color ForeColor {
get {
return base.ForeColor;
}
set {
base.ForeColor = value;
}
}
///
/// [To be supplied.]
///
[
Browsable(false),
EditorBrowsable(EditorBrowsableState.Never),
Localizable(true)
]
public new virtual bool RightToLeft {
get {
RightToLeft rtol = base.RightToLeft;
return rtol == System.Windows.Forms.RightToLeft.Yes;
}
set {
base.RightToLeft = (value) ? System.Windows.Forms.RightToLeft.Yes : System.Windows.Forms.RightToLeft.No;
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public override string Text {
get {
return text;
}
set {
text = value;
}
}
internal override bool CanAccessProperties {
get {
int ocState = GetOcState();
return(axState[fOwnWindow] &&
(ocState > OC_RUNNING || (IsUserMode() && ocState >= OC_RUNNING)) ||
ocState >= OC_INPLACE);
}
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void BeginInit() {
}
///
/// Signals the object that loading of all peer components and property
/// sets are complete.
/// It should be possible to invoke any property get or set after calling this method.
/// Note that a sideeffect of this method is the creation of the parent control's
/// handle, therefore, this control must be parented before begin is called
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void EndInit() {
if (ParentInternal != null) {
ParentInternal.CreateControl(true);
ContainerControl f = ContainingControl;
if (f != null) {
f.VisibleChanged += this.onContainerVisibleChanged;
}
}
}
private void OnContainerVisibleChanged(object sender, EventArgs e) {
ContainerControl f = ContainingControl;
if (f != null) {
if (f.Visible && Visible && !axState[fOwnWindow]) {
MakeVisibleWithShow();
}
else if (!f.Visible && Visible && IsHandleCreated && GetOcState() >= OC_INPLACE) {
HideAxControl();
}
else if (f.Visible && !GetState(STATE_VISIBLE) && IsHandleCreated && GetOcState() >= OC_INPLACE) {
HideAxControl();
}
}
}
//
///
/// Determines if the control is in edit mode.
///
[ Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public bool EditMode {
get {
return editMode != EDITM_NONE;
}
}
///
/// Determines if this control has an about box.
///
[ Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public bool HasAboutBox {
get {
return aboutBoxDelegate != null;
}
}
private int NoComponentChangeEvents {
get {
return noComponentChange;
}
set {
noComponentChange = value;
}
}
//
///
/// Shows the about box for this control.
///
public void ShowAboutBox() {
if (aboutBoxDelegate != null) {
aboutBoxDelegate();
}
}
//
///
/// Retrieves the OCX control flags.
///
#if false
// FxCop: Currently not used
[ Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
private int OcxFlags {
get {
return flags;
}
}
#endif
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler BackColorChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "BackColorChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler BackgroundImageChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "BackgroundImageChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler BackgroundImageLayoutChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "BackgroundImageLayoutChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler BindingContextChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "BindingContextChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler ContextMenuChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "ContextMenuChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler CursorChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "CursorChanged"));
}
remove {
}
}
///
/// Occurs when the control is enabled.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler EnabledChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "EnabledChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler FontChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "FontChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler ForeColorChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "ForeColorChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler RightToLeftChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "RightToLeftChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler TextChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "TextChanged"));
}
remove {
}
}
///
/// Occurs when the control is clicked.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler Click {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "Click"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event DragEventHandler DragDrop {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "DragDrop"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event DragEventHandler DragEnter {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "DragEnter"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event DragEventHandler DragOver {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "DragOver"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler DragLeave {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "DragLeave"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event GiveFeedbackEventHandler GiveFeedback {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "GiveFeedback"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event HelpEventHandler HelpRequested {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "HelpRequested"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event PaintEventHandler Paint {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "Paint"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event QueryContinueDragEventHandler QueryContinueDrag {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "QueryContinueDrag"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event QueryAccessibilityHelpEventHandler QueryAccessibilityHelp {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "QueryAccessibilityHelp"));
}
remove {
}
}
///
/// Occurs when the control is double clicked.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler DoubleClick {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "DoubleClick"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler ImeModeChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "ImeModeChanged"));
}
remove {
}
}
///
/// Occurs when a key is pressed down while the control has focus.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event KeyEventHandler KeyDown {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "KeyDown"));
}
remove {
}
}
///
/// Occurs when a key is pressed while the control has focus.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event KeyPressEventHandler KeyPress {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "KeyPress"));
}
remove {
}
}
///
/// Occurs when a key is released while the control has focus.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event KeyEventHandler KeyUp {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "KeyUp"));
}
remove {
}
}
///
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event LayoutEventHandler Layout {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "Layout"));
}
remove {
}
}
///
/// Occurs when the mouse pointer is over the control and a mouse button is
/// pressed.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event MouseEventHandler MouseDown {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseDown"));
}
remove {
}
}
///
/// Occurs when the mouse pointer enters the AxHost.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler MouseEnter {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseEnter"));
}
remove {
}
}
///
/// Occurs when the mouse pointer leaves the AxHost.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler MouseLeave {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseLeave"));
}
remove {
}
}
///
/// Occurs when the mouse pointer hovers over the contro.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler MouseHover {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseHover"));
}
remove {
}
}
///
/// Occurs when the mouse pointer is moved over the AxHost.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event MouseEventHandler MouseMove {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseMove"));
}
remove {
}
}
///
/// Occurs when the mouse pointer is over the control and a mouse button is released.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event MouseEventHandler MouseUp {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseUp"));
}
remove {
}
}
///
/// Occurs when the mouse wheel moves while the control has focus.
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event MouseEventHandler MouseWheel {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "MouseWheel"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event UICuesEventHandler ChangeUICues {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "ChangeUICues"));
}
remove {
}
}
///
/// [To be supplied.]
///
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
new public event EventHandler StyleChanged {
add {
throw new NotSupportedException(SR.GetString(SR.AXAddInvalidEvent, "StyleChanged"));
}
remove {
}
}
///
/// [To be supplied.]
///
protected override void OnFontChanged(EventArgs e) {
base.OnFontChanged(e);
AmbientChanged(NativeMethods.ActiveX.DISPID_AMBIENT_FONT);
}
///
/// [To be supplied.]
///
protected override void OnForeColorChanged(EventArgs e) {
base.OnForeColorChanged(e);
AmbientChanged(NativeMethods.ActiveX.DISPID_AMBIENT_FORECOLOR);
}
///
/// [To be supplied.]
///
protected override void OnBackColorChanged(EventArgs e) {
base.OnBackColorChanged(e);
AmbientChanged(NativeMethods.ActiveX.DISPID_AMBIENT_BACKCOLOR);
}
private void AmbientChanged(int dispid) {
if (GetOcx() != null) {
try {
Invalidate();
GetOleControl().OnAmbientPropertyChange(dispid);
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
}
}
private bool OwnWindow() {
return axState[fOwnWindow] || axState[fFakingWindow];
}
private IntPtr GetHandleNoCreate() {
if (IsHandleCreated) return Handle;
return IntPtr.Zero;
}
private ISelectionService GetSelectionService() {
return GetSelectionService(this);
}
private static ISelectionService GetSelectionService(Control ctl) {
ISite site = ctl.Site;
if (site != null) {
Object o = site.GetService(typeof(ISelectionService));
Debug.Assert(o == null || o is ISelectionService, "service must implement ISelectionService");
//Note: if o is null, we want to return null anyway. Happy day.
return o as ISelectionService;
}
return null;
}
private void AddSelectionHandler() {
if (axState[addedSelectionHandler]) return;
ISelectionService iss = GetSelectionService();
if (iss != null) {
iss.SelectionChanging += selectionChangeHandler;
}
axState[addedSelectionHandler] = true;
}
private void OnComponentRename(object sender, ComponentRenameEventArgs e)
{
// When we're notified of a rename, see if this is the componnent that is being
// renamed.
//
if (e.Component == this)
{
// if it is, call DISPID_AMBIENT_DISPLAYNAME directly on the
// control itself.
//
UnsafeNativeMethods.IOleControl oleCtl = this.GetOcx() as UnsafeNativeMethods.IOleControl;
if (oleCtl != null)
{
oleCtl.OnAmbientPropertyChange(NativeMethods.ActiveX.DISPID_AMBIENT_DISPLAYNAME);
}
}
}
private bool RemoveSelectionHandler() {
if (!axState[addedSelectionHandler]) return false;
ISelectionService iss = GetSelectionService();
if (iss != null) {
iss.SelectionChanging -= selectionChangeHandler;
}
axState[addedSelectionHandler] = false;
return true;
}
private void SyncRenameNotification(bool hook) {
if (DesignMode && hook != axState[renameEventHooked])
{
// if we're in design mode, listen to the following events from the component change service
//
IComponentChangeService changeService = (IComponentChangeService)GetService(typeof(IComponentChangeService));
if (changeService != null)
{
if (hook) {
changeService.ComponentRename += new ComponentRenameEventHandler(OnComponentRename);
}
else {
changeService.ComponentRename -= new ComponentRenameEventHandler(OnComponentRename);
}
axState[renameEventHooked] = hook;
}
}
}
///
/// Sets the site of this component. A non-null value indicates that the
/// component has been added to a container, and a null value indicates that
/// the component is being removed from a container.
///
public override ISite Site {
set {
// If we are disposed then just return.
if (axState[disposed])
{
return;
}
bool reAddHandler = RemoveSelectionHandler();
bool olduMode = IsUserMode();
// clear the old hook
//
SyncRenameNotification(false);
base.Site = value;
bool newuMode = IsUserMode();
if (!newuMode) GetOcxCreate();
if (reAddHandler) AddSelectionHandler();
SyncRenameNotification(value != null);
// For inherited forms we create the OCX first in User mode
// and then we get sited. At that time, we have to re-activate
// the OCX by transitioning down to and up to the current state.
//
if (value != null && !newuMode && olduMode != newuMode && GetOcState() > OC_LOADED) {
TransitionDownTo(OC_LOADED);
TransitionUpTo(OC_INPLACE);
ContainerControl f = ContainingControl;
if (f != null && f.Visible && Visible)
MakeVisibleWithShow();
}
if (olduMode != newuMode && !IsHandleCreated && !axState[disposed]) {
if (GetOcx() != null) {
RealizeStyles();
}
}
if (!newuMode) {
//SetupClass_Info(this);
}
}
}
///
/// Raises the
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected override void OnLostFocus(EventArgs e) {
// ASURT 93669
// Office WebControl and MS DDS control create a child window that gains
// focus in order to handle keyboard input. Since, UIDeactivate() could
// destroy that window, these controls will crash trying to process WM_CHAR.
// We now check to see if we are losing focus to a child, and if so, not call
// UIDeactivate().
//
bool uiDeactivate = (GetHandleNoCreate() != hwndFocus);
if (uiDeactivate && IsHandleCreated) {
uiDeactivate = !UnsafeNativeMethods.IsChild(new HandleRef(this, GetHandleNoCreate()), new HandleRef(null, hwndFocus));
}
base.OnLostFocus(e);
if (uiDeactivate) {
UiDeactivate();
}
}
private void OnNewSelection(Object sender, EventArgs e) {
if (IsUserMode()) return;
ISelectionService iss = GetSelectionService();
// What we care about:
// if we are uiactive and we lose selection, then we need to uideactivate ourselves...
if (iss != null) {
if (GetOcState() >= OC_UIACTIVE && !iss.GetComponentSelected(this)) {
// need to deactivate...
int hr = UiDeactivate();
if (NativeMethods.Failed(hr)) {
// not much we can do here...
Debug.Fail("Failed to UiDeactivate: " + hr.ToString(CultureInfo.InvariantCulture));
}
}
if (!iss.GetComponentSelected(this)) {
if (editMode != EDITM_NONE) {
GetParentContainer().OnExitEditMode(this);
editMode = EDITM_NONE;
}
// need to exit edit mode...
SetSelectionStyle(1);
RemoveSelectionHandler();
}
else {
// The AX Host designer will offer an extender property called "SelectionStyle"
//
PropertyDescriptor prop = TypeDescriptor.GetProperties(this)["SelectionStyle"];
if (prop != null && prop.PropertyType == typeof(int)) {
int curSelectionStyle = (int)prop.GetValue(this);
if (curSelectionStyle != this.selectionStyle) {
prop.SetValue(this, selectionStyle);
}
}
}
}
}
//DrawToBitmap doesn't work for this control, so we should hide it. We'll
//still call base so that this has a chance to work if it can.
[EditorBrowsable(EditorBrowsableState.Never)]
new public void DrawToBitmap(Bitmap bitmap, Rectangle targetBounds)
{
base.DrawToBitmap(bitmap, targetBounds);
}
///
/// Creates a handle for this control. This method is called by the .NET framework, this should
/// not be called.
///
protected override void CreateHandle() {
if (!IsHandleCreated) {
TransitionUpTo(OC_RUNNING);
if (!axState[fOwnWindow]) {
if (axState[fNeedOwnWindow]) {
Debug.Assert(!Visible, "if we were visible we would not be needing a fake window...");
axState[fNeedOwnWindow] = false;
axState[fFakingWindow] = true;
base.CreateHandle();
// note that we do not need to attach the handle because the work usually done in there
// will be done in Control's wndProc on WM_CREATE...
}
else {
TransitionUpTo(OC_INPLACE);
// it is possible that we were hidden while in place activating, in which case we don't
// really have a handle now because the act of hiding could have destroyed it
// so, just call ourselves again recursively, and if we dont't have a handle, we will
// just take the "axState[fNeedOwnWindow]" path above...
if (axState[fNeedOwnWindow]) {
Debug.Assert(!IsHandleCreated, "if we need a fake window, we can't have a real one");
CreateHandle();
return;
}
}
}
else {
SetState(STATE_VISIBLE, false);
base.CreateHandle();
}
GetParentContainer().ControlCreated(this);
}
}
private NativeMethods.COMRECT GetClipRect(NativeMethods.COMRECT clipRect) {
if (clipRect != null) {
FillInRect(clipRect, new Rectangle(0, 0, 32000, 32000));
}
return clipRect;
}
private static int SetupLogPixels(bool force) {
if (logPixelsX == -1 || force) {
IntPtr hDC = UnsafeNativeMethods.GetDC(NativeMethods.NullHandleRef);
if (hDC == IntPtr.Zero)
return NativeMethods.E_FAIL;
logPixelsX = UnsafeNativeMethods.GetDeviceCaps(new HandleRef(null, hDC), NativeMethods.LOGPIXELSX);
logPixelsY = UnsafeNativeMethods.GetDeviceCaps(new HandleRef(null, hDC), NativeMethods.LOGPIXELSY);
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "log pixels are: "+logPixelsX.ToString(CultureInfo.InvariantCulture)+" "+logPixelsY.ToString(CultureInfo.InvariantCulture));
UnsafeNativeMethods.ReleaseDC(NativeMethods.NullHandleRef, new HandleRef(null, hDC));
}
return NativeMethods.S_OK;
}
private void HiMetric2Pixel(NativeMethods.tagSIZEL sz, NativeMethods.tagSIZEL szout) {
NativeMethods._POINTL phm = new NativeMethods._POINTL();
phm.x = sz.cx;
phm.y = sz.cy;
NativeMethods.tagPOINTF pcont = new NativeMethods.tagPOINTF();
((UnsafeNativeMethods.IOleControlSite)oleSite).TransformCoords(phm, pcont, NativeMethods.ActiveX.XFORMCOORDS_SIZE | NativeMethods.ActiveX.XFORMCOORDS_HIMETRICTOCONTAINER);
szout.cx = (int)pcont.x;
szout.cy = (int)pcont.y;
}
private void Pixel2hiMetric(NativeMethods.tagSIZEL sz, NativeMethods.tagSIZEL szout) {
NativeMethods.tagPOINTF pcont = new NativeMethods.tagPOINTF();
pcont.x = (float) sz.cx;
pcont.y = (float) sz.cy;
NativeMethods._POINTL phm = new NativeMethods._POINTL();
((UnsafeNativeMethods.IOleControlSite)oleSite).TransformCoords(phm, pcont, NativeMethods.ActiveX.XFORMCOORDS_SIZE | NativeMethods.ActiveX.XFORMCOORDS_CONTAINERTOHIMETRIC);
szout.cx = phm.x;
szout.cy = phm.y;
}
private static int Pixel2Twip(int v, bool xDirection) {
SetupLogPixels(false);
int logP = xDirection ? logPixelsX : logPixelsY;
return(int) ((((double)v) / logP) * 72.0 * 20.0);
}
private static int Twip2Pixel(double v, bool xDirection) {
SetupLogPixels(false);
int logP = xDirection ? logPixelsX : logPixelsY;
return(int) (((v / 20.0) / 72.0) * logP);
}
private static int Twip2Pixel(int v, bool xDirection) {
SetupLogPixels(false);
int logP = xDirection ? logPixelsX : logPixelsY;
return(int) (((((double) v) / 20.0) / 72.0) * logP);
}
private Size SetExtent(int width, int height) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "setting extent to "+width.ToString(CultureInfo.InvariantCulture)+" "+height.ToString(CultureInfo.InvariantCulture));
NativeMethods.tagSIZEL sz = new NativeMethods.tagSIZEL();
sz.cx = width;
sz.cy = height;
bool resetExtents = !IsUserMode();
try {
Pixel2hiMetric(sz, sz);
GetOleObject().SetExtent(NativeMethods.ActiveX.DVASPECT_CONTENT, sz);
}
catch (COMException) {
resetExtents = true;
}
if (resetExtents) {
GetOleObject().GetExtent(NativeMethods.ActiveX.DVASPECT_CONTENT, sz);
try {
GetOleObject().SetExtent(NativeMethods.ActiveX.DVASPECT_CONTENT, sz);
}
catch (COMException e) {
Debug.Fail(e.ToString());
}
}
return GetExtent();
}
private Size GetExtent() {
NativeMethods.tagSIZEL sz = new NativeMethods.tagSIZEL();
GetOleObject().GetExtent(NativeMethods.ActiveX.DVASPECT_CONTENT, sz);
HiMetric2Pixel(sz, sz);
return new Size(sz.cx, sz.cy);
}
///
/// ActiveX controls scale themselves, so GetScaledBounds simply returns their
/// original unscaled bounds.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected override Rectangle GetScaledBounds(Rectangle bounds, SizeF factor, BoundsSpecified specified) {
return bounds;
}
private void SetObjectRects(Rectangle bounds) {
if (GetOcState() < OC_INPLACE) return;
GetInPlaceObject().SetObjectRects(FillInRect(new NativeMethods.COMRECT(), bounds), GetClipRect(new NativeMethods.COMRECT()));
}
///
/// Performs the work of setting the bounds of this control.
/// User code should usually not call this function.
///
protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) {
// We have already been in this Code so please avoid re-entering this CODE PATH or else the
// IOleObject will "give a Catastrophic error" in SetObjectRects( ).
// Please refer : VsWhidbey 341212.
if (GetAxState(AxHost.handlePosRectChanged))
return;
axState[handlePosRectChanged] = true;
// Provide control with an opportunity to apply self imposed constraints on its size.
Size adjustedSize = ApplySizeConstraints(width, height);
width = adjustedSize.Width;
height = adjustedSize.Height;
try {
if (axState[fFakingWindow]) {
base.SetBoundsCore(x, y, width, height, specified);
return;
}
Rectangle oldBounds = Bounds;
if (oldBounds.X == x && oldBounds.Y == y && oldBounds.Width == width &&
oldBounds.Height == height) {
return;
}
if (!IsHandleCreated) {
UpdateBounds(x, y, width, height);
return;
}
if (GetOcState() > OC_RUNNING) {
CheckSubclassing();
if (width != oldBounds.Width || height != oldBounds.Height) {
Size p = SetExtent(width, height);
width = p.Width;
height = p.Height;
}
}
if (axState[manualUpdate]) {
SetObjectRects(new Rectangle(x, y, width, height));
CheckSubclassing();
UpdateBounds();
}
else {
SetObjectRects(new Rectangle(x, y, width, height));
base.SetBoundsCore(x, y, width, height, specified);
Invalidate();
}
}
finally {
axState[handlePosRectChanged] = false;
}
}
private bool CheckSubclassing() {
if (!IsHandleCreated || wndprocAddr == IntPtr.Zero) return true;
IntPtr handle = Handle;
IntPtr currentWndproc = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, handle), NativeMethods.GWL_WNDPROC);
if (currentWndproc == wndprocAddr) return true;
if ((int)SendMessage(REGMSG_MSG, 0, 0) == REGMSG_RETVAL) {
wndprocAddr = currentWndproc;
return true;
}
// yikes, we were resubclassed...
Debug.WriteLineIf(AxHostSwitch.TraceVerbose, "The horrible control subclassed itself w/o calling the old wndproc...");
// we need to resubclass outselves now...
Debug.Assert(!OwnWindow(), "why are we here if we own our window?");
this.WindowReleaseHandle();
UnsafeNativeMethods.SetWindowLong(new HandleRef(this, handle), NativeMethods.GWL_WNDPROC, new HandleRef(this, currentWndproc));
this.WindowAssignHandle(handle, axState[assignUniqueID]);
InformOfNewHandle();
axState[manualUpdate] = true;
return false;
}
///
/// Destroys the handle associated with this control.
/// User code should in general not call this function.
///
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
// security review: this is a breaking change, but should it be fixed?
protected override void DestroyHandle() {
if (axState[fOwnWindow]) {
base.DestroyHandle();
}
else {
if (IsHandleCreated) {
TransitionDownTo(OC_RUNNING);
}
}
}
#if false
// FxCop: Currently not used
private void TransitionTo(int state) {
if (state > GetOcState()) {
TransitionUpTo(state);
}
else if (state < GetOcState()) {
TransitionDownTo(state);
}
}
#endif
private void TransitionDownTo(int state) {
if (axState[inTransition]) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Recursively entering TransitionDownTo...");
return;
}
try {
axState[inTransition] = true;
while (state < GetOcState()) {
switch (GetOcState()) {
case OC_OPEN:
Debug.Fail("how did we ever get into the open state?");
SetOcState(OC_UIACTIVE);
break;
case OC_UIACTIVE:
int hr = UiDeactivate();
Debug.Assert(NativeMethods.Succeeded(hr), "Failed in UiDeactivate: " + hr.ToString(CultureInfo.InvariantCulture));
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose && GetOcState() == OC_INPLACE, "failed transition");
SetOcState(OC_INPLACE);
break;
case OC_INPLACE:
if (axState[fFakingWindow]) {
DestroyFakeWindow();
SetOcState(OC_RUNNING);
}
else {
InPlaceDeactivate();
}
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose && GetOcState() == OC_RUNNING, "failed transition");
SetOcState(OC_RUNNING);
break;
case OC_RUNNING:
StopEvents();
DisposeAxControl();
Debug.Assert(GetOcState() == OC_LOADED," failed transition");
SetOcState(OC_LOADED);
break;
case OC_LOADED:
ReleaseAxControl();
Debug.Assert(GetOcState() == OC_PASSIVE," failed transition");
SetOcState(OC_PASSIVE);
break;
default:
Debug.Fail("bad state");
SetOcState(GetOcState() - 1);
break;
}
}
}
finally {
axState[inTransition] = false;
}
}
private void TransitionUpTo(int state) {
if (axState[inTransition]) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Recursively entering TransitionUpTo...");
return;
}
try {
axState[inTransition] = true;
while (state > GetOcState()) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Transitioning up from: " + GetOcState().ToString(CultureInfo.InvariantCulture) + " to: " + state.ToString(CultureInfo.InvariantCulture));
switch (GetOcState()) {
case OC_PASSIVE:
axState[disposed] = false;
GetOcxCreate();
Debug.Assert(GetOcState() == OC_LOADED, " failed transition");
SetOcState(OC_LOADED);
break;
case OC_LOADED:
ActivateAxControl();
Debug.Assert(GetOcState() == OC_RUNNING, " failed transition");
SetOcState(OC_RUNNING);
if (IsUserMode()) {
// start the events flowing!
//createSink();
StartEvents();
}
break;
case OC_RUNNING:
axState[ownDisposing] = false;
Debug.Assert(!axState[fOwnWindow], "If we are invis at runtime, we should never be going beynd OC_RUNNING");
if (!axState[fOwnWindow]) {
InPlaceActivate();
if (!Visible && ContainingControl != null && ContainingControl.Visible) {
HideAxControl();
}
else {
// if we do this in both codepaths, then we will force handle creation of the fake window
// even if we don't need it...
// This optimization will break, however, if:
// a) the hWnd goes away on a OLEIVERB_HIDE and
// b) this is a simple frame control
// However, if you satisfy both of these conditions then you must be REALLY
// brain dead and you don't deserve to work anyway...
CreateControl(true);
// if our default size is wrong for the control, let's resize ourselves...
// Note: some controls haven't updated their extents at this time
// (even though they got it from the DoVerb call and
// also from GetWindowContext) so we don't poke in a new value.
// The reason to do this at design time is that that's the only way we
// can find out if the control has a default which we have to obey.
if (!IsUserMode() && !axState[ocxStateSet]) {
Size p = GetExtent();
Rectangle b = Bounds;
if ((b.Size.Equals(DefaultSize)) && (!b.Size.Equals(p))) {
b.Width = p.Width;
b.Height = p.Height;
Bounds = b;
}
}
}
}
//Debug.Assert(GetOcState() == OC_INPLACE, " failed transition");
if (GetOcState() < OC_INPLACE) {
SetOcState(OC_INPLACE);
}
OnInPlaceActive();
break;
case OC_INPLACE:
DoVerb(OLEIVERB_SHOW);
Debug.Assert(GetOcState() == OC_UIACTIVE, " failed transition");
SetOcState(OC_UIACTIVE);
break;
default:
Debug.Fail("bad state");
SetOcState(GetOcState() + 1);
break;
}
}
}
finally {
axState[inTransition] = false;
}
}
///
/// [To be supplied.]
///
///
/// [To be supplied.]
///
protected override void SetVisibleCore(bool value) {
if (GetState(STATE_VISIBLE) != value) {
bool oldVisible = Visible;
if ((IsHandleCreated || value) && ParentInternal != null && ParentInternal.Created) {
if (!axState[fOwnWindow]) {
TransitionUpTo(OC_RUNNING);
if (value) {
if (axState[fFakingWindow]) {
// first we need to destroy the fake window...
DestroyFakeWindow();
}
// We want to avoid using SHOW since that may uiactivate us, and we don't
// want that...
if (!IsHandleCreated) {
// So, if we don't have a handle, we just try to create it and hope that this will make
// us appear...
try {
SetExtent(Width, Height);
InPlaceActivate();
CreateControl(true);
}
catch {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Could not make ctl visible by using INPLACE. Will try SHOW");
MakeVisibleWithShow();
}
}
else {
// if, otoh, we had a handle to begin with, we need to use show since INPLACE is just
// a noop...
MakeVisibleWithShow();
}
}
else {
Debug.Assert(!axState[fFakingWindow], "if we were visible, we could not have had a fake window...");
HideAxControl();
}
}
}
if (!value) {
axState[fNeedOwnWindow] = false;
}
if (!axState[fOwnWindow]) {
SetState(STATE_VISIBLE, value);
if (Visible != oldVisible)
OnVisibleChanged(EventArgs.Empty);
}
}
}
private void MakeVisibleWithShow() {
ContainerControl f = ContainingControl;
Control ctl = f == null ? null : f.ActiveControl;
try {
DoVerb(OLEIVERB_SHOW);
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw new TargetInvocationException(SR.GetString(SR.AXNohWnd,GetType().Name), t);
}
EnsureWindowPresent();
CreateControl(true);
if (f != null && f.ActiveControl != ctl) {
f.ActiveControl = ctl;
}
}
private void HideAxControl() {
Debug.Assert(!axState[fOwnWindow], "can't own our window when hiding");
Debug.Assert(IsHandleCreated, "gotta have a window to hide");
Debug.Assert(GetOcState() >= OC_INPLACE, "have to be in place in order to hide.");
DoVerb(OLEIVERB_HIDE);
if (GetOcState() < OC_INPLACE) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Naughty control inplace deactivated on a hide verb...");
Debug.Assert(!IsHandleCreated, "if we are inplace deactivated we should not have a window.");
// all we do here is set a flag saying that we need the window to be created if
// create handle is ever called...
axState[fNeedOwnWindow] = true;
// also, set the state to our "pretend oc_inplace state"
//
SetOcState(OC_INPLACE);
}
}
///
/// Determines if charCode is an input character that the control
/// wants. This method is called during window message pre-processing to
/// determine whether the given input character should be pre-processed or
/// sent directly to the control. If isInputChar returns true, the
/// given character is sent directly to the control. If isInputChar
/// returns false, the character is pre-processed and only sent to the
/// control if it is not consumed by the pre-processing phase. The
/// pre-processing of a character includes checking whether the character
/// is a mnemonic of another control.
///
[UIPermission(SecurityAction.InheritanceDemand, Window=UIPermissionWindow.AllWindows)]
protected override bool IsInputChar(char charCode) {
return true;
}
///
/// [To be supplied.]
///
[SuppressMessage("Microsoft.Security", "CA2114:MethodSecurityShouldBeASupersetOfType")]
[UIPermission(SecurityAction.LinkDemand, Window=UIPermissionWindow.AllWindows)]
protected override bool ProcessDialogKey(Keys keyData)
{
return ignoreDialogKeys ? false : base.ProcessDialogKey(keyData);
}
///
/// This method is called by the application's message loop to pre-process
/// input messages before they are dispatched. Possible values for the
/// msg.message field are WM_KEYDOWN, WM_SYSKEYDOWN, WM_CHAR, and WM_SYSCHAR.
/// If this method processes the message it must return true, in which case
/// the message loop will not dispatch the message.
/// This method should not be called directly by the user.
///
/// The keyboard processing of input keys to AxHost controls go in 3 steps inside AxHost.PreProcessMessage()
///
/// (1) Call the OCX's TranslateAccelarator. This may or may not call back into us using IOleControlSite::TranslateAccelarator()
///
/// (2) If the control completely processed this without calling us back:
/// -- If this returns S_OK, then it means that the control already processed this message and we return true,
/// forcing us to not do any more processing or dispatch the message.
/// -- If this returns S_FALSE, then it means that the control wants us to dispatch the message without doing any processing on our side.
///
/// (3) If the control completely processed this by calling us back:
/// -- If this returns S_OK, then it means that the control processed this message and we return true,
/// forcing us to not do any more processing or dispatch the message.
/// -- If this returns S_FALSE, then it means that the control did not process this message,
/// but we did, and so we should route it through our PreProcessMessage().
///
public override bool PreProcessMessage(ref Message msg) {
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "AxHost.PreProcessMessage " + msg.ToString());
if (IsUserMode()) {
if (axState[siteProcessedInputKey]) {
// In this case, the control called the us back through the IControlSite
// and giving us a chance to see if we want to process it. We in turn
// call the base implementation which normally would call the control's
// IsInputKey() or IsInputChar(). So, we short-circuit those to return false
// and only return true, if the container-chain wanted to process the keystroke
// (e.g. tab, accelarators etc.)
//
return base.PreProcessMessage(ref msg);
}
NativeMethods.MSG win32Message = new NativeMethods.MSG();
win32Message.message = msg.Msg;
win32Message.wParam = msg.WParam;
win32Message.lParam = msg.LParam;
win32Message.hwnd = msg.HWnd;
axState[siteProcessedInputKey] = false;
try {
UnsafeNativeMethods.IOleInPlaceActiveObject activeObj = GetInPlaceActiveObject();
if (activeObj != null)
{
int hr = activeObj.TranslateAccelerator(ref win32Message);
msg.Msg = win32Message.message;
msg.WParam = win32Message.wParam;
msg.LParam = win32Message.lParam;
msg.HWnd = win32Message.hwnd;
if (hr == NativeMethods.S_OK) {
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "\t Message translated by control to " + msg);
return true;
}
else if (hr == NativeMethods.S_FALSE) {
bool ret = false;
ignoreDialogKeys = true;
try {
ret = base.PreProcessMessage(ref msg);
}
finally {
ignoreDialogKeys = false;
}
return ret;
}
else if (axState[siteProcessedInputKey]) {
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "\t Message processed by site. Calling base.PreProcessMessage() " + msg);
return base.PreProcessMessage (ref msg);
}
else {
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "\t Message not processed by site. Returning false. " + msg);
return false;
}
}
}
finally {
axState[siteProcessedInputKey] = false;
}
}
return false;
}
///
/// Process a mnemonic character.
/// This is done by manufacturing a WM_SYSKEYDOWN message and passing it
/// to the ActiveX control.
///
[SuppressMessage("Microsoft.Security", "CA2114:MethodSecurityShouldBeASupersetOfType")]
[UIPermission(SecurityAction.LinkDemand, Window=UIPermissionWindow.AllWindows)]
protected internal override bool ProcessMnemonic(char charCode) {
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "In AxHost.ProcessMnemonic: " + (int)charCode);
if (CanSelect) {
try {
NativeMethods.tagCONTROLINFO ctlInfo = new NativeMethods.tagCONTROLINFO();
int hr = GetOleControl().GetControlInfo(ctlInfo);
if (NativeMethods.Failed(hr)) {
return false;
}
NativeMethods.MSG msg = new NativeMethods.MSG();
// Sadly, we don't have a message so we must fake one ourselves...
// A bit of ugliness here (a bit? more like a bucket...)
// The message we are faking is a WM_SYSKEYDOWN w/ the right alt key setting...
msg.hwnd = (ContainingControl == null) ? IntPtr.Zero : ContainingControl.Handle;
msg.message = NativeMethods.WM_SYSKEYDOWN;
msg.wParam = (IntPtr) Char.ToUpper(charCode, CultureInfo.CurrentCulture);
msg.lParam = (IntPtr) 0x20180001;
msg.time = SafeNativeMethods.GetTickCount();
NativeMethods.POINT p = new NativeMethods.POINT();
UnsafeNativeMethods.GetCursorPos(p);
msg.pt_x = p.x;
msg.pt_y = p.y;
if (SafeNativeMethods.IsAccelerator(new HandleRef(ctlInfo, ctlInfo.hAccel), ctlInfo.cAccel, ref msg, null)) {
GetOleControl().OnMnemonic(ref msg);
Debug.WriteLineIf(ControlKeyboardRouting.TraceVerbose, "\t Processed mnemonic " + msg);
Focus();
return true;
}
}
catch (Exception t) {
Debug.Fail("error in processMnemonic");
Debug.Fail(t.ToString());
return false;
}
}
return false;
}
// misc methods:
///
/// Sets the delegate which will be called when the user selects the "About..."
/// entry on the context menu.
///
protected void SetAboutBoxDelegate(AboutBoxDelegate d) {
aboutBoxDelegate += d;
}
///
/// Sets the persisted state of the control.
/// This should either be null, obtained from getOcxState, or
/// read from a resource. The value of this property will
/// be used after the control is created but before it is
/// shown.
/// Computes the persisted state of the underlying ActiveX control and
/// returns it in the encapsulated State object.
/// If the control has been modified since it was last saved to a
/// persisted state, it will be asked to save itself.
///
[
DefaultValue(null),
RefreshProperties(RefreshProperties.All),
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced)
]
public State OcxState {
get {
if (IsDirty() || ocxState == null) {
Debug.Assert(!axState[disposed], "we chould not be asking for the object when we are axState[disposed]...");
ocxState = CreateNewOcxState(ocxState);
}
return ocxState;
}
set {
axState[ocxStateSet] = true;
if (value == null) return;
if (storageType != STG_UNKNOWN && storageType != value.type) {
Debug.Fail("Trying to reload with a OcxState that is of a different type.");
throw new InvalidOperationException(SR.GetString(SR.AXOcxStateLoaded));
}
if (this.ocxState == value)
return;
this.ocxState = value;
if (this.ocxState != null) {
this.axState[manualUpdate] = ocxState._GetManualUpdate();
this.licenseKey = ocxState._GetLicenseKey();
}
else {
this.axState[manualUpdate] = false;
this.licenseKey = null;
}
if (this.ocxState != null && GetOcState() >= OC_RUNNING) {
DepersistControl();
}
}
}
private State CreateNewOcxState(State oldOcxState) {
NoComponentChangeEvents++;
try {
if (GetOcState() < OC_RUNNING) {
return null;
}
try {
PropertyBagStream propBag = null;
if (iPersistPropBag != null) {
propBag = new PropertyBagStream();
iPersistPropBag.Save(propBag, true, true);
}
MemoryStream ms = null;
switch (storageType) {
case STG_STREAM:
case STG_STREAMINIT:
ms = new MemoryStream();
if (storageType == STG_STREAM) {
iPersistStream.Save(new UnsafeNativeMethods.ComStreamFromDataStream(ms), true);
}
else {
iPersistStreamInit.Save(new UnsafeNativeMethods.ComStreamFromDataStream(ms), true);
}
break;
case STG_STORAGE:
Debug.Assert(oldOcxState != null, "we got to have an old state which holds out scribble storage...");
if (oldOcxState != null) return oldOcxState.RefreshStorage(iPersistStorage);
return null;
default:
Debug.Fail("unknown storage type.");
return null;
}
if (ms != null) {
return new State(ms, storageType, this, propBag);
}
else if (propBag != null) {
return new State(propBag);
}
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Could not create new OCX State: " + e.ToString());
}
}
finally {
NoComponentChangeEvents--;
}
return null;
}
///
/// Returns this control's logicaly containing form.
/// At design time this is always the form being designed.
/// At runtime it is either the form set with setContainingForm or,
/// by default, the parent form.
/// Sets the form which is the logical container of this control.
/// By default, the parent form performs that function. It is
/// however possible for another form higher in the parent chain
/// to serve in that role. The logical container of this
/// control determines the set of logical sibling control.
/// In general this property exists only to enable some speficic
/// behaviours of ActiveX controls and should in general not be set
/// by the user.
///
[
Browsable(false),
EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public ContainerControl ContainingControl {
get {
Debug.WriteLineIf(IntSecurity.SecurityDemand.TraceVerbose, "GetParent Demanded");
IntSecurity.GetParent.Demand();
if (containingControl == null) {
containingControl = FindContainerControlInternal();
}
return containingControl;
}
set {
containingControl = value;
}
}
///
/// Determines if the Text property needs to be persisted.
///
[EditorBrowsable(EditorBrowsableState.Never)]
internal override bool ShouldSerializeText() {
bool ret = false;
try {
ret = (Text.Length != 0);
}
catch (COMException) {
}
return ret;
}
///
/// Determines whether to persist the ContainingControl property.
///
[EditorBrowsable(EditorBrowsableState.Never)]
private bool ShouldSerializeContainingControl() {
return ContainingControl != ParentInternal;
}
private ContainerControl FindContainerControlInternal() {
if (Site != null) {
IDesignerHost host = (IDesignerHost)Site.GetService(typeof(IDesignerHost));
if (host != null) {
ContainerControl rootControl = host.RootComponent as ContainerControl;
if (rootControl != null)
{
return rootControl;
}
}
}
ContainerControl cc = null;
Control control = this;
while (control != null) {
ContainerControl tempCC = control as ContainerControl;
if (tempCC != null)
{
cc = tempCC;
break;
}
control = control.ParentInternal;
}
return cc;
}
private bool IsDirty() {
if (GetOcState() < OC_RUNNING) return false;
Debug.Assert(storageType != STG_UNKNOWN, "if we are loaded, out storage type must be set!");
if (axState[valueChanged]) {
axState[valueChanged] = false;
return true;
}
#if DEBUG
if (AxAlwaysSaveSwitch.Enabled) return true;
#endif
int hr = NativeMethods.E_FAIL;
switch (storageType) {
case STG_STREAM:
hr = iPersistStream.IsDirty();
break;
case STG_STREAMINIT:
hr = iPersistStreamInit.IsDirty();
break;
case STG_STORAGE:
hr = iPersistStorage.IsDirty();
break;
default:
Debug.Fail("unknown storage type");
return true;
}
if (hr == NativeMethods.S_FALSE) {
// NOTE: This was a note from the old AxHost codebase. The problem
// with doing this is that the some controls that do not run in
// unlicensed mode (e.g. ProtoView ScheduleX pvtaskpad.ocx) will
// always return S_FALSE to disallow design-time support.
// Sadly, some controls lie and never say that they are dirty...
// SO, we don't believe them unless they told us that they were
// dirty at least once...
return false;
}
else if (NativeMethods.Failed(hr)) {
return true;
}
return true;
}
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
internal bool IsUserMode() {
ISite site = Site;
return site == null || !site.DesignMode;
}
private Object GetAmbientProperty(int dispid) {
Control richParent = ParentInternal;
switch (dispid) {
case NativeMethods.ActiveX.DISPID_AMBIENT_USERMODE:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for usermode");
return IsUserMode();
case NativeMethods.ActiveX.DISPID_AMBIENT_AUTOCLIP:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for autoclip");
return true;
case NativeMethods.ActiveX.DISPID_AMBIENT_MESSAGEREFLECT:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for message reflect");
return true;
case NativeMethods.ActiveX.DISPID_AMBIENT_UIDEAD:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for uidead");
return false;
case NativeMethods.ActiveX.DISPID_AMBIENT_DISPLAYASDEFAULT:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for displayasdefault");
return false;
case NativeMethods.ActiveX.DISPID_AMBIENT_FONT:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for font");
if (richParent != null) {
return GetIFontFromFont(richParent.Font);
}
return null;
case NativeMethods.ActiveX.DISPID_AMBIENT_SHOWGRABHANDLES:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for showGrabHandles");
return false;
case NativeMethods.ActiveX.DISPID_AMBIENT_SHOWHATCHING:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for showHatching");
return false;
case NativeMethods.ActiveX.DISPID_AMBIENT_BACKCOLOR:
if (richParent != null) {
return GetOleColorFromColor(richParent.BackColor);
}
return null;
case NativeMethods.ActiveX.DISPID_AMBIENT_FORECOLOR:
if (richParent != null) {
return GetOleColorFromColor(richParent.ForeColor);
}
return null;
case NativeMethods.ActiveX.DISPID_AMBIENT_DISPLAYNAME:
string rval = GetParentContainer().GetNameForControl(this);
if (rval == null) rval = "";
return rval;
case NativeMethods.ActiveX.DISPID_AMBIENT_LOCALEID:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for localeid");
return Thread.CurrentThread.CurrentCulture.LCID;
case NativeMethods.ActiveX.DISPID_AMBIENT_RIGHTTOLEFT:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "asked for right to left");
Control ctl = this;
while (ctl != null) {
if (ctl.RightToLeft == System.Windows.Forms.RightToLeft.No)
return false;
if (ctl.RightToLeft == System.Windows.Forms.RightToLeft.Yes)
return true;
if (ctl.RightToLeft == System.Windows.Forms.RightToLeft.Inherit)
ctl = ctl.Parent;
}
return null;
default:
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "unsupported ambient "+dispid.ToString(CultureInfo.InvariantCulture));
return null;
}
}
///
/// [To be supplied.]
///
public void DoVerb(int verb) {
Control parent = ParentInternal;
GetOleObject().DoVerb(verb, IntPtr.Zero, oleSite, -1, parent != null ? parent.Handle : IntPtr.Zero, FillInRect(new NativeMethods.COMRECT(), Bounds));
}
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
private bool AwaitingDefreezing() {
return freezeCount > 0;
}
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
private void Freeze(bool v) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "freezing "+v.ToString());
if (v) {
try {
GetOleControl().FreezeEvents(-1);
}
catch (COMException t) {
Debug.Fail(t.ToString());
}
freezeCount ++;
}
else {
try {
GetOleControl().FreezeEvents(0);
}
catch (COMException t) {
Debug.Fail(t.ToString());
}
freezeCount --;
}
Debug.Assert(freezeCount >=0, "invalid freeze count!");
}
private int UiDeactivate() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "calling uiDeactivate for "+this.ToString());
bool ownDispose = this.axState[ownDisposing];
this.axState[ownDisposing] = true;
int hr = 0;
try {
hr = GetInPlaceObject().UIDeactivate();
}
finally {
this.axState[ownDisposing] = ownDispose;
}
return hr;
}
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
private int GetOcState() {
return ocState;
}
private void SetOcState(int nv) {
ocState = nv;
}
private string GetLicenseKey() {
return GetLicenseKey(this.clsid);
}
private string GetLicenseKey(Guid clsid) {
if (licenseKey != null || !axState[needLicenseKey]) {
return licenseKey;
}
try {
UnsafeNativeMethods.IClassFactory2 icf2 = UnsafeNativeMethods.CoGetClassObject(ref clsid, INPROC_SERVER, 0, ref icf2_Guid);
NativeMethods.tagLICINFO licInfo = new NativeMethods.tagLICINFO();
icf2.GetLicInfo(licInfo);
if (licInfo.fRuntimeAvailable != 0) {
string[] rval = new string[1];
icf2.RequestLicKey(0, rval);
licenseKey = rval[0];
return licenseKey;
}
}
catch (COMException e) {
if (e.ErrorCode == E_NOINTERFACE.ErrorCode) return null;
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Failed to get the license key: " + e.ToString());
axState[needLicenseKey] = false;
}
catch (Exception t) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Failed to get the license key: " + t.ToString());
axState[needLicenseKey] = false;
}
return null;
}
private void CreateWithoutLicense(Guid clsid) {
object ret = null;
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Creating object without license: " + clsid.ToString());
ret = UnsafeNativeMethods.CoCreateInstance(ref clsid, null, INPROC_SERVER, ref NativeMethods.ActiveX.IID_IUnknown);
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t" + (ret != null).ToString());
instance = ret;
}
private void CreateWithLicense(string license, Guid clsid) {
if (license != null) {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Creating object with license: " + clsid.ToString());
UnsafeNativeMethods.IClassFactory2 icf2 = UnsafeNativeMethods.CoGetClassObject(ref clsid, INPROC_SERVER, 0, ref icf2_Guid);
if (icf2 != null) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\tClassFactory" + (icf2 != null).ToString());
icf2.CreateInstanceLic(null, null, ref NativeMethods.ActiveX.IID_IUnknown, license, out instance);
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t" + (instance != null).ToString());
}
}
catch (Exception t) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Failed to create with license: " + t.ToString());
}
}
if (instance == null) {
CreateWithoutLicense(clsid);
}
}
private void CreateInstance() {
Debug.Assert(instance == null, "instance must be null");
//Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "before created "+Windows.GetCurrentThreadId());
//Debug.WriteStackTraceIf("AxHTrace");
//checkThreadingModel();
try {
instance = CreateInstanceCore(this.clsid);
Debug.Assert(instance != null, "w/o an exception being thrown we must have an object...");
}
catch (ExternalException e) {
if (e.ErrorCode == unchecked((int)0x80040112)) { // CLASS_E_NOTLICENSED
throw new LicenseException(GetType(), this, SR.GetString(SR.AXNoLicenseToUse));
}
throw;
}
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "created");
SetOcState(OC_LOADED);
}
///
/// Called to create the ActiveX control. Override this member to perform your own creation logic
/// or call base to do the default creation logic.
///
protected virtual object CreateInstanceCore(Guid clsid) {
if (IsUserMode()) {
CreateWithLicense(licenseKey, clsid);
}
else {
CreateWithoutLicense(clsid);
}
return instance;
}
private CategoryAttribute GetCategoryForDispid(int dispid) {
NativeMethods.ICategorizeProperties icp = GetCategorizeProperties();
if (icp == null) return null;
CategoryAttribute rval = null;
int propcat = 0;
try {
icp.MapPropertyToCategory(dispid, ref propcat);
if (propcat != 0) {
int cat = -propcat;
if (cat > 0 && cat < categoryNames.Length && categoryNames[cat] != null) {
return categoryNames[cat];
}
cat = - cat;
Int32 key = cat;
if (objectDefinedCategoryNames != null) {
rval = (CategoryAttribute) objectDefinedCategoryNames[key];
if (rval != null) return rval;
}
string name = null;
int hr = icp.GetCategoryName(cat, CultureInfo.CurrentCulture.LCID, out name);
if (hr == NativeMethods.S_OK && name != null) {
rval = new CategoryAttribute(name);
if (objectDefinedCategoryNames == null) {
objectDefinedCategoryNames = new Hashtable();
}
objectDefinedCategoryNames.Add(key, rval);
return rval;
}
}
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
return null;
}
private void SetSelectionStyle(int selectionStyle) {
if (!this.IsUserMode()) {
// selectionStyle can be 0 (not selected), 1 (selected) or 2 (active)
Debug.Assert(selectionStyle >= 0 && selectionStyle <= 2, "Invalid selection style");
ISelectionService iss = GetSelectionService();
this.selectionStyle = selectionStyle;
if (iss != null && iss.GetComponentSelected(this)) {
// The AX Host designer will offer an extender property called "SelectionStyle"
//
PropertyDescriptor prop = TypeDescriptor.GetProperties(this)["SelectionStyle"];
if (prop != null && prop.PropertyType == typeof(int)) {
prop.SetValue(this, selectionStyle);
}
}
}
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void InvokeEditMode() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "invoking EditMode for "+this.ToString());
Debug.Assert((flags & AxFlags.PreventEditMode) == 0, "edit mode should have been disabled");
if (editMode != EDITM_NONE) return;
AddSelectionHandler();
editMode = EDITM_HOST;
SetSelectionStyle(2);
IntPtr hwndFocus = UnsafeNativeMethods.GetFocus();
try {
UiActivate();
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
// It so happens that some controls don't get focus in this case, so
// we have got to force it onto them...
// int hwndFocusNow = NativeMethods.GetFocus();
// Windows.SetFocus(getHandle());
// while (hwndFocusNow != getHandle()) {
// if (hwndFocusNow == 0) {
// break;
// }
// hwndFocusNow = Windows.GetParent(hwndFocusNow);
// }
}
//
// ICustomTypeDescriptor implementation.
//
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
AttributeCollection ICustomTypeDescriptor.GetAttributes() {
if (!axState[editorRefresh] && HasPropertyPages()) {
axState[editorRefresh] = true;
TypeDescriptor.Refresh(this.GetType());
}
return TypeDescriptor.GetAttributes(this, true);
}
///
/// Retrieves the class name for this object. If null is returned,
/// the type name is used.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
string ICustomTypeDescriptor.GetClassName() {
return null;
}
///
/// Retrieves the name for this object. If null is returned,
/// the default is used.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
string ICustomTypeDescriptor.GetComponentName() {
return null;
}
///
/// Retrieves the type converter for this object.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
TypeConverter ICustomTypeDescriptor.GetConverter() {
return null;
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() {
return TypeDescriptor.GetDefaultEvent(this, true);
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() {
return TypeDescriptor.GetDefaultProperty(this, true);
}
///
/// Retrieves the an editor for this object.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
Object ICustomTypeDescriptor.GetEditor(Type editorBaseType) {
if (editorBaseType != typeof(ComponentEditor))
return null;
if (editor != null)
return editor;
if (editor == null && HasPropertyPages())
editor = new AxComponentEditor();
return editor;
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
EventDescriptorCollection ICustomTypeDescriptor.GetEvents() {
return TypeDescriptor.GetEvents(this, true);
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) {
return TypeDescriptor.GetEvents(this, attributes, true);
}
private void OnIdle(object sender, EventArgs e) {
if (axState[refreshProperties]) {
TypeDescriptor.Refresh(this.GetType());
}
}
private bool RefreshAllProperties {
get {
return axState[refreshProperties];
}
set {
axState[refreshProperties] = value;
if (value && !axState[listeningToIdle]) {
Application.Idle += new EventHandler(this.OnIdle);
axState[listeningToIdle] = true;
}
else if (!value && axState[listeningToIdle]) {
Application.Idle -= new EventHandler(this.OnIdle);
axState[listeningToIdle] = false;
}
}
}
private PropertyDescriptorCollection FillProperties(Attribute[] attributes) {
if (RefreshAllProperties) {
RefreshAllProperties = false;
propsStash = null;
attribsStash = null;
}
else if (propsStash != null) {
if (attributes == null && attribsStash == null) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Returning stashed values for : " + "");
return propsStash;
}
else if (attributes != null && attribsStash != null && attributes.Length == attribsStash.Length) {
bool attribsEqual = true;
int i = 0;
foreach(Attribute attrib in attributes) {
if (!attrib.Equals(attribsStash[i++])) {
attribsEqual = false;
break;
}
}
if (attribsEqual) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Returning stashed values for : " + attributes.Length);
return propsStash;
}
}
}
ArrayList retProps = new ArrayList();
if (properties == null)
properties = new Hashtable();
if (propertyInfos == null) {
propertyInfos = new Hashtable();
PropertyInfo[] propInfos = this.GetType().GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
foreach(PropertyInfo propInfo in propInfos)
propertyInfos.Add(propInfo.Name, propInfo);
}
PropertyDescriptorCollection baseProps = TypeDescriptor.GetProperties(this, null, true);
if (baseProps != null) {
for (int i = 0; i < baseProps.Count; ++i) {
Debug.Assert(baseProps[i] != null, "Null base prop at location: " + i.ToString(CultureInfo.InvariantCulture));
if (baseProps[i].DesignTimeOnly) {
retProps.Add(baseProps[i]);
continue;
}
string propName = baseProps[i].Name;
PropertyDescriptor prop = null;
PropertyInfo propInfo = (PropertyInfo)propertyInfos[propName];
// We do not support "write-only" properties that some activex controls support.
if (propInfo != null && !propInfo.CanRead)
continue;
if (!properties.ContainsKey(propName)) {
if (propInfo != null) {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Added AxPropertyDescriptor for: " + propName);
prop = new AxPropertyDescriptor(baseProps[i], this);
((AxPropertyDescriptor)prop).UpdateAttributes();
}
else {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Added PropertyDescriptor for: " + propName);
prop = baseProps[i];
}
properties.Add(propName, prop);
retProps.Add(prop);
}
else {
PropertyDescriptor propDesc = (PropertyDescriptor)properties[propName];
Debug.Assert(propDesc != null, "Cannot find cached entry for: " + propName);
AxPropertyDescriptor axPropDesc = propDesc as AxPropertyDescriptor;
if ((propInfo == null && axPropDesc != null) || (propInfo != null && axPropDesc == null)) {
Debug.Fail("Duplicate property with same name: " + propName);
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Duplicate property with same name: " + propName);
}
else {
if (axPropDesc != null) {
axPropDesc.UpdateAttributes();
}
retProps.Add(propDesc);
}
}
}
// Filter only the Browsable attribute, since that is the only
// one we mess with.
//
if (attributes != null) {
Attribute browse = null;
foreach(Attribute attr in attributes) {
if (attr is BrowsableAttribute) {
browse = attr;
}
}
if (browse != null) {
ArrayList removeList = null;
foreach(PropertyDescriptor prop in retProps) {
if (prop is AxPropertyDescriptor) {
Attribute attr = prop.Attributes[typeof(BrowsableAttribute)];
if (attr != null && !attr.Equals(browse)) {
if (removeList == null) {
removeList = new ArrayList();
}
removeList.Add(prop);
}
}
}
if (removeList != null) {
foreach(object prop in removeList)
retProps.Remove(prop);
}
}
}
}
PropertyDescriptor[] temp = new PropertyDescriptor[retProps.Count];
retProps.CopyTo(temp, 0);
// Update our stashed values.
//
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Updating stashed values for : " + ((attributes != null) ? attributes.Length.ToString(CultureInfo.InvariantCulture) : ""));
propsStash = new PropertyDescriptorCollection(temp);
attribsStash = attributes;
return propsStash;
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() {
return FillProperties(null);
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) {
return FillProperties(attributes);
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
Object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) {
return this;
}
private AxPropertyDescriptor GetPropertyDescriptorFromDispid(int dispid) {
Debug.Assert(dispid != NativeMethods.ActiveX.DISPID_UNKNOWN, "Wrong dispid sent to GetPropertyDescriptorFromDispid");
PropertyDescriptorCollection props = FillProperties(null);
foreach (PropertyDescriptor prop in props) {
AxPropertyDescriptor axprop = prop as AxPropertyDescriptor;
if (axprop != null && axprop.Dispid == dispid) {
return axprop;
}
}
return null;
}
#if false
// FxCop: Currently not used
private void CheckThreadingModel() {
#if DEBUG
if (AxIgnoreTMSwitch.Enabled) return;
#endif
if ((flags & AxFlags.IgnoreThreadModel) != 0) return;
bool singleThreaded = true;
new RegistryPermission(PermissionState.Unrestricted).Assert();
try {
try {
using (RegistryKey rk = Registry.ClassesRoot.OpenSubKey("CLSID\\" + clsid.ToString() + "\\InprocServer32", /*writable*/false)) {
object value = rk.GetValue("ThreadingModel");
if (value != null && value is string) {
if (value.Equals("Both")
|| value.Equals("Apartment")
|| value.Equals("Free")) {
singleThreaded = false;
}
}
}
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw new InvalidOperationException(SR.GetString(SR.AXNoThreadInfo));
}
}
finally {
System.Security.CodeAccessPermission.RevertAssert();
}
if (singleThreaded) {
throw new InvalidOperationException(SR.GetString(SR.AXSingleThreaded));
}
}
#endif
private void ActivateAxControl() {
if (QuickActivate()) {
DepersistControl();
}
else {
SlowActivate();
}
SetOcState(OC_RUNNING);
}
private void DepersistFromIPropertyBag(UnsafeNativeMethods.IPropertyBag propBag) {
iPersistPropBag.Load(propBag, null);
}
private void DepersistFromIStream(UnsafeNativeMethods.IStream istream) {
storageType = STG_STREAM;
iPersistStream.Load(istream);
}
private void DepersistFromIStreamInit(UnsafeNativeMethods.IStream istream) {
storageType = STG_STREAMINIT;
iPersistStreamInit.Load(istream);
}
private void DepersistFromIStorage(UnsafeNativeMethods.IStorage storage) {
storageType = STG_STORAGE;
// ASURT 65913 Looks like MapPoint control does not create a valid IStorage
// until some property has changed. Since we end up creating a bogus (empty)
// storage, we end up not being able to re-create a valid one and this would
// fail.
//
if (storage != null) {
int hr = iPersistStorage.Load(storage);
if (hr != NativeMethods.S_OK) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Error trying load depersist from IStorage: " + hr);
}
}
}
private void DepersistControl() {
Freeze(true);
if (ocxState == null) {
// must init new:
//
if (instance is UnsafeNativeMethods.IPersistStreamInit) {
iPersistStreamInit = (UnsafeNativeMethods.IPersistStreamInit) instance;
try {
storageType = STG_STREAMINIT;
iPersistStreamInit.InitNew();
}
catch (Exception e1) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistStreamInit.InitNew(). Is this good?" + e1.ToString());
}
return;
}
if (instance is UnsafeNativeMethods.IPersistStream) {
storageType = STG_STREAM;
iPersistStream = (UnsafeNativeMethods.IPersistStream) instance;
return;
}
if (instance is UnsafeNativeMethods.IPersistStorage) {
storageType = STG_STORAGE;
ocxState = new State(this);
iPersistStorage = (UnsafeNativeMethods.IPersistStorage) instance;
try {
iPersistStorage.InitNew(ocxState.GetStorage());
}
catch (Exception e2) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistStorage.InitNew(). Is this good?" + e2.ToString());
}
return;
}
if (instance is UnsafeNativeMethods.IPersistPropertyBag) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, this + " supports IPersistPropertyBag.");
iPersistPropBag = (UnsafeNativeMethods.IPersistPropertyBag) instance;
try {
iPersistPropBag.InitNew();
}
catch (Exception e1) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistPropertyBag.InitNew(). Is this good?" + e1.ToString());
}
}
Debug.Fail("no implemented persitance interfaces on object");
throw new InvalidOperationException(SR.GetString(SR.UnableToInitComponent));
}
// Otherwise, we have state to deperist from:
switch (ocxState.Type) {
case STG_STREAM:
try {
iPersistStream = (UnsafeNativeMethods.IPersistStream) instance;
DepersistFromIStream(ocxState.GetStream());
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistStream.DepersistFromIStream(). Is this good?" + e.ToString());
}
break;
case STG_STREAMINIT:
if (instance is UnsafeNativeMethods.IPersistStreamInit) {
try {
iPersistStreamInit = (UnsafeNativeMethods.IPersistStreamInit) instance;
DepersistFromIStreamInit(ocxState.GetStream());
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistStreamInit.DepersistFromIStreamInit(). Is this good?" + e.ToString());
}
GetControlEnabled();
}
else {
ocxState.Type = STG_STREAM;
DepersistControl();
return;
}
break;
case STG_STORAGE:
try {
iPersistStorage = (UnsafeNativeMethods.IPersistStorage) instance;
DepersistFromIStorage(ocxState.GetStorage());
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistStorage.DepersistFromIStorage(). Is this good?" + e.ToString());
}
break;
default:
Debug.Fail("unknown storage type.");
throw new InvalidOperationException(SR.GetString(SR.UnableToInitComponent));
}
if (ocxState.GetPropBag() != null) {
try {
iPersistPropBag = (UnsafeNativeMethods.IPersistPropertyBag)instance;
DepersistFromIPropertyBag(ocxState.GetPropBag());
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Exception thrown trying to IPersistPropertyBag.DepersistFromIPropertyBag(). Is this good?" + e.ToString());
}
}
}
///
/// Returns the IUnknown pointer to the enclosed ActiveX control.
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
public object GetOcx() {
return instance;
}
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
private Object GetOcxCreate() {
if (instance == null) {
CreateInstance();
RealizeStyles();
AttachInterfaces();
oleSite.OnOcxCreate();
}
return instance;
}
private void StartEvents() {
if (!axState[sinkAttached]) {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Creating sink for events...");
CreateSink();
oleSite.StartEvents();
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
axState[sinkAttached] = true;
}
}
private void StopEvents() {
if (axState[sinkAttached]) {
try {
DetachSink();
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
axState[sinkAttached] = false;
}
oleSite.StopEvents();
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void CreateSink() {
// nop... windows forms wrapper will override...
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void DetachSink() {
// nop... windows forms wrapper will override...
}
private bool CanShowPropertyPages() {
if (GetOcState() < OC_RUNNING) return false;
return(GetOcx() is NativeMethods.ISpecifyPropertyPages);
}
///
/// [To be supplied.]
///
public bool HasPropertyPages() {
if (!CanShowPropertyPages()) return false;
NativeMethods.ISpecifyPropertyPages ispp = (NativeMethods.ISpecifyPropertyPages) GetOcx();
try {
NativeMethods.tagCAUUID uuids = new NativeMethods.tagCAUUID();
try {
ispp.GetPages(uuids);
if (uuids.cElems > 0) return true;
}
finally {
if (uuids.pElems != IntPtr.Zero) {
Marshal.FreeCoTaskMem(uuids.pElems);
}
}
}
catch {
}
return false;
}
unsafe private void ShowPropertyPageForDispid(int dispid, Guid guid) {
try {
IntPtr pUnk = Marshal.GetIUnknownForObject(GetOcx());
NativeMethods.OCPFIPARAMS opcparams = new NativeMethods.OCPFIPARAMS();
opcparams.hwndOwner = (ContainingControl == null) ? IntPtr.Zero : ContainingControl.Handle;
opcparams.lpszCaption = Name;
opcparams.ppUnk = (IntPtr) (long) &pUnk;
opcparams.uuid = (IntPtr)(long) &guid;
opcparams.dispidInitial = dispid;
UnsafeNativeMethods.OleCreatePropertyFrameIndirect(opcparams);
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw t;
}
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void MakeDirty() {
ISite isite = Site;
if (isite == null)
return;
IComponentChangeService ccs = (IComponentChangeService)isite.GetService(typeof(IComponentChangeService));
if (ccs == null)
return;
ccs.OnComponentChanging(this, null);
ccs.OnComponentChanged(this, null, null, null);
}
///
/// [To be supplied.]
///
public void ShowPropertyPages() {
if (ParentInternal == null) return;
if (!ParentInternal.IsHandleCreated) return;
ShowPropertyPages(ParentInternal);
}
///
/// [To be supplied.]
///
public void ShowPropertyPages(Control control) {
try {
if (!CanShowPropertyPages()) return;
NativeMethods.ISpecifyPropertyPages ispp = (NativeMethods.ISpecifyPropertyPages) GetOcx();
NativeMethods.tagCAUUID uuids = new NativeMethods.tagCAUUID();
try {
ispp.GetPages(uuids);
if (uuids.cElems <= 0) return;
}
catch {
return;
}
// State oldOcxState = OcxState;
IDesignerHost host = null;
if (Site != null)
host = (IDesignerHost)Site.GetService(typeof(IDesignerHost));
DesignerTransaction trans = null;
try {
if (host != null)
trans = host.CreateTransaction(SR.GetString(SR.AXEditProperties));
string name = null;
object o = GetOcx();
IntPtr handle = (ContainingControl == null) ? IntPtr.Zero : ContainingControl.Handle;
SafeNativeMethods.OleCreatePropertyFrame(new HandleRef(this, handle), 0, 0, name, 1, ref o, uuids.cElems, new HandleRef(null, uuids.pElems), Application.CurrentCulture.LCID, 0, IntPtr.Zero);
}
finally {
if (oleSite != null)
((UnsafeNativeMethods.IPropertyNotifySink)oleSite).OnChanged(NativeMethods.MEMBERID_NIL);
if (trans != null)
trans.Commit();
if (uuids.pElems != IntPtr.Zero)
Marshal.FreeCoTaskMem(uuids.pElems);
}
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw t;
}
}
internal override IntPtr InitializeDCForWmCtlColor (IntPtr dc, int msg)
{
if (isMaskEdit) {
return base.InitializeDCForWmCtlColor(dc, msg);
}
else {
return IntPtr.Zero; // bypass Control's anti-reflect logic
}
}
///
/// AxHost wndProc. All messages are sent to wndProc after getting filtered
/// through the preProcessMessage function.
/// Certain messages are forwarder directly to the ActiveX control,
/// others are first processed by the wndProc of Control
///
protected override void WndProc(ref Message m) {
#pragma warning disable 162, 429
// Ignore the warnings generated by the following code (unreachable code, and unreachable expression)
if (false && (axState[manualUpdate] && IsUserMode())) {
DefWndProc(ref m);
return;
}
#pragma warning restore 162, 429
switch (m.Msg) {
// Things we explicitly ignore and pass to the ocx's windproc
case NativeMethods.WM_ERASEBKGND:
case NativeMethods.WM_REFLECT + NativeMethods.WM_NOTIFYFORMAT:
case NativeMethods.WM_SETCURSOR:
case NativeMethods.WM_SYSCOLORCHANGE:
// Some of the MSComCtl controls respond to this message
// to do some custom painting. So, we should just pass this message
// through.
//
case NativeMethods.WM_DRAWITEM:
case NativeMethods.WM_LBUTTONDBLCLK:
case NativeMethods.WM_LBUTTONUP:
case NativeMethods.WM_MBUTTONDBLCLK:
case NativeMethods.WM_MBUTTONUP:
case NativeMethods.WM_RBUTTONDBLCLK:
case NativeMethods.WM_RBUTTONUP:
DefWndProc(ref m);
break;
case NativeMethods.WM_LBUTTONDOWN:
case NativeMethods.WM_MBUTTONDOWN:
case NativeMethods.WM_RBUTTONDOWN:
if (IsUserMode()) {
Focus();
}
DefWndProc(ref m);
break;
case NativeMethods.WM_KILLFOCUS:
{
hwndFocus = m.WParam;
try {
base.WndProc(ref m);
}
finally {
hwndFocus = IntPtr.Zero;
}
break;
}
case NativeMethods.WM_COMMAND:
if (!ReflectMessageInternal(m.LParam, ref m))
DefWndProc(ref m);
break;
case NativeMethods.WM_CONTEXTMENU:
DefWndProc(ref m);
break;
case NativeMethods.WM_DESTROY:
#if DEBUG
if (!OwnWindow()) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "WM_DESTROY naughty control is destroying the window from under us..." + GetType().ToString());
}
#endif
//
// If we are currently in a state of InPlaceActive or above,
// we should first reparent the ActiveX control to our parking
// window before we transition to a state below InPlaceActive.
// Otherwise we face all sorts of problems when we try to
// transition back to a state >= InPlaceActive.
//
if (GetOcState() >= OC_INPLACE) {
UnsafeNativeMethods.IOleInPlaceObject ipo = GetInPlaceObject();
IntPtr hwnd;
if (NativeMethods.Succeeded(ipo.GetWindow(out hwnd))) {
Application.ParkHandle(new HandleRef(ipo, hwnd));
}
}
bool visible = GetState(STATE_VISIBLE);
TransitionDownTo(OC_RUNNING);
DetachAndForward(ref m);
if (visible != GetState(STATE_VISIBLE)) {
SetState(STATE_VISIBLE, visible);
}
break;
case NativeMethods.WM_HELP:
// We want to both fire the event, and let the ocx have the message...
base.WndProc(ref m);
DefWndProc(ref m);
break;
case NativeMethods.WM_KEYUP:
if (axState[processingKeyUp])
break;
axState[processingKeyUp] = true;
try {
if (PreProcessControlMessage(ref m) != PreProcessControlState.MessageProcessed)
DefWndProc(ref m);
}
finally {
axState[processingKeyUp] = false;
}
break;
case NativeMethods.WM_NCDESTROY:
#if DEBUG
if (!OwnWindow()) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "WM_NCDESTROY naughty control is destroying the window from under us..." + GetType().ToString());
}
#endif
// need to detach it now...
DetachAndForward(ref m);
break;
default:
if (m.Msg == REGMSG_MSG) {
m.Result = (IntPtr)REGMSG_RETVAL;
return;
}
// Other things we may care about and we will pass them to the Control's wndProc
base.WndProc(ref m);
break;
}
}
private void DetachAndForward(ref Message m) {
IntPtr handle = GetHandleNoCreate();
DetachWindow();
if (handle != IntPtr.Zero) {
IntPtr wndProc = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, handle), NativeMethods.GWL_WNDPROC);
m.Result = UnsafeNativeMethods.CallWindowProc(wndProc, handle, m.Msg, m.WParam, m.LParam);
}
}
private void DetachWindow() {
if (IsHandleCreated) {
OnHandleDestroyed(EventArgs.Empty);
for (Control c = this; c != null; c = c.ParentInternal) {
/* NOT NEEDED
if (c.GetAxState(STATE_HANDLEHOOK)) {
((IHandleHook)c.Site.GetService(IHandleHook.class)).OnDestroyHandle(GetHandle());
break;
}
*/
}
this.WindowReleaseHandle();
}
}
private void InformOfNewHandle() {
Debug.Assert(IsHandleCreated, "we got to have a handle to be here...");
for (Control c = this; c != null; c = c.ParentInternal) {
/* NOT NEEDED
if (c.GetAxState(STATE_HANDLEHOOK)) {
((IHandleHook)c.Site.GetService(IHandleHook.class)).OnCreateHandle(GetHandle());
break;
}
*/
}
wndprocAddr = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, Handle), NativeMethods.GWL_WNDPROC);
/* NOT NEEDED
SetAxState(STATE_CREATENOTIFIED, true);
*/
}
private void AttachWindow(IntPtr hwnd) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "attaching window for "+this.ToString()+" "+hwnd.ToString());
if (!axState[fFakingWindow]) {
this.WindowAssignHandle(hwnd, axState[assignUniqueID]);
}
UpdateZOrder();
// Get the latest bounds set by the user.
Size setExtent = Size;
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "SetBounds " + setExtent.ToString());
// Get the default bounds set by the ActiveX control.
UpdateBounds();
Size ocxExtent = GetExtent();
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "OcxBounds " + ocxExtent.ToString());
Point location = Location;
// Choose the setBounds unless it is smaller than the default bounds.
if (setExtent.Width < ocxExtent.Width || setExtent.Height < ocxExtent.Height)
Bounds = new Rectangle(location.X, location.Y, ocxExtent.Width, ocxExtent.Height);
else {
Size newSize = SetExtent(setExtent.Width, setExtent.Height);
if (!newSize.Equals(setExtent)) {
Bounds = new Rectangle(location.X, location.Y, newSize.Width, newSize.Height);
}
}
OnHandleCreated(EventArgs.Empty);
InformOfNewHandle();
}
///
/// Inheriting classes should override this method to find out when the
/// handle has been created.
/// Call base.OnHandleCreated first.
///
protected override void OnHandleCreated(EventArgs e) {
// ASURT 43741 This is needed to prevent some controls (for e.g. Office Web Components) from
// failing to InPlaceActivate() when they call RegisterDragDrop() but do not call
// OleInitialize(). The EE calls CoInitializeEx() on the thread, but I believe
// that is not good enough for DragDrop.
//
if (Application.OleRequired() != System.Threading.ApartmentState.STA) {
throw new ThreadStateException(SR.GetString(SR.ThreadMustBeSTA));
}
SetAcceptDrops(AllowDrop);
RaiseCreateHandleEvent(e);
}
///
/// [To be supplied.]
///
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.InheritanceDemand, Name="FullTrust")]
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.LinkDemand, Name="FullTrust")]
public class ConnectionPointCookie {
private UnsafeNativeMethods.IConnectionPoint connectionPoint;
private int cookie;
internal int threadId;
#if DEBUG
private string callStack;
#endif
///
/// Creates a connection point to of the given interface type.
/// which will call on a managed code sink that implements that interface.
///
public ConnectionPointCookie(object source, object sink, Type eventInterface)
: this(source, sink, eventInterface, true) {
}
internal ConnectionPointCookie(object source, object sink, Type eventInterface, bool throwException) {
if (source is UnsafeNativeMethods.IConnectionPointContainer) {
UnsafeNativeMethods.IConnectionPointContainer cpc = (UnsafeNativeMethods.IConnectionPointContainer)source;
try {
Guid tmp = eventInterface.GUID;
if (cpc.FindConnectionPoint(ref tmp, out connectionPoint) != NativeMethods.S_OK) {
connectionPoint = null;
}
}
catch {
connectionPoint = null;
}
if (connectionPoint == null) {
if (throwException) {
throw new ArgumentException(SR.GetString(SR.AXNoEventInterface, eventInterface.Name));
}
}
else if (sink == null || !eventInterface.IsInstanceOfType(sink)) {
if (throwException) {
throw new InvalidCastException(SR.GetString(SR.AXNoSinkImplementation, eventInterface.Name));
}
}
else {
int hr = connectionPoint.Advise(sink, ref cookie);
if (hr == NativeMethods.S_OK) {
threadId = Thread.CurrentThread.ManagedThreadId;
}
else {
cookie = 0;
Marshal.ReleaseComObject(connectionPoint);
connectionPoint = null;
if (throwException) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.AXNoSinkAdvise, eventInterface.Name), hr));
}
}
}
}
else {
if (throwException) {
throw new InvalidCastException(SR.GetString(SR.AXNoConnectionPointContainer));
}
}
if (connectionPoint == null || cookie == 0) {
if (connectionPoint != null) {
Marshal.ReleaseComObject(connectionPoint);
}
if (throwException) {
throw new ArgumentException(SR.GetString(SR.AXNoConnectionPoint, eventInterface.Name));
}
}
#if DEBUG
new EnvironmentPermission(PermissionState.Unrestricted).Assert();
try {
callStack = Environment.StackTrace;
}
finally {
System.Security.CodeAccessPermission.RevertAssert();
}
#endif
}
///
/// Disconnect the current connection point. If the object is not connected,
/// this method will do nothing.
///
public void Disconnect() {
if (connectionPoint != null && cookie != 0) {
try {
connectionPoint.Unadvise(cookie);
}
catch (Exception ex) {
if (ClientUtils.IsCriticalException(ex)) {
throw;
}
}
finally {
cookie = 0;
}
try {
Marshal.ReleaseComObject(connectionPoint);
}
catch (Exception ex) {
if (ClientUtils.IsCriticalException(ex)) {
throw;
}
}
finally {
connectionPoint = null;
}
}
}
///
///
private class OleInterfaces
: UnsafeNativeMethods.IOleControlSite, UnsafeNativeMethods.IOleClientSite, UnsafeNativeMethods.IOleInPlaceSite, UnsafeNativeMethods.ISimpleFrameSite, UnsafeNativeMethods.IVBGetControl, UnsafeNativeMethods.IGetVBAObject, UnsafeNativeMethods.IPropertyNotifySink, IReflect {
private AxHost host;
private ConnectionPointCookie connectionPoint;
internal OleInterfaces(AxHost host) {
if (host == null)
throw new ArgumentNullException("host");
this.host = host;
}
~OleInterfaces() {
if (!AppDomain.CurrentDomain.IsFinalizingForUnload()) {
SynchronizationContext context = SynchronizationContext.Current;
if (context == null) {
Debug.Fail("Attempted to disconnect ConnectionPointCookie from the finalizer with no SynchronizationContext.");
}
else {
context.Post(new SendOrPostCallback(AttemptStopEvents), null);
}
}
}
internal AxHost GetAxHost() {
return host;
}
internal void OnOcxCreate() {
StartEvents();
}
internal void StartEvents() {
if (connectionPoint != null)
return;
Object nativeObject = host.GetOcx();
try {
connectionPoint = new ConnectionPointCookie(nativeObject, this, typeof(UnsafeNativeMethods.IPropertyNotifySink));
}
catch {
}
}
void AttemptStopEvents(object trash) {
if( connectionPoint == null ){
return;
}
if (connectionPoint.threadId == Thread.CurrentThread.ManagedThreadId) {
StopEvents();
}
else {
Debug.Fail("Attempted to disconnect ConnectionPointCookie from the wrong thread (finalizer).");
}
}
internal void StopEvents() {
if (connectionPoint != null) {
connectionPoint.Disconnect();
connectionPoint = null;
}
}
// IGetVBAObject methods:
int UnsafeNativeMethods.IGetVBAObject.GetObject(ref Guid riid, UnsafeNativeMethods.IVBFormat[] rval, int dwReserved) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetObject");
if (rval == null || riid.Equals(Guid.Empty))
return NativeMethods.E_INVALIDARG;
if (riid.Equals(ivbformat_Guid)) {
rval[0] = new VBFormat();
return NativeMethods.S_OK;
}
else {
rval[0] = null;
return NativeMethods.E_NOINTERFACE;
}
}
// IVBGetControl methods:
int UnsafeNativeMethods.IVBGetControl.EnumControls(int dwOleContF, int dwWhich, out UnsafeNativeMethods.IEnumUnknown ppenum) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in EnumControls");
ppenum = null;
ppenum = host.GetParentContainer().EnumControls(host, dwOleContF, dwWhich);
return NativeMethods.S_OK;
}
// ISimpleFrameSite methods:
int UnsafeNativeMethods.ISimpleFrameSite.PreMessageFilter(IntPtr hwnd, int msg, IntPtr wp, IntPtr lp, ref IntPtr plResult, ref int pdwCookie) {
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.ISimpleFrameSite.PostMessageFilter(IntPtr hwnd, int msg, IntPtr wp, IntPtr lp, ref IntPtr plResult, int dwCookie) {
return NativeMethods.S_FALSE;
}
// IReflect methods:
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr,Binder binder, Type[] types,ParameterModifier[] modifiers) {
return null;
}
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr) {
return null;
}
MethodInfo[] IReflect.GetMethods(BindingFlags bindingAttr) {
return new MethodInfo[0];
}
FieldInfo IReflect.GetField(String name, BindingFlags bindingAttr) {
return null;
}
FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) {
return new FieldInfo[0];
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr) {
return null;
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers) {
return null;
}
PropertyInfo[] IReflect.GetProperties(BindingFlags bindingAttr) {
return new PropertyInfo[0];
}
MemberInfo[] IReflect.GetMember(String name, BindingFlags bindingAttr) {
return new MemberInfo[0];
}
MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr) {
return new MemberInfo[0];
}
Object IReflect.InvokeMember(String name, BindingFlags invokeAttr, Binder binder,
Object target, Object[] args, ParameterModifier[] modifiers, CultureInfo culture, String[] namedParameters) {
if (name.StartsWith("[DISPID=")) {
int endIndex = name.IndexOf("]");
int dispid = Int32.Parse(name.Substring(8, endIndex - 8), CultureInfo.InvariantCulture);
object ambient = host.GetAmbientProperty(dispid);
if (ambient != null) return ambient;
}
throw E_FAIL;
}
Type IReflect.UnderlyingSystemType {
get {
return null;
}
}
// IOleControlSite methods:
int UnsafeNativeMethods.IOleControlSite.OnControlInfoChanged() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnControlInfoChanged");
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleControlSite.LockInPlaceActive(int fLock) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in LockInPlaceActive");
return NativeMethods.E_NOTIMPL;
}
int UnsafeNativeMethods.IOleControlSite.GetExtendedControl(out object ppDisp) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetExtendedControl " + host.ToString());
ppDisp = host.GetParentContainer().GetProxyForControl(host);
if (ppDisp == null)
return NativeMethods.E_NOTIMPL;
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleControlSite.TransformCoords(NativeMethods._POINTL pPtlHimetric, NativeMethods.tagPOINTF pPtfContainer, int dwFlags) {
int hr = SetupLogPixels(false);
if (NativeMethods.Failed(hr))
return hr;
if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_HIMETRICTOCONTAINER) != 0) {
if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_SIZE) != 0) {
pPtfContainer.x = (float) host.HM2Pix(pPtlHimetric.x, logPixelsX);
pPtfContainer.y = (float) host.HM2Pix(pPtlHimetric.y, logPixelsY);
}
else if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_POSITION) != 0) {
pPtfContainer.x = (float) host.HM2Pix(pPtlHimetric.x, logPixelsX);
pPtfContainer.y = (float) host.HM2Pix(pPtlHimetric.y, logPixelsY);
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose,"\t dwFlags not supported: " + dwFlags);
return NativeMethods.E_INVALIDARG;
}
}
else if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_CONTAINERTOHIMETRIC) != 0) {
if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_SIZE) != 0) {
pPtlHimetric.x = host.Pix2HM((int)pPtfContainer.x, logPixelsX);
pPtlHimetric.y = host.Pix2HM((int)pPtfContainer.y, logPixelsY);
}
else if ((dwFlags & NativeMethods.ActiveX.XFORMCOORDS_POSITION) != 0) {
pPtlHimetric.x = host.Pix2HM((int)pPtfContainer.x, logPixelsX);
pPtlHimetric.y = host.Pix2HM((int)pPtfContainer.y, logPixelsY);
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t dwFlags not supported: " + dwFlags);
return NativeMethods.E_INVALIDARG;
}
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t dwFlags not supported: " + dwFlags);
return NativeMethods.E_INVALIDARG;
}
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleControlSite.TranslateAccelerator(ref NativeMethods.MSG pMsg, int grfModifiers) {
Debug.Assert(!host.GetAxState(AxHost.siteProcessedInputKey), "Re-entering UnsafeNativeMethods.IOleControlSite.TranslateAccelerator!!!");
host.SetAxState(AxHost.siteProcessedInputKey, true);
Message msg = new Message();
msg.Msg = pMsg.message;
msg.WParam = pMsg.wParam;
msg.LParam = pMsg.lParam;
msg.HWnd = pMsg.hwnd;
try {
bool f = ((Control)host).PreProcessMessage(ref msg);
return f ? NativeMethods.S_OK : NativeMethods.S_FALSE;
}
finally {
host.SetAxState(AxHost.siteProcessedInputKey, false);
}
}
int UnsafeNativeMethods.IOleControlSite.OnFocus(int fGotFocus) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnFocus " + ((fGotFocus == 0) ? "lost" : "gained"));
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleControlSite.ShowPropertyFrame() {
if (host.CanShowPropertyPages()) {
host.ShowPropertyPages();
return NativeMethods.S_OK;
}
return NativeMethods.E_NOTIMPL;
}
// IOleClientSite methods:
int UnsafeNativeMethods.IOleClientSite.SaveObject() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SaveObject");
return NativeMethods.E_NOTIMPL;
}
int UnsafeNativeMethods.IOleClientSite.GetMoniker(int dwAssign, int dwWhichMoniker, out Object moniker) {
Debug.WriteLineIf(CompModSwitches.ActiveX.TraceInfo, "AxSource:GetMoniker");
moniker = null;
return NativeMethods.E_NOTIMPL;
}
int UnsafeNativeMethods.IOleClientSite.GetContainer(out UnsafeNativeMethods.IOleContainer container) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getContainer");
container = host.GetParentContainer();
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleClientSite.ShowObject() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in ShowObject");
if (host.GetAxState(AxHost.fOwnWindow)) {
Debug.Fail("we can't be in showobject if we own our window...");
return NativeMethods.S_OK;
}
if (host.GetAxState(AxHost.fFakingWindow)) {
// we really should not be here...
// this means that the ctl inplace deactivated and didn't call on inplace activate before calling showobject
// so we need to destroy our fake window first...
host.DestroyFakeWindow();
// ASURT 46393
// The fact that we have a fake window means that the OCX inplace deactivated when we hid it. It means
// that we have to bring it back from RUNNING to INPLACE so that it can re-create its handle properly.
//
host.TransitionDownTo(OC_LOADED);
host.TransitionUpTo(OC_INPLACE);
}
if (host.GetOcState() < OC_INPLACE)
return NativeMethods.S_OK;
IntPtr hwnd;
if (NativeMethods.Succeeded(host.GetInPlaceObject().GetWindow(out hwnd))) {
if (host.GetHandleNoCreate() != hwnd) {
host.DetachWindow();
if (hwnd != IntPtr.Zero) {
host.AttachWindow(hwnd);
}
}
}
else if (host.GetInPlaceObject() is UnsafeNativeMethods.IOleInPlaceObjectWindowless) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Windowless control.");
throw new InvalidOperationException(SR.GetString(SR.AXWindowlessControl));
}
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleClientSite.OnShowWindow(int fShow) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnShowWindow");
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleClientSite.RequestNewObjectLayout() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in RequestNewObjectLayout");
return NativeMethods.E_NOTIMPL;
}
// IOleInPlaceSite methods:
///
/// [To be supplied.]
///
IntPtr UnsafeNativeMethods.IOleInPlaceSite.GetWindow() {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetWindow");
Control parent = host.ParentInternal;
return parent != null ? parent.Handle : IntPtr.Zero;
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw t;
}
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceSite.ContextSensitiveHelp(int fEnterMode) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in ContextSensitiveHelp");
return NativeMethods.E_NOTIMPL;
}
int UnsafeNativeMethods.IOleInPlaceSite.CanInPlaceActivate() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in CanInPlaceActivate");
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.OnInPlaceActivate() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnInPlaceActivate");
host.SetAxState(AxHost.ownDisposing, false);
host.SetAxState(AxHost.rejectSelection, false);
host.SetOcState(OC_INPLACE);
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.OnUIActivate() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnUIActivate for " + host.ToString());
host.SetOcState(OC_UIACTIVE);
host.GetParentContainer().OnUIActivate(host);
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.GetWindowContext(out UnsafeNativeMethods.IOleInPlaceFrame ppFrame, out UnsafeNativeMethods.IOleInPlaceUIWindow ppDoc,
NativeMethods.COMRECT lprcPosRect, NativeMethods.COMRECT lprcClipRect, NativeMethods.tagOIFI lpFrameInfo) {
ppDoc = null;
ppFrame = host.GetParentContainer();
FillInRect(lprcPosRect, host.Bounds);
host.GetClipRect(lprcClipRect);
if (lpFrameInfo != null) {
lpFrameInfo.cb = Marshal.SizeOf(typeof(NativeMethods.tagOIFI));
lpFrameInfo.fMDIApp = false;
lpFrameInfo.hAccel = IntPtr.Zero;
lpFrameInfo.cAccelEntries = 0;
lpFrameInfo.hwndFrame = host.ParentInternal.Handle;
}
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.Scroll(NativeMethods.tagSIZE scrollExtant) {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in Scroll");
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw t;
}
return(NativeMethods.S_FALSE);
}
int UnsafeNativeMethods.IOleInPlaceSite.OnUIDeactivate(int fUndoable) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnUIDeactivate for " + host.ToString());
host.GetParentContainer().OnUIDeactivate(host);
if (host.GetOcState() > OC_INPLACE) {
host.SetOcState(OC_INPLACE);
}
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.OnInPlaceDeactivate() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnInPlaceDeactivate");
if (host.GetOcState() == OC_UIACTIVE) {
((UnsafeNativeMethods.IOleInPlaceSite)this).OnUIDeactivate(0);
}
host.GetParentContainer().OnInPlaceDeactivate(host);
host.DetachWindow();
host.SetOcState(OC_RUNNING);
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.DiscardUndoState() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in DiscardUndoState");
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IOleInPlaceSite.DeactivateAndUndo() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in DeactivateAndUndo for "+host.ToString());
return host.GetInPlaceObject().UIDeactivate();
}
int UnsafeNativeMethods.IOleInPlaceSite.OnPosRectChange(NativeMethods.COMRECT lprcPosRect) {
// ASURT 68752
// The MediaPlayer control has a AllowChangeDisplaySize property that users
// can set to control size changes at runtime, but the control itself ignores that and sets the new size.
// We prevent this by not allowing controls to call OnPosRectChange(), unless we instantiated the resize.
// visual basic6 does the same.
//
bool useRect = true;
if (AxHost.windowsMediaPlayer_Clsid.Equals(host.clsid))
useRect = host.GetAxState(AxHost.handlePosRectChanged);
if (useRect) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnPosRectChange" + lprcPosRect.ToString());
host.GetInPlaceObject().SetObjectRects(lprcPosRect, host.GetClipRect(new NativeMethods.COMRECT()));
host.MakeDirty();
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Control directly called OnPosRectChange... ignoring the new size");
}
return NativeMethods.S_OK;
}
// IPropertyNotifySink methods
void UnsafeNativeMethods.IPropertyNotifySink.OnChanged(int dispid) {
// Some controls fire OnChanged() notifications when getting values of some properties. ASURT 20190.
// To prevent this kind of recursion, we check to see if we are already inside a OnChanged() call.
//
if (host.NoComponentChangeEvents != 0)
return;
host.NoComponentChangeEvents++;
try {
AxPropertyDescriptor prop = null;
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnChanged");
if (dispid != NativeMethods.ActiveX.DISPID_UNKNOWN) {
prop = host.GetPropertyDescriptorFromDispid(dispid);
if (prop != null) {
prop.OnValueChanged(this.host);
if (!prop.SettingValue) {
prop.UpdateTypeConverterAndTypeEditor(true);
}
}
}
else {
// update them all for DISPID_UNKNOWN.
//
PropertyDescriptorCollection props = ((ICustomTypeDescriptor)host).GetProperties();
foreach(PropertyDescriptor p in props) {
prop = p as AxPropertyDescriptor;
if (prop != null && !prop.SettingValue) {
prop.UpdateTypeConverterAndTypeEditor(true);
}
}
}
ISite site = host.Site;
if (site != null) {
IComponentChangeService changeService = (IComponentChangeService)site.GetService(typeof(IComponentChangeService));
if (changeService != null) {
try {
changeService.OnComponentChanging(host, prop);
}
catch (CheckoutException coEx) {
if (coEx == CheckoutException.Canceled) {
return;
}
throw coEx;
}
// Now notify the change service that the change was successful.
//
changeService.OnComponentChanged(host, prop, null, ((prop != null) ? prop.GetValue(host) : null));
}
}
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw t;
}
finally {
host.NoComponentChangeEvents--;
}
}
int UnsafeNativeMethods.IPropertyNotifySink.OnRequestEdit(int dispid) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in OnRequestEdit for "+host.ToString());
return NativeMethods.S_OK;
}
}
private const int HMperInch = 2540;
private int Pix2HM(int pix, int logP) {
return(HMperInch * pix + ( logP >> 1)) / logP;
}
private int HM2Pix(int hm, int logP) {
return(logP * hm + HMperInch / 2) / HMperInch;
}
private bool QuickActivate() {
if (!(instance is UnsafeNativeMethods.IQuickActivate)) return false;
UnsafeNativeMethods.IQuickActivate iqa = (UnsafeNativeMethods.IQuickActivate) instance;
UnsafeNativeMethods.tagQACONTAINER qaContainer = new UnsafeNativeMethods.tagQACONTAINER();
UnsafeNativeMethods.tagQACONTROL qaControl = new UnsafeNativeMethods.tagQACONTROL();
qaContainer.pClientSite = oleSite;
qaContainer.pPropertyNotifySink = oleSite;
// qaContainer.pControlSite = oleSite;
// qaContainer.pAdviseSink = null;
// qaContainer.pUnkEventSink = null;
// qaContainer.pUndoMgr = null;
// qaContainer.pBindHost = null;
// qaContainer.pServiveProvider = null;
// qaContainer.hpal = 0;
qaContainer.pFont = GetIFontFromFont(GetParentContainer().parent.Font);
qaContainer.dwAppearance = 0;
qaContainer.lcid = Application.CurrentCulture.LCID;
Control p = ParentInternal;
if (p != null) {
qaContainer.colorFore = GetOleColorFromColor(p.ForeColor);
qaContainer.colorBack = GetOleColorFromColor(p.BackColor);
}
else {
qaContainer.colorFore = GetOleColorFromColor(SystemColors.WindowText);
qaContainer.colorBack = GetOleColorFromColor(SystemColors.Window);
}
qaContainer.dwAmbientFlags = NativeMethods.ActiveX.QACONTAINER_AUTOCLIP | NativeMethods.ActiveX.QACONTAINER_MESSAGEREFLECT |
NativeMethods.ActiveX.QACONTAINER_SUPPORTSMNEMONICS;
if (IsUserMode()) {
qaContainer.dwAmbientFlags |= NativeMethods.ActiveX.QACONTAINER_USERMODE;
}
else {
// Can't set ui dead becuase MFC controls return NOWHERE on NCHITTEST which
// messes up the designer...
// But, without this the FarPoint SpreadSheet and the Office SpreadSheet
// controls take keyboard input at design time.
//qaContainer.dwAmbientFlags |= NativeMethods.ActiveX.QACONTAINER_UIDEAD;
// qaContainer.dwAmbientFlags |= ActiveX.QACONTAINER_SHOWHATCHING;
}
try {
iqa.QuickActivate(qaContainer, qaControl);
}
catch (Exception t) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Failed to QuickActivate: " + t.ToString());
DisposeAxControl();
return false;
}
miscStatusBits = qaControl.dwMiscStatus;
ParseMiscBits(miscStatusBits);
return true;
}
internal override void DisposeAxControls() {
axState[rejectSelection] = true;
base.DisposeAxControls();
TransitionDownTo(OC_PASSIVE);
}
private bool GetControlEnabled() {
try {
return IsHandleCreated;
}
catch (Exception t) {
Debug.Fail(t.ToString());
return true;
}
}
internal override bool CanSelectCore() {
if (!GetControlEnabled() || axState[rejectSelection]) return false;
return base.CanSelectCore();
}
///
/// Frees all resources assocaited with this control. This method may not be
/// called at runtime. Any resources used by the control should be setup to
/// be released when the control is garbage collected. Inheriting classes should always
/// call base.dispose.
///
protected override void Dispose(bool disposing) {
if (disposing) {
TransitionDownTo(OC_PASSIVE);
if (newParent != null)
{
newParent.Dispose();
}
}
base.Dispose(disposing);
}
private bool GetSiteOwnsDeactivation() {
return axState[ownDisposing];
}
private void DisposeAxControl() {
if (GetParentContainer() != null) {
GetParentContainer().RemoveControl(this);
}
TransitionDownTo(OC_RUNNING);
if (GetOcState() == OC_RUNNING) {
GetOleObject().SetClientSite(null);
SetOcState(OC_LOADED);
}
}
private void ReleaseAxControl() {
// This line is like a bit of magic...
// sometimes, we crash with it on,
// sometimes, with it off...
// Lately, I have decided to leave it on...
// (oh, yes, and the crashes seemed to disappear...)
//cpr: ComLib.Release(instance);
this.NoComponentChangeEvents++;
ContainerControl f = ContainingControl;
if (f != null) {
f.VisibleChanged -= this.onContainerVisibleChanged;
}
try {
if (instance != null) {
Marshal.FinalReleaseComObject(instance);
instance = null;
iOleInPlaceObject = null;
iOleObject = null;
iOleControl = null;
iOleInPlaceActiveObject = null;
iOleInPlaceActiveObjectExternal = null;
iPerPropertyBrowsing = null;
iCategorizeProperties = null;
iPersistStream = null;
iPersistStreamInit = null;
iPersistStorage = null;
}
axState[checkedIppb] = false;
axState[checkedCP] = false;
axState[disposed] = true;
freezeCount = 0;
axState[sinkAttached] = false;
wndprocAddr = IntPtr.Zero;
SetOcState(OC_PASSIVE);
}
finally {
this.NoComponentChangeEvents--;
}
}
private void ParseMiscBits(int bits) {
axState[fOwnWindow] = ((bits & NativeMethods.ActiveX.OLEMISC_INVISIBLEATRUNTIME) != 0) && IsUserMode();
axState[fSimpleFrame] = ((bits & NativeMethods.ActiveX.OLEMISC_SIMPLEFRAME) != 0);
}
private void SlowActivate() {
bool setClientSite = false;
if ((miscStatusBits & NativeMethods.ActiveX.OLEMISC_SETCLIENTSITEFIRST) != 0) {
GetOleObject().SetClientSite(oleSite);
setClientSite = true;
}
DepersistControl();
if (!setClientSite) {
GetOleObject().SetClientSite(oleSite);
}
}
private static NativeMethods.COMRECT FillInRect(NativeMethods.COMRECT dest, Rectangle source) {
dest.left = source.X;
dest.top = source.Y;
dest.right = source.Width + source.X;
dest.bottom = source.Height + source.Y;
return dest;
}
private AxContainer GetParentContainer() {
Debug.WriteLineIf(IntSecurity.SecurityDemand.TraceVerbose, "GetParent Demanded");
IntSecurity.GetParent.Demand();
if (container == null) {
container = AxContainer.FindContainerForControl(this);
}
if (container == null) {
ContainerControl f = ContainingControl;
if (f == null) {
// ContainingCointrol can be null if the AxHost is still not parented to a containerControl
// In everett we used to return a parking window.
// now we just set the containingControl to a dummyValue.
if (newParent == null)
{
newParent = new ContainerControl();
axContainer = newParent.CreateAxContainer();
axContainer.AddControl(this);
}
return axContainer;
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "calling upon "+f.ToString()+" to create a container");
container = f.CreateAxContainer();
container.AddControl(this);
containingControl = f;
}
}
return container;
}
private UnsafeNativeMethods.IOleControl GetOleControl() {
if (iOleControl == null) {
Debug.Assert(instance != null, "must have the ocx");
iOleControl = (UnsafeNativeMethods.IOleControl) instance;
}
return iOleControl;
}
private UnsafeNativeMethods.IOleInPlaceActiveObject GetInPlaceActiveObject() {
// if our AxContainer was set an external active object then use it.
if(iOleInPlaceActiveObjectExternal != null) {
return iOleInPlaceActiveObjectExternal;
}
// otherwise use our instance.
if (iOleInPlaceActiveObject == null) {
Debug.Assert(instance != null, "must have the ocx");
try {
iOleInPlaceActiveObject = (UnsafeNativeMethods.IOleInPlaceActiveObject)instance;
}
catch (InvalidCastException e) {
Debug.Fail("Invalid cast in GetInPlaceActiveObject: " + e.ToString());
}
}
return iOleInPlaceActiveObject;
}
private UnsafeNativeMethods.IOleObject GetOleObject() {
if (iOleObject == null) {
Debug.Assert(instance != null, "must have the ocx");
iOleObject = (UnsafeNativeMethods.IOleObject) instance;
}
return iOleObject;
}
private UnsafeNativeMethods.IOleInPlaceObject GetInPlaceObject() {
if (iOleInPlaceObject == null) {
Debug.Assert(instance != null, "must have the ocx");
iOleInPlaceObject = (UnsafeNativeMethods.IOleInPlaceObject) instance;
#if DEBUG
if (iOleInPlaceObject is UnsafeNativeMethods.IOleInPlaceObjectWindowless)
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, GetType().FullName + " Can also be a Windowless control.");
#endif //DEBUG
}
return iOleInPlaceObject;
}
private NativeMethods.ICategorizeProperties GetCategorizeProperties() {
if (iCategorizeProperties == null && !axState[checkedCP] && instance != null) {
axState[checkedCP] = true;
if (instance is NativeMethods.ICategorizeProperties) {
iCategorizeProperties = (NativeMethods.ICategorizeProperties) instance;
}
}
return iCategorizeProperties;
}
private NativeMethods.IPerPropertyBrowsing GetPerPropertyBrowsing() {
if (iPerPropertyBrowsing == null && !axState[checkedIppb] && instance != null) {
axState[checkedIppb] = true;
if (instance is NativeMethods.IPerPropertyBrowsing) {
iPerPropertyBrowsing = (NativeMethods.IPerPropertyBrowsing) instance;
}
}
return iPerPropertyBrowsing;
}
// Mapping functions:
#if false
// FxCop: Currently not used
private static IntPtr CopyPalette(IntPtr hPal) {
if (hPal == IntPtr.Zero) return IntPtr.Zero;
int[] nEntries = new int[1];
UnsafeNativeMethods.GetObject(new HandleRef(null, hPal), 4, nEntries);
IntPtr memory = Marshal.AllocHGlobal(nEntries[0] * 4 + 8);
IntPtr ret = IntPtr.Zero;
try {
Marshal.WriteInt32(memory, 0, 0x300);
Marshal.WriteInt32(memory, 4, nEntries[0]);
SafeNativeMethods.GetPaletteEntries(new HandleRef(null, hPal), 0, nEntries[0], (IntPtr)((long)memory + 8));
ret = SafeNativeMethods.CreatePalette(new HandleRef(null, memory));
}
finally {
Marshal.FreeHGlobal(memory);
}
return ret;
}
#endif
private static Object GetPICTDESCFromPicture(Image image) {
Bitmap bmp = image as Bitmap;
if (bmp != null) {
return new NativeMethods.PICTDESCbmp(bmp);
}
Metafile mf = image as Metafile;
if (mf != null)
{
return new NativeMethods.PICTDESCemf(mf);
}
throw new ArgumentException(SR.GetString(SR.AXUnknownImage), "image");
}
///
/// Maps from a System.Drawing.Image to an OLE IPicture
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static object GetIPictureFromPicture(Image image) {
if (image == null) return null;
Object pictdesc = GetPICTDESCFromPicture(image);
return UnsafeNativeMethods.OleCreateIPictureIndirect(pictdesc, ref ipicture_Guid, true);
}
///
/// Maps from a System.Drawing.Cursor to an OLE IPicture
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static object GetIPictureFromCursor(Cursor cursor) {
if (cursor == null) return null;
NativeMethods.PICTDESCicon pictdesc = new NativeMethods.PICTDESCicon(Icon.FromHandle(cursor.Handle));
return UnsafeNativeMethods.OleCreateIPictureIndirect(pictdesc, ref ipicture_Guid, true);
}
///
/// Maps from a System.Drawing.Image to an OLE IPictureDisp
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static object GetIPictureDispFromPicture(Image image) {
if (image == null) return null;
Object pictdesc = GetPICTDESCFromPicture(image);
return UnsafeNativeMethods.OleCreateIPictureDispIndirect(pictdesc, ref ipictureDisp_Guid, true);
}
///
/// Maps from an OLE IPicture to a System.Drawing.Image
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static Image GetPictureFromIPicture(object picture) {
if (picture == null) return null;
IntPtr hPal = IntPtr.Zero;
UnsafeNativeMethods.IPicture pict = (UnsafeNativeMethods.IPicture)picture;
int type = pict.GetPictureType();
if (type == NativeMethods.Ole.PICTYPE_BITMAP) {
try {
hPal = pict.GetHPal();
}
catch (COMException) {
}
}
return GetPictureFromParams(pict, pict.GetHandle(), type, hPal, pict.GetWidth(), pict.GetHeight());
}
///
/// Maps from an OLE IPictureDisp to a System.Drawing.Image
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static Image GetPictureFromIPictureDisp(object picture) {
if (picture == null) return null;
IntPtr hPal = IntPtr.Zero;
UnsafeNativeMethods.IPictureDisp pict = (UnsafeNativeMethods.IPictureDisp)picture;
int type = pict.PictureType;
if (type == NativeMethods.Ole.PICTYPE_BITMAP) {
try {
hPal = pict.HPal;
}
catch (COMException) {
}
}
return GetPictureFromParams(pict, pict.Handle, type, hPal, pict.Width, pict.Height);
}
private static Image GetPictureFromParams(object pict, IntPtr handle, int type, IntPtr paletteHandle, int width, int height) {
switch (type) {
case NativeMethods.Ole.PICTYPE_ICON:
return(Image)(Icon.FromHandle(handle)).Clone();
case NativeMethods.Ole.PICTYPE_METAFILE:
WmfPlaceableFileHeader header = new WmfPlaceableFileHeader();
header.BboxRight = (short)width;
header.BboxBottom = (short)height;
return(Image)(new Metafile(handle, header, false)).Clone();
case NativeMethods.Ole.PICTYPE_ENHMETAFILE:
return(Image)(new Metafile(handle, false)).Clone();
case NativeMethods.Ole.PICTYPE_BITMAP:
return Image.FromHbitmap(handle, paletteHandle);
case NativeMethods.Ole.PICTYPE_NONE:
// MSDN sez this should not be a valid value, but comctl32 returns it...
return null;
case NativeMethods.Ole.PICTYPE_UNINITIALIZED:
return null;
default:
Debug.Fail("Invalid image type "+ type.ToString(CultureInfo.InvariantCulture));
throw new ArgumentException(SR.GetString(SR.AXUnknownImage), "type");
}
}
private static NativeMethods.FONTDESC GetFONTDESCFromFont(Font font) {
NativeMethods.FONTDESC fdesc = null;
if (fontTable == null) {
fontTable = new Hashtable();
}
else {
fdesc = (NativeMethods.FONTDESC)fontTable[font];
}
if (fdesc == null) {
fdesc = new NativeMethods.FONTDESC();
fdesc.lpstrName = font.Name;
fdesc.cySize = (long)(font.SizeInPoints * 10000);
NativeMethods.LOGFONT logfont = new NativeMethods.LOGFONT();
font.ToLogFont(logfont);
fdesc.sWeight = (short) logfont.lfWeight;
fdesc.sCharset = logfont.lfCharSet;
fdesc.fItalic = font.Italic;
fdesc.fUnderline = font.Underline;
fdesc.fStrikethrough = font.Strikeout;
fontTable[font] = fdesc;
}
return fdesc;
}
///
/// Maps from an OLE COLOR to a System.Drawing.Color
///
[CLSCompliantAttribute(false)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static Color GetColorFromOleColor(uint color) {
return ColorTranslator.FromOle((int)color);
}
///
/// Maps from an System.Drawing.Color to an OLE COLOR
///
[CLSCompliantAttribute(false)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static uint GetOleColorFromColor(Color color) {
return (uint)ColorTranslator.ToOle(color);
}
///
/// Maps from a System.Drawing.Font object to an OLE IFont
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static object GetIFontFromFont(Font font) {
if (font == null) return null;
if (font.Unit != GraphicsUnit.Point)
throw new ArgumentException(SR.GetString(SR.AXFontUnitNotPoint), "font");
try {
return (UnsafeNativeMethods.IFont)UnsafeNativeMethods.OleCreateIFontIndirect(GetFONTDESCFromFont(font), ref ifont_Guid);
}
catch {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Failed to create IFrom from font: " + font.ToString());
return null;
}
}
///
/// Maps from an OLE IFont to a System.Drawing.Font object
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static Font GetFontFromIFont(object font) {
if (font == null) return null;
UnsafeNativeMethods.IFont oleFont = (UnsafeNativeMethods.IFont)font;
try {
Font f = Font.FromHfont(oleFont.GetHFont());
if (f.Unit != GraphicsUnit.Point)
f = new Font(f.Name, f.SizeInPoints, f.Style, GraphicsUnit.Point, f.GdiCharSet, f.GdiVerticalFont);
return f;
}
catch (Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Could not create font." + e.Message);
return DefaultFont;
}
}
///
/// Maps from a System.Drawing.Font object to an OLE IFontDisp
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static object GetIFontDispFromFont(Font font) {
if (font == null) return null;
if (font.Unit != GraphicsUnit.Point)
throw new ArgumentException(SR.GetString(SR.AXFontUnitNotPoint), "font");
SafeNativeMethods.IFontDisp rval = SafeNativeMethods.OleCreateIFontDispIndirect(GetFONTDESCFromFont(font), ref ifontDisp_Guid);
return rval;
}
///
/// Maps from an IFontDisp to a System.Drawing.Font object
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static Font GetFontFromIFontDisp(object font) {
if (font == null)
{
return null;
}
UnsafeNativeMethods.IFont ifont = font as UnsafeNativeMethods.IFont;
if (ifont != null)
{
return GetFontFromIFont(ifont);
}
SafeNativeMethods.IFontDisp oleFont = (SafeNativeMethods.IFontDisp)font;
FontStyle style = FontStyle.Regular;
Font f = null;
try {
if (oleFont.Bold)
style |= FontStyle.Bold;
if (oleFont.Italic)
style |= FontStyle.Italic;
if (oleFont.Underline)
style |= FontStyle.Underline;
if (oleFont.Strikethrough)
style |= FontStyle.Strikeout;
if ((int) oleFont.Weight >= 700) // bold
style |= FontStyle.Bold;
f = new Font(oleFont.Name, (float)oleFont.Size/(float)10000, style, GraphicsUnit.Point, (byte)oleFont.Charset);
return f;
}
catch(Exception e) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Could not create font from: " + oleFont.Name + ". " + e.Message);
return DefaultFont;
}
}
///
/// Maps from a DateTime object to an OLE DATE (expressed as a double)
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static double GetOADateFromTime(DateTime time) {
return time.ToOADate();
}
///
/// Maps from an OLE DATE (expressed as a double) to a DateTime object
///
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected static DateTime GetTimeFromOADate(double date) {
return DateTime.FromOADate(date);
}
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
private class VBFormat : UnsafeNativeMethods.IVBFormat {
// IVBFormat methods:
//
int UnsafeNativeMethods.IVBFormat.Format(ref Object var, IntPtr pszFormat, IntPtr lpBuffer, short cpBuffer, int lcid, short firstD, short firstW, short[] result) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in Format");
if (result == null)
return NativeMethods.E_INVALIDARG;
result[0] = 0;
if (lpBuffer == IntPtr.Zero || cpBuffer < 2)
return NativeMethods.E_INVALIDARG;
IntPtr pbstr = IntPtr.Zero;
int hr = UnsafeNativeMethods.VarFormat(ref var, new HandleRef(null, pszFormat), firstD, firstW, 32 /* VAR_FORMAT_NOSUBSTITUTE */, ref pbstr);
try {
int i = 0;
if (pbstr != IntPtr.Zero) {
short ch = 0;
cpBuffer --;
for (;i < cpBuffer && (ch = Marshal.ReadInt16(pbstr, i * 2)) != 0; i++) {
Marshal.WriteInt16(lpBuffer, i * 2, ch);
}
}
Marshal.WriteInt16(lpBuffer, i * 2, (short) 0);
result[0] = (short) i;
}
finally {
SafeNativeMethods.SysFreeString(new HandleRef(null, pbstr));
}
return NativeMethods.S_OK;
}
}
///
///
internal class EnumUnknown : UnsafeNativeMethods.IEnumUnknown {
private Object[] arr;
private int loc;
private int size;
internal EnumUnknown(Object[] arr) {
//if (AxHTraceSwitch.TraceVerbose) Debug.WriteObject(arr);
this.arr = arr;
loc = 0;
size = (arr == null) ? 0 : arr.Length;
}
private EnumUnknown(Object[] arr, int loc) : this(arr) {
this.loc = loc;
}
unsafe int UnsafeNativeMethods.IEnumUnknown.Next(int celt, IntPtr rgelt, IntPtr pceltFetched) {
if (pceltFetched != IntPtr.Zero)
Marshal.WriteInt32(pceltFetched, 0, 0);
if (celt < 0) {
return NativeMethods.E_INVALIDARG;
}
int fetched = 0;
if (loc >= size) {
fetched = 0;
}
else {
for (; loc < size && fetched < celt; ++loc) {
if (arr[loc] != null) {
Marshal.WriteIntPtr(rgelt, Marshal.GetIUnknownForObject(arr[loc]));
rgelt = (IntPtr)((long)rgelt + (long)sizeof(IntPtr));
++fetched;
}
}
}
if (pceltFetched != IntPtr.Zero)
Marshal.WriteInt32(pceltFetched, 0, fetched);
if (fetched != celt) {
return(NativeMethods.S_FALSE);
}
return NativeMethods.S_OK;
}
int UnsafeNativeMethods.IEnumUnknown.Skip(int celt) {
loc += celt;
if (loc >= size) {
return(NativeMethods.S_FALSE);
}
return NativeMethods.S_OK;
}
void UnsafeNativeMethods.IEnumUnknown.Reset() {
loc = 0;
}
void UnsafeNativeMethods.IEnumUnknown.Clone(out UnsafeNativeMethods.IEnumUnknown ppenum) {
ppenum = new EnumUnknown(arr, loc);
}
}
///
///
internal class AxContainer : UnsafeNativeMethods.IOleContainer, UnsafeNativeMethods.IOleInPlaceFrame, IReflect {
internal ContainerControl parent;
private IContainer assocContainer; // associated IContainer...
// the assocContainer may be null, in which case all this container does is
// forward [de]activation messages to the requisite container...
private AxHost siteUIActive;
private AxHost siteActive;
private bool formAlreadyCreated = false;
private Hashtable containerCache = new Hashtable(); // name -> Control
private int lockCount = 0;
private Hashtable components = null; // Control -> any
private Hashtable proxyCache = null;
private AxHost ctlInEditMode = null;
private const int GC_CHILD = 0x1;
private const int GC_LASTSIBLING = 0x2;
private const int GC_FIRSTSIBLING = 0x4;
private const int GC_CONTAINER = 0x20;
private const int GC_PREVSIBLING = 0x40;
private const int GC_NEXTSIBLING = 0x80;
internal AxContainer(ContainerControl parent) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in constructor. Parent created : "+parent.Created.ToString());
this.parent = parent;
if (parent.Created) FormCreated();
}
// IReflect methods:
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr,Binder binder, Type[] types,ParameterModifier[] modifiers) {
return null;
}
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr) {
return null;
}
MethodInfo[] IReflect.GetMethods(BindingFlags bindingAttr) {
return new MethodInfo[0];
}
FieldInfo IReflect.GetField(String name, BindingFlags bindingAttr) {
return null;
}
FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) {
return new FieldInfo[0];
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr) {
return null;
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers) {
return null;
}
PropertyInfo[] IReflect.GetProperties(BindingFlags bindingAttr) {
return new PropertyInfo[0];
}
MemberInfo[] IReflect.GetMember(String name, BindingFlags bindingAttr) {
return new MemberInfo[0];
}
MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr) {
return new MemberInfo[0];
}
Object IReflect.InvokeMember(String name, BindingFlags invokeAttr, Binder binder,
Object target, Object[] args, ParameterModifier[] modifiers, CultureInfo culture, String[] namedParameters) {
foreach(DictionaryEntry e in containerCache) {
string ctlName = GetNameForControl((Control)e.Key);
if (ctlName.Equals(name)) {
return GetProxyForControl((Control)e.Value);
}
}
throw E_FAIL;
}
Type IReflect.UnderlyingSystemType {
get {
return null;
}
}
///
/// [To be supplied.]
///
internal UnsafeNativeMethods.IExtender GetProxyForControl(Control ctl) {
UnsafeNativeMethods.IExtender rval = null;
if (proxyCache == null) {
proxyCache = new Hashtable();
}
else {
rval = (UnsafeNativeMethods.IExtender) proxyCache[ctl];
}
if (rval == null) {
if (ctl != parent && !GetControlBelongs(ctl)) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "!parent || !belongs NYI");
AxContainer c = FindContainerForControl(ctl);
if (c != null) {
rval = new ExtenderProxy(ctl, c);
}
else {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "unable to find proxy, returning null");
return null;
}
}
else {
rval = new ExtenderProxy(ctl, this);
}
proxyCache.Add(ctl, rval);
}
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "found proxy "+rval.ToString());
return rval;
}
///
/// [To be supplied.]
///
internal string GetNameForControl(Control ctl) {
string name = (ctl.Site != null) ? ctl.Site.Name : ctl.Name;
return (name == null) ? "" : name;
}
///
/// [To be supplied.]
///
internal Object GetProxyForContainer() {
return this;
}
///
/// [To be supplied.]
///
internal void AddControl(Control ctl) {
//
lock(this) {
if (containerCache.Contains(ctl))
throw new ArgumentException(SR.GetString(SR.AXDuplicateControl, GetNameForControl(ctl)), "ctl");
containerCache.Add(ctl, ctl);
if (assocContainer == null) {
ISite site = ctl.Site;
if (site != null) {
assocContainer = site.Container;
IComponentChangeService ccs = (IComponentChangeService)site.GetService(typeof(IComponentChangeService));
if (ccs != null) {
ccs.ComponentRemoved += new ComponentEventHandler(this.OnComponentRemoved);
}
}
}
else {
#if DEBUG
ISite site = ctl.Site;
if (site != null && assocContainer != site.Container) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "mismatch between assoc container & added control");
}
#endif
}
}
}
internal void RemoveControl(Control ctl) {
//
lock(this) {
if (containerCache.Contains(ctl)) {
containerCache.Remove(ctl);
}
}
}
///
/// [To be supplied.]
///
private void LockComponents() {
lockCount++;
}
///
/// [To be supplied.]
///
private void UnlockComponents() {
lockCount--;
if (lockCount == 0) {
components = null;
}
}
///
/// [To be supplied.]
///
internal UnsafeNativeMethods.IEnumUnknown EnumControls(Control ctl, int dwOleContF, int dwWhich) {
GetComponents();
LockComponents();
try {
ArrayList l = null;
bool selected = (dwWhich & NativeMethods.ActiveX.GC_WCH_FSELECTED) != 0;
bool reverse = (dwWhich & NativeMethods.ActiveX.GC_WCH_FREVERSEDIR) != 0;
// Note that visual basic actually ignores the next/prev flags... we will not
bool onlyNext = (dwWhich & NativeMethods.ActiveX.GC_WCH_FONLYNEXT) != 0;
bool onlyPrev = (dwWhich & NativeMethods.ActiveX.GC_WCH_FONLYPREV) != 0;
dwWhich = dwWhich & ~(NativeMethods.ActiveX.GC_WCH_FSELECTED | NativeMethods.ActiveX.GC_WCH_FREVERSEDIR |
NativeMethods.ActiveX.GC_WCH_FONLYNEXT | NativeMethods.ActiveX.GC_WCH_FONLYPREV);
if (onlyNext && onlyPrev) {
Debug.Fail("onlyNext && onlyPrev are both set!");
throw E_INVALIDARG;
}
if (dwWhich == NativeMethods.ActiveX.GC_WCH_CONTAINER || dwWhich == NativeMethods.ActiveX.GC_WCH_CONTAINED) {
if (onlyNext || onlyPrev) {
Debug.Fail("GC_WCH_FONLYNEXT or FONLYPREV used with CONTANER or CONATINED");
throw E_INVALIDARG;
}
}
int first = 0;
int last = -1; // meaning all
Control[] ctls = null;
switch (dwWhich) {
default:
Debug.Fail("Bad GC_WCH");
throw E_INVALIDARG;
case NativeMethods.ActiveX.GC_WCH_CONTAINED:
ctls = ctl.GetChildControlsInTabOrder(false);
ctl = null;
break;
case NativeMethods.ActiveX.GC_WCH_SIBLING:
Control p = ctl.ParentInternal;
if (p != null) {
ctls = p.GetChildControlsInTabOrder(false);
if (onlyPrev) {
last = ctl.TabIndex;
}
else if (onlyNext) {
first = ctl.TabIndex + 1;
}
}
else {
ctls = new Control[0];
}
ctl = null;
break;
case NativeMethods.ActiveX.GC_WCH_CONTAINER:
l = new ArrayList();
MaybeAdd(l, ctl, selected, dwOleContF, false);
while (ctl != null) {
AxContainer cont = FindContainerForControl(ctl);
if (cont != null) {
MaybeAdd(l, cont.parent, selected, dwOleContF, true);
ctl = cont.parent;
}
else {
break;
}
}
break;
case NativeMethods.ActiveX.GC_WCH_ALL:
Hashtable htbl = GetComponents();
ctls = new Control[htbl.Keys.Count];
htbl.Keys.CopyTo(ctls, 0);
ctl = parent;
break;
}
if (l == null) {
l = new ArrayList();
if (last == -1 && ctls != null) last = ctls.Length;
if (ctl != null) MaybeAdd(l, ctl, selected, dwOleContF, false);
for (int i = first; i < last; i++) {
MaybeAdd(l, ctls[i], selected, dwOleContF, false);
}
}
Object[] rval = new Object[l.Count];
l.CopyTo(rval, 0);
if (reverse) {
for (int i = 0, j = rval.Length - 1; i < j; i++, j--) {
Object temp = rval[i];
rval[i] = rval[j];
rval[j] = temp;
}
}
return new EnumUnknown(rval);
}
finally {
UnlockComponents();
}
}
///
/// [To be supplied.]
///
private void MaybeAdd(ArrayList l, Control ctl, bool selected, int dwOleContF, bool ignoreBelong) {
if (!ignoreBelong && ctl != parent && !GetControlBelongs(ctl)) return;
if (selected) {
ISelectionService iss = GetSelectionService(ctl);
if (iss == null || !iss.GetComponentSelected(this)) return;
}
AxHost hostctl = ctl as AxHost;
if (hostctl != null && (dwOleContF & NativeMethods.ActiveX.OLECONTF_EMBEDDINGS) != 0) {
l.Add(hostctl.GetOcx());
}
else if ((dwOleContF & NativeMethods.ActiveX.OLECONTF_OTHERS) != 0) {
Object item = GetProxyForControl(ctl);
if (item != null) l.Add(item);
}
}
///
/// [To be supplied.]
///
private void FillComponentsTable(IContainer container) {
if (container != null) {
ComponentCollection comps = container.Components;
if (comps != null) {
components = new Hashtable();
foreach (IComponent comp in comps) {
if (comp is Control && comp != parent && comp.Site != null) {
components.Add(comp, comp);
}
}
return;
}
}
Debug.Assert(parent.Site == null, "Parent is sited but we could not find IContainer!!!");
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Did not find a container in FillComponentsTable!!!");
bool checkHashTable = true;
Control[] ctls = new Control[containerCache.Values.Count];
containerCache.Values.CopyTo(ctls, 0);
if (ctls != null) {
if (ctls.Length > 0 && components == null) {
components = new Hashtable();
checkHashTable = false;
}
for (int i = 0; i < ctls.Length; i ++) {
if (checkHashTable && !components.Contains(ctls[i])) {
components.Add(ctls[i], ctls[i]);
}
}
}
GetAllChildren(this.parent);
}
private void GetAllChildren(Control ctl) {
if (ctl == null)
return;
if (components == null) {
components = new Hashtable();
}
if (ctl != this.parent && !components.Contains(ctl))
components.Add(ctl, ctl);
foreach(Control c in ctl.Controls) {
GetAllChildren(c);
}
}
///
/// [To be supplied.]
///
private Hashtable GetComponents() {
return GetComponents(GetParentsContainer());
}
///
/// [To be supplied.]
///
private Hashtable GetComponents(IContainer cont) {
if (lockCount == 0) {
FillComponentsTable(cont);
}
return components;
}
///
/// [To be supplied.]
///
private bool GetControlBelongs(Control ctl) {
Hashtable comps = GetComponents();
return comps[ctl] != null;
}
///
/// [To be supplied.]
///
private IContainer GetParentIsDesigned() {
ISite site = parent.Site;
if (site != null && site.DesignMode) return site.Container;
return null;
}
///
/// [To be supplied.]
///
private IContainer GetParentsContainer() {
IContainer rval = GetParentIsDesigned();
Debug.Assert(rval == null || assocContainer == null || (rval == assocContainer),
"mismatch between getIPD & aContainer");
return rval == null ? assocContainer : rval;
}
///
/// [To be supplied.]
///
private bool RegisterControl(AxHost ctl) {
ISite site = ctl.Site;
if (site != null) {
IContainer cont = site.Container;
if (cont != null) {
if (assocContainer != null) {
return cont == assocContainer;
}
else {
assocContainer = cont;
IComponentChangeService ccs = (IComponentChangeService)site.GetService(typeof(IComponentChangeService));
if (ccs != null) {
ccs.ComponentRemoved += new ComponentEventHandler(this.OnComponentRemoved);
}
return true;
}
}
}
return false;
}
private void OnComponentRemoved(object sender, ComponentEventArgs e) {
Control c = e.Component as Control;
if (sender == assocContainer && c != null) {
RemoveControl(c);
}
}
///
/// [To be supplied.]
///
internal static AxContainer FindContainerForControl(Control ctl) {
AxHost axctl = ctl as AxHost;
if (axctl != null)
{
if (axctl.container != null) return axctl.container;
ContainerControl f = axctl.ContainingControl;
if (f != null) {
AxContainer container = f.CreateAxContainer();
if (container.RegisterControl(axctl)) {
container.AddControl(axctl);
return container;
}
}
}
return null;
}
#if false
// FxCop: Currently not used
private void OnOldActiveControl(Control valueOld, Control valueNew) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "onOAC called with old: "+valueOld.ToString()+" new: "+valueNew.ToString());
if (!(valueOld is AxHost)) return;
AxContainer c = FindContainerForControl(valueOld);
if (c != null) {
c.OnOldActiveControlInternal(valueOld);
}
else {
Debug.Fail("control w/o a container... pretty bad..."+valueOld.ToString());
}
}
///
/// [To be supplied.]
///
// FxCop: Currently not used
private void OnOldActiveControlInternal(Control valueOld) {
if (siteUIActive == valueOld) siteUIActive.UiDeactivate();
}
// FxCop: Currently not used
private void OnNewActiveControl(Control value) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "onNAC called with new: "+value.ToString());
if (!(value is AxHost)) return;
AxContainer c = FindContainerForControl(value);
if (c != null) {
c.OnNewActiveControlInternal((AxHost)value);
}
else {
Debug.Fail("control w/o a container... pretty bad..."+value.ToString());
}
}
///
/// [To be supplied.]
///
// FxCop: Currently not used
private void OnNewActiveControlInternal(AxHost value) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "New active control. siteUIActive is" +siteUIActive.ToString()+" Control is "+value.ToString());
if (siteUIActive != null && siteUIActive != value) {
Debug.Fail("we should not have an ui active site on this container!"+parent.ToString());
siteUIActive.UiDeactivate();
}
#if DEBUG
if (siteUIActive != null && siteUIActive != value) Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Why is "+siteUIActive.ToString()+" still active?");
if (!value.CanUIActivate) Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "why can't "+value.ToString()+" be uiactivated?");
#endif
if (siteUIActive == null && value.CanUIActivate) {
// we need to uiactivate it ourselves...
try {
((AxHost)value).UiActivate();
}
catch (Exception e) {
Debug.Fail(e.ToString());
}
}
#if DEBUG
if (siteUIActive != parent.ActiveControl && value.CanUIActivate) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "form's active control is "+parent.ActiveControl.ToString());
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "could not reconcile active controls... bad things loom on the horizon...");
}
#endif
if (siteUIActive == null) {
// so now the form thinks that value is the active control but it's not ui active...
// this can often lead to bad things unless we are carefull...
siteActive = value;
// basically, when siteActive goes inplacedeactivate, we need to treat it the same as a
// siteuiactive going uiactivedeactivate...
}
}
#endif
///
/// [To be supplied.]
///
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?");
}
}
}
///
/// [To be supplied.]
///
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);
}
}
}
///
/// [To be supplied.]
///
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;
}
}
///
/// [To be supplied.]
///
private void ListAxControls(ArrayList list, bool fuseOcx) {
Hashtable components = GetComponents();
if (components == null) return;
Control[] ctls = new Control[components.Keys.Count];
components.Keys.CopyTo(ctls, 0);
if (ctls != null) {
for (int i = 0; i < ctls.Length; i++) {
Control ctl = ctls[i];
AxHost hostctl = ctl as AxHost;
if (hostctl != null) {
if (fuseOcx) {
list.Add(hostctl.GetOcx());
}
else {
list.Add(ctl);
}
}
}
}
}
///
/// [To be supplied.]
///
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();
}
}
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);
}
}
}
// IOleContainer methods:
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleContainer.ParseDisplayName(Object pbc, string pszDisplayName, int[] pchEaten, Object[] ppmkOut) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in ParseDisplayName");
if (ppmkOut != null)
ppmkOut[0] = null;
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleContainer.EnumObjects(int grfFlags, out UnsafeNativeMethods.IEnumUnknown ppenum) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in EnumObjects");
ppenum = null;
if ((grfFlags & 1) != 0) { // 1 == OLECONTF_EMBEDDINGS
Debug.Assert(parent != null, "gotta have it...");
ArrayList list = new ArrayList();
ListAxControls(list, true);
if (list.Count > 0) {
Object[] temp = new Object[list.Count];
list.CopyTo(temp, 0);
ppenum = new EnumUnknown(temp);
return NativeMethods.S_OK;
}
}
ppenum = new EnumUnknown(null);
return NativeMethods.S_OK;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleContainer.LockContainer(bool fLock) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in LockContainer");
return NativeMethods.E_NOTIMPL;
}
// IOleInPlaceFrame methods:
IntPtr UnsafeNativeMethods.IOleInPlaceFrame.GetWindow() {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetWindow");
return parent.Handle;
}
int UnsafeNativeMethods.IOleInPlaceFrame.ContextSensitiveHelp(int fEnterMode) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in ContextSensitiveHelp");
return NativeMethods.S_OK;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.GetBorder(NativeMethods.COMRECT lprectBorder) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetBorder");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.RequestBorderSpace(NativeMethods.COMRECT pborderwidths) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in RequestBorderSpace");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.SetBorderSpace(NativeMethods.COMRECT pborderwidths) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SetBorderSpace");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
internal void OnExitEditMode(AxHost ctl) {
Debug.Assert(ctlInEditMode == null || ctlInEditMode == ctl, "who is exiting edit mode?");
if (ctlInEditMode == null || ctlInEditMode != ctl) return;
ctlInEditMode = null;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.SetActiveObject(UnsafeNativeMethods.IOleInPlaceActiveObject pActiveObject, string pszObjName) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SetActiveObject " + ((pszObjName == 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;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.InsertMenus(IntPtr hmenuShared, NativeMethods.tagOleMenuGroupWidths lpMenuWidths) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in InsertMenus");
return NativeMethods.S_OK;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.SetMenu(IntPtr hmenuShared, IntPtr holemenu, IntPtr hwndActiveObject) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SetMenu");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.RemoveMenus(IntPtr hmenuShared) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in RemoveMenus");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.SetStatusText(string pszStatusText) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in SetStatusText");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.EnableModeless(bool fEnable) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in EnableModeless");
return NativeMethods.E_NOTIMPL;
}
///
/// [To be supplied.]
///
int UnsafeNativeMethods.IOleInPlaceFrame.TranslateAccelerator(ref NativeMethods.MSG lpmsg, short wID) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in IOleInPlaceFrame.TranslateAccelerator");
return NativeMethods.S_FALSE;
}
// EXPOSED
///
///
private class ExtenderProxy : UnsafeNativeMethods.IExtender, UnsafeNativeMethods.IVBGetControl, UnsafeNativeMethods.IGetVBAObject, UnsafeNativeMethods.IGetOleObject, IReflect {
private WeakReference pRef;
private WeakReference pContainer;
internal ExtenderProxy(Control principal, AxContainer container) {
pRef = new WeakReference(principal);
pContainer = new WeakReference(container);
}
private Control GetP() {
return(Control) pRef.Target;
}
private AxContainer GetC() {
return(AxContainer) pContainer.Target;
}
int UnsafeNativeMethods.IVBGetControl.EnumControls(int dwOleContF, int dwWhich, out UnsafeNativeMethods.IEnumUnknown ppenum) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in EnumControls for proxy");
ppenum = GetC().EnumControls(GetP(), dwOleContF, dwWhich);
return NativeMethods.S_OK;
}
object UnsafeNativeMethods.IGetOleObject.GetOleObject(ref Guid riid) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetOleObject for proxy");
if (!riid.Equals(ioleobject_Guid))
throw E_INVALIDARG;
Control ctl = GetP();
if (ctl != null && ctl is AxHost) {
return ((AxHost)ctl).GetOcx();
}
throw E_FAIL;
}
int UnsafeNativeMethods.IGetVBAObject.GetObject(ref Guid riid, UnsafeNativeMethods.IVBFormat[] rval, int dwReserved) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in GetObject for proxy");
if (rval == null || riid.Equals(Guid.Empty))
return NativeMethods.E_INVALIDARG;
if (riid.Equals(ivbformat_Guid)) {
rval[0] = new VBFormat();
return NativeMethods.S_OK;
}
else {
rval[0] = null;
return NativeMethods.E_NOINTERFACE;
}
}
public int Align {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getAlign for proxy for "+ GetP().ToString());
int rval = (int)((Control)GetP()).Dock;
if (rval < NativeMethods.ActiveX.ALIGN_MIN || rval > NativeMethods.ActiveX.ALIGN_MAX) {
rval = NativeMethods.ActiveX.ALIGN_NO_CHANGE;
}
return rval;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setAlign for proxy for "+ GetP().ToString()+" "+
value.ToString(CultureInfo.InvariantCulture));
GetP().Dock = (DockStyle)value;
}
}
public UInt32 BackColor {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getBackColor for proxy for "+ GetP().ToString());
return AxHost.GetOleColorFromColor(((Control)GetP()).BackColor);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setBackColor for proxy for "+ GetP().ToString()+" "+
value.ToString(CultureInfo.InvariantCulture));
GetP().BackColor = AxHost.GetColorFromOleColor(value);
}
}
public bool Enabled {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getEnabled for proxy for "+ GetP().ToString());
return GetP().Enabled;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setEnabled for proxy for "+ GetP().ToString()+" "+value.ToString());
GetP().Enabled = value;
}
}
public UInt32 ForeColor {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getForeColor for proxy for "+ GetP().ToString());
return AxHost.GetOleColorFromColor(((Control)GetP()).ForeColor);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setForeColor for proxy for "+ GetP().ToString()+" "+
value.ToString(CultureInfo.InvariantCulture));
GetP().ForeColor = AxHost.GetColorFromOleColor(value);
}
}
public int Height {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getHeight for proxy for "+ GetP().ToString());
return Pixel2Twip(GetP().Height, false);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setHeight for proxy for "+ GetP().ToString()+" "+
Twip2Pixel(value,false).ToString(CultureInfo.InvariantCulture));
GetP().Height = Twip2Pixel(value, false);
}
}
public int Left {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getLeft for proxy for "+ GetP().ToString());
return Pixel2Twip(GetP().Left, true);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setLeft for proxy for "+ GetP().ToString()+" "+
Twip2Pixel(value, true).ToString(CultureInfo.InvariantCulture));
GetP().Left = Twip2Pixel(value, true);
}
}
public object Parent {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getParent for proxy for "+ GetP().ToString());
return GetC().GetProxyForControl(GetC().parent);
}
}
public short TabIndex {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getTabIndex for proxy for "+ GetP().ToString());
return (short)GetP().TabIndex;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setTabIndex for proxy for "+ GetP().ToString()+" "+
value.ToString(CultureInfo.InvariantCulture));
GetP().TabIndex = (int)value;
}
}
public bool TabStop {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getTabStop for proxy for "+ GetP().ToString());
return GetP().TabStop;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setTabStop for proxy for "+ GetP().ToString()+" "+value.ToString());
GetP().TabStop = value;
}
}
public int Top {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getTop for proxy for "+ GetP().ToString());
return Pixel2Twip(GetP().Top, false);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setTop for proxy for "+ GetP().ToString()+" "+
Twip2Pixel(value, false).ToString(CultureInfo.InvariantCulture));
GetP().Top = Twip2Pixel(value, false);
}
}
public bool Visible {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getVisible for proxy for "+ GetP().ToString());
return GetP().Visible;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setVisible for proxy for "+ GetP().ToString()+" "+value.ToString());
GetP().Visible = value;
}
}
public int Width {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getWidth for proxy for "+ GetP().ToString());
return Pixel2Twip(GetP().Width,true);
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setWidth for proxy for "+ GetP().ToString()+" "+
Twip2Pixel(value, true).ToString(CultureInfo.InvariantCulture));
GetP().Width = Twip2Pixel(value, true);
}
}
public string Name {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getName for proxy for "+ GetP().ToString());
return GetC().GetNameForControl(GetP());
}
}
public IntPtr Hwnd {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getHwnd for proxy for "+ GetP().ToString());
return GetP().Handle;
}
}
public object Container {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getContainer for proxy for "+ GetP().ToString());
return GetC().GetProxyForContainer();
}
}
public string Text {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in getText for proxy for "+ GetP().ToString());
return GetP().Text;
}
set {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in setText for proxy for "+ GetP().ToString());
GetP().Text = value;
}
}
public void Move(Object left, Object top, Object width, Object height) {
}
// IReflect methods:
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr,Binder binder, Type[] types,ParameterModifier[] modifiers) {
return null;
}
MethodInfo IReflect.GetMethod(String name,BindingFlags bindingAttr) {
return null;
}
MethodInfo[] IReflect.GetMethods(BindingFlags bindingAttr) {
return new MethodInfo[] {this.GetType().GetMethod("Move")};
}
FieldInfo IReflect.GetField(String name, BindingFlags bindingAttr) {
return null;
}
FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) {
return new FieldInfo[0];
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr) {
PropertyInfo prop = GetP().GetType().GetProperty(name, bindingAttr);
if (prop == null) {
prop = this.GetType().GetProperty(name, bindingAttr);
}
return prop;
}
PropertyInfo IReflect.GetProperty(String name, BindingFlags bindingAttr, Binder binder,Type returnType, Type[] types, ParameterModifier[] modifiers) {
PropertyInfo prop = GetP().GetType().GetProperty(name, bindingAttr, binder, returnType, types, modifiers);
if (prop == null) {
prop = this.GetType().GetProperty(name, bindingAttr, binder, returnType, types, modifiers);
}
return prop;
}
PropertyInfo[] IReflect.GetProperties(BindingFlags bindingAttr) {
PropertyInfo[] extenderProps = this.GetType().GetProperties(bindingAttr);
PropertyInfo[] ctlProps = GetP().GetType().GetProperties(bindingAttr);
if (extenderProps == null) {
return ctlProps;
}
else if (ctlProps == null) {
return extenderProps;
}
else {
int iProp = 0;
PropertyInfo[] props = new PropertyInfo[extenderProps.Length + ctlProps.Length];
foreach(PropertyInfo prop in extenderProps) {
props[iProp++] = prop;
}
foreach(PropertyInfo prop in ctlProps) {
props[iProp++] = prop;
}
return props;
}
}
MemberInfo[] IReflect.GetMember(String name, BindingFlags bindingAttr) {
MemberInfo[] memb = GetP().GetType().GetMember(name, bindingAttr);
if (memb == null) {
memb = this.GetType().GetMember(name, bindingAttr);
}
return memb;
}
MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr) {
MemberInfo[] extenderMembs = this.GetType().GetMembers(bindingAttr);
MemberInfo[] ctlMembs = GetP().GetType().GetMembers(bindingAttr);
if (extenderMembs == null) {
return ctlMembs;
}
else if (ctlMembs == null) {
return extenderMembs;
}
else {
MemberInfo[] membs = new MemberInfo[extenderMembs.Length + ctlMembs.Length];
Array.Copy(extenderMembs, 0, membs, 0, extenderMembs.Length);
Array.Copy(ctlMembs, 0, membs, extenderMembs.Length, ctlMembs.Length);
return membs;
}
}
Object IReflect.InvokeMember(String name, BindingFlags invokeAttr, Binder binder,
Object target, Object[] args, ParameterModifier[] modifiers, CultureInfo culture, String[] namedParameters) {
try {
return this.GetType().InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
}
catch(MissingMethodException) {
return this.GetP().GetType().InvokeMember(name, invokeAttr, binder, GetP(), args, modifiers, culture, namedParameters);
}
}
Type IReflect.UnderlyingSystemType {
get {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "In UnderlyingSystemType");
return null;
}
}
}
}
///
/// StateConverter is a class that can be used to convert
/// State from one data type to another. Access this
/// class through the TypeDescriptor.
///
///
/// Gets a value indicating whether this converter can
/// convert an object in the given source type to the native type of the converter
/// using the context.
///
///
/// Gets a value indicating whether this converter can
/// convert an object to the given destination type using the context.
///
///
/// Converts the given object to the converter's native type.
///
///
/// Converts the given object to another type. The most common types to convert
/// are to and from a string object. The default implementation will make a call
/// to ToString on the object if the object is valid and if the destination
/// type is string. If this cannot convert to the desitnation type, this will
/// throw a NotSupportedException.
///
///
/// The class which encapsulates the persisted state of the underlying activeX control
/// An instance of this class my be obtained either by calling getOcxState on an
/// AxHost object, or by reading in from a stream.
///
[
TypeConverterAttribute(typeof(TypeConverter)),
Serializable
]
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.InheritanceDemand, Name="FullTrust")]
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.LinkDemand, Name="FullTrust")]
[SuppressMessage("Microsoft.Usage", "CA2240:ImplementISerializableCorrectly")]
public class State : ISerializable {
private int VERSION = 1;
private int length;
private byte[] buffer;
internal int type;
private MemoryStream ms;
private UnsafeNativeMethods.IStorage storage;
private UnsafeNativeMethods.ILockBytes iLockBytes;
private bool manualUpdate = false;
private string licenseKey = null;
private PropertyBagStream propBag;
// create on save from ipersist stream
///
/// [To be supplied.]
///
internal State(MemoryStream ms, int storageType, AxHost ctl, PropertyBagStream propBag) {
type = storageType;
this.propBag = propBag;
// dangerous?
length = (int)ms.Length;
this.ms = ms;
this.manualUpdate = ctl.GetAxState(AxHost.manualUpdate);
this.licenseKey = ctl.GetLicenseKey();
}
internal State(PropertyBagStream propBag) {
this.propBag = propBag;
}
internal State(MemoryStream ms) {
this.ms = ms;
this.length = (int)ms.Length;
InitializeFromStream(ms);
}
// create on init new w/ storage...
///
/// [To be supplied.]
///
internal State(AxHost ctl) {
CreateStorage();
manualUpdate = ctl.GetAxState(AxHost.manualUpdate);
licenseKey = ctl.GetLicenseKey();
type = STG_STORAGE;
}
///
/// [To be supplied.]
///
public State(Stream ms, int storageType, bool manualUpdate, string licKey) {
type = storageType;
// dangerous?
length = (int)ms.Length;
this.manualUpdate = manualUpdate;
this.licenseKey = licKey;
InitializeBufferFromStream(ms);
}
/**
* Constructor used in deserialization
*/
protected State(SerializationInfo info, StreamingContext context) {
SerializationInfoEnumerator sie = info.GetEnumerator();
if (sie == null) {
return;
}
for (; sie.MoveNext();) {
if (String.Compare(sie.Name, "Data", true, CultureInfo.InvariantCulture) == 0) {
try {
byte[] dat = (byte[])sie.Value;
if (dat != null) {
InitializeFromStream(new MemoryStream(dat));
}
}
catch (Exception e) {
Debug.Fail("failure: " + e.ToString());
}
}
else if (String.Compare(sie.Name, "PropertyBagBinary", true, CultureInfo.InvariantCulture) == 0) {
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Loading up property bag from stream...");
byte[] dat = (byte[])sie.Value;
if (dat != null) {
this.propBag = new PropertyBagStream();
propBag.Read(new MemoryStream(dat));
}
}
catch (Exception e) {
Debug.Fail("failure: " + e.ToString());
}
}
}
}
///
/// [To be supplied.]
///
internal int Type {
get {
return type;
}
set {
type = value;
}
}
internal bool _GetManualUpdate() {
return manualUpdate;
}
internal string _GetLicenseKey() {
return licenseKey;
}
///
/// [To be supplied.]
///
private void CreateStorage() {
Debug.Assert(storage == null, "but we already have a storage!!!");
IntPtr hglobal = IntPtr.Zero;
if (buffer != null) {
hglobal = UnsafeNativeMethods.GlobalAlloc(NativeMethods.GMEM_MOVEABLE, length);
IntPtr pointer = UnsafeNativeMethods.GlobalLock(new HandleRef(null, hglobal));
try {
if (pointer != IntPtr.Zero) {
Marshal.Copy(buffer, 0, pointer, length);
}
}
finally {
UnsafeNativeMethods.GlobalUnlock(new HandleRef(null, hglobal));
}
}
bool failed = false;
try {
iLockBytes = UnsafeNativeMethods.CreateILockBytesOnHGlobal(new HandleRef(null, hglobal), true);
if (buffer == null) {
storage = UnsafeNativeMethods.StgCreateDocfileOnILockBytes(iLockBytes,
NativeMethods.STGM_CREATE | NativeMethods.STGM_READWRITE | NativeMethods.STGM_SHARE_EXCLUSIVE, 0);
}
else {
storage = UnsafeNativeMethods.StgOpenStorageOnILockBytes(iLockBytes,
null, NativeMethods.STGM_READWRITE | NativeMethods.STGM_SHARE_EXCLUSIVE, 0, 0);
}
}
catch (Exception t) {
Debug.Fail(t.ToString());
failed = true;
}
if (failed) {
if (iLockBytes == null && hglobal != IntPtr.Zero) {
UnsafeNativeMethods.GlobalFree(new HandleRef(null, hglobal));
}
else {
iLockBytes = null;
}
storage = null;
}
}
internal UnsafeNativeMethods.IPropertyBag GetPropBag() {
return propBag;
}
internal UnsafeNativeMethods.IStorage GetStorage() {
if (storage == null)
CreateStorage();
return storage;
}
internal UnsafeNativeMethods.IStream GetStream() {
if (ms == null) {
Debug.Assert(buffer != null, "gotta have the buffer already...");
if (buffer == null) return null;
ms = new MemoryStream(buffer);
}
else {
ms.Seek(0, SeekOrigin.Begin);
}
return new UnsafeNativeMethods.ComStreamFromDataStream(ms);
}
private void InitializeFromStream(Stream ids) {
BinaryReader br = new BinaryReader(ids);
type = br.ReadInt32();
int version = br.ReadInt32();
manualUpdate = br.ReadBoolean();
int cc = br.ReadInt32();
if (cc != 0) {
licenseKey = new string(br.ReadChars(cc));
}
for (int skipUnits = br.ReadInt32(); skipUnits > 0; skipUnits --) {
int len = br.ReadInt32();
ids.Position = ids.Position + len;
}
length = br.ReadInt32();
if (length > 0)
buffer = br.ReadBytes(length);
}
private void InitializeBufferFromStream(Stream ids) {
BinaryReader br = new BinaryReader(ids);
length = br.ReadInt32();
if (length > 0)
buffer = br.ReadBytes(length);
}
internal State RefreshStorage(UnsafeNativeMethods.IPersistStorage iPersistStorage) {
Debug.Assert(storage != null, "how can we not have a storage object?");
Debug.Assert(iLockBytes != null, "how can we have a storage w/o ILockBytes?");
if (storage == null || iLockBytes == null) return null;
iPersistStorage.Save(storage, true);
storage.Commit(0);
iPersistStorage.HandsOffStorage();
try {
buffer = null;
ms = null;
NativeMethods.STATSTG stat = new NativeMethods.STATSTG();
iLockBytes.Stat(stat, NativeMethods.Ole.STATFLAG_NONAME);
length = (int) stat.cbSize;
buffer = new byte[length];
IntPtr hglobal = UnsafeNativeMethods.GetHGlobalFromILockBytes(iLockBytes);
IntPtr pointer = UnsafeNativeMethods.GlobalLock(new HandleRef(null, hglobal));
try {
if (pointer != IntPtr.Zero) {
Marshal.Copy(pointer, buffer, 0, length);
}
else {
length = 0;
buffer = null;
}
}
finally {
UnsafeNativeMethods.GlobalUnlock(new HandleRef(null, hglobal));
}
}
finally {
iPersistStorage.SaveCompleted(storage);
}
return this;
}
internal void Save(MemoryStream stream) {
BinaryWriter bw = new BinaryWriter(stream);
bw.Write(type);
bw.Write(VERSION);
bw.Write(manualUpdate);
if (licenseKey != null) {
bw.Write(licenseKey.Length);
bw.Write(licenseKey.ToCharArray());
}
else {
bw.Write((int)0);
}
bw.Write((int)0); // skip units
bw.Write(length);
if (buffer != null) {
bw.Write(buffer);
}
else if (ms != null) {
ms.Position = 0;
ms.WriteTo(stream);
}
else {
Debug.Assert(length == 0, "if we have no data, then our length has to be 0");
}
}
///
/// ISerializable private implementation
///
/// " : pVar.ToString()));
// The EE returns a VT_EMPTY for a null. The problem is that visual basic6 expects the caller to respect the
// "hint" it gives in the VariantType. For eg., for a VT_BSTR, it expects that the callee will null
// out the BSTR field of the variant. Since, the EE or us cannot do anything about this, we will return
// a E_INVALIDARG rather than let visual basic6 crash.
//
return (pVar == null) ? NativeMethods.E_INVALIDARG : NativeMethods.S_OK;
}
int UnsafeNativeMethods.IPropertyBag.Write(string pszPropName, ref object pVar) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Writing property " + pszPropName + " [" + pVar + "] into OCXState propertybag.");
if (pVar != null && !pVar.GetType().IsSerializable) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t " + pVar.GetType().FullName + " is not serializable.");
return NativeMethods.S_OK;
}
bag[pszPropName] = pVar;
return NativeMethods.S_OK;
}
internal void Write(Stream stream) {
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, bag);
}
}
///
/// [To be supplied.]
///
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.InheritanceDemand, Name="FullTrust")]
[System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.LinkDemand, Name="FullTrust")]
[ComVisible(false)]
public class AxComponentEditor : WindowsFormsComponentEditor {
///
/// [To be supplied.]
///
public override bool EditComponent(ITypeDescriptorContext context, object obj, IWin32Window parent) {
AxHost host = obj as AxHost;
if (host != null)
{
try {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "in AxComponentEditor.EditComponent");
((UnsafeNativeMethods.IOleControlSite)host.oleSite).ShowPropertyFrame();
return true;
}
catch (Exception t) {
Debug.Fail(t.ToString());
throw;
}
}
return false;
}
}
///
///
internal class AxPropertyDescriptor : PropertyDescriptor {
private PropertyDescriptor baseProp;
internal AxHost owner;
private DispIdAttribute dispid;
private TypeConverter converter;
private UITypeEditor editor;
private ArrayList updateAttrs = new ArrayList();
private int flags = 0;
private const int FlagUpdatedEditorAndConverter = 0x00000001;
private const int FlagCheckGetter = 0x00000002;
private const int FlagGettterThrew = 0x00000004;
private const int FlagIgnoreCanAccessProperties = 0x00000008;
private const int FlagSettingValue = 0x00000010;
[
SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors") // Shipped in Everett
]
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);
}
}
}
public override Type ComponentType {
get {
return baseProp.ComponentType;
}
}
public override TypeConverter Converter {
get {
if (dispid != null) {
UpdateTypeConverterAndTypeEditorInternal(false, Dispid);
}
return (converter != null) ? converter : base.Converter;
}
}
internal int Dispid {
get {
DispIdAttribute dispid = (DispIdAttribute)baseProp.Attributes[typeof(DispIdAttribute)];
if (dispid != null) {
return dispid.Value;
}
return NativeMethods.ActiveX.DISPID_UNKNOWN;
}
}
public override bool IsReadOnly {
get {
return baseProp.IsReadOnly;
}
}
public override Type PropertyType {
get {
return baseProp.PropertyType;
}
}
internal bool SettingValue {
get {
return GetFlag(FlagSettingValue);
}
}
private void AddAttribute(Attribute attr) {
updateAttrs.Add(attr);
}
public override bool CanResetValue(object o) {
return baseProp.CanResetValue(o);
}
public override object GetEditor(Type editorBaseType) {
UpdateTypeConverterAndTypeEditorInternal(false, dispid.Value);
if (editorBaseType.Equals(typeof(UITypeEditor)) && editor != null) {
return editor;
}
return base.GetEditor(editorBaseType);
}
private bool GetFlag(int flagValue) {
return ((flags & flagValue) == flagValue);
}
private Guid GetPropertyPage(int dispid) {
try {
NativeMethods.IPerPropertyBrowsing ippb = owner.GetPerPropertyBrowsing();
if (ippb == null) return Guid.Empty;
Guid rval;
if (NativeMethods.Succeeded(ippb.MapPropertyToPage(dispid, out rval))) {
return rval;
}
}
catch (COMException) {
}
catch (Exception t) {
Debug.Fail(t.ToString());
}
return Guid.Empty;
}
public override object GetValue(object component) {
if ((!GetFlag(FlagIgnoreCanAccessProperties) && !owner.CanAccessProperties) || GetFlag(FlagGettterThrew)) {
return null;
}
try {
// Some controls fire OnChanged() notifications when getting values of some properties. ASURT 20190.
// To prevent this kind of recursion, we check to see if we are already inside a OnChanged() call.
//
owner.NoComponentChangeEvents++;
return baseProp.GetValue(component);
}
catch (Exception e) {
if (!GetFlag(FlagCheckGetter)) {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Get failed for : " + Name + " with exception: " + e.Message + " .Making property non-browsable.");
SetFlag(FlagCheckGetter, true);
AddAttribute(new BrowsableAttribute(false));
owner.RefreshAllProperties = true;
SetFlag(FlagGettterThrew, true);
}
throw e;
}
finally {
owner.NoComponentChangeEvents--;
}
}
public void OnValueChanged(object component) {
this.OnValueChanged(component, EventArgs.Empty);
}
public override void ResetValue(object o) {
baseProp.ResetValue(o);
}
private void SetFlag(int flagValue, bool value) {
if (value) {
flags |= flagValue;
}
else {
flags &= ~flagValue;
}
}
public override void SetValue(Object component, Object value) {
if (!GetFlag(FlagIgnoreCanAccessProperties) && !owner.CanAccessProperties) {
return;
}
// State oldOcxState = owner.OcxState;
try {
SetFlag(FlagSettingValue, true);
if (this.PropertyType.IsEnum && (value.GetType() != this.PropertyType)) {
baseProp.SetValue(component, Enum.ToObject(this.PropertyType, value));
}
else {
baseProp.SetValue(component, value);
}
}
finally {
SetFlag(FlagSettingValue, false);
}
OnValueChanged(component);
if (owner == component) {
owner.SetAxState(AxHost.valueChanged, true);
}
}
public override bool ShouldSerializeValue(object o) {
return baseProp.ShouldSerializeValue(o);
}
internal void UpdateAttributes() {
if (updateAttrs.Count == 0)
return;
ArrayList attributes = new ArrayList(AttributeArray);
foreach(Attribute attr in updateAttrs) {
attributes.Add(attr);
}
Attribute[] temp = new Attribute[attributes.Count];
attributes.CopyTo(temp, 0);
AttributeArray = temp;
updateAttrs.Clear();
}
///
/// Called externally to update the editor or type converter.
/// This simply sets flags so this will happen, it doesn't actually to the update...
/// we wait and do that on-demand for perf.
///
internal void UpdateTypeConverterAndTypeEditor(bool force) {
// if this is an external request, flip the flag to false so we do the update on demand.
//
if (GetFlag(FlagUpdatedEditorAndConverter) && force) {
SetFlag(FlagUpdatedEditorAndConverter, false);
}
}
///
/// Called externally to update the editor or type converter.
/// This simply sets flags so this will happen, it doesn't actually to the update...
/// we wait and do that on-demand for perf.
///
internal void UpdateTypeConverterAndTypeEditorInternal(bool force, int dispid) {
// check to see if we're being forced here or if the work really
// needs to be done.
//
if (GetFlag(FlagUpdatedEditorAndConverter) && !force) {
return;
}
if (owner.GetOcx() == null) {
return;
}
try {
NativeMethods.IPerPropertyBrowsing ppb = owner.GetPerPropertyBrowsing();
if (ppb != null) {
bool hasStrings = false;
// check for enums
NativeMethods.CA_STRUCT caStrings = new NativeMethods.CA_STRUCT();
NativeMethods.CA_STRUCT caCookies = new NativeMethods.CA_STRUCT();
int hr = NativeMethods.S_OK;
try {
hr = ppb.GetPredefinedStrings(dispid, caStrings, caCookies);
}
catch(ExternalException ex) {
hr = ex.ErrorCode;
Debug.Fail("An exception occurred inside IPerPropertyBrowsing::GetPredefinedStrings(dispid=" +
dispid + "), object type=" + new ComNativeDescriptor().GetClassName(ppb));
}
if (hr != NativeMethods.S_OK) {
hasStrings = false;
// Destroy the existing editor if we created the current one
// so if the items have disappeared, we don't hold onto the old
// items.
if (converter is Com2EnumConverter) {
converter = null;
}
}
else {
hasStrings = true;
}
if (hasStrings) {
OleStrCAMarshaler stringMarshaler = new OleStrCAMarshaler(caStrings);
Int32CAMarshaler intMarshaler = new Int32CAMarshaler(caCookies);
if (stringMarshaler.Count > 0 && intMarshaler.Count > 0) {
if (converter == null) {
converter = new AxEnumConverter(this, new AxPerPropertyBrowsingEnum(this, owner, stringMarshaler, intMarshaler, true));
}
else if (converter is AxEnumConverter){
((AxEnumConverter)converter).RefreshValues();
AxPerPropertyBrowsingEnum axEnum = ((AxEnumConverter)converter).com2Enum as AxPerPropertyBrowsingEnum;
if (axEnum != null) {
axEnum.RefreshArrays(stringMarshaler, intMarshaler);
}
}
}
else {
//hasStrings = false;
}
}
else {
// if we didn't get any strings, try the proppage edtior
//
// Check to see if this is a property that we have already massaged to be a
// .Net type. If it is, don't bother with custom property pages. We already
// have a .Net Editor for this type.
//
ComAliasNameAttribute comAlias = (ComAliasNameAttribute)baseProp.Attributes[typeof(ComAliasNameAttribute)];
if (comAlias == null) {
Guid g = GetPropertyPage(dispid);
if (!Guid.Empty.Equals(g)) {
editor = new AxPropertyTypeEditor(this, g);
// Show any non-browsable property that has an editor through a
// property page.
//
if (!this.IsBrowsable) {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "Making property: " + this.Name + " browsable because we found an editor.");
AddAttribute(new BrowsableAttribute(true));
}
}
}
}
}
SetFlag(FlagUpdatedEditorAndConverter, true);
}
catch (Exception e) {
Debug.WriteLineIf(AxPropTraceSwitch.TraceVerbose, "could not get the type editor for property: " + this.Name + " Exception: " + e);
}
}
}
private class AxPropertyTypeEditor : UITypeEditor {
private AxPropertyDescriptor propDesc;
private Guid guid;
public AxPropertyTypeEditor(AxPropertyDescriptor pd, Guid guid) {
propDesc = pd;
this.guid = guid;
}
///
/// Takes the value returned from valueAccess.getValue() and modifies or replaces
/// the value, passing the result into valueAccess.setValue(). This is where
/// an editor can launch a modal dialog or create a drop down editor to allow
/// the user to modify the value. Host assistance in presenting UI to the user
/// can be found through the valueAccess.getService function.
///
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) {
try {
object instance = context.Instance;
propDesc.owner.ShowPropertyPageForDispid(propDesc.Dispid, this.guid);
}
catch (Exception ex1) {
if (provider != null) {
IUIService uiSvc = (IUIService)provider.GetService(typeof(IUIService));
if (uiSvc != null){
uiSvc.ShowError(ex1, SR.GetString(SR.ErrorTypeConverterFailed));
}
}
}
return value;
}
///
/// Retrieves the editing style of the Edit method. If the method
/// is not supported, this will return None.
///
public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context) {
return UITypeEditorEditStyle.Modal;
}
}
///
/// simple derivation of the com2enumconverter that allows us to intercept
/// the call to GetStandardValues so we can on-demand update the enum values.
///
private class AxEnumConverter : Com2EnumConverter {
private AxPropertyDescriptor target;
public AxEnumConverter(AxPropertyDescriptor target, Com2Enum com2Enum) : base(com2Enum) {
this.target = target;
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) {
// make sure the converter has been properly refreshed -- calling
// the Converter property does this.
//
TypeConverter tc = this;
tc = target.Converter;
return base.GetStandardValues(context);
}
}
// This exists for perf reasons. We delay doing this until we
// are actually asked for the array of values.
//
private class AxPerPropertyBrowsingEnum : Com2Enum {
private AxPropertyDescriptor target;
private AxHost owner;
private OleStrCAMarshaler nameMarshaller;
private Int32CAMarshaler valueMarshaller;
private bool arraysFetched;
public AxPerPropertyBrowsingEnum(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;
}
///
/// Retrieve a copy of the value array
///
public override object[] Values {
get {
EnsureArrays();
return base.Values;
}
}
///
/// Retrieve a copy of the nme array.
///
public override string[] Names {
get {
EnsureArrays();
return base.Names;
}
}
// ensure that we have processed the caStructs into arrays
// of values and strings
//
private void EnsureArrays() {
if (this.arraysFetched) {
return;
}
this.arraysFetched = true;
try {
// marshal the items.
object[] nameItems = nameMarshaller.Items;
object[] cookieItems= valueMarshaller.Items;
NativeMethods.IPerPropertyBrowsing ppb = (NativeMethods.IPerPropertyBrowsing)owner.GetPerPropertyBrowsing();
int itemCount = 0;
Debug.Assert(cookieItems != null && nameItems != null, "An item array is null");
if (nameItems.Length > 0) {
object[] valueItems = new object[cookieItems.Length];
NativeMethods.VARIANT var = new NativeMethods.VARIANT();
int cookie;
Debug.Assert(cookieItems.Length == nameItems.Length, "Got uneven names and cookies");
// for each name item, we ask the object for it's corresponding value.
//
for (int i = 0; i < nameItems.Length; i++) {
cookie = (int)cookieItems[i];
if (nameItems[i] == null || !(nameItems[i] is string)) {
Debug.Fail("Bad IPerPropertyBrowsing item [" + i.ToString(CultureInfo.InvariantCulture) + "], name=" + (nameItems == null ? "(unknown)" : nameItems[i].ToString()));
continue;
}
var.vt = (short)NativeMethods.tagVT.VT_EMPTY;
int hr = ppb.GetPredefinedValue(target.Dispid, cookie, var);
if (hr == NativeMethods.S_OK && var.vt != (short)NativeMethods.tagVT.VT_EMPTY) {
valueItems[i] = var.ToObject();
}
var.Clear();
itemCount++;
}
// pass this data down to the base Com2Enum object...
if (itemCount > 0) {
string[] strings = new string[itemCount];
Array.Copy(nameItems, 0, strings, 0, itemCount);
base.PopulateArrays(strings, valueItems);
}
}
}
catch (Exception ex) {
Debug.Fail("Failed to build IPerPropertyBrowsing editor. " + ex.GetType().Name + ", " + ex.Message);
}
}
internal void RefreshArrays( OleStrCAMarshaler names, Int32CAMarshaler values) {
this.nameMarshaller = names;
this.valueMarshaller = values;
this.arraysFetched = false;
}
#if false
// FxCop: Currently not used
private string GetDisplayString(int dispid, ref bool success) {
NativeMethods.IPerPropertyBrowsing ppb = (NativeMethods.IPerPropertyBrowsing)owner.GetPerPropertyBrowsing();
string[] strVal = new string[1];
int hr = ppb.GetDisplayString(dispid, strVal);
if (hr == NativeMethods.S_OK) {
success = (strVal[0] != null);
//Debug.Assert(success, "IPerPropertyBrowsing::GetDisplayString returned NULL and S_OK -- this is not a valid state. This component does not property implement IPerPropertyBrowsing. (component class=" + TypeDescriptor.GetClassName(ppb) + ")");
return strVal[0];
}
else {
success = false;
}
return null;
}
#endif
protected override void PopulateArrays(string[] names, object[] values) {
// we call base.PopulateArrays directly when we actually want to do this.
}
public override object FromString(string s) {
EnsureArrays();
return base.FromString(s);
}
public override string ToString(object v) {
EnsureArrays();
return base.ToString(v);
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- AccessedThroughPropertyAttribute.cs
- RestClientProxyHandler.cs
- RoutedUICommand.cs
- DataServiceRequest.cs
- ClientScriptManager.cs
- OperationCanceledException.cs
- LogicalExpr.cs
- PersonalizationProvider.cs
- MeasureItemEvent.cs
- PersonalizationProviderHelper.cs
- ObjectTokenCategory.cs
- CodeDomConfigurationHandler.cs
- DataMisalignedException.cs
- ProgressBar.cs
- SchemaSetCompiler.cs
- Rijndael.cs
- Menu.cs
- EventProxy.cs
- OpenTypeLayout.cs
- TaiwanCalendar.cs
- ProtectedConfigurationSection.cs
- SessionPageStateSection.cs
- DescendentsWalkerBase.cs
- IgnoreFileBuildProvider.cs
- messageonlyhwndwrapper.cs
- XPathChildIterator.cs
- SharedPerformanceCounter.cs
- SchemaReference.cs
- InfoCardBaseException.cs
- SqlDelegatedTransaction.cs
- CreateUserWizardStep.cs
- SmiXetterAccessMap.cs
- PipeSecurity.cs
- ItemDragEvent.cs
- WebPartDescriptionCollection.cs
- ToolStripItemRenderEventArgs.cs
- BatchWriter.cs
- DrawToolTipEventArgs.cs
- EditingMode.cs
- DecimalAverageAggregationOperator.cs
- TransformerInfoCollection.cs
- XamlSerializer.cs
- CancellationTokenSource.cs
- MruCache.cs
- IdentifierService.cs
- DesignerVerb.cs
- NotifyIcon.cs
- PageCodeDomTreeGenerator.cs
- RequestCachingSection.cs
- IProvider.cs
- EntityType.cs
- TextEncodedRawTextWriter.cs
- TextDecoration.cs
- PropertyToken.cs
- CategoryNameCollection.cs
- RoleManagerSection.cs
- DataListItem.cs
- NullableConverter.cs
- ConfigXmlWhitespace.cs
- LinearKeyFrames.cs
- ParallelQuery.cs
- StickyNote.cs
- ContentPlaceHolder.cs
- propertyentry.cs
- ImageCollectionEditor.cs
- PseudoWebRequest.cs
- HtmlGenericControl.cs
- FtpWebRequest.cs
- BinaryObjectWriter.cs
- SizeAnimation.cs
- VideoDrawing.cs
- BitmapEffectOutputConnector.cs
- ErrorHandler.cs
- SqlWriter.cs
- XmlComplianceUtil.cs
- ClientRolePrincipal.cs
- ContextMenuAutomationPeer.cs
- MinMaxParagraphWidth.cs
- WebServiceMethodData.cs
- StateMachine.cs
- SQLResource.cs
- DataServiceBehavior.cs
- ASCIIEncoding.cs
- EnumUnknown.cs
- TextBoxRenderer.cs
- DesignTimeResourceProviderFactoryAttribute.cs
- ControlIdConverter.cs
- BaseDataListActionList.cs
- ApplySecurityAndSendAsyncResult.cs
- InvariantComparer.cs
- HttpPostedFile.cs
- ClientRuntimeConfig.cs
- sqlcontext.cs
- MeshGeometry3D.cs
- WebScriptServiceHostFactory.cs
- AspCompat.cs
- MachineKeyConverter.cs
- SynchronizedDisposablePool.cs
- XsdDataContractImporter.cs
- SiteMapDataSourceView.cs