/// <summary>
/// This function is called when the user clicks the menu item that shows the
/// tool window. See the Initialize method to see how the menu item is associated to
/// this function using the OleMenuCommandService service and the MenuCommand class.
/// </summary>
private void ShowMergeToolWindow(object sender, EventArgs e)
{
IVsUIShell4 uiShell = GetService(typeof(SVsUIShell)) as IVsUIShell4;
// Get the instance number 0 of this tool window. This window is single instance so this instance
// is actually the only one.
// The last flag is set to true so that if the tool window does not exists it will be created.
ToolWindowPane window = this.FindToolWindow(typeof(vMergeMergeToolWindow), 0, true);
if ((null == window) || (null == window.Frame))
{
throw new NotSupportedException(Resources.CanNotCreateWindow);
}
IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
SetMergeToolWindowIsVisible();
var windowEvents = new ToolWindowEvents(windowFrame);
windowEvents.OnClose = (options) =>
{
MergeToolWindowIsVisible = false;
if (_mergeToolWindowVisibilityChanged != null)
{
_mergeToolWindowVisibilityChanged(this, new EventArgs());
}
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_ViewHelper, null);
windowEvents.Dispose();
return(VSConstants.S_OK);
};
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_ViewHelper, windowEvents);
vMergeMergeToolWindow mergeToolWindow = (vMergeMergeToolWindow)window;
}
private IVsWindowFrame CreateChildEditorFrame(Guid guidEditorFactory, SplitterPanel panel)
{
ThreadHelper.ThrowIfNotOnUIThread();
IVsUIShellOpenDocument vsUISHOD = GetService(typeof(SVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
IVsWindowFrame childFrame = null;
IVsUIHierarchy vsUIHier;
uint itemid;
int fOpen;
Guid guidLogEditorView = Guid.Empty;
IOleServiceProvider oleServiceProvider;
int hr = vsUISHOD.IsSpecificDocumentViewOpen((IVsUIHierarchy)this.vsHierarchy, this.itemid, this.fileName, ref guidEditorFactory, null, 0, out vsUIHier, out itemid, out childFrame, out fOpen);
if (ErrorHandler.Succeeded(hr) && fOpen != 0)
{
// if already open, create a copy
hr = vsUISHOD.OpenCopyOfStandardEditor(childFrame, ref guidLogEditorView, out childFrame);
}
else
{
hr = vsUISHOD.OpenDocumentViaProjectWithSpecific(fileName,
(uint)__VSSPECIFICEDITORFLAGS.VSSPECIFICEDITOR_UseEditor | (uint)__VSSPECIFICEDITORFLAGS.VSSPECIFICEDITOR_DoOpen,
ref guidEditorFactory, null, ref guidLogEditorView, out oleServiceProvider, out vsUIHier, out itemid, out childFrame);
}
if (ErrorHandler.Failed(hr))
{
Debug.Fail("Failed to create/open editor!!!");
Marshal.ThrowExceptionForHR(hr);
}
IVsWindowFrame parentFrame = GetService(typeof(SVsWindowFrame)) as IVsWindowFrame;
if (parentFrame == null)
{
throw new System.InvalidOperationException("could not retrieve the parent Window Frame");
}
childFrame.SetProperty((int)__VSFPROPID2.VSFPROPID_ParentFrame, parentFrame);
childFrame.SetProperty((int)__VSFPROPID.VSFPROPID_ViewHelper, this);
childFrame.SetProperty((int)__VSFPROPID3.VSFPROPID_NotifyOnActivate, true);
childFrame.SetProperty((int)__VSFPROPID5.VSFPROPID_DontAutoOpen, true);
childFrame.SetProperty((int)__VSFPROPID2.VSFPROPID_ParentHwnd, panel.Handle);
Guid cmdUITextEditorGuid = VSConstants.GUID_TextEditorFactory;
childFrame.SetGuidProperty((int)__VSFPROPID.VSFPROPID_InheritKeyBindings, ref cmdUITextEditorGuid);
return(childFrame);
}
private void HostCSharpEditor()
{
if (_TextViewHost == null)
{
InitializeEditor(_CurrentScriptName);
}
if (_childWindowFrame != null)
{
//because VsShellUtilities.OpenDocumentWithSpecificEditor call Show, i should cause hide, before changing parent
_childWindowFrame.Hide();
var window = VsShellUtilities.GetWindowObject(parentWindowFrame);
_childWindowFrame.SetProperty((int)__VSFPROPID2.VSFPROPID_ParentHwnd, window.HWnd);
_childWindowFrame.SetProperty((int)__VSFPROPID2.VSFPROPID_ParentFrame, parentWindowFrame);
}
}
public static WinForms.Panel create_WinForms_Window(this string title, VSFRAMEMODE frameMode)
{
var visualStudio = new VisualStudio_2010();
var _panel = visualStudio.invokeOnThread(
() =>
{
var type = typeof(O2.FluentSharp.VisualStudio.WindowPane_WinForms);
var window = (ToolWindowPane)visualStudio.package().invoke("CreateToolWindow", type, 64000.random());
window.Caption = title;
IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
//if(floating)
// windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSFRAMEMODE.VSFM_Float);
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, frameMode);
windowFrame.Show();
var content = (Control_WinForms)window.Content;
var windowsFormHost = (System.Windows.Forms.Integration.WindowsFormsHost)content.Content;
var panel = new WinForms.Panel();
panel.backColor("Control");
windowsFormHost.Child = panel;
return(panel);
});
return(_panel);
}
/// <summary>
/// Creates a new instance from the specified frame
/// </summary>
/// <param name="frame"></param>
public WindowFrame(IVsWindowFrame frame)
{
ThreadHelper.ThrowIfNotOnUIThread();
_frame = frame ?? throw new ArgumentNullException("frame");
ErrorHandler.ThrowOnFailure(_frame.SetProperty((int)__VSFPROPID.VSFPROPID_ViewHelper, this));
}
private static void DockWindow(IVsWindowFrame windowFrame)
{
if (windowFrame == null)
{
return;
}
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSFRAMEMODE.VSFM_Dock);
}
public override void Execute()
{
rm = new ResourceManager(typeof(Resources));
CodeFile codeFile;
IList <ISyntaxEntity> contextHierarchy;
//Getting the code text from the active document
var path = TalkCodePackage.vsOperations.GetActiveDocumentPath();
var codeText = TalkCodePackage.vsOperations.GetActiveDocumentCode();
//Creating a language service
var lService = new Language(path);
try
{
//Parsing the code
codeFile = lService.Parse(codeText, System.IO.Path.GetFileName(path));
}
catch (CodeTalkLanguageServiceException)
{
MessageBox.Show(rm.GetString("CompilationErrorMessage", CultureInfo.CurrentCulture), rm.GetString("CodeTalkString", CultureInfo.CurrentCulture), MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
try
{
int currentLineNumber = 0;
currentLineNumber = TalkCodePackage.vsOperations.GetCurrentCursorPosition().lineNumber;
contextHierarchy = codeFile.GetContextAtLine(currentLineNumber) as IList <ISyntaxEntity>;
if (0 == contextHierarchy.Count)
{
MessageBox.Show(rm.GetString("NoContextString", CultureInfo.CurrentCulture) + " " + currentLineNumber.ToString(), rm.GetString("CodeTalkString", CultureInfo.CurrentCulture), MessageBoxButtons.OK);
return;
}
var entities = contextHierarchy.Reverse().ToList().ConvertAll(x => (ISyntaxEntity)x);
ToolWindowPane listFunctionsWindow = TalkCodePackage.currentPackage.FindToolWindow(typeof(AccessibilityToolWindow), 0, true);
if ((null == listFunctionsWindow) || (null == listFunctionsWindow.Frame))
{
MessageBox.Show("Cannote create tool window", "Cannot create tool window", MessageBoxButtons.OK);
}
IVsWindowFrame windowFrame = (IVsWindowFrame)listFunctionsWindow.Frame;
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_Caption, rm.GetString("GetContextTitle", CultureInfo.CurrentCulture));
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
(listFunctionsWindow as AccessibilityToolWindow).windowControl.SetListView(entities, rm.GetString("GetContextTitle", CultureInfo.CurrentCulture), false);
}
catch (IndexOutOfRangeException)
{
MessageBox.Show("The cursor does not seem to be in code. please move the cursor and try again.", "CodeTalk", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public static void RenameDocument(ServiceProvider site, string oldName, string newName)
{
IVsRunningDocumentTable pRDT = (IVsRunningDocumentTable)site.QueryService(VsConstants.SID_SVsRunningDocumentTable, typeof(IVsRunningDocumentTable));
IVsUIShellOpenDocument doc = (IVsUIShellOpenDocument)site.QueryService(VsConstants.SID_VsUIShellOpenDocument, typeof(IVsUIShellOpenDocument));
IVsUIShell uiShell = (IVsUIShell)site.QueryService(VsConstants.guidShellIID, typeof(IVsUIShell));
if (pRDT == null || doc == null)
{
return;
}
IVsHierarchy pIVsHierarchy;
uint itemId;
IntPtr docData;
uint uiVsDocCookie;
pRDT.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock,
oldName, out pIVsHierarchy, out itemId, out docData, out uiVsDocCookie);
if (docData != IntPtr.Zero)
{
IntPtr pUnk = Marshal.GetIUnknownForObject(pIVsHierarchy);
Guid iid = typeof(IVsHierarchy).GUID;
IntPtr pHier;
Marshal.QueryInterface(pUnk, ref iid, out pHier);
try
{
pRDT.RenameDocument(oldName, newName, pHier, itemId);
}
finally
{
Marshal.Release(pHier);
Marshal.Release(pUnk);
}
string newCaption = Path.GetFileName(newName);
// now we need to tell the windows to update their captions.
IEnumWindowFrames ppenum;
uiShell.GetDocumentWindowEnum(out ppenum);
IVsWindowFrame[] rgelt = new IVsWindowFrame[1];
uint fetched;
while (ppenum.Next(1, rgelt, out fetched) == 0 && fetched == 1)
{
IVsWindowFrame windowFrame = rgelt[0];
object data;
windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out data);
IntPtr ptr = Marshal.GetIUnknownForObject(data);
if (ptr == docData)
{
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_OwnerCaption, newCaption);
}
Marshal.Release(ptr);
}
Marshal.Release(docData);
}
}
public static ToolWindowPane as_Dock(this ToolWindowPane toolWindow)
{
if (toolWindow.notNull())
{
IVsWindowFrame windowFrame = (IVsWindowFrame)toolWindow.Frame;
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSFRAMEMODE.VSFM_Dock);
}
return(toolWindow);
}
// i wish we could simply do th:is:
//VsShellUtilities.GetWindowObject(wf).Caption = some caption;
// but its impossible. Exception is thrown - invalid operation, bla bla.
public static void SetDocumentWindowFrameCaptionWithLabel(this IVsWindowFrame wf,
string vanillaTabCaption, string jumpLabel)
{
//TODO: (check for length (what if vanilla caption is shorter than label & decor ???!!!)
var newCaption = PeasyMotionEdAdornment.getDocumentTabCaptionWithLabel(vanillaTabCaption, jumpLabel);
wf.SetProperty((int)VsFramePropID.OverrideCaption, newCaption);
//Debug.WriteLine($"WindowFrame oldCaption={vanillaTabCaption} => newCaption={newCaption}");
}
/// <summary>
/// Sets ToolWindowEvents instance as a listener for the VS events
/// </summary>
public void AddEventsListener()
{
IVsWindowFrame frame = (IVsWindowFrame)Frame;
if (frame != null)
{
frame.SetProperty((int)__VSFPROPID.VSFPROPID_ViewHelper, windowEvents);
}
}
/// <summary>
/// Updates all of the open windows that are editing this node's files to update their captions.
/// </summary>
/// <param name="newCaption">The new caption.</param>
protected void UpdateOpenWindowCaptions(string newCaption)
{
// Get the environment's UI shell in preparation for enumerating the window frames.
IVsUIShell uiShell = this.ServiceProvider.GetVsUIShell(classType, "UpdateOpenWindowCaptions");
IEnumWindowFrames enumerator;
NativeMethods.ThrowOnFailure(uiShell.GetDocumentWindowEnum(out enumerator));
IVsWindowFrame[] windowFrames = new IVsWindowFrame[1];
uint fetchCount;
// Get the document data for this node (don't find by cookie because the document cookie
// could have changed on a rename).
DocumentInfo docInfo = Package.Instance.Context.RunningDocumentTable.FindByPath(this.AbsolutePath);
if (docInfo == null)
{
// There's no need to rename any captions if the document isn't open.
return;
}
IntPtr docData = Marshal.GetIUnknownForObject(docInfo.DocumentData);
try
{
// Tell all of the windows to update their caption to the new file name.
while (enumerator.Next(1, windowFrames, out fetchCount) == NativeMethods.S_OK && fetchCount == 1)
{
IVsWindowFrame windowFrame = windowFrames[0];
object documentDataObject;
NativeMethods.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out documentDataObject));
IntPtr pUnknownDocData = Marshal.GetIUnknownForObject(documentDataObject);
try
{
// We found a window frame that contains the document to rename.
if (pUnknownDocData == docData)
{
NativeMethods.ThrowOnFailure(windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_OwnerCaption, newCaption));
}
}
finally
{
if (pUnknownDocData != IntPtr.Zero)
{
Marshal.Release(pUnknownDocData);
}
}
}
}
finally
{
if (docData != IntPtr.Zero)
{
Marshal.Release(docData);
}
}
}
private void Execute(object sender, EventArgs e)
{
ThreadHelper.ThrowIfNotOnUIThread();
var toolWindow = _packageProvider.AsyncPackage.FindToolWindow(typeof(HistoryToolWindow), 0, true);
_window = (IVsWindowFrame)toolWindow.Frame;
_window.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSFRAMEMODE.VSFM_MdiChild);
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(_window.Show());
}
public void ForceMDIDock()
{
IVsWindowFrame gettingStartedWindowFrame = (IVsWindowFrame)this.Frame;
try
{
gettingStartedWindowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSFRAMEMODE.VSFM_MdiChild);
}
catch { }
}
private static void HideWindow(IVsWindowFrame windowFrame)
{
if (windowFrame == null)
{
return;
}
// HACK! Internal code for setting FrameMode property will set to Docked if already in AutoHide mode.
// To avoid this, ensure that the window's current FrameMode is not AutoHide. (Set to Dock if necessary.)
if (IsAutoHideWindow(windowFrame))
{
// Temporarily Dock
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSFRAMEMODE.VSFM_Dock);
}
// Hide window (Set to auto-hide)
System.Diagnostics.Debug.WriteLine($"Hiding window: {GetWindowTitle(windowFrame)}");
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSFRAMEMODE2.VSFM_AutoHide);
}
internal void SetWindowFrame(IVsWindowFrame windowFrame)
{
AssertIsForeground();
if (_windowFrame != null)
{
// We already have a window frame, and we don't expect to get a second one
return;
}
_windowFrame = windowFrame;
// We'll override the window frame and never show it as dirty, even if there's an underlying edit
windowFrame.SetProperty((int)__VSFPROPID2.VSFPROPID_OverrideDirtyState, false);
windowFrame.SetProperty((int)__VSFPROPID5.VSFPROPID_OverrideCaption, _generatedSourceHintName + " " + ServicesVSResources.generated_suffix);
windowFrame.SetProperty((int)__VSFPROPID5.VSFPROPID_OverrideToolTip, _generatedSourceHintName + " " + string.Format(ServicesVSResources.generated_by_0_suffix, _generatorTypeName));
EnsureWindowFrameInfoBarUpdated();
}
public override void Execute()
{
rm = new ResourceManager(typeof(Resources));
System.Diagnostics.Debug.WriteLine("Get Functions");
IEnumerable <ISyntaxEntity> functions = new List <ISyntaxEntity>();
CodeFile codeFile;
//Getting the code text from the active document
var path = TalkCodePackage.vsOperations.GetActiveDocumentPath();
var codeText = TalkCodePackage.vsOperations.GetActiveDocumentCode();
//Creating a language service
var lService = new Language(path);
try
{
//Parsing the code
codeFile = lService.Parse(codeText, path);
}
catch (CodeTalkLanguageServiceException)
{
MessageBox.Show(rm.GetString("CompilationErrorMessage", CultureInfo.CurrentCulture), rm.GetString("CodeTalkString", CultureInfo.CurrentCulture), MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
//Creating a function collector for getting all the functions
var functionCollector = new FunctionCollector();
functionCollector.VisitCodeFile(codeFile);
//Getting all the functions
functions = functionCollector.FunctionsInFile;
if (0 == functions.Count())
{
MessageBox.Show(rm.GetString("NoFunctionsString", CultureInfo.CurrentCulture), rm.GetString("CodeTalkString", CultureInfo.CurrentCulture), MessageBoxButtons.OK);
return;
}
ToolWindowPane listFunctionsWindow = TalkCodePackage.currentPackage.FindToolWindow(typeof(AccessibilityToolWindow), 0, true);
if ((null == listFunctionsWindow) || (null == listFunctionsWindow.Frame))
{
throw new NotSupportedException("Cannot create tool window");
}
IVsWindowFrame windowFrame = (IVsWindowFrame)listFunctionsWindow.Frame;
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_Caption, rm.GetString("FunctionsListTitle", CultureInfo.CurrentCulture));
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
(listFunctionsWindow as AccessibilityToolWindow).windowControl.SetListView(functions, rm.GetString("FunctionsListTitle", CultureInfo.CurrentCulture));
}
/// <summary>
/// Docks the specified frame window if it is currently floating.
/// </summary>
/// <remarks>Works in VS2010, does not appear to work in VS2008.</remarks>
/// <param name="frame">The frame.</param>
private static void DockWindowIfFloating(IVsWindowFrame frame)
{
// Get the current tool window frame mode.
frame.GetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, out object currentFrameMode);
// If currently floating, switch to dock mode.
if ((VSFRAMEMODE)currentFrameMode == VSFRAMEMODE.VSFM_Float)
{
frame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSFRAMEMODE.VSFM_Dock);
}
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Creates a new instance of the class
/// </summary>
/// <param name="frame"></param>
// --------------------------------------------------------------------------------------------
public WindowFrame(IVsWindowFrame frame)
{
if (frame == null)
{
throw new ArgumentNullException("frame");
}
_Frame = frame;
// --- Set up event handlers
ErrorHandler.ThrowOnFailure(_Frame.SetProperty((int)__VSFPROPID.VSFPROPID_ViewHelper, this));
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Creates a new instance of the class
/// </summary>
/// <param name="frame"></param>
// --------------------------------------------------------------------------------------------
public WindowFrame(IVsWindowFrame frame)
{
if (frame == null)
{
throw new ArgumentNullException("frame");
}
_Frame = frame;
// --- Set up event handlers
ErrorHandler.ThrowOnFailure(_Frame.SetProperty((int)__VSFPROPID.VSFPROPID_ViewHelper, this));
}
public bool RunDiff(AnkhDiffArgs args)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (args == null)
{
throw new ArgumentNullException("args");
}
else if (!HasDiff)
{
throw new InvalidOperationException();
}
if (_ocw2 == null)
{
_ocw2 = GetInterfaceDelegate <OpenComparisonWindow2>(_type_IVsDifferenceService, _vsDifferenceService);
}
if (_ocw2 == null)
{
return(false);
}
uint flags = VSDIFFOPT_DetectBinaryFiles;
if (TempPath != null)
{
if (SvnItem.IsBelowRoot(args.BaseFile, TempPath))
{
flags |= VSDIFFOPT_LeftFileIsTemporary;
}
if (SvnItem.IsBelowRoot(args.MineFile, TempPath))
{
flags |= VSDIFFOPT_RightFileIsTemporary;
}
}
IVsWindowFrame frame = _ocw2(args.BaseFile, args.MineFile, args.Caption ?? args.MineTitle, "", args.BaseTitle, args.MineTitle, args.Label ?? "", null, flags);
if (frame != null)
{
GC.KeepAlive(new DiffMergeInstance(this, frame));
if (!args.ShowDiffAsDocument)
{
frame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, (int)VSFRAMEMODE.VSFM_Float);
}
return(true);
}
return(false);
}
public void ShowSearchWindow2()
{
ToolWindowPane window = BabePackage.Current.FindToolWindow(typeof(SearchWndPane2), 0, true);
if ((null == window) || (null == window.Frame))
{
throw new NotSupportedException(Properties.Resources.CanNotCreateWindow);
}
IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_ViewHelper, new WindowFrameSink(SearchWndPane2.Current)));
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
}
protected override void Load(string fileName, bool isReload)
{
base.Load(fileName, isReload);
IVsRunningDocumentTable rdt = this.ServiceProvider.GetService(typeof(IVsRunningDocumentTable)) as IVsRunningDocumentTable;
uint a, b, c, d, e, f, g, h; string x; IVsHierarchy pp; System.IntPtr docptr;
rdt.GetDocumentInfo(this.Cookie, out a, out b, out c, out x, out pp, out d, out docptr);
IVsWindowFrame frame = this.ServiceProvider.GetService(typeof(IVsWindowFrame)) as IVsWindowFrame;
if (frame != null)
{
frame.SetProperty((int)__VSFPROPID.VSFPROPID_EditorCaption, "bloogle");
}
}
/// <summary>
/// Used to ReadOnly property for the Rich TextBox and correspondingly update the editor caption
/// </summary>
/// <param name="_isFileReadOnly">Indicates whether the file loaded is Read Only or not</param>
private void SetReadOnly(bool _isFileReadOnly)
{
this.editorControl.IsEnabled = !_isFileReadOnly;
//update editor caption with "[Read Only]" or "" as necessary
IVsWindowFrame frame = (IVsWindowFrame)GetService(typeof(SVsWindowFrame));
string editorCaption = "";
if (_isFileReadOnly)
{
editorCaption = this.GetResourceString("@100");
}
ErrorHandler.ThrowOnFailure(frame.SetProperty((int)__VSFPROPID.VSFPROPID_EditorCaption, editorCaption));
backupObsolete = true;
}
public bool RunMerge(AnkhMergeArgs args)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (args == null)
{
throw new ArgumentNullException("args");
}
else if (!HasMerge)
{
throw new InvalidOperationException();
}
if (_ormw == null)
{
_ormw = GetInterfaceDelegate <OpenAndRegisterMergeWindow>(_type_IVsFileMergeService, _vsFileMergeService);
_umw = GetInterfaceDelegate <UnregisterMergeWindow>(_type_IVsFileMergeService, _vsFileMergeService);
_qmws = GetInterfaceDelegate <QueryMergeWindowState>(_type_IVsFileMergeService, _vsFileMergeService);
}
if (_ormw == null || _umw == null || _qmws == null)
{
return(false);
}
int cookie;
IVsWindowFrame frame = _ormw(args.TheirsFile, args.MineFile, args.BaseFile, args.MergedFile,
Path.GetFileName(args.TheirsFile), Path.GetFileName(args.MineFile),
Path.GetFileName(args.BaseFile), Path.GetFileName(args.MergedFile),
args.TheirsTitle, args.MineTitle, args.BaseTitle, args.MergedTitle,
Guid.Empty.ToString(), null, null, out cookie);
if (frame != null)
{
GC.KeepAlive(new DiffMergeInstance(this, frame, _umw, _qmws, cookie));
if (!args.ShowDiffAsDocument)
{
frame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, (int)VSFRAMEMODE.VSFM_Float);
}
return(true);
}
return(false);
}
/// <summary>
/// Shows the tool window when the menu item is clicked.
/// </summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">The event args.</param>
private void ShowToolWindow(object sender, EventArgs e)
{
// Get the instance number 0 of this tool window. This window is single instance so this instance
// is actually the only one.
// The last flag is set to true so that if the tool window does not exists it will be created.
ToolWindowPane window = this.package.FindToolWindow(typeof(ToolWindow), 0, true);
if ((null == window) || (null == window.Frame))
{
throw new NotSupportedException("Cannot create tool window");
}
IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_CmdUIGuid, ToolWindow.ToolWindowGuidString);
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
}
/// <summary>
/// Shows the tool window when the menu item is clicked.
/// </summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">The event args.</param>
protected override void MenuItemCallback(object sender, EventArgs e)
{
// Get the instance number 0 of this tool window. This window is single instance so this instance
// is actually the only one.
// The last flag is set to true so that if the tool window does not exists it will be created.
ToolWindowPane window = Package.FindToolWindow(typeof(GraphWindow.IncludeGraphToolWindow), 0, true);
if (window?.Frame == null)
{
Output.Instance.ErrorMsg("Failed to open BuildTime Graph window!");
}
else
{
IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_CmdUIGuid, GraphWindow.IncludeGraphToolWindow.GUIDString);
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
}
}
/// <summary>
/// Shows the tool window when the menu item is clicked.
/// </summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">The event args.</param>
private async void Execute(object sender, EventArgs e)
{
ThreadHelper.ThrowIfNotOnUIThread();
// Get the instance number 0 of this tool window. This window is single instance so this instance
// is actually the only one.
// The last flag is set to true so that if the tool window does not exists it will be created.
DTE2 dte = await this.ServiceProvider.GetServiceAsync(typeof(DTE)) as DTE2;
OutputsWindow.outputPane.Activate();
try
{
ToolWindowPane window = this.package.FindToolWindow(typeof(WDotykCmd), 0, true);
if ((null == window) || (null == window.Frame))
{
throw new NotSupportedException("Cannot create tool window");
}
if (dte.Solution.Count != 0)
{
if (dte.Solution.Projects.Count != 0)
// заполнить окно команды pack, вынести в отдельную функцию класса Filler
{
WDotykCmdControl wDotykCmdControl = window.Content as WDotykCmdControl;
Filler.fillPack(new PackBox()
{
//SolName = wDotykCmdControl.solution,
Conf = wDotykCmdControl.PackConf,
ProjName = wDotykCmdControl.PackProj,
OutpFolderName = wDotykCmdControl.PackOutp
}, dte.Solution, ref wDotykCmdControl.solution);
}
}
IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSSETFRAMEPOS.SFP_fTab);
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
}
catch (Exception)
{
MessageBox.Show("Не выбран проект");
}
}
/// <summary>
/// Updates the caption for all windows associated to the document.
/// </summary>
/// <param name="site">The service provider.</param>
/// <param name="caption">The new caption.</param>
/// <param name="docData">The IUnknown interface to a document data object associated with a registered document.</param>
public static void UpdateCaption(IServiceProvider site, string caption, IntPtr docData)
{
if (site == null)
{
throw new ArgumentNullException("site");
}
if (String.IsNullOrEmpty(caption))
{
throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty, CultureInfo.CurrentUICulture), "caption");
}
IVsUIShell uiShell = site.GetService(typeof(SVsUIShell)) as IVsUIShell;
// We need to tell the windows to update their captions.
IEnumWindowFrames windowFramesEnum;
ErrorHandler.ThrowOnFailure(uiShell.GetDocumentWindowEnum(out windowFramesEnum));
IVsWindowFrame[] windowFrames = new IVsWindowFrame[1];
uint fetched;
while (windowFramesEnum.Next(1, windowFrames, out fetched) == VSConstants.S_OK && fetched == 1)
{
IVsWindowFrame windowFrame = windowFrames[0];
object data;
ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out data));
IntPtr ptr = Marshal.GetIUnknownForObject(data);
try
{
if (ptr == docData)
{
ErrorHandler.ThrowOnFailure(windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_OwnerCaption, caption));
}
}
finally
{
if (ptr != IntPtr.Zero)
{
Marshal.Release(ptr);
}
}
}
}
private IVsUserContext GetUserContext()
{
RecreateContext();
if (_Context == null)
{
if (_ServiceProvider == null)
{
return(null);
}
IVsWindowFrame frame = (IVsWindowFrame)_ServiceProvider.GetService(typeof(IVsWindowFrame));
if (frame != null)
{
object obj2;
NativeMethods.ThrowOnFailure(frame.GetProperty(-3010, out obj2));
_Context = (IVsUserContext)obj2;
}
if (_Context == null)
{
IVsMonitorUserContext context =
(IVsMonitorUserContext)_ServiceProvider.GetService(typeof(IVsMonitorUserContext));
if (context != null)
{
NativeMethods.ThrowOnFailure(context.CreateEmptyContext(out _Context));
if (((_Context != null) && (frame != null)) && IsToolWindow(frame))
{
NativeMethods.ThrowOnFailure(frame.SetProperty(-3010, _Context));
}
}
}
if ((_SubContextList != null) && (_Context != null))
{
foreach (object obj3 in _SubContextList)
{
HelpService service = obj3 as HelpService;
if (service != null)
{
service.RecreateContext();
}
}
}
}
return(_Context);
}
public override void Execute()
{
rm = new ResourceManager(typeof(Resources));
System.Diagnostics.Debug.WriteLine("Get Errors");
var errors = new List <ISyntaxEntity>();
//Getting the code text from the active document
var path = TalkCodePackage.vsOperations.GetActiveDocumentPath();
var codeText = TalkCodePackage.vsOperations.GetActiveDocumentCode();
//Creating a language service
var lService = new Language(path);
//Parse the code and get the list of errors
errors = lService.GetDiagnostics(codeText).ToList().ConvertAll(error => (ISyntaxEntity)error);
if (0 == errors.Count)
{
System.Threading.Tasks.Task.Run(() =>
{
MessageBox.Show(rm.GetString("NoErrorsString", CultureInfo.CurrentCulture), rm.GetString("CodeTalkString", CultureInfo.CurrentCulture), MessageBoxButtons.OK);
});
return;
}
ToolWindowPane listFunctionsWindow = TalkCodePackage.currentPackage.FindToolWindow(typeof(AccessibilityToolWindow), 0, true);
if ((null == listFunctionsWindow) || (null == listFunctionsWindow.Frame))
{
MessageBox.Show("Cannote create tool window", "Cannot create tool window", MessageBoxButtons.OK);
}
else
{
IVsWindowFrame windowFrame = (IVsWindowFrame)listFunctionsWindow.Frame;
windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_Caption, rm.GetString("ErrorListTitle", CultureInfo.CurrentCulture));
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
(listFunctionsWindow as AccessibilityToolWindow).windowControl.SetListView(errors, rm.GetString("ErrorListTitle", CultureInfo.CurrentCulture));
}
}
/// <summary>
/// Implements IVsProject3::TransferItem
/// This function is called when an open miscellaneous file is being transferred
/// to our project. The sequence is for the shell to call AddItemWithSpecific and
/// then use TransferItem to transfer the open document to our project.
/// </summary>
/// <param name="oldMkDoc">Old document name</param>
/// <param name="newMkDoc">New document name</param>
/// <param name="frame">Optional frame if the document is open</param>
/// <returns></returns>
public virtual int TransferItem(string oldMkDoc, string newMkDoc, IVsWindowFrame frame)
{
// Fail if hierarchy already closed
if (this.ProjectMgr == null || this.ProjectMgr.IsClosed)
{
return VSConstants.E_FAIL;
}
//Fail if the document names passed are null.
if (oldMkDoc == null || newMkDoc == null)
return VSConstants.E_INVALIDARG;
int hr = VSConstants.S_OK;
VSDOCUMENTPRIORITY[] priority = new VSDOCUMENTPRIORITY[1];
uint itemid = VSConstants.VSITEMID_NIL;
uint cookie = 0;
uint grfFlags = 0;
IVsRunningDocumentTable pRdt = GetService(typeof(IVsRunningDocumentTable)) as IVsRunningDocumentTable;
if (pRdt == null)
return VSConstants.E_ABORT;
string doc;
int found;
IVsHierarchy pHier;
uint id, readLocks, editLocks;
IntPtr docdataForCookiePtr = IntPtr.Zero;
IntPtr docDataPtr = IntPtr.Zero;
IntPtr hierPtr = IntPtr.Zero;
// We get the document from the running doc table so that we can see if it is transient
try
{
ErrorHandler.ThrowOnFailure(pRdt.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock, oldMkDoc, out pHier, out id, out docdataForCookiePtr, out cookie));
}
finally
{
if (docdataForCookiePtr != IntPtr.Zero)
Marshal.Release(docdataForCookiePtr);
}
//Get the document info
try
{
ErrorHandler.ThrowOnFailure(pRdt.GetDocumentInfo(cookie, out grfFlags, out readLocks, out editLocks, out doc, out pHier, out id, out docDataPtr));
}
finally
{
if (docDataPtr != IntPtr.Zero)
Marshal.Release(docDataPtr);
}
// Now see if the document is in the project. If not, we fail
try
{
ErrorHandler.ThrowOnFailure(IsDocumentInProject(newMkDoc, out found, priority, out itemid));
Debug.Assert(itemid != VSConstants.VSITEMID_NIL && itemid != VSConstants.VSITEMID_ROOT);
hierPtr = Marshal.GetComInterfaceForObject(this, typeof(IVsUIHierarchy));
// Now rename the document
ErrorHandler.ThrowOnFailure(pRdt.RenameDocument(oldMkDoc, newMkDoc, hierPtr, itemid));
}
finally
{
if (hierPtr != IntPtr.Zero)
Marshal.Release(hierPtr);
}
//Change the caption if we are passed a window frame
if (frame != null)
{
string caption = "%2";
hr = frame.SetProperty((int)(__VSFPROPID.VSFPROPID_OwnerCaption), caption);
}
return hr;
}
/// <summary>
/// Docks the specified frame window if it is currently floating.
/// </summary>
/// <remarks>Works in VS2010, does not appear to work in VS2008.</remarks>
/// <param name="frame">The frame.</param>
private static void DockWindowIfFloating(IVsWindowFrame frame)
{
// Get the current tool window frame mode.
object currentFrameMode;
frame.GetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, out currentFrameMode);
// If currently floating, switch to dock mode.
if ((VSFRAMEMODE)currentFrameMode == VSFRAMEMODE.VSFM_Float)
{
frame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSFRAMEMODE.VSFM_Dock);
}
}