public TextLineEventListener(IVsTextLines buffer, string fileName, ModuleId id)
{
_buffer = buffer;
_fileId = id;
_fileName = fileName;
IConnectionPointContainer container = buffer as IConnectionPointContainer;
if (null != container) {
Guid eventsGuid = typeof(IVsTextLinesEvents).GUID;
container.FindConnectionPoint(ref eventsGuid, out _connectionPoint);
_connectionPoint.Advise(this as IVsTextLinesEvents, out _connectionCookie);
}
}
public LibraryTask(string fileName, ITextBuffer textBuffer, ModuleId moduleId)
{
_fileName = fileName;
_textBuffer = textBuffer;
_moduleId = moduleId;
}
public void Dispose()
{
if ((null != _connectionPoint) && (0 != _connectionCookie)) {
_connectionPoint.Unadvise(_connectionCookie);
}
_connectionCookie = 0;
_connectionPoint = null;
_buffer = null;
_fileId = null;
}
private void OnDeleteFile(object sender, HierarchyEventArgs args)
{
IVsHierarchy hierarchy = sender as IVsHierarchy;
if (null == hierarchy) {
return;
}
ModuleId id = new ModuleId(hierarchy, args.ItemID);
LibraryNode node = null;
lock (_files) {
if (_files.TryGetValue(id, out node)) {
_files.Remove(id);
}
}
if (null != node) {
_library.RemoveNode(node);
}
}
private void CreateModuleTree(LibraryNode root, LibraryNode current, IScopeNode scope, string namePrefix, ModuleId moduleId)
{
if ((null == root) || (null == scope) || (null == scope.NestedScopes)) {
return;
}
foreach (IScopeNode subItem in scope.NestedScopes) {
LibraryNode newNode = CreateLibraryNode(subItem, namePrefix, moduleId.Hierarchy, moduleId.ItemID);
string newNamePrefix = namePrefix;
// The classes are always added to the root node, the functions to the
// current node.
if ((newNode.NodeType & LibraryNodeType.Classes) != LibraryNodeType.None) {
// Classes are always added to the root.
root.AddNode(newNode);
newNamePrefix = namePrefix + newNode.Name + ".";
} else {
current.AddNode(newNode);
}
// Now use recursion to get the other types.
CreateModuleTree(root, newNode, subItem, newNamePrefix, moduleId);
}
}
public void UnregisterHierarchy(IVsHierarchy hierarchy)
{
if ((null == hierarchy) || !_hierarchies.ContainsKey(hierarchy)) {
return;
}
HierarchyListener listener = _hierarchies[hierarchy];
if (null != listener) {
listener.Dispose();
}
_hierarchies.Remove(hierarchy);
if (0 == _hierarchies.Count) {
UnregisterRDTEvents();
}
lock (_files) {
ModuleId[] keys = new ModuleId[_files.Keys.Count];
_files.Keys.CopyTo(keys, 0);
foreach (ModuleId id in keys) {
if (hierarchy.Equals(id.Hierarchy)) {
_library.RemoveNode(_files[id]);
_files.Remove(id);
}
}
}
// Remove the document listeners.
uint[] docKeys = new uint[_documents.Keys.Count];
_documents.Keys.CopyTo(docKeys, 0);
foreach (uint id in docKeys) {
TextLineEventListener docListener = _documents[id];
if (hierarchy.Equals(docListener.FileID.Hierarchy)) {
_documents.Remove(id);
docListener.Dispose();
}
}
}
public int OnBeforeDocumentWindowShow(uint docCookie, int fFirstShow, IVsWindowFrame pFrame)
{
// Check if this document is in the list of the documents.
if (_documents.ContainsKey(docCookie)) {
return VSConstants.S_OK;
}
// Get the information about this document from the RDT.
IVsRunningDocumentTable rdt = GetPackageService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable;
if (null != rdt) {
// Note that here we don't want to throw in case of error.
uint flags;
uint readLocks;
uint writeLoks;
string documentMoniker;
IVsHierarchy hierarchy;
uint itemId;
IntPtr unkDocData;
int hr = rdt.GetDocumentInfo(docCookie, out flags, out readLocks, out writeLoks,
out documentMoniker, out hierarchy, out itemId, out unkDocData);
try {
if (Microsoft.VisualStudio.ErrorHandler.Failed(hr) || (IntPtr.Zero == unkDocData)) {
return VSConstants.S_OK;
}
// Check if the herarchy is one of the hierarchies this service is monitoring.
if (!_hierarchies.ContainsKey(hierarchy)) {
// This hierarchy is not monitored, we can exit now.
return VSConstants.S_OK;
}
// Check the file to see if a listener is required.
if (_package.IsRecognizedFile(documentMoniker)) {
return VSConstants.S_OK;
}
// Create the module id for this document.
ModuleId docId = new ModuleId(hierarchy, itemId);
// Try to get the text buffer.
IVsTextLines buffer = Marshal.GetObjectForIUnknown(unkDocData) as IVsTextLines;
// Create the listener.
TextLineEventListener listener = new TextLineEventListener(buffer, documentMoniker, docId);
// Set the event handler for the change event. Note that there is no difference
// between the AddFile and FileChanged operation, so we can use the same handler.
listener.OnFileChanged += new EventHandler<HierarchyEventArgs>(OnNewFile);
// Add the listener to the dictionary, so we will not create it anymore.
_documents.Add(docCookie, listener);
} finally {
if (IntPtr.Zero != unkDocData) {
Marshal.Release(unkDocData);
}
}
}
// Always return success.
return VSConstants.S_OK;
}