private void Insert(SnapinNode parent, IntPtr nextHScopeItem)
{
GetImageIndices();
Snapin.EnsureImages();
IConsoleNameSpace2 ns = Snapin.ConsoleNamespace;
ScopeDataItem item = new ScopeDataItem();
item.Mask = (uint)ScopeDataItemFlags.Str
| (uint)ScopeDataItemFlags.Param
| (uint)ScopeDataItemFlags.Next
| (uint)ScopeDataItemFlags.Image
| (uint)ScopeDataItemFlags.OpenImage
| (uint)ScopeDataItemFlags.Children;
item.Image = m_closedImageIndex;
item.OpenImage = m_openImageIndex;
item.RelativeId = nextHScopeItem;
item.DisplayName = (IntPtr)(-1);
item.Param = Cookie;
item.Children = HasChildren() ? 1 : 0;
// Expand the parent node before adding the child.
ns.Expand(parent.HScopeItem);
ns.InsertItem(ref item);
HScopeItem = item.Id;
m_parentHScopeItem = parent.HScopeItem;
m_parentNode = parent;
}
public virtual void OnCommand(SnapinNode node)
{
if (m_handler != null)
{
m_handler(this, node);
}
}
/// <summary>
/// Called when MMC wants an IDataObject for a node by cookie
/// </summary>
/// <param name="cookie"></param>
/// <param name="type"></param>
/// <param name="ppDataObject"></param>
public void QueryDataObject(IntPtr cookie, uint type, out IDataObject ppDataObject)
{
ppDataObject = null;
try
{
// Check if this a MULTI_SELECT_COOKIE then just find
// first selected item and return the node it depends to.
if (cookie == (IntPtr)CookieType.MultiSelectCookie)
{
ResultDataItem rdi = m_snapin.GetSelectedItem((IResultData)m_console);
SnapinNode node = m_snapin.FindNode(rdi.Param);
ppDataObject = new DataObject(node);
node.AreMultipleResultsSelected = true;
m_areMultipleResultsSelected = true;
}
else
{
SnapinNode node = m_snapin.FindNode(cookie);
ppDataObject = new DataObject(node);
node.AreMultipleResultsSelected = false;
m_areMultipleResultsSelected = false;
}
}
catch (Exception e)
{
new ExceptionDialog(e, "The following exception has occurred in the snap-in:").ShowDialog(m_snapin);
}
}
protected void DeleteChildNode(SnapinNode node)
{
// Delete the item and unregister the node.
node.DeleteItem();
Snapin.Unregister(node);
RemoveChild(node);
}
/// <summary>
/// Called be SnapinNode constructor to register itself back here for
/// centralized lookup when MMC want to talk to a Node
/// </summary>
internal IntPtr Register(SnapinNode newNode)
{
// Return the index in the array.
int id = m_nodeId++;
m_nodes.Add(id, newNode);
return((IntPtr)id);
}
public void RestoreSelection(string path)
{
SnapinNode node = RootNode.FindNodeInTree(path);
if (node != null)
{
node.Select();
}
}
public string GetPathRelativeTo(SnapinNode relativeToNode)
{
if (relativeToNode == this)
{
return(string.Empty);
}
else
{
return(m_parentNode == null || m_parentNode == this || m_parentNode == relativeToNode ?
m_displayName : m_parentNode.GetPathRelativeTo(relativeToNode) + PathSeparatorChar + m_displayName);
}
}
/// <summary>
/// Find a node with the given cookie in list.
/// </summary>
internal SnapinNode FindNode(IntPtr cookie)
{
// Some nodes use the high order word for item id
// so mask off this word to get the "real" cookie.
int realCookie = (int)cookie & 0xffff;
SnapinNode node = (SnapinNode)m_nodes[realCookie];
if (node == null)
{
throw new ApplicationException("Failed to find Node with cookie " + realCookie);
}
return(node);
}
/// <summary>
/// Called to get Result view type information.
/// </summary>
/// <param name="cookie"></param>
/// <param name="ppViewType"></param>
/// <param name="pViewOptions"></param>
/// <returns></returns>
public int GetResultViewType(IntPtr cookie, out IntPtr ppViewType, out int pViewOptions)
{
pViewOptions = 0;
SnapinNode node = m_snapin.FindNode(cookie);
if (node != null)
{
ppViewType = Marshal.StringToCoTaskMemUni(node.GetResultViewType(ref pViewOptions));
return(Constants.Win32.HResults.S_OK);
}
else
{
ppViewType = IntPtr.Zero;
return(Constants.Win32.HResults.S_FALSE);
}
}
protected void ReplaceChildNode(SnapinNode node, SnapinNode newNode)
{
// Get information about the old node.
IntPtr nextHScopeItem;
IntPtr cookie;
IConsoleNameSpace2 ns = Snapin.ConsoleNamespace;
ns.GetNextItem(node.HScopeItem, out nextHScopeItem, out cookie);
DeleteChildNode(node);
if (nextHScopeItem != IntPtr.Zero)
{
InsertChildNode(newNode, nextHScopeItem);
}
else
{
InsertChildNode(newNode);
}
}
public SnapinNode FindNodeInTree(string path)
{
if (path == null)
{
return(null);
}
else if (path == string.Empty)
{
return(this);
}
string[] names = path.Split(PathSeparatorChar);
SnapinNode node = this;
int index = 0;
while (node != null && index < names.Length)
{
node = node.FindNode(names[index++]);
}
return(node);
}
/// <summary>
/// Called when nodes are selected and controlbar commands fire.
/// </summary>
public int ControlbarNotify(uint notifyEvent, IntPtr arg, IntPtr param)
{
int hr = Constants.Win32.HResults.S_OK;
switch ((MmcNotify)notifyEvent)
{
case MmcNotify.Select:
bool scope = ((short)arg) != 0;
bool select = ((((int)arg) >> 16) & 0xffff) != 0;
if ((int)param > 0)
{
DataObject dataObject = (IDataObject)Marshal.GetObjectForIUnknown(param) as DataObject;
SnapinNode node = dataObject == null ? m_snapin.RootNode : dataObject.Node;
node.OnControlbarNotify(m_controlbar, m_toolbar, scope, select);
}
break;
case MmcNotify.BtnClick:
if ((int)arg > 0)
{
IDataObject dataObject = (IDataObject)Marshal.GetObjectForIUnknown(arg);
SnapinNode node = dataObject == null ? m_snapin.RootNode : ((DataObject)dataObject).Node;
node.OnControlbarCommand(m_controlbar, m_toolbar, (MmcConsoleVerb)param.ToInt32());
}
break;
default:
hr = Constants.Win32.HResults.S_FALSE;
break;
}
return(hr);
}
/// <summary>
/// Delegate to the relevent node or handle it directly.
/// </summary>
public int Notify(IntPtr lpDataObject, uint notifyEvent, IntPtr arg, IntPtr param)
{
int hr = Constants.Win32.HResults.S_FALSE;
try
{
// There are some sneaky values for the IDataObject parameters that make
// interop with this interface a little trick. This is why lpDataObject is an IntPtr
// not an actual IDataObject interface.
if (lpDataObject == (IntPtr)DataObject.CUSTOMOCX || lpDataObject == (IntPtr)DataObject.CUSTOMWEB)
{
return(hr);
}
hr = Constants.Win32.HResults.S_OK;
IDataObject dataObject = null;
if (lpDataObject != (IntPtr)0)
{
dataObject = (IDataObject)Marshal.GetObjectForIUnknown(lpDataObject);
}
// Get the node.
SnapinNode node;
if (dataObject != null)
{
node = ((DataObject)dataObject).Node;
}
else
{
// Try to get the node of the selected item.
ResultDataItem item = m_snapin.GetSelectedItem((IResultData)m_console);
if (item.Index != -1)
{
node = m_snapin.FindNode(item.Param);
}
else
{
node = m_snapin.CurrentScopeNode;
if (node == null)
{
node = m_snapin.RootNode;
}
}
}
Debug.WriteLine("IComponent.Notify: " + ((MmcNotify)notifyEvent) + " " + node.DisplayName);
// Dispatch the event to the node.
switch ((MmcNotify)notifyEvent)
{
case MmcNotify.Activate:
node.OnActivate(arg.ToInt32() != 0);
break;
case MmcNotify.AddImages:
// arg actually contains the IImageList interface. We need to
// marshall that manually as well.
IImageList imageList = (IImageList)Marshal.GetObjectForIUnknown(arg);
// Param contains the HScopeItem so use it to get the node it represents.
node = m_snapin.FindNodeByHScopeItem(param);
if (node != null)
{
node.OnAddResultPaneImages(imageList);
}
break;
case MmcNotify.BtnClick:
node.OnBtnClick(param.ToInt32());
break;
case MmcNotify.Click:
node.OnClick();
break;
case MmcNotify.ColumnClick:
node.OnColumnClick((int)arg, (int)param == 0);
break;
case MmcNotify.CutOrMove:
dataObject = (IDataObject)Marshal.GetObjectForIUnknown(arg);
if (!node.OnCutOrMove(dataObject))
{
hr = Constants.Win32.HResults.S_FALSE;
}
break;
case MmcNotify.DblClick:
// Check if the default verb is enabled. If it is let MMC invoke it, otherwise
// say that the action was handled. This prevents it from asking for a property page
// when the Properties verb is disabled.
IConsoleVerb consoleVerb;
Console.QueryConsoleVerb(out consoleVerb);
MmcConsoleVerb defaultVerb = MmcConsoleVerb.None;
consoleVerb.GetDefaultVerb(ref defaultVerb);
int state = 0;
consoleVerb.GetVerbState(defaultVerb, MmcButtonState.Enabled, ref state);
hr = (state == 0 ? Constants.Win32.HResults.S_OK : Constants.Win32.HResults.S_FALSE);
break;
case MmcNotify.Delete:
node.OnDelete();
break;
case MmcNotify.DeselectAll:
node.OnDeselectAll();
break;
case MmcNotify.Expand:
if (arg == IntPtr.Zero)
{
node.OnExpand(false);
}
else
{
node.OnCollapse();
}
break;
case MmcNotify.MenuBtnClick:
MenuButtonData data = (MenuButtonData)(Marshal.PtrToStructure(param, typeof(MenuButtonData)));
node.OnMenuBtnClick(data.CommandId, data.X, data.Y);
break;
case MmcNotify.Minimized:
if (arg.ToInt32() == 0)
{
node.OnMaximized();
}
else
{
node.OnMinimized();
}
break;
case MmcNotify.Paste:
dataObject = (IDataObject)Marshal.GetObjectForIUnknown(arg);
if (node.OnPaste(dataObject))
{
param = Marshal.GetIUnknownForObject(dataObject);
}
else
{
hr = Constants.Win32.HResults.S_FALSE;
}
break;
case MmcNotify.PropertyChange:
break;
case MmcNotify.QueryPaste:
dataObject = (IDataObject)Marshal.GetObjectForIUnknown(arg);
if (!node.OnQueryPaste(dataObject))
{
hr = Constants.Win32.HResults.S_FALSE;
}
break;
case MmcNotify.Refresh:
node.OnRefresh();
break;
case MmcNotify.Print:
node.OnPrint();
break;
case MmcNotify.Rename:
if (arg == IntPtr.Zero)
{
// Check.
if (!node.OnTryRename())
{
hr = Constants.Win32.HResults.S_FALSE;
}
}
else
{
if (node.OnRename(Marshal.PtrToStringAuto(param)))
{
SetStatusText(node.GetStatusText());
}
else
{
hr = Constants.Win32.HResults.S_FALSE;
}
}
break;
case MmcNotify.Select:
bool scope = ((short)arg) != 0;
bool select = ((((int)arg) >> 16) & 0xffff) != 0;
if (scope)
{
if (select)
{
if (m_scopeItemChanging)
{
m_scopeItemChanging = false;
m_snapin.CurrentScopeNode = node;
}
// Defect 54593: for some reason when multiple result items are selected and the
// user clicks on the scope node MMC does NOT send a "deselect result" notification
// (if a single result item is selected then it does). Work around this.
if (node.IsResultSelected)
{
node.OnDeselectResult();
}
node.OnSelectScopeItem();
SetStatusText(node.GetStatusText());
}
else
{
node.OnDeselectScopeItem();
}
}
else
{
if (select)
{
node.OnSelectResult();
}
else
{
node.OnDeselectResult();
}
}
break;
case MmcNotify.Show:
bool selecting = (arg != IntPtr.Zero);
if (selecting)
{
m_scopeItemChanging = true;
m_snapin.FindNodeByHScopeItem(param).OnShow();
}
else
{
m_snapin.FindNodeByHScopeItem(param).OnHide();
}
break;
case MmcNotify.ViewChange:
dataObject = null;
if (param != (IntPtr)0)
{
dataObject = (IDataObject)Marshal.GetObjectForIUnknown(param);
}
SnapinNode nodeChanged = dataObject == null ? m_snapin.RootNode : ((DataObject)dataObject).Node;
if (arg != IntPtr.Zero)
{
node.OnViewChangeScope(nodeChanged);
}
else
{
node.OnViewChangeResult(nodeChanged);
}
break;
case MmcNotify.SnapinHelp:
hr = Constants.Win32.HResults.S_FALSE;
break;
case MmcNotify.ContextHelp:
node.OnContextHelp();
break;
case MmcNotify.InitOcx:
// param is the IUnknown of the OCX.
object ocx = Marshal.GetObjectForIUnknown(param);
if (node.OnInitOcx(ocx))
{
hr = Constants.Win32.HResults.S_OK;
}
else
{
hr = Constants.Win32.HResults.S_FALSE;
}
break;
case MmcNotify.FilterChange:
node.OnFilterChange((MmcFilterChangeCode)arg.ToInt32(), param.ToInt32());
hr = Constants.Win32.HResults.S_OK;
break;
case MmcNotify.GetFilterMenu:
hr = Constants.Win32.HResults.S_FALSE;
break;
case MmcNotify.FilterOperator:
hr = Constants.Win32.HResults.S_FALSE;
break;
case MmcNotify.ColumnsChanged:
hr = Constants.Win32.HResults.S_OK;
break;
default:
// The notification is not supported.
hr = Constants.Win32.HResults.S_FALSE;
break;
}
}
catch (Exception e)
{
new ExceptionDialog(e, "The following exception has occurred in the snap-in:").ShowDialog(m_snapin);
hr = Constants.Win32.HResults.S_FALSE;
}
return(hr);
}
protected void RenameChildNode(SnapinNode node, string newName)
{
// Update the display name.
node.DisplayName = newName;
}
/// <summary>
/// Unregister the node.
/// </summary>
/// <param name="node"></param>
internal void Unregister(SnapinNode node)
{
m_nodes.Remove(node.Cookie);
}
private void RemoveChild(SnapinNode node)
{
m_childNodes.Remove(node);
}
/// <summary>
/// This notify is primarily responsible for inserting data items into
/// the console namespace.
/// </summary>
int IComponentData.Notify(IDataObject lpDataObject, uint notifyEvent, IntPtr arg, IntPtr param)
{
int hr = Constants.Win32.HResults.S_OK;
try
{
// Use the root node if none is supplied.
DataObject dataObject = (DataObject)lpDataObject;
SnapinNode node = dataObject == null ? RootNode : dataObject.Node;
Debug.WriteLine("IComponentData.Notify: " + ((MmcNotify)notifyEvent) + " " + node.DisplayName);
switch ((MmcNotify)notifyEvent)
{
case MmcNotify.Expand:
// Pass onto the node.
if ((int)arg != 0)
{
if (node.HScopeItem == IntPtr.Zero)
{
node.HScopeItem = param;
}
CurrentScopeNode = node;
bool duringStartup = !m_started || m_oneMoreNodeDuringStartup;
m_oneMoreNodeDuringStartup = false;
node.OnExpand(duringStartup);
}
else
{
node.OnCollapse();
}
break;
case MmcNotify.Delete:
// Pass onto the node.
node.OnDelete();
break;
case MmcNotify.BtnClick:
// Pass onto the node.
node.OnBtnClick(param.ToInt32());
break;
case MmcNotify.Rename:
// Pass onto the node.
if ((int)arg == 0)
{
// Check first.
if (!node.OnTryRename())
{
hr = Constants.Win32.HResults.S_FALSE;
}
}
else
{
// Pass the name.
if (node.OnRename(Marshal.PtrToStringAuto(param)))
{
m_component.SetStatusText(node.GetStatusText());
}
else
{
hr = Constants.Win32.HResults.S_FALSE;
}
}
break;
case MmcNotify.RemoveChildren:
node = FindNodeByHScopeItem(arg);
node.OnRemoveChildren();
break;
default:
// Didn't handle the message.
hr = Constants.Win32.HResults.S_FALSE;
break;
}
}
catch (Exception e)
{
new ExceptionDialog(e, "The following exception has occurred in the snap-in:").ShowDialog(this);
hr = Constants.Win32.HResults.S_FALSE;
}
return(hr);
}
internal void OnViewChangeScope(SnapinNode node)
{
}
internal void OnViewChangeResult(SnapinNode node)
{
}
protected void InsertChildNode(SnapinNode node)
{
m_childNodes.Add(node);
node.Insert(this);
}
private void InsertChildNode(SnapinNode node, IntPtr nextHScopeItem)
{
m_childNodes.Add(node);
node.Insert(this, nextHScopeItem);
}
public DataObject(SnapinNode node)
{
m_node = node;
}
public NodeControl(SnapinNode node)
{
m_node = node;
CreateHandle();
}
