/// <summary>
/// Opens the standard editor for this file type in Visual Studio.
/// </summary>
/// <param name="logicalView">The type of view in which to open the document.</param>
/// <param name="existingDocumentData">
/// Passed through to the IVsUIShellOpenDocument.OpenStandardEditor or OpenSpecificEditor, which
/// will then determine if the document is already opened and reused the open window.
/// </param>
/// <param name="physicalView">
/// Name of the physical view if we're opening with a specific editor. Not used if opening with a standard editor.
/// </param>
/// <param name="specificEditor">The GUID of the specific registered editor to use to open this node.</param>
/// <returns>The <see cref="IVsWindowFrame"/> object that contains the opened document.</returns>
private IVsWindowFrame Open(VsLogicalView logicalView, IntPtr existingDocumentData, Guid specificEditor, string physicalView)
{
Tracer.VerifyNonNullArgument(logicalView, "logicalView");
// Check to see if the file exists before we try to open it.
if (!File.Exists(this.AbsolutePath))
{
Context.ShowErrorMessageBox(SconceStrings.FileDoesNotExist(this.AbsolutePath));
return(null);
}
IVsWindowFrame windowFrame;
Guid logicalViewGuid = logicalView.Value;
Guid editorTypeGuid = specificEditor;
bool useSpecificEditor = (specificEditor != Guid.Empty);
int hr;
// Get a IVsUIShellOpenDocument object so that we can use it to open the document.
IVsUIShellOpenDocument vsUIShellOpenDocument = (IVsUIShellOpenDocument)this.ServiceProvider.GetServiceOrThrow(typeof(SVsUIShellOpenDocument), typeof(IVsUIShellOpenDocument), classType, "Open");
// Open the document.
if (useSpecificEditor)
{
hr = vsUIShellOpenDocument.OpenSpecificEditor(
0,
this.CanonicalName,
ref editorTypeGuid,
physicalView,
ref logicalViewGuid,
this.Caption,
(IVsUIHierarchy)this.Hierarchy,
this.HierarchyId,
existingDocumentData,
(Microsoft.VisualStudio.OLE.Interop.IServiceProvider)Package.Instance,
out windowFrame);
}
else
{
hr = vsUIShellOpenDocument.OpenStandardEditor(
unchecked ((uint)__VSOSEFLAGS.OSE_ChooseBestStdEditor),
this.CanonicalName,
ref logicalViewGuid,
this.Caption,
(IVsUIHierarchy)this.Hierarchy,
this.HierarchyId,
existingDocumentData,
(Microsoft.VisualStudio.OLE.Interop.IServiceProvider)Package.Instance,
out windowFrame);
}
string editorTypeName = useSpecificEditor ? "specific" : "standard";
if (NativeMethods.Succeeded(hr))
{
Tracer.WriteLineInformation(classType, "Open", "Succeeded in opening '{0}' with a {1} editor.", this.AbsolutePath, editorTypeName);
if (windowFrame != null)
{
// Get the document cookie and cache it.
object pvar;
hr = windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocCookie, out pvar);
NativeMethods.ThrowOnFailure(hr);
// pvar is an int, but we need a uint. We get an error if we try to immediately cast to uint
// without first casting to an int.
uint cookie = unchecked ((uint)(int)pvar);
this.SetDocumentCookie(cookie);
Tracer.WriteLineInformation(classType, "Open", "Document '{0}' has a cookie value of {1}", this.AbsolutePath, cookie);
// Show the window frame of the open document. The documentation says we don't need to do this, but the reality is different.
hr = windowFrame.Show();
Tracer.Assert(NativeMethods.Succeeded(hr), "Error in IVsWindowFrame.Show(): 0x{0:x}", hr);
// Trace the running documents.
VsHelperMethods.TraceRunningDocuments();
}
else
{
Tracer.Fail("Open succeeded but we were returned a null IVsWindowFrame so we can't show the document.");
}
}
else if (hr == NativeMethods.OLE_E_PROMPTSAVECANCELLED)
{
Tracer.WriteLineInformation(classType, "Open", "The user canceled out of the open dialog box.");
}
else
{
Tracer.Fail("Failed to open '{0}' with a {1} editor. Hr=0x{2:x}", this.AbsolutePath, editorTypeName, hr);
NativeMethods.ThrowOnFailure(hr);
}
return(windowFrame);
}
/// <summary>
/// Loads a project file from disk.
/// </summary>
/// <param name="filePath">The absolute path of the project file to load.</param>
/// <returns>true if the project file was loaded correctly; otherwise, false.</returns>
public bool Load(string filePath)
{
Tracer.VerifyStringArgument(filePath, "filePath");
// Create a new project.
this.project = this.CreateProject(this);
// Set the project's file path to the one being loaded in. Do this first in case we have
// to make the project unavailable it can still display the correct caption in Solution Explorer.
this.Project.FilePath = filePath;
// Make sure the file exists.
if (!File.Exists(filePath))
{
if (!this.SilentFailures)
{
string message = SconceStrings.FileDoesNotExist(filePath);
Package.Instance.Context.ShowErrorMessageBox(message);
}
this.Project.Unavailable = true;
Tracer.WriteLine(classType, "Load", Tracer.Level.Warning, "The project file '{0}' does not exist.", filePath);
return(false);
}
try
{
using (StreamReader stream = new StreamReader(filePath))
{
XmlTextReader reader = new XmlTextReader(stream);
reader.WhitespaceHandling = WhitespaceHandling.None;
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(reader);
XmlNode node = xmlDoc.DocumentElement;
// <VisualStudioProject>
if (!this.VerifyNode(node, ElementNames.VisualStudioProject))
{
this.Project.Unavailable = true;
return(false);
}
node = node.FirstChild;
if (!this.ReadProjectNode(node))
{
this.Project.Unavailable = true;
return(false);
}
}
}
catch (XmlException e)
{
if (!this.SilentFailures)
{
string projectFileName = Path.GetFileName(filePath);
string title = Package.Instance.Context.NativeResources.GetString(ResId.IDS_E_INVALIDPROJECTFILE_TITLE);
string message = Package.Instance.Context.NativeResources.GetString(ResId.IDS_E_INVALIDPROJECTFILE, projectFileName);
Package.Instance.Context.ShowErrorMessageBox(title, message);
}
this.Project.Unavailable = true;
Tracer.Fail("There was an error parsing '{0}': {1}", filePath, e.ToString());
return(false);
}
// Once the project has been loaded, it's not dirty anymore.
this.Project.ClearDirty();
return(true);
}