Hi Oren,

I have forwarded your question to our VSIP support team to see whether
there is any new update on it. If there is any information, I will post
back here as soon as possible.

Thanks very much.

Best regards,
Yanhong Huang
Microsoft Community Support

Get Secure! ¨C www.microsoft.com/security
Register to Access MSDN Managed Newsgroups!
-http://support.microsoft.com/default.aspx?scid=/servicedesks/msdn/nospam.as
p&SD=msdn

This posting is provided "AS IS" with no warranties, and confers no rights.

Hi Oren,

Based on my understanding, you want to trace your caret position and find
its related code elements to sync the item in the class view, please let me
know if I have misunderstood anything.

Currently, I will perform some research on this issue and update you when
we get any results.

Thanks for your patience!

Best regards,

Gary Chang
Microsoft Community Support
--------------------
Get Secure! ¡§C www.microsoft.com/security
Register to Access MSDN Managed Newsgroups!
http://support.microsoft.com/default.aspx?scid=/servicedesks/msdn/nospam.asp
&SD=msdn

This posting is provided "AS IS" with no warranties, and confers no rights.

Well, where there is a will, there is a way.  I resorted to some good ole'
fashioned subclassing to listen to the keydown and mousedown events, but I
got it working.  I'm not using any DTE2 interfaces or any .net 2.0 features,
so this should work with VS 2003 as well.

Note one hackish section is that at least in VS 2005, the Window object's
HWnd was always 0.  I've bugged this in the product feedback center, but
none-the-less, I worked around with Spy++ and FindWindowEx.

Hopefully the code below can be of help to someone; maybe it can be used as
part of a sample in the sdk?

Thanks for your help,
--Oren

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Text;
using System.Reflection;
using System.Runtime.InteropServices;

using EnvDTE;

using System.Windows.Forms;

namespace ClassSync
{

   internal class CaretWatcher : IDisposable
   {
       DTE applicationObject;

       WindowEvents windowEvents;

       HybridDictionary windowHandles = new HybridDictionary();

       HybridDictionary subclassedWindows = new HybridDictionary();

       IntPtr mainWindowHandle;

       public CaretWatcher(DTE application)
       {
           applicationObject = application;

           windowEvents = applicationObject.Events.get_WindowEvents(null);

           windowEvents.WindowCreated += new
_dispWindowEvents_WindowCreatedEventHandler(OnWindowCreated);
           windowEvents.WindowClosing += new
_dispWindowEvents_WindowClosingEventHandler(OnWindowClosing);

           KeyboardMouseWatcher mainWindow = new KeyboardMouseWatcher();

           // get main window handle of devenv
           mainWindowHandle = (IntPtr)application.MainWindow.HWnd;

           mainWindow.AssignHandle(mainWindowHandle);

           mainWindow.InputDetected += new EventHandler(OnInput);

           subclassedWindows.Add(mainWindowHandle, mainWindow);
       }

       void OnWindowClosing(Window Window)
       {
           TextWindow wnd = Window.Object as TextWindow;
           if (wnd != null)
           {
               // remove the subclass
               IntPtr hwnd = (IntPtr)windowHandles[wnd.Parent];
               windowHandles.Remove(wnd.Parent);

               // Get the subclassed window
               KeyboardMouseWatcher watcher =
(KeyboardMouseWatcher)subclassedWindows[hwnd];

               subclassedWindows.Remove(hwnd);
               watcher.InputDetected -= new EventHandler(OnInput);
               watcher.ReleaseHandle();
           }
       }

       void OnWindowCreated(Window Window)
       {
           TextWindow wnd = Window.Object as TextWindow;
           if (wnd != null)
           {
               string caption = wnd.Parent.Caption;

               // top level that we can id
               IntPtr hwndParent = FindWindowEx(mainWindowHandle,
IntPtr.Zero, null, caption);

               // This is hackish since we have no easier way to do this
               hwndParent = FindWindowEx(hwndParent, IntPtr.Zero, null,
null);

               // an intermediate window
               hwndParent = FindWindowEx(hwndParent, IntPtr.Zero, null,
null);

               // This is the VsTextEditPane item
               IntPtr pane = FindWindowEx(hwndParent, IntPtr.Zero, null,
null);

               windowHandles[wnd.Parent] = pane;

               KeyboardMouseWatcher watcher = new KeyboardMouseWatcher();
               watcher.AssignHandle(pane);
               watcher.InputDetected += new EventHandler(OnInput);
               subclassedWindows.Add(pane, watcher);
           }
       }

       [DllImport("User32.dll", SetLastError=true)]
       private static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr
hwndChildAfter, string className, string windowName);

       private void OnInput(object sender, EventArgs e)
       {
           TryCaratChanged();
       }

       private TextWindow oldWindow;
       private VirtualPoint oldPoint;

       private int oldLine;
       private int oldCol;

       public event CaretChangedEventHandler CaretChanged;

       private bool TryCaratChanged()
       {
           bool retval = false;
           try
           {
               TextWindow newWindow = applicationObject.ActiveWindow.Object
as TextWindow;

               // first check to see if the window is the same
               if (newWindow == null)
               {
                   oldWindow = null;
               }
               else if (oldWindow != newWindow)
               {
                   retval = true;
                   oldWindow = newWindow;
               }

               if (oldWindow == null)
               {
                   retval = false;
                   oldPoint = null;
                   oldLine = 0;
                   oldCol = 0;
               }
               else if (newWindow.Selection.ActivePoint.Line != oldLine ||
newWindow.Selection.ActivePoint.VirtualDisplayColumn != oldCol)
               {
                   retval = true;
                   oldPoint = newWindow.Selection.ActivePoint;
                   oldLine = newWindow.Selection.ActivePoint.Line;
                   oldCol =
newWindow.Selection.ActivePoint.VirtualDisplayColumn;
               }

               if (retval)
               {
                   CaretChangedEventHandler evt = CaretChanged;
                   if (evt != null)
                       evt(this, new
CaretChangedEventArgs(newWindow.Selection.ActivePoint));
               }

               return retval;
           }
           catch (COMException)
           {
               // If we get any exceptions, return false
               return false;
           }
       }

       #region IDisposable Members

       public void Dispose()
       {

           if (windowEvents != null)
           {
               windowEvents.WindowCreated -= new
_dispWindowEvents_WindowCreatedEventHandler(OnWindowCreated);
               windowEvents.WindowClosing -= new
_dispWindowEvents_WindowClosingEventHandler(OnWindowClosing);
           }

           foreach (KeyboardMouseWatcher watcher in subclassedWindows)
           {
               watcher.ReleaseHandle();
           }
       }

       #endregion
}

   internal class CaretChangedEventArgs : EventArgs
   {
       private VirtualPoint currentPoint;
       public CaretChangedEventArgs(VirtualPoint CaratPoint)
       {
           currentPoint = CaratPoint;
       }

       public VirtualPoint CurrentPoint
       {
           get { return currentPoint; }
       }
   }

   internal delegate void CaretChangedEventHandler(object sender,
CaretChangedEventArgs e);

   internal class KeyboardMouseWatcher : NativeWindow
   {
       private const int WM_KEYDOWN = 0x0100;
       private const int WM_KEYUP = 0x101;
       private const int WM_LBUTTONUP = 0x202;
       private const int WM_RBUTTONUP = 0x205;
       private const int WM_MBUTTONUP = 0x208;
       private const int WM_XBUTTONUP = 0x20C;
       private const int WM_LBUTTONDOWN = 0x201;
       private const int WM_RBUTTONDOWN = 0x204;
       private const int WM_MBUTTONDOWN = 0x207;
       private const int WM_XBUTTONDOWN = 0x20B;
       private const int WM_PARENTNOTIFY = 0x0210;

       public event EventHandler InputDetected;

       protected override void WndProc(ref Message m)
       {
           bool keymousedown = false;

           // Get the mouse args
           switch (m.Msg)
           {

               case WM_KEYUP:
               case WM_LBUTTONDOWN:
               case WM_MBUTTONDOWN:
               case WM_RBUTTONDOWN:
               case WM_XBUTTONDOWN:
                   keymousedown = true;
                   break;
           }

           // let the base have it
           base.WndProc(ref m);

           //now trigger our event
           if (keymousedown)
           {
               EventHandler evt = InputDetected;
               if (evt != null)
                   evt(this, EventArgs.Empty);
           }
       }
   }
}