src/VisVim/Commands.cpp - third_party/vim - Git at Google

 #include "stdafx.h"
 #include <comdef.h>	// For _bstr_t
 #include "VisVim.h"
 #include "Commands.h"
 #include "OleAut.h"

 #ifdef _DEBUG
 #define new DEBUG_NEW
 #undef THIS_FILE
 static char THIS_FILE[] = __FILE__;

 #endif


 // Change directory before opening file?
 #define CD_SOURCE		0	// Cd to source path
 #define CD_SOURCE_PARENT	1	// Cd to parent directory of source path
 #define CD_NONE			2	// No cd


 static BOOL g_bEnableVim = TRUE;	// Vim enabled
 static BOOL g_bDevStudioEditor = FALSE;	// Open file in Dev Studio editor simultaneously
 static BOOL g_bNewTabs = FALSE;
 static int g_ChangeDir = CD_NONE;	// CD after file open?

 static void VimSetEnableState(BOOL bEnableState);
 static BOOL VimOpenFile(BSTR& FileName, long LineNr);
 static DISPID VimGetDispatchId(COleAutomationControl& VimOle, char* Method);
 static void VimErrDiag(COleAutomationControl& VimOle);
 static void VimChangeDir(COleAutomationControl& VimOle, DISPID DispatchId, BSTR& FileName);
 static void DebugMsg(char* Msg, char* Arg = NULL);


 /////////////////////////////////////////////////////////////////////////////
 // CCommands

 CCommands::CCommands()
 {
 	// m_pApplication == NULL; M$ Code generation bug!!!
 	m_pApplication = NULL;
 	m_pApplicationEventsObj = NULL;
 	m_pDebuggerEventsObj = NULL;
 }

 CCommands::~CCommands()
 {
 	ASSERT(m_pApplication != NULL);
 	if (m_pApplication)
 	{
 		m_pApplication->Release();
 		m_pApplication = NULL;
 	}
 }

 void CCommands::SetApplicationObject(IApplication * pApplication)
 {
 	// This function assumes pApplication has already been AddRef'd
 	// for us, which CDSAddIn did in it's QueryInterface call
 	// just before it called us.
 	m_pApplication = pApplication;
 	if (! m_pApplication)
 		return;

 	// Create Application event handlers
 	XApplicationEventsObj::CreateInstance(&m_pApplicationEventsObj);
 	if (! m_pApplicationEventsObj)
 	{
 		ReportInternalError("XApplicationEventsObj::CreateInstance");
 		return;
 	}
 	m_pApplicationEventsObj->AddRef();
 	m_pApplicationEventsObj->Connect(m_pApplication);
 	m_pApplicationEventsObj->m_pCommands = this;

 #ifdef NEVER
 	// Create Debugger event handler
 	CComPtr < IDispatch > pDebugger;
 	if (SUCCEEDED(m_pApplication->get_Debugger(&pDebugger))
 	    && pDebugger != NULL)
 	{
 		XDebuggerEventsObj::CreateInstance(&m_pDebuggerEventsObj);
 		m_pDebuggerEventsObj->AddRef();
 		m_pDebuggerEventsObj->Connect(pDebugger);
 		m_pDebuggerEventsObj->m_pCommands = this;
 	}
 #endif

 	// Get settings from registry HKEY_CURRENT_USER\Software\Vim\VisVim
 	HKEY hAppKey = GetAppKey("Vim");
 	if (hAppKey)
 	{
 		HKEY hSectionKey = GetSectionKey(hAppKey, "VisVim");
 		if (hSectionKey)
 		{
 			g_bEnableVim = GetRegistryInt(hSectionKey, "EnableVim",
 						       g_bEnableVim);
 			g_bDevStudioEditor = GetRegistryInt(hSectionKey,
 					"DevStudioEditor", g_bDevStudioEditor);
 			g_bNewTabs = GetRegistryInt(hSectionKey, "NewTabs",
 						    g_bNewTabs);
 			g_ChangeDir = GetRegistryInt(hSectionKey, "ChangeDir",
 						      g_ChangeDir);
 			RegCloseKey(hSectionKey);
 		}
 		RegCloseKey(hAppKey);
 	}
 }

 void CCommands::UnadviseFromEvents()
 {
 	ASSERT(m_pApplicationEventsObj != NULL);
 	if (m_pApplicationEventsObj)
 	{
 		m_pApplicationEventsObj->Disconnect(m_pApplication);
 		m_pApplicationEventsObj->Release();
 		m_pApplicationEventsObj = NULL;
 	}

 #ifdef NEVER
 	if (m_pDebuggerEventsObj)
 	{
 		// Since we were able to connect to the Debugger events, we
 		// should be able to access the Debugger object again to
 		// unadvise from its events (thus the VERIFY_OK below--see
 		// stdafx.h).
 		CComPtr < IDispatch > pDebugger;
 		VERIFY_OK(m_pApplication->get_Debugger(&pDebugger));
 		ASSERT(pDebugger != NULL);
 		m_pDebuggerEventsObj->Disconnect(pDebugger);
 		m_pDebuggerEventsObj->Release();
 		m_pDebuggerEventsObj = NULL;
 	}
 #endif
 }


 /////////////////////////////////////////////////////////////////////////////
 // Event handlers

 // Application events

 HRESULT CCommands::XApplicationEvents::BeforeBuildStart()
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }

 HRESULT CCommands::XApplicationEvents::BuildFinish(long nNumErrors, long nNumWarnings)
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }

 HRESULT CCommands::XApplicationEvents::BeforeApplicationShutDown()
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }

 // The open document event handle is the place where the real interface work
 // is done.
 // Vim gets called from here.
 //
 HRESULT CCommands::XApplicationEvents::DocumentOpen(IDispatch * theDocument)
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());

 	if (! g_bEnableVim)
 		// Vim not enabled or empty command line entered
 		return S_OK;

 	// First get the current file name and line number

 	// Get the document object
 	CComQIPtr < ITextDocument, &IID_ITextDocument > pDoc(theDocument);
 	if (! pDoc)
 		return S_OK;

 	BSTR FileName;
 	long LineNr = -1;

 	// Get the document name
 	if (FAILED(pDoc->get_FullName(&FileName)))
 		return S_OK;

 	LPDISPATCH pDispSel;

 	// Get a selection object dispatch pointer
 	if (SUCCEEDED(pDoc->get_Selection(&pDispSel)))
 	{
 		// Get the selection object
 		CComQIPtr < ITextSelection, &IID_ITextSelection > pSel(pDispSel);

 		if (pSel)
 			// Get the selection line number
 			pSel->get_CurrentLine(&LineNr);

 		pDispSel->Release();
 	}

 	// Open the file in Vim and position to the current line
 	if (VimOpenFile(FileName, LineNr))
 	{
 		if (! g_bDevStudioEditor)
 		{
 			// Close the document in developer studio
 			CComVariant vSaveChanges = dsSaveChangesPrompt;
 			DsSaveStatus Saved;

 			pDoc->Close(vSaveChanges, &Saved);
 		}
 	}

 	// We're done here
 	SysFreeString(FileName);
 	return S_OK;
 }

 HRESULT CCommands::XApplicationEvents::BeforeDocumentClose(IDispatch * theDocument)
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }

 HRESULT CCommands::XApplicationEvents::DocumentSave(IDispatch * theDocument)
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }

 HRESULT CCommands::XApplicationEvents::NewDocument(IDispatch * theDocument)
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());

 	if (! g_bEnableVim)
 		// Vim not enabled or empty command line entered
 		return S_OK;

 	// First get the current file name and line number

 	CComQIPtr < ITextDocument, &IID_ITextDocument > pDoc(theDocument);
 	if (! pDoc)
 		return S_OK;

 	BSTR FileName;
 	HRESULT hr;

 	hr = pDoc->get_FullName(&FileName);
 	if (FAILED(hr))
 		return S_OK;

 	// Open the file in Vim and position to the current line
 	if (VimOpenFile(FileName, 0))
 	{
 		if (! g_bDevStudioEditor)
 		{
 			// Close the document in developer studio
 			CComVariant vSaveChanges = dsSaveChangesPrompt;
 			DsSaveStatus Saved;

 			pDoc->Close(vSaveChanges, &Saved);
 		}
 	}

 	SysFreeString(FileName);
 	return S_OK;
 }

 HRESULT CCommands::XApplicationEvents::WindowActivate(IDispatch * theWindow)
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }

 HRESULT CCommands::XApplicationEvents::WindowDeactivate(IDispatch * theWindow)
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }

 HRESULT CCommands::XApplicationEvents::WorkspaceOpen()
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }

 HRESULT CCommands::XApplicationEvents::WorkspaceClose()
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }

 HRESULT CCommands::XApplicationEvents::NewWorkspace()
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }

 // Debugger event

 HRESULT CCommands::XDebuggerEvents::BreakpointHit(IDispatch * pBreakpoint)
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	return S_OK;
 }


 /////////////////////////////////////////////////////////////////////////////
 // VisVim dialog

 class CMainDialog : public CDialog
 {
     public:
 	CMainDialog(CWnd * pParent = NULL);	// Standard constructor

 	//{{AFX_DATA(CMainDialog)
 	enum { IDD = IDD_ADDINMAIN };
 	int	m_ChangeDir;
 	BOOL	m_bDevStudioEditor;
 	BOOL	m_bNewTabs;
 	//}}AFX_DATA

 	//{{AFX_VIRTUAL(CMainDialog)
     protected:
 	virtual void DoDataExchange(CDataExchange * pDX);	// DDX/DDV support
 	//}}AFX_VIRTUAL

     protected:
 	//{{AFX_MSG(CMainDialog)
 	afx_msg void OnEnable();
 	afx_msg void OnDisable();
 	//}}AFX_MSG
 	DECLARE_MESSAGE_MAP()
 };

 CMainDialog::CMainDialog(CWnd * pParent /* =NULL */ )
 	: CDialog(CMainDialog::IDD, pParent)
 {
 	//{{AFX_DATA_INIT(CMainDialog)
 	m_ChangeDir = -1;
 	m_bDevStudioEditor = FALSE;
 	m_bNewTabs = FALSE;
 	//}}AFX_DATA_INIT
 }

 void CMainDialog::DoDataExchange(CDataExchange * pDX)
 {
 	CDialog::DoDataExchange(pDX);
 	//{{AFX_DATA_MAP(CMainDialog)
 	DDX_Radio(pDX, IDC_CD_SOURCE_PATH, m_ChangeDir);
 	DDX_Check(pDX, IDC_DEVSTUDIO_EDITOR, m_bDevStudioEditor);
 	DDX_Check(pDX, IDC_NEW_TABS, m_bNewTabs);
 	//}}AFX_DATA_MAP
 }

 BEGIN_MESSAGE_MAP(CMainDialog, CDialog)
 	//{{AFX_MSG_MAP(CMainDialog)
 	//}}AFX_MSG_MAP
 END_MESSAGE_MAP()


 /////////////////////////////////////////////////////////////////////////////
 // CCommands methods

 STDMETHODIMP CCommands::VisVimDialog()
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());

 	// Use m_pApplication to access the Developer Studio Application
 	// object,
 	// and VERIFY_OK to see error strings in DEBUG builds of your add-in
 	// (see stdafx.h)

 	VERIFY_OK(m_pApplication->EnableModeless(VARIANT_FALSE));

 	CMainDialog Dlg;

 	Dlg.m_bDevStudioEditor = g_bDevStudioEditor;
 	Dlg.m_bNewTabs = g_bNewTabs;
 	Dlg.m_ChangeDir = g_ChangeDir;
 	if (Dlg.DoModal() == IDOK)
 	{
 		g_bDevStudioEditor = Dlg.m_bDevStudioEditor;
 		g_bNewTabs = Dlg.m_bNewTabs;
 		g_ChangeDir = Dlg.m_ChangeDir;

 		// Save settings to registry HKEY_CURRENT_USER\Software\Vim\VisVim
 		HKEY hAppKey = GetAppKey("Vim");
 		if (hAppKey)
 		{
 			HKEY hSectionKey = GetSectionKey(hAppKey, "VisVim");
 			if (hSectionKey)
 			{
 				WriteRegistryInt(hSectionKey, "DevStudioEditor",
 						  g_bDevStudioEditor);
 				WriteRegistryInt(hSectionKey, "NewTabs",
 						  g_bNewTabs);
 				WriteRegistryInt(hSectionKey, "ChangeDir", g_ChangeDir);
 				RegCloseKey(hSectionKey);
 			}
 			RegCloseKey(hAppKey);
 		}
 	}

 	VERIFY_OK(m_pApplication->EnableModeless(VARIANT_TRUE));
 	return S_OK;
 }

 STDMETHODIMP CCommands::VisVimEnable()
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	VimSetEnableState(true);
 	return S_OK;
 }

 STDMETHODIMP CCommands::VisVimDisable()
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	VimSetEnableState(false);
 	return S_OK;
 }

 STDMETHODIMP CCommands::VisVimToggle()
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());
 	VimSetEnableState(! g_bEnableVim);
 	return S_OK;
 }

 STDMETHODIMP CCommands::VisVimLoad()
 {
 	AFX_MANAGE_STATE(AfxGetStaticModuleState());

 	// Use m_pApplication to access the Developer Studio Application object,
 	// and VERIFY_OK to see error strings in DEBUG builds of your add-in
 	// (see stdafx.h)

 	CComBSTR bStr;
 	// Define dispatch pointers for document and selection objects
 	CComPtr < IDispatch > pDispDoc, pDispSel;

 	// Get a document object dispatch pointer
 	VERIFY_OK(m_pApplication->get_ActiveDocument(&pDispDoc));
 	if (! pDispDoc)
 		return S_OK;

 	BSTR FileName;
 	long LineNr = -1;

 	// Get the document object
 	CComQIPtr < ITextDocument, &IID_ITextDocument > pDoc(pDispDoc);

 	if (! pDoc)
 		return S_OK;

 	// Get the document name
 	if (FAILED(pDoc->get_FullName(&FileName)))
 		return S_OK;

 	// Get a selection object dispatch pointer
 	if (SUCCEEDED(pDoc->get_Selection(&pDispSel)))
 	{
 		// Get the selection object
 		CComQIPtr < ITextSelection, &IID_ITextSelection > pSel(pDispSel);

 		if (pSel)
 			// Get the selection line number
 			pSel->get_CurrentLine(&LineNr);
 	}

 	// Open the file in Vim
 	VimOpenFile(FileName, LineNr);

 	SysFreeString(FileName);
 	return S_OK;
 }


 //
 // Here we do the actual processing and communication with Vim
 //

 // Set the enable state and save to registry
 //
 static void VimSetEnableState(BOOL bEnableState)
 {
 	g_bEnableVim = bEnableState;
 	HKEY hAppKey = GetAppKey("Vim");
 	if (hAppKey)
 	{
 		HKEY hSectionKey = GetSectionKey(hAppKey, "VisVim");
 		if (hSectionKey)
 			WriteRegistryInt(hSectionKey, "EnableVim", g_bEnableVim);
 		RegCloseKey(hAppKey);
 	}
 }

 // Open the file 'FileName' in Vim and goto line 'LineNr'
 // 'FileName' is expected to contain an absolute DOS path including the drive
 // letter.
 // 'LineNr' must contain a valid line number or 0, e. g. for a new file
 //
 static BOOL VimOpenFile(BSTR& FileName, long LineNr)
 {

 	// OLE automation object for com. with Vim
 	// When the object goes out of scope, it's destructor destroys the OLE
 	// connection;
 	// This is important to avoid blocking the object
 	// (in this memory corruption would be likely when terminating Vim
 	// while still running DevStudio).
 	// So keep this object local!
 	COleAutomationControl VimOle;

 	// :cd D:/Src2/VisVim/
 	//
 	// Get a dispatch id for the SendKeys method of Vim;
 	// enables connection to Vim if necessary
 	DISPID DispatchId;
 	DispatchId = VimGetDispatchId(VimOle, "SendKeys");
 	if (! DispatchId)
 		// OLE error, can't obtain dispatch id
 		goto OleError;

 	OLECHAR Buf[MAX_OLE_STR];
 	char FileNameTmp[MAX_OLE_STR];
 	char VimCmd[MAX_OLE_STR];
 	char *s, *p;

 	// Prepend CTRL-\ CTRL-N to exit insert mode
 	VimCmd[0] = 0x1c;
 	VimCmd[1] = 0x0e;
 	VimCmd[2] = 0;

 #ifdef SINGLE_WINDOW
 	// Update the current file in Vim if it has been modified.
 	// Disabled, because it could write the file when you don't want to.
 	sprintf(VimCmd + 2, ":up\n");
 #endif
 	if (! VimOle.Method(DispatchId, "s", TO_OLE_STR_BUF(VimCmd, Buf)))
 		goto OleError;

 	// Change Vim working directory to where the file is if desired
 	if (g_ChangeDir != CD_NONE)
 		VimChangeDir(VimOle, DispatchId, FileName);

 	// Make Vim open the file.
 	// In the filename convert all \ to /, put a \ before a space.
 	if (g_bNewTabs)
 	{
 		sprintf(VimCmd, ":tab drop ");
 		s = VimCmd + 10;
 	}
 	else
 	{
 		sprintf(VimCmd, ":drop ");
 		s = VimCmd + 6;
 	}
 	sprintf(FileNameTmp, "%S", (char *)FileName);
 	for (p = FileNameTmp; *p != '\0' && s < VimCmd + MAX_OLE_STR - 4; ++p)
 		if (*p == '\\')
 			*s++ = '/';
 		else
 		{
 			if (*p == ' ')
 				*s++ = '\\';
 			*s++ = *p;
 		}
 	*s++ = '\n';
 	*s = '\0';

 	if (! VimOle.Method(DispatchId, "s", TO_OLE_STR_BUF(VimCmd, Buf)))
 		goto OleError;

 	if (LineNr > 0)
 	{
 		// Goto line
 		sprintf(VimCmd, ":%ld\n", LineNr);
 		if (! VimOle.Method(DispatchId, "s", TO_OLE_STR_BUF(VimCmd, Buf)))
 			goto OleError;
 	}

 	// Make Vim come to the foreground
 	if (! VimOle.Method("SetForeground"))
 		VimOle.ErrDiag();

 	// We're done
 	return true;

     OleError:
 	// There was an OLE error
 	// Check if it's the "unknown class string" error
 	VimErrDiag(VimOle);
 	return false;
 }

 // Return the dispatch id for the Vim method 'Method'
 // Create the Vim OLE object if necessary
 // Returns a valid dispatch id or null on error
 //
 static DISPID VimGetDispatchId(COleAutomationControl& VimOle, char* Method)
 {
 	// Initialize Vim OLE connection if not already done
 	if (! VimOle.IsCreated())
 	{
 		if (! VimOle.CreateObject("Vim.Application"))
 			return NULL;
 	}

 	// Get the dispatch id for the SendKeys method.
 	// By doing this, we are checking if Vim is still there...
 	DISPID DispatchId = VimOle.GetDispatchId("SendKeys");
 	if (! DispatchId)
 	{
 		// We can't get a dispatch id.
 		// This means that probably Vim has been terminated.
 		// Don't issue an error message here, instead
 		// destroy the OLE object and try to connect once more
 		//
 		// In fact, this should never happen, because the OLE aut. object
 		// should not be kept long enough to allow the user to terminate Vim
 		// to avoid memory corruption (why the heck is there no system garbage
 		// collection for those damned OLE memory chunks???).
 		VimOle.DeleteObject();
 		if (! VimOle.CreateObject("Vim.Application"))
 			// If this create fails, it's time for an error msg
 			return NULL;

 		if (! (DispatchId = VimOle.GetDispatchId("SendKeys")))
 			// There is something wrong...
 			return NULL;
 	}

 	return DispatchId;
 }

 // Output an error message for an OLE error
 // Check on the classstring error, which probably means Vim wasn't registered.
 //
 static void VimErrDiag(COleAutomationControl& VimOle)
 {
 	SCODE sc = GetScode(VimOle.GetResult());
 	if (sc == CO_E_CLASSSTRING)
 	{
 		char Buf[256];
 		sprintf(Buf, "There is no registered OLE automation server named "
 			 "\"Vim.Application\".\n"
 			 "Use the OLE-enabled version of Vim with VisVim and "
 			 "make sure to register Vim by running \"vim -register\".");
 		MessageBox(NULL, Buf, "OLE Error", MB_OK);
 	}
 	else
 		VimOle.ErrDiag();
 }

 // Change directory to the directory the file 'FileName' is in or it's parent
 // directory according to the setting of the global 'g_ChangeDir':
 // 'FileName' is expected to contain an absolute DOS path including the drive
 // letter.
 //	CD_NONE
 //	CD_SOURCE_PATH
 //	CD_SOURCE_PARENT
 //
 static void VimChangeDir(COleAutomationControl& VimOle, DISPID DispatchId, BSTR& FileName)
 {
 	// Do a :cd first

 	// Get the path name of the file ("dir/")
 	CString StrFileName = FileName;
 	char Drive[_MAX_DRIVE];
 	char Dir[_MAX_DIR];
 	char DirUnix[_MAX_DIR * 2];
 	char *s, *t;

 	_splitpath(StrFileName, Drive, Dir, NULL, NULL);

 	// Convert to Unix path name format, escape spaces.
 	t = DirUnix;
 	for (s = Dir; *s; ++s)
 		if (*s == '\\')
 			*t++ = '/';
 		else
 		{
 			if (*s == ' ')
 				*t++ = '\\';
 			*t++ = *s;
 		}
 	*t = '\0';


 	// Construct the cd command; append /.. if cd to parent
 	// directory and not in root directory
 	OLECHAR Buf[MAX_OLE_STR];
 	char VimCmd[MAX_OLE_STR];

 	sprintf(VimCmd, ":cd %s%s%s\n", Drive, DirUnix,
 		 g_ChangeDir == CD_SOURCE_PARENT && DirUnix[1] ? ".." : "");
 	VimOle.Method(DispatchId, "s", TO_OLE_STR_BUF(VimCmd, Buf));
 }

 #ifdef _DEBUG
 // Print out a debug message
 //
 static void DebugMsg(char* Msg, char* Arg)
 {
 	char Buf[400];
 	sprintf(Buf, Msg, Arg);
 	AfxMessageBox(Buf);
 }
 #endif
	#include "stdafx.h"
	#include <comdef.h> // For _bstr_t
	#include "VisVim.h"
	#include "Commands.h"
	#include "OleAut.h"

	#ifdef _DEBUG
	#define new DEBUG_NEW
	#undef THIS_FILE
	static char THIS_FILE[] = __FILE__;

	#endif


	// Change directory before opening file?
	#define CD_SOURCE 0 // Cd to source path
	#define CD_SOURCE_PARENT 1 // Cd to parent directory of source path
	#define CD_NONE 2 // No cd


	static BOOL g_bEnableVim = TRUE; // Vim enabled
	static BOOL g_bDevStudioEditor = FALSE; // Open file in Dev Studio editor simultaneously
	static BOOL g_bNewTabs = FALSE;
	static int g_ChangeDir = CD_NONE; // CD after file open?

	static void VimSetEnableState(BOOL bEnableState);
	static BOOL VimOpenFile(BSTR& FileName, long LineNr);
	static DISPID VimGetDispatchId(COleAutomationControl& VimOle, char* Method);
	static void VimErrDiag(COleAutomationControl& VimOle);
	static void VimChangeDir(COleAutomationControl& VimOle, DISPID DispatchId, BSTR& FileName);
	static void DebugMsg(char* Msg, char* Arg = NULL);


	/////////////////////////////////////////////////////////////////////////////
	// CCommands

	CCommands::CCommands()
	{
	// m_pApplication == NULL; M$ Code generation bug!!!
	m_pApplication = NULL;
	m_pApplicationEventsObj = NULL;
	m_pDebuggerEventsObj = NULL;
	}

	CCommands::~CCommands()
	{
	ASSERT(m_pApplication != NULL);
	if (m_pApplication)
	{
	m_pApplication->Release();
	m_pApplication = NULL;
	}
	}

	void CCommands::SetApplicationObject(IApplication * pApplication)
	{
	// This function assumes pApplication has already been AddRef'd
	// for us, which CDSAddIn did in it's QueryInterface call
	// just before it called us.
	m_pApplication = pApplication;
	if (! m_pApplication)
	return;

	// Create Application event handlers
	XApplicationEventsObj::CreateInstance(&m_pApplicationEventsObj);
	if (! m_pApplicationEventsObj)
	{
	ReportInternalError("XApplicationEventsObj::CreateInstance");
	return;
	}
	m_pApplicationEventsObj->AddRef();
	m_pApplicationEventsObj->Connect(m_pApplication);
	m_pApplicationEventsObj->m_pCommands = this;

	#ifdef NEVER
	// Create Debugger event handler
	CComPtr < IDispatch > pDebugger;
	if (SUCCEEDED(m_pApplication->get_Debugger(&pDebugger))
	&& pDebugger != NULL)
	{
	XDebuggerEventsObj::CreateInstance(&m_pDebuggerEventsObj);
	m_pDebuggerEventsObj->AddRef();
	m_pDebuggerEventsObj->Connect(pDebugger);
	m_pDebuggerEventsObj->m_pCommands = this;
	}
	#endif

	// Get settings from registry HKEY_CURRENT_USER\Software\Vim\VisVim
	HKEY hAppKey = GetAppKey("Vim");
	if (hAppKey)
	{
	HKEY hSectionKey = GetSectionKey(hAppKey, "VisVim");
	if (hSectionKey)
	{
	g_bEnableVim = GetRegistryInt(hSectionKey, "EnableVim",
	g_bEnableVim);
	g_bDevStudioEditor = GetRegistryInt(hSectionKey,
	"DevStudioEditor", g_bDevStudioEditor);
	g_bNewTabs = GetRegistryInt(hSectionKey, "NewTabs",
	g_bNewTabs);
	g_ChangeDir = GetRegistryInt(hSectionKey, "ChangeDir",
	g_ChangeDir);
	RegCloseKey(hSectionKey);
	}
	RegCloseKey(hAppKey);
	}
	}

	void CCommands::UnadviseFromEvents()
	{
	ASSERT(m_pApplicationEventsObj != NULL);
	if (m_pApplicationEventsObj)
	{
	m_pApplicationEventsObj->Disconnect(m_pApplication);
	m_pApplicationEventsObj->Release();
	m_pApplicationEventsObj = NULL;
	}

	#ifdef NEVER
	if (m_pDebuggerEventsObj)
	{
	// Since we were able to connect to the Debugger events, we
	// should be able to access the Debugger object again to
	// unadvise from its events (thus the VERIFY_OK below--see
	// stdafx.h).
	CComPtr < IDispatch > pDebugger;
	VERIFY_OK(m_pApplication->get_Debugger(&pDebugger));
	ASSERT(pDebugger != NULL);
	m_pDebuggerEventsObj->Disconnect(pDebugger);
	m_pDebuggerEventsObj->Release();
	m_pDebuggerEventsObj = NULL;
	}
	#endif
	}


	/////////////////////////////////////////////////////////////////////////////
	// Event handlers

	// Application events

	HRESULT CCommands::XApplicationEvents::BeforeBuildStart()
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}

	HRESULT CCommands::XApplicationEvents::BuildFinish(long nNumErrors, long nNumWarnings)
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}

	HRESULT CCommands::XApplicationEvents::BeforeApplicationShutDown()
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}

	// The open document event handle is the place where the real interface work
	// is done.
	// Vim gets called from here.
	//
	HRESULT CCommands::XApplicationEvents::DocumentOpen(IDispatch * theDocument)
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	if (! g_bEnableVim)
	// Vim not enabled or empty command line entered
	return S_OK;

	// First get the current file name and line number

	// Get the document object
	CComQIPtr < ITextDocument, &IID_ITextDocument > pDoc(theDocument);
	if (! pDoc)
	return S_OK;

	BSTR FileName;
	long LineNr = -1;

	// Get the document name
	if (FAILED(pDoc->get_FullName(&FileName)))
	return S_OK;

	LPDISPATCH pDispSel;

	// Get a selection object dispatch pointer
	if (SUCCEEDED(pDoc->get_Selection(&pDispSel)))
	{
	// Get the selection object
	CComQIPtr < ITextSelection, &IID_ITextSelection > pSel(pDispSel);

	if (pSel)
	// Get the selection line number
	pSel->get_CurrentLine(&LineNr);

	pDispSel->Release();
	}

	// Open the file in Vim and position to the current line
	if (VimOpenFile(FileName, LineNr))
	{
	if (! g_bDevStudioEditor)
	{
	// Close the document in developer studio
	CComVariant vSaveChanges = dsSaveChangesPrompt;
	DsSaveStatus Saved;

	pDoc->Close(vSaveChanges, &Saved);
	}
	}

	// We're done here
	SysFreeString(FileName);
	return S_OK;
	}

	HRESULT CCommands::XApplicationEvents::BeforeDocumentClose(IDispatch * theDocument)
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}

	HRESULT CCommands::XApplicationEvents::DocumentSave(IDispatch * theDocument)
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}

	HRESULT CCommands::XApplicationEvents::NewDocument(IDispatch * theDocument)
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	if (! g_bEnableVim)
	// Vim not enabled or empty command line entered
	return S_OK;

	// First get the current file name and line number

	CComQIPtr < ITextDocument, &IID_ITextDocument > pDoc(theDocument);
	if (! pDoc)
	return S_OK;

	BSTR FileName;
	HRESULT hr;

	hr = pDoc->get_FullName(&FileName);
	if (FAILED(hr))
	return S_OK;

	// Open the file in Vim and position to the current line
	if (VimOpenFile(FileName, 0))
	{
	if (! g_bDevStudioEditor)
	{
	// Close the document in developer studio
	CComVariant vSaveChanges = dsSaveChangesPrompt;
	DsSaveStatus Saved;

	pDoc->Close(vSaveChanges, &Saved);
	}
	}

	SysFreeString(FileName);
	return S_OK;
	}

	HRESULT CCommands::XApplicationEvents::WindowActivate(IDispatch * theWindow)
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}

	HRESULT CCommands::XApplicationEvents::WindowDeactivate(IDispatch * theWindow)
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}

	HRESULT CCommands::XApplicationEvents::WorkspaceOpen()
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}

	HRESULT CCommands::XApplicationEvents::WorkspaceClose()
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}

	HRESULT CCommands::XApplicationEvents::NewWorkspace()
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}

	// Debugger event

	HRESULT CCommands::XDebuggerEvents::BreakpointHit(IDispatch * pBreakpoint)
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return S_OK;
	}


	/////////////////////////////////////////////////////////////////////////////
	// VisVim dialog

	class CMainDialog : public CDialog
	{
	public:
	CMainDialog(CWnd * pParent = NULL); // Standard constructor

	//{{AFX_DATA(CMainDialog)
	enum { IDD = IDD_ADDINMAIN };
	int m_ChangeDir;
	BOOL m_bDevStudioEditor;
	BOOL m_bNewTabs;
	//}}AFX_DATA

	//{{AFX_VIRTUAL(CMainDialog)
	protected:
	virtual void DoDataExchange(CDataExchange * pDX); // DDX/DDV support
	//}}AFX_VIRTUAL

	protected:
	//{{AFX_MSG(CMainDialog)
	afx_msg void OnEnable();
	afx_msg void OnDisable();
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
	};

	CMainDialog::CMainDialog(CWnd * pParent /* =NULL */ )
	: CDialog(CMainDialog::IDD, pParent)
	{
	//{{AFX_DATA_INIT(CMainDialog)
	m_ChangeDir = -1;
	m_bDevStudioEditor = FALSE;
	m_bNewTabs = FALSE;
	//}}AFX_DATA_INIT
	}

	void CMainDialog::DoDataExchange(CDataExchange * pDX)
	{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CMainDialog)
	DDX_Radio(pDX, IDC_CD_SOURCE_PATH, m_ChangeDir);
	DDX_Check(pDX, IDC_DEVSTUDIO_EDITOR, m_bDevStudioEditor);
	DDX_Check(pDX, IDC_NEW_TABS, m_bNewTabs);
	//}}AFX_DATA_MAP
	}

	BEGIN_MESSAGE_MAP(CMainDialog, CDialog)
	//{{AFX_MSG_MAP(CMainDialog)
	//}}AFX_MSG_MAP
	END_MESSAGE_MAP()


	/////////////////////////////////////////////////////////////////////////////
	// CCommands methods

	STDMETHODIMP CCommands::VisVimDialog()
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	// Use m_pApplication to access the Developer Studio Application
	// object,
	// and VERIFY_OK to see error strings in DEBUG builds of your add-in
	// (see stdafx.h)

	VERIFY_OK(m_pApplication->EnableModeless(VARIANT_FALSE));

	CMainDialog Dlg;

	Dlg.m_bDevStudioEditor = g_bDevStudioEditor;
	Dlg.m_bNewTabs = g_bNewTabs;
	Dlg.m_ChangeDir = g_ChangeDir;
	if (Dlg.DoModal() == IDOK)
	{
	g_bDevStudioEditor = Dlg.m_bDevStudioEditor;
	g_bNewTabs = Dlg.m_bNewTabs;
	g_ChangeDir = Dlg.m_ChangeDir;

	// Save settings to registry HKEY_CURRENT_USER\Software\Vim\VisVim
	HKEY hAppKey = GetAppKey("Vim");
	if (hAppKey)
	{
	HKEY hSectionKey = GetSectionKey(hAppKey, "VisVim");
	if (hSectionKey)
	{
	WriteRegistryInt(hSectionKey, "DevStudioEditor",
	g_bDevStudioEditor);
	WriteRegistryInt(hSectionKey, "NewTabs",
	g_bNewTabs);
	WriteRegistryInt(hSectionKey, "ChangeDir", g_ChangeDir);
	RegCloseKey(hSectionKey);
	}
	RegCloseKey(hAppKey);
	}
	}

	VERIFY_OK(m_pApplication->EnableModeless(VARIANT_TRUE));
	return S_OK;
	}

	STDMETHODIMP CCommands::VisVimEnable()
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	VimSetEnableState(true);
	return S_OK;
	}

	STDMETHODIMP CCommands::VisVimDisable()
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	VimSetEnableState(false);
	return S_OK;
	}

	STDMETHODIMP CCommands::VisVimToggle()
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	VimSetEnableState(! g_bEnableVim);
	return S_OK;
	}

	STDMETHODIMP CCommands::VisVimLoad()
	{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	// Use m_pApplication to access the Developer Studio Application object,
	// and VERIFY_OK to see error strings in DEBUG builds of your add-in
	// (see stdafx.h)

	CComBSTR bStr;
	// Define dispatch pointers for document and selection objects
	CComPtr < IDispatch > pDispDoc, pDispSel;

	// Get a document object dispatch pointer
	VERIFY_OK(m_pApplication->get_ActiveDocument(&pDispDoc));
	if (! pDispDoc)
	return S_OK;

	BSTR FileName;
	long LineNr = -1;

	// Get the document object
	CComQIPtr < ITextDocument, &IID_ITextDocument > pDoc(pDispDoc);

	if (! pDoc)
	return S_OK;

	// Get the document name
	if (FAILED(pDoc->get_FullName(&FileName)))
	return S_OK;

	// Get a selection object dispatch pointer
	if (SUCCEEDED(pDoc->get_Selection(&pDispSel)))
	{
	// Get the selection object
	CComQIPtr < ITextSelection, &IID_ITextSelection > pSel(pDispSel);

	if (pSel)
	// Get the selection line number
	pSel->get_CurrentLine(&LineNr);
	}

	// Open the file in Vim
	VimOpenFile(FileName, LineNr);

	SysFreeString(FileName);
	return S_OK;
	}


	//
	// Here we do the actual processing and communication with Vim
	//

	// Set the enable state and save to registry
	//
	static void VimSetEnableState(BOOL bEnableState)
	{
	g_bEnableVim = bEnableState;
	HKEY hAppKey = GetAppKey("Vim");
	if (hAppKey)
	{
	HKEY hSectionKey = GetSectionKey(hAppKey, "VisVim");
	if (hSectionKey)
	WriteRegistryInt(hSectionKey, "EnableVim", g_bEnableVim);
	RegCloseKey(hAppKey);
	}
	}

	// Open the file 'FileName' in Vim and goto line 'LineNr'
	// 'FileName' is expected to contain an absolute DOS path including the drive
	// letter.
	// 'LineNr' must contain a valid line number or 0, e. g. for a new file
	//
	static BOOL VimOpenFile(BSTR& FileName, long LineNr)
	{

	// OLE automation object for com. with Vim
	// When the object goes out of scope, it's destructor destroys the OLE
	// connection;
	// This is important to avoid blocking the object
	// (in this memory corruption would be likely when terminating Vim
	// while still running DevStudio).
	// So keep this object local!
	COleAutomationControl VimOle;

	// :cd D:/Src2/VisVim/
	//
	// Get a dispatch id for the SendKeys method of Vim;
	// enables connection to Vim if necessary
	DISPID DispatchId;
	DispatchId = VimGetDispatchId(VimOle, "SendKeys");
	if (! DispatchId)
	// OLE error, can't obtain dispatch id
	goto OleError;

	OLECHAR Buf[MAX_OLE_STR];
	char FileNameTmp[MAX_OLE_STR];
	char VimCmd[MAX_OLE_STR];
	char s, p;

	// Prepend CTRL-\ CTRL-N to exit insert mode
	VimCmd[0] = 0x1c;
	VimCmd[1] = 0x0e;
	VimCmd[2] = 0;

	#ifdef SINGLE_WINDOW
	// Update the current file in Vim if it has been modified.
	// Disabled, because it could write the file when you don't want to.
	sprintf(VimCmd + 2, ":up\n");
	#endif
	if (! VimOle.Method(DispatchId, "s", TO_OLE_STR_BUF(VimCmd, Buf)))
	goto OleError;

	// Change Vim working directory to where the file is if desired
	if (g_ChangeDir != CD_NONE)
	VimChangeDir(VimOle, DispatchId, FileName);

	// Make Vim open the file.
	// In the filename convert all \ to /, put a \ before a space.
	if (g_bNewTabs)
	{
	sprintf(VimCmd, ":tab drop ");
	s = VimCmd + 10;
	}
	else
	{
	sprintf(VimCmd, ":drop ");
	s = VimCmd + 6;
	}
	sprintf(FileNameTmp, "%S", (char *)FileName);
	for (p = FileNameTmp; *p != '\0' && s < VimCmd + MAX_OLE_STR - 4; ++p)
	if (*p == '\\')
	*s++ = '/';
	else
	{
	if (*p == ' ')
	*s++ = '\\';
	s++ = p;
	}
	*s++ = '\n';
	*s = '\0';

	if (! VimOle.Method(DispatchId, "s", TO_OLE_STR_BUF(VimCmd, Buf)))
	goto OleError;

	if (LineNr > 0)
	{
	// Goto line
	sprintf(VimCmd, ":%ld\n", LineNr);
	if (! VimOle.Method(DispatchId, "s", TO_OLE_STR_BUF(VimCmd, Buf)))
	goto OleError;
	}

	// Make Vim come to the foreground
	if (! VimOle.Method("SetForeground"))
	VimOle.ErrDiag();

	// We're done
	return true;

	OleError:
	// There was an OLE error
	// Check if it's the "unknown class string" error
	VimErrDiag(VimOle);
	return false;
	}

	// Return the dispatch id for the Vim method 'Method'
	// Create the Vim OLE object if necessary
	// Returns a valid dispatch id or null on error
	//
	static DISPID VimGetDispatchId(COleAutomationControl& VimOle, char* Method)
	{
	// Initialize Vim OLE connection if not already done
	if (! VimOle.IsCreated())
	{
	if (! VimOle.CreateObject("Vim.Application"))
	return NULL;
	}

	// Get the dispatch id for the SendKeys method.
	// By doing this, we are checking if Vim is still there...
	DISPID DispatchId = VimOle.GetDispatchId("SendKeys");
	if (! DispatchId)
	{
	// We can't get a dispatch id.
	// This means that probably Vim has been terminated.
	// Don't issue an error message here, instead
	// destroy the OLE object and try to connect once more
	//
	// In fact, this should never happen, because the OLE aut. object
	// should not be kept long enough to allow the user to terminate Vim
	// to avoid memory corruption (why the heck is there no system garbage
	// collection for those damned OLE memory chunks???).
	VimOle.DeleteObject();
	if (! VimOle.CreateObject("Vim.Application"))
	// If this create fails, it's time for an error msg
	return NULL;

	if (! (DispatchId = VimOle.GetDispatchId("SendKeys")))
	// There is something wrong...
	return NULL;
	}

	return DispatchId;
	}

	// Output an error message for an OLE error
	// Check on the classstring error, which probably means Vim wasn't registered.
	//
	static void VimErrDiag(COleAutomationControl& VimOle)
	{
	SCODE sc = GetScode(VimOle.GetResult());
	if (sc == CO_E_CLASSSTRING)
	{
	char Buf[256];
	sprintf(Buf, "There is no registered OLE automation server named "
	"\"Vim.Application\".\n"
	"Use the OLE-enabled version of Vim with VisVim and "
	"make sure to register Vim by running \"vim -register\".");
	MessageBox(NULL, Buf, "OLE Error", MB_OK);
	}
	else
	VimOle.ErrDiag();
	}

	// Change directory to the directory the file 'FileName' is in or it's parent
	// directory according to the setting of the global 'g_ChangeDir':
	// 'FileName' is expected to contain an absolute DOS path including the drive
	// letter.
	// CD_NONE
	// CD_SOURCE_PATH
	// CD_SOURCE_PARENT
	//
	static void VimChangeDir(COleAutomationControl& VimOle, DISPID DispatchId, BSTR& FileName)
	{
	// Do a :cd first

	// Get the path name of the file ("dir/")
	CString StrFileName = FileName;
	char Drive[_MAX_DRIVE];
	char Dir[_MAX_DIR];
	char DirUnix[_MAX_DIR * 2];
	char s, t;

	_splitpath(StrFileName, Drive, Dir, NULL, NULL);

	// Convert to Unix path name format, escape spaces.
	t = DirUnix;
	for (s = Dir; *s; ++s)
	if (*s == '\\')
	*t++ = '/';
	else
	{
	if (*s == ' ')
	*t++ = '\\';
	t++ = s;
	}
	*t = '\0';


	// Construct the cd command; append /.. if cd to parent
	// directory and not in root directory
	OLECHAR Buf[MAX_OLE_STR];
	char VimCmd[MAX_OLE_STR];

	sprintf(VimCmd, ":cd %s%s%s\n", Drive, DirUnix,
	g_ChangeDir == CD_SOURCE_PARENT && DirUnix[1] ? ".." : "");
	VimOle.Method(DispatchId, "s", TO_OLE_STR_BUF(VimCmd, Buf));
	}

	#ifdef _DEBUG
	// Print out a debug message
	//
	static void DebugMsg(char* Msg, char* Arg)
	{
	char Buf[400];
	sprintf(Buf, Msg, Arg);
	AfxMessageBox(Buf);
	}
	#endif