/// <summary>
/// Initializes a new instance of the <see cref="ComObject"/> class from a IUnknown object.
/// </summary>
/// <param name="iunknowObject">Reference to a IUnknown object</param>
public ComObject(object iunknownObject)
{
NativePointer = Marshal.GetIUnknownForObject(iunknownObject);
}
public static SoundInfo[] GetCurrentSoundInfo()
{
SoundInfo[] soundSourceInfos = new SoundInfo[0];
try
{ // TODO: properly handle when headphones are used, etc.
MMDeviceEnumerator DevEnum = new MMDeviceEnumerator();
MMDevice device = DevEnum.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia);
List <SoundInfo> soundSourceInfoList = new List <SoundInfo>();
SoundInfo soundInfo = null;
// Note the AudioSession manager did not have a method to enumerate all sessions in windows Vista; this will only work on Win7 and newer.
for (int i = 0; i < device.AudioSessionManager.Sessions.Count; i++)
{
AudioSessionControl session = device.AudioSessionManager.Sessions[i];
soundInfo = new SoundInfo();
// if (session.State == AudioSessionState.AudioSessionStateActive)
{
soundInfo.Pid = (int)session.ProcessID;
soundInfo.IconPath = session.IconPath;
soundInfo.DisplayName = session.DisplayName;
soundInfo.SessionIdentifier = session.SessionIdentifier;
soundInfo.SessionInstanceIdentifier = session.SessionInstanceIdentifier;
soundInfo.IsSystemSoundsSession = session.IsSystemSoundsSession;
//soundSourceInfo.State = session.State;
try
{
int pid = (int)session.ProcessID;
if (pid != 0)
{
string procName;
if (false == ProcNameDict.TryGetValue(pid, out procName))
{
try
{
Process p = Process.GetProcessById(pid); //TO_DO: should remove processname and windowtitle from this class (but make sure that windowtitle gets updated at appropriate interval)
ProcNameDict[pid] = p.ProcessName;
ProcWindowTitleDict[pid] = p.MainWindowTitle;
try
{
if (p.Modules.Count > 0)
{
ProcFullPathDict[pid] = p.Modules[0].FileName;
}
else
{
ProcFullPathDict[pid] = "";
}
}
catch (Exception ex)
{
// WMI code from stackoverflow
string query = "SELECT ExecutablePath, ProcessID FROM Win32_Process";
System.Management.ManagementObjectSearcher searcher = new System.Management.ManagementObjectSearcher(query);
foreach (ManagementObject item in searcher.Get())
{
object id = item["ProcessID"];
object path = item["ExecutablePath"];
if (path != null && id.ToString() == p.Id.ToString())
{
ProcFullPathDict[pid] = path.ToString();
break;
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
ProcNameDict[pid] = "";
ProcWindowTitleDict[pid] = "";
ProcFullPathDict[pid] = "";
}
}
soundInfo.ProcessName = ProcNameDict[pid];
soundInfo.WindowTitle = ProcWindowTitleDict[pid];
if (soundInfo.WindowTitle == "")
{
try
{
Process proc = Process.GetProcessById(pid);
soundInfo.WindowTitle = proc.MainWindowTitle;
if (soundInfo.WindowTitle == "")
{
soundInfo.WindowTitle = proc.ProcessName;
}
}
catch { }
}
soundInfo.ProcessFullPath = ProcFullPathDict[pid];
if ((soundInfo.ProcessFullPath == "") && (soundInfo.IsSystemSoundsSession == false))
{
int x = 0;
x++;
}
}
else
{
soundInfo.ProcessName = "";
soundInfo.WindowTitle = "System Sounds";
soundInfo.ProcessFullPath = "";
}
}
catch (Exception ex)
{
string msg = ex.Message;
}
AudioMeterInformation mi = session.AudioMeterInformation;
SimpleAudioVolume vol = session.SimpleAudioVolume;
soundInfo.Muted = vol.Mute;
soundInfo.MixerVolume = session.SimpleAudioVolume.MasterVolume;
//session.SimpleAudioVolume.MasterVolume = soundSourceInfo.ChannelVolume;
soundInfo.EmittedVolume = session.AudioMeterInformation.MasterPeakValue;
soundSourceInfoList.Add(soundInfo);
}
}
// Free up the memory
IntPtr pointer = Marshal.GetIUnknownForObject(device);
Marshal.Release(pointer);
soundSourceInfos = soundSourceInfoList.ToArray();
Array.Sort(soundSourceInfos, delegate(SoundInfo info1, SoundInfo info2)
{
return(info1.CompareTo(info2));
});
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex);
}
return(soundSourceInfos);
}
public void GetIUnknownForObject_NullObject_ThrowsArgumentNullException()
{
AssertExtensions.Throws <ArgumentNullException>("o", () => Marshal.GetIUnknownForObject(null));
}
/// <summary>Provides the document view to the document window.</summary>
/// <param name="ppUnkDocView">[out] Pointer to the <see langword="IUnknown" /> interface of the document view. Used as an argument to <see cref="M:Microsoft.VisualStudio.Shell.Interop.IVsUIShell.CreateDocumentWindow(System.UInt32,System.String,Microsoft.VisualStudio.Shell.Interop.IVsUIHierarchy,System.UInt32,System.IntPtr,System.IntPtr,System.Guid@,System.String,System.Guid@,Microsoft.VisualStudio.OLE.Interop.IServiceProvider,System.String,System.String,System.Int32[],Microsoft.VisualStudio.Shell.Interop.IVsWindowFrame@)" />.</param>
/// <returns>If the method succeeds, it returns <see cref="F:Microsoft.VisualStudio.VSConstants.S_OK" />. If it fails, it returns an error code.</returns>
int IVsDeferredDocView.get_DocView(out IntPtr ppUnkDocView)
{
ppUnkDocView = Marshal.GetIUnknownForObject(this);
return(VSConstants.S_OK);
}
public int CreateEditorInstance(
uint grfCreateDoc,
string pszMkDocument,
string pszPhysicalView,
IVsHierarchy pvHier,
uint itemid,
System.IntPtr punkDocDataExisting,
out System.IntPtr ppunkDocView,
out System.IntPtr ppunkDocData,
out string pbstrEditorCaption,
out Guid pguidCmdUI,
out int pgrfCDW)
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering {0} CreateEditorInstace()", this.ToString()));
// Initialize to null
ppunkDocView = IntPtr.Zero;
ppunkDocData = IntPtr.Zero;
pguidCmdUI = Constants.EtoPreviewEditorFactory_guid;
pgrfCDW = 0;
pbstrEditorCaption = null;
if (!BuilderInfo.Supports(pszMkDocument))
{
return(VSConstants.VS_E_UNSUPPORTEDFORMAT);
}
// Validate inputs
if ((grfCreateDoc & (VSConstants.CEF_OPENFILE | VSConstants.CEF_SILENT)) == 0)
{
return(VSConstants.E_INVALIDARG);
}
object prjItemObject;
var projectItemId = VSConstants.VSITEMID_ROOT;
pvHier.GetProperty(projectItemId, (int)__VSHPROPID.VSHPROPID_ExtObject, out prjItemObject);
var proj = prjItemObject as EnvDTE.Project;
// Get or open text buffer
var textBuffer = GetTextBuffer(punkDocDataExisting, pszMkDocument, ToVsProject(proj));
if (textBuffer == null)
{
return(VSConstants.VS_E_INCOMPATIBLEDOCDATA);
}
if (punkDocDataExisting != IntPtr.Zero)
{
ppunkDocData = punkDocDataExisting;
Marshal.AddRef(ppunkDocData);
}
else
{
ppunkDocData = Marshal.GetIUnknownForObject(textBuffer);
}
var outputFile = GetAssemblyPath(proj);
var references = GetReferences(proj).ToList();
//var outputDir = Path.GetDirectoryName(outputFile);
// Create the Document (editor)
var editor = new EtoPreviewPane(editorPackage, pszMkDocument, textBuffer, outputFile, references);
ppunkDocView = Marshal.GetIUnknownForObject(editor);
//pbstrEditorCaption = " [Preview]";
return(VSConstants.S_OK);
}
public static bool IsAssignableFrom(this Type type, ref object value)
{
if (type.IsByRef)
{
type = type.GetElementType();
}
if (type.IsNullable())
{
// ReSharper disable once AssignNullToNotNullAttribute
return((value == null) || (Nullable.GetUnderlyingType(type).IsAssignableFrom(ref value)));
}
if (value == null)
{
// ReSharper disable once PossibleNullReferenceException
return(!type.IsValueType);
}
var valueType = value.GetType();
if (valueType == type)
{
return(true);
}
// ReSharper disable once PossibleNullReferenceException
if (!type.IsValueType)
{
if (type.IsAssignableFrom(valueType))
{
return(true);
}
if (type.IsInterface && type.IsImport && valueType.IsCOMObject)
{
var result = false;
var pUnknown = Marshal.GetIUnknownForObject(value);
var iid = type.GUID;
if (iid != Guid.Empty)
{
IntPtr pInterface;
if (RawCOMHelpers.HResult.Succeeded(Marshal.QueryInterface(pUnknown, ref iid, out pInterface)))
{
Marshal.Release(pInterface);
result = true;
}
}
Marshal.Release(pUnknown);
return(result);
}
return(false);
}
if (!valueType.IsValueType)
{
return(false);
}
if (type.IsEnum)
{
return(Enum.GetUnderlyingType(type).IsAssignableFrom(ref value) && (value.DynamicCast <int>() == 0));
}
if (valueType.IsEnum)
{
return(false);
}
bool typeIsIntegral;
if (type.IsNumeric(out typeIsIntegral))
{
if (typeIsIntegral)
{
if (!valueType.IsIntegral())
{
return(false);
}
}
else if (!valueType.IsNumeric())
{
return(false);
}
value = Convert.ChangeType(value, type);
return(true);
}
return(false);
}
internal void SetIUnknown(object value)
{
_valueType = (ushort)VarEnum.VT_UNKNOWN;
_ptr = Marshal.GetIUnknownForObject(value);
}
/// <summary>
/// Uses the IMAPIPROP.SetProps to set the content ID
/// </summary>
/// <param name="attachment"></param>
/// <param name="contentId"></param>
public static void SetContentID(IAttachment attachment, string contentId)
{
// Pointer to IUnknown Interface
IntPtr IUnknown = IntPtr.Zero;
// Pointer to IMAPIProp Interface
IntPtr IMAPIProp = IntPtr.Zero;
// A pointer that points to the SPropValue structure
IntPtr ptrPropValue = IntPtr.Zero;
// Structure that will hold the Property Value
SPropValue propValue;
// if we have no MAPIObject everything is senseless...
if (attachment == null)
{
return;
}
try {
// We can pass NULL here as parameter, so we do it.
MAPIInitialize(IntPtr.Zero);
// retrive the IUnknon Interface from our MAPIObject comming from Outlook.
IUnknown = Marshal.GetIUnknownForObject(attachment.MAPIOBJECT);
IMAPIProp mapiProp = (IMAPIProp)Marshal.GetTypedObjectForIUnknown(IUnknown, typeof(IMAPIProp));
// Create structure
propValue = new SPropValue();
propValue.propTag = (uint)PropTags.PR_ATTACH_CONTENT_ID;
//propValue.propTag = 0x3712001E;
// Create Ansi string
propValue.Value = Marshal.StringToHGlobalUni(contentId);
// Create unmanaged memory for structure
ptrPropValue = Marshal.AllocHGlobal(Marshal.SizeOf(propValue));
// Copy structure to unmanged memory
Marshal.StructureToPtr(propValue, ptrPropValue, false);
mapiProp.SetProps(1, ptrPropValue, IntPtr.Zero);
propValue.propTag = (uint)PropTags.PR_ATTACH_CONTENT_LOCATION;
// Copy structure to unmanged memory
Marshal.StructureToPtr(propValue, ptrPropValue, false);
mapiProp.SetProps(1, ptrPropValue, IntPtr.Zero);
// Free string
Marshal.FreeHGlobal(propValue.Value);
mapiProp.SaveChanges(KEEP_OPEN_READWRITE);
} catch (Exception ex) {
LOG.Error(ex);
} finally {
// Free used Memory structures
if (ptrPropValue != IntPtr.Zero)
{
Marshal.FreeHGlobal(ptrPropValue);
}
// cleanup all references to COM Objects
if (IMAPIProp != IntPtr.Zero)
{
Marshal.Release(IMAPIProp);
}
//if (IMessage != IntPtr.Zero) Marshal.Release(IMessage);
if (IUnknown != IntPtr.Zero)
{
Marshal.Release(IUnknown);
}
}
}
/// <summary>
/// Use MAPI32.DLL "HrSetOneProp" from managed code
/// </summary>
/// <param name="attachment"></param>
/// <param name="proptag"></param>
/// <param name="propertyValue"></param>
/// <returns></returns>
public static bool SetMAPIProperty(IAttachment attachment, PropTags proptag, string propertyValue)
{
// Pointer to IUnknown Interface
IntPtr IUnknown = IntPtr.Zero;
// Pointer to IMAPIProp Interface
IntPtr IMAPIProp = IntPtr.Zero;
// Structure that will hold the Property Value
SPropValue propValue;
// A pointer that points to the SPropValue structure
IntPtr ptrPropValue = IntPtr.Zero;
object mapiObject = attachment.MAPIOBJECT;
// if we have no MAPIObject everything is senseless...
if (mapiObject == null)
{
return(false);
}
try {
// We can pass NULL here as parameter, so we do it.
MAPIInitialize(IntPtr.Zero);
// retrive the IUnknon Interface from our MAPIObject comming from Outlook.
IUnknown = Marshal.GetIUnknownForObject(mapiObject);
// create a Guid that we pass to retreive the IMAPIProp Interface.
Guid guidIMAPIProp = new Guid(IID_IMAPIProp);
// try to retrieve the IMAPIProp interface from IMessage Interface, everything else is sensless.
if (Marshal.QueryInterface(IUnknown, ref guidIMAPIProp, out IMAPIProp) != 0)
{
return(false);
}
// double check, if we wave no pointer, exit...
if (IMAPIProp == IntPtr.Zero)
{
return(false);
}
// Create structure
propValue = new SPropValue();
propValue.propTag = (uint)proptag;
// Create Ansi string
propValue.Value = Marshal.StringToHGlobalUni(propertyValue);
// Create unmanaged memory for structure
ptrPropValue = Marshal.AllocHGlobal(Marshal.SizeOf(propValue));
// Copy structure to unmanged memory
Marshal.StructureToPtr(propValue, ptrPropValue, false);
// Set the property
HrSetOneProp(IMAPIProp, ptrPropValue);
// Free string
Marshal.FreeHGlobal(propValue.Value);
IMAPIProp mapiProp = (IMAPIProp)Marshal.GetTypedObjectForIUnknown(IUnknown, typeof(IMAPIProp));
return(mapiProp.SaveChanges(4) == 0);
} catch (System.Exception ex) {
LOG.Error(ex);
return(false);
} finally {
// Free used Memory structures
if (ptrPropValue != IntPtr.Zero)
{
Marshal.FreeHGlobal(ptrPropValue);
}
// cleanup all references to COM Objects
if (IMAPIProp != IntPtr.Zero)
{
Marshal.Release(IMAPIProp);
}
//if (IMessage != IntPtr.Zero) Marshal.Release(IMessage);
if (IUnknown != IntPtr.Zero)
{
Marshal.Release(IUnknown);
}
MAPIUninitialize();
}
}
/// <summary>
/// <para>Waits for the next event that matches the specified query to arrive, and
/// then returns it.</para>
/// </summary>
/// <returns>
/// <para>A <see cref='System.Management.ManagementBaseObject'/> representing the
/// newly arrived event.</para>
/// </returns>
/// <remarks>
/// <para>If the event watcher object contains options with
/// a specified timeout, the API will wait for the next event only for the specified
/// amount of time; otherwise, the API will be blocked until the next event occurs.</para>
/// </remarks>
public ManagementBaseObject WaitForNextEvent()
{
ManagementBaseObject obj = null;
Initialize();
lock (this)
{
SecurityHandler securityHandler = Scope.GetSecurityHandler();
int status = (int)ManagementStatus.NoError;
try
{
if (null == enumWbem) //don't have an enumerator yet - get it
{
//Execute the query
status = scope.GetSecuredIWbemServicesHandler(Scope.GetIWbemServices()).ExecNotificationQuery_(
query.QueryLanguage,
query.QueryString,
options.Flags,
options.GetContext(),
ref enumWbem);
}
if (status >= 0)
{
if ((cachedCount - cacheIndex) == 0) //cache is empty - need to get more objects
{
//Because Interop doesn't support custom marshalling for arrays, we have to use
//the "DoNotMarshal" objects in the interop and then convert to the "FreeThreaded"
//counterparts afterwards.
IWbemClassObject_DoNotMarshal[] tempArray = new IWbemClassObject_DoNotMarshal[options.BlockSize];
int timeout = (ManagementOptions.InfiniteTimeout == options.Timeout)
? (int)tag_WBEM_TIMEOUT_TYPE.WBEM_INFINITE :
(int)options.Timeout.TotalMilliseconds;
status = scope.GetSecuredIEnumWbemClassObjectHandler(enumWbem).Next_(timeout, (uint)options.BlockSize, tempArray, ref cachedCount);
cacheIndex = 0;
if (status >= 0)
{
//Convert results and put them in cache. Note that we may have timed out
//in which case we might not have all the objects. If no object can be returned
//we throw a timeout exception.
if (cachedCount == 0)
{
ManagementException.ThrowWithExtendedInfo(ManagementStatus.Timedout);
}
for (int i = 0; i < cachedCount; i++)
{
cachedObjects[i] = new IWbemClassObjectFreeThreaded(Marshal.GetIUnknownForObject(tempArray[i]));
}
}
}
if (status >= 0)
{
obj = new ManagementBaseObject(cachedObjects[cacheIndex]);
cacheIndex++;
}
}
}
finally
{
securityHandler.Reset();
}
if (status < 0)
{
if ((status & 0xfffff000) == 0x80041000)
{
ManagementException.ThrowWithExtendedInfo((ManagementStatus)status);
}
else
{
Marshal.ThrowExceptionForHR(status, WmiNetUtilsHelper.GetErrorInfo_f());
}
}
}
return(obj);
}
private static void ValidateMarshalAPIs(bool validateUseRegistered)
{
string scenario = validateUseRegistered ? "use registered wrapper" : "fall back to runtime";
Console.WriteLine($"Running {nameof(ValidateMarshalAPIs)}: {scenario}...");
GlobalComWrappers registeredWrapper = GlobalComWrappers.Instance;
registeredWrapper.ReturnInvalid = !validateUseRegistered;
Console.WriteLine($" -- Validate Marshal.GetIUnknownForObject...");
var testObj = new Test();
IntPtr comWrapper1 = Marshal.GetIUnknownForObject(testObj);
Assert.AreNotEqual(IntPtr.Zero, comWrapper1);
Assert.AreEqual(testObj, registeredWrapper.LastComputeVtablesObject, "Registered ComWrappers instance should have been called");
IntPtr comWrapper2 = Marshal.GetIUnknownForObject(testObj);
Assert.AreEqual(comWrapper1, comWrapper2);
Marshal.Release(comWrapper1);
Marshal.Release(comWrapper2);
Console.WriteLine($" -- Validate Marshal.GetIDispatchForObject...");
Assert.Throws <InvalidCastException>(() => Marshal.GetIDispatchForObject(testObj));
if (validateUseRegistered)
{
var dispatchObj = new TestEx(IID_IDISPATCH);
IntPtr dispatchWrapper = Marshal.GetIDispatchForObject(dispatchObj);
Assert.AreNotEqual(IntPtr.Zero, dispatchWrapper);
Assert.AreEqual(dispatchObj, registeredWrapper.LastComputeVtablesObject, "Registered ComWrappers instance should have been called");
Console.WriteLine($" -- Validate Marshal.GetIDispatchForObject != Marshal.GetIUnknownForObject...");
IntPtr unknownWrapper = Marshal.GetIUnknownForObject(dispatchObj);
Assert.AreNotEqual(IntPtr.Zero, unknownWrapper);
Assert.AreNotEqual(unknownWrapper, dispatchWrapper);
}
Console.WriteLine($" -- Validate Marshal.GetObjectForIUnknown...");
IntPtr trackerObjRaw = MockReferenceTrackerRuntime.CreateTrackerObject();
object objWrapper1 = Marshal.GetObjectForIUnknown(trackerObjRaw);
Assert.AreEqual(validateUseRegistered, objWrapper1 is FakeWrapper, $"GetObjectForIUnknown should{(validateUseRegistered ? string.Empty : "not")} have returned {nameof(FakeWrapper)} instance");
object objWrapper2 = Marshal.GetObjectForIUnknown(trackerObjRaw);
Assert.AreEqual(objWrapper1, objWrapper2);
Console.WriteLine($" -- Validate Marshal.GetUniqueObjectForIUnknown...");
object objWrapper3 = Marshal.GetUniqueObjectForIUnknown(trackerObjRaw);
Assert.AreEqual(validateUseRegistered, objWrapper3 is FakeWrapper, $"GetObjectForIUnknown should{(validateUseRegistered ? string.Empty : "not")} have returned {nameof(FakeWrapper)} instance");
Assert.AreNotEqual(objWrapper1, objWrapper3);
Marshal.Release(trackerObjRaw);
}
private static bool DeepEquals(IAccessible ia1, IAccessible ia2)
{
if (ia1.Equals(ia2))
{
return(true);
}
if (Marshal.GetIUnknownForObject(ia1) == Marshal.GetIUnknownForObject(ia2))
{
return(true);
}
try
{
if (ia1.accChildCount != ia2.accChildCount)
{
return(false);
}
SystemAccessibleObject sa1 = new SystemAccessibleObject(ia1, 0);
SystemAccessibleObject sa2 = new SystemAccessibleObject(ia2, 0);
if (sa1.Window.HWnd != sa2.Window.HWnd)
{
return(false);
}
if (sa1.Location != sa2.Location)
{
return(false);
}
if (sa1.DefaultAction != sa2.DefaultAction)
{
return(false);
}
if (sa1.Description != sa2.Description)
{
return(false);
}
if (sa1.KeyboardShortcut != sa2.KeyboardShortcut)
{
return(false);
}
if (sa1.Name != sa2.Name)
{
return(false);
}
if (!sa1.Role.Equals(sa2.Role))
{
return(false);
}
if (sa1.State != sa2.State)
{
return(false);
}
if (sa1.Value != sa2.Value)
{
return(false);
}
if (sa1.Visible != sa2.Visible)
{
return(false);
}
if (ia1.accParent == null && ia2.accParent == null)
{
return(true);
}
if (ia1.accParent == null || ia2.accParent == null)
{
return(false);
}
}
catch (COMException)
{
return(false);
}
bool de = DeepEquals((IAccessible)ia1.accParent, (IAccessible)ia2.accParent);
return(de);
}
private async Task <IVsWindowFrame> CreateDocWindowForSolutionAsync()
{
ThreadHelper.ThrowIfNotOnUIThread();
IVsWindowFrame windowFrame = null;
var solution = await this.GetServiceAsync <IVsSolution>();
var uiShell = await this.GetServiceAsync <SVsUIShell, IVsUIShell>();
var windowFlags =
(uint)_VSRDTFLAGS.RDT_DontAddToMRU |
(uint)_VSRDTFLAGS.RDT_DontSaveAs;
// when VSSolutionManager is already initialized, then use the existing APIs to check pre-conditions.
if (!await SolutionManager.Value.IsSolutionAvailableAsync())
{
throw new InvalidOperationException(Resources.SolutionIsNotSaved);
}
var projects = (await SolutionManager.Value.GetNuGetProjectsAsync()).ToArray();
if (projects.Length == 0)
{
MessageHelper.ShowWarningMessage(Resources.NoSupportedProjectsInSolution, Resources.ErrorDialogBoxTitle);
return(null);
}
// pass empty array of NuGetProject
var uiController = UIFactory.Value.Create(projects);
var solutionName = (string)_dte.Solution.Properties.Item("Name").Value;
var model = new PackageManagerModel(
uiController,
isSolution: true,
editorFactoryGuid: GuidList.guidNuGetEditorType)
{
SolutionName = solutionName
};
var vsWindowSearchHostfactory = await GetServiceAsync(typeof(SVsWindowSearchHostFactory)) as IVsWindowSearchHostFactory;
var vsShell = await GetServiceAsync(typeof(SVsShell)) as IVsShell4;
var control = new PackageManagerControl(model, Settings.Value, vsWindowSearchHostfactory, vsShell, OutputConsoleLogger.Value);
var windowPane = new PackageManagerWindowPane(control);
var guidEditorType = GuidList.guidNuGetEditorType;
var guidCommandUI = Guid.Empty;
var caption = Resx.Label_SolutionNuGetWindowCaption;
var documentName = _dte.Solution.FullName;
var ppunkDocView = IntPtr.Zero;
var ppunkDocData = IntPtr.Zero;
var hr = 0;
try
{
ppunkDocView = Marshal.GetIUnknownForObject(windowPane);
ppunkDocData = Marshal.GetIUnknownForObject(model);
hr = uiShell.CreateDocumentWindow(
windowFlags,
documentName,
(IVsUIHierarchy)solution,
(uint)VSConstants.VSITEMID.Root,
ppunkDocView,
ppunkDocData,
ref guidEditorType,
null,
ref guidCommandUI,
null,
caption,
string.Empty,
null,
out windowFrame);
if (windowFrame != null)
{
WindowFrameHelper.AddF1HelpKeyword(windowFrame, keywordValue: F1KeywordValuePmUI);
}
}
finally
{
if (ppunkDocView != IntPtr.Zero)
{
Marshal.Release(ppunkDocData);
}
if (ppunkDocData != IntPtr.Zero)
{
Marshal.Release(ppunkDocView);
}
}
ErrorHandler.ThrowOnFailure(hr);
return(windowFrame);
}
public PropertyPagePanel(bool OkCloseButtons, IBaseFilter filter)
{
_filter = filter;
base.BackColor = SystemColors.Control;
_tabs = new TabControl();
_tabs.Dock = DockStyle.Fill;
this.Dock = DockStyle.Fill;
_tabs.Multiline = false;
Controls.Add(_tabs);
_buttonsPanel = new Panel();
_buttonsPanel.Dock = DockStyle.Bottom;
_interfacesButton = new Button();
_interfacesButton.Text = "Scan Interfaces";
_interfacesButton.Width = 100;
_interfacesButton.Dock = DockStyle.Left;
_interfacesButton.BackColor = SystemColors.Control;
_interfacesButton.Click += new EventHandler(_interfacesButton_Click);
_buttonsPanel.Controls.Add(_interfacesButton);
_applyButton = new Button();
_applyButton.Text = "Apply";
_applyButton.Dock = DockStyle.Left;
_applyButton.BackColor = SystemColors.Control;
_applyButton.Enabled = false;
_applyButton.Click += new EventHandler(_applyButton_Click);
_buttonsPanel.Controls.Add(_applyButton);
if (OkCloseButtons)
{
_closeButton = new Button();
_closeButton.Text = "Close";
_closeButton.Dock = DockStyle.Left;
_closeButton.BackColor = SystemColors.Control;
_buttonsPanel.Controls.Add(_closeButton);
_okButton = new Button();
_okButton.Text = "Ok";
_okButton.Dock = DockStyle.Left;
_okButton.BackColor = SystemColors.Control;
_okButton.Click += new EventHandler(_applyButton_Click);
_buttonsPanel.Controls.Add(_okButton);
}
_buttonsPanel.Height = 23;
Controls.Add(_buttonsPanel);
int hr = 0;
ISpecifyPropertyPages pProp = filter as ISpecifyPropertyPages;
if (pProp != null)
{
// Get the propertypages from the property bag
DsCAUUID caGUID;
hr = pProp.GetPages(out caGUID);
if (hr != 0 || caGUID.cElems == 0)
{
// could not get property sheets or got 0 property sheets
return;
}
// convert caGUID to a managed array of Guids
Guid[] propertyPages = caGUID.ToGuidArray();
for (int i = 0; i < propertyPages.Length; i++)
{
try
{
Type type = Type.GetTypeFromCLSID(propertyPages[i]);
object o = Activator.CreateInstance(type);
IPropertyPage pp = o as IPropertyPage;
PROPPAGEINFO pi = new PROPPAGEINFO();
pp.GetPageInfo(ref pi);
// get the page size, adjusting for button panel and padding
_pageSize.Width = Math.Max(_pageSize.Width, pi.size.Width + 10);
_pageSize.Height = Math.Max(_pageSize.Height, pi.size.Height + 33);
// we want to inc the refcount so the property page won't vanish on us
_iunk.Add(Marshal.GetIUnknownForObject(o));
object[] obs = { filter };
pp.SetObjects(1, obs);
pp.SetPageSite(this);
Rectangle rect = new Rectangle(0, 0, pi.size.Width, pi.size.Height);
TabPage tp = new TabPage(Marshal.PtrToStringAuto(pi.szTitle));
_tabs.Controls.Add(tp);
_pages.Add(pp);
pp.Activate(tp.Handle, ref rect, false);
// some PropertyPages aren't visible by default
IntPtr childwindow = GetWindow(tp.Handle, 5);
if (childwindow != IntPtr.Zero)
{
ShowWindow(childwindow, 5);
}
}
catch
{
// some property pages don't abide by the rules of COM
}
}
}
}
public static IntPtr GetIUnknownForObject(object obj)
{
return(obj == null ? IntPtr.Zero : Marshal.GetIUnknownForObject(obj));
}
IntPtr nsIFactory.CreateInstance(nsISupports aOuter, ref Guid iid)
{
return(Marshal.GetIUnknownForObject(new PromptService()));
}
/// <summary>
/// Rename document in the running document table from oldName to newName.
/// </summary>
/// <param name="provider">The service provider.</param>
/// <param name="oldName">Full path to the old name of the document.</param>
/// <param name="newName">Full path to the new name of the document.</param>
/// <param name="newItemId">The new item id of the document</param>
public static void RenameDocument(IServiceProvider site, string oldName, string newName, uint newItemId)
{
Utilities.ArgumentNotNull("site", site);
if (String.IsNullOrEmpty(oldName))
{
throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty, CultureInfo.CurrentUICulture), "oldName");
}
if (String.IsNullOrEmpty(newName))
{
throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty, CultureInfo.CurrentUICulture), "newName");
}
IVsRunningDocumentTable pRDT = site.GetService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable;
IVsUIShellOpenDocument doc = site.GetService(typeof(SVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
if (pRDT == null || doc == null)
{
return;
}
IVsHierarchy pIVsHierarchy;
uint itemId;
IntPtr docData;
uint uiVsDocCookie;
ErrorHandler.ThrowOnFailure(pRDT.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock, oldName, out pIVsHierarchy, out itemId, out docData, out uiVsDocCookie));
if (docData != IntPtr.Zero)
{
try
{
IntPtr pUnk = Marshal.GetIUnknownForObject(pIVsHierarchy);
Guid iid = typeof(IVsHierarchy).GUID;
IntPtr pHier;
Marshal.QueryInterface(pUnk, ref iid, out pHier);
try
{
ErrorHandler.ThrowOnFailure(pRDT.RenameDocument(oldName, newName, pHier, newItemId));
}
catch (Exception)
{
int i = 0;
}
finally
{
if (pHier != IntPtr.Zero)
{
Marshal.Release(pHier);
}
if (pUnk != IntPtr.Zero)
{
Marshal.Release(pUnk);
}
}
}
finally
{
Marshal.Release(docData);
}
}
}
internal Direct3DSurface9(ComInterface.IDirect3DSurface9 obj)
{
this.comObject = obj;
this.native = Marshal.GetIUnknownForObject(this.comObject);
}
internal static IntPtr GetJSContextForDomWindow(nsIDOMWindow window)
{
IntPtr context = IntPtr.Zero;
nsIDOMEventTarget eventTarget = window.GetWindowRootAttribute();
try
{
context = eventTarget.GetJSContextForEventHandlers();
if (context == IntPtr.Zero)
{
IntPtr pUnk = Marshal.GetIUnknownForObject(window);
Marshal.Release(pUnk);
if (!_windowContexts.TryGetValue(pUnk, out context))
{
context = IntPtr.Zero;
IntPtr cx;
IntPtr iterp = IntPtr.Zero;
IntPtr rt = Runtime;
while ((cx = SpiderMonkey.JS_ContextIterator(rt, ref iterp)) != IntPtr.Zero)
{
IntPtr pGlobal = SpiderMonkey.DefaultObjectForContextOrNull(cx);
if (pGlobal != IntPtr.Zero)
{
using (var auto = new AutoJSContext(cx))
{
using (ComPtr <nsISupports> global = auto.GetGlobalNsObject())
{
if (global != null)
{
var domWindow = Xpcom.QueryInterface <nsIDOMWindow>(global.Instance);
if (domWindow != null)
{
try
{
IntPtr pUnkTest = Marshal.GetIUnknownForObject(domWindow.GetWindowAttribute());
Marshal.Release(pUnkTest);
if (pUnk == pUnkTest)
{
_windowContexts.Add(pUnk, cx);
context = cx;
break;
}
}
finally
{
Xpcom.FreeComObject(ref domWindow);
}
}
}
}
}
}
}
}
}
}
finally
{
if (eventTarget != null)
{
Xpcom.FreeComObject(ref eventTarget);
}
}
return(context);
}
public PROPVARIANT(object obj)
{
vt = VT_UNKNOWN;
pUnknown = Marshal.GetIUnknownForObject(obj);
}
public static object QueryInterface(object obj, Guid iid)
{
AssertCorrectThread();
if (obj == null)
{
return(null);
}
// get an nsISupports (aka IUnknown) pointer from the object
IntPtr pUnk = Marshal.GetIUnknownForObject(obj);
if (pUnk == IntPtr.Zero)
{
return(null);
}
// query interface
IntPtr ppv;
Marshal.QueryInterface(pUnk, ref iid, out ppv);
// if QueryInterface didn't work, try using nsIInterfaceRequestor instead
if (ppv == IntPtr.Zero)
{
// QueryInterface the object for nsIInterfaceRequestor
Guid interfaceRequestorIID = typeof(nsIInterfaceRequestor).GUID;
IntPtr pInterfaceRequestor;
Marshal.QueryInterface(pUnk, ref interfaceRequestorIID, out pInterfaceRequestor);
// if we got a pointer to nsIInterfaceRequestor
if (pInterfaceRequestor != IntPtr.Zero)
{
// convert it to a managed interface
QI_nsIInterfaceRequestor req = (QI_nsIInterfaceRequestor)Xpcom.GetObjectForIUnknown(pInterfaceRequestor);
if (req != null)
{
try
{
req.GetInterface(ref iid, out ppv);
// clean up
Marshal.ReleaseComObject(req);
}
catch (NullReferenceException ex)
{
Debug.WriteLine("NullRefException from native code.\n" + ex.ToString());
}
}
Marshal.Release(pInterfaceRequestor);
}
}
object result = (ppv != IntPtr.Zero) ? Xpcom.GetObjectForIUnknown(ppv) : null;
Marshal.Release(pUnk);
if (ppv != IntPtr.Zero)
{
Marshal.Release(ppv);
}
return(result);
}
public int CreateEditorInstance(
uint grfCreateDoc,
string pszMkDocument,
string pszPhysicalView,
IVsHierarchy vsHierarchy,
uint itemid,
IntPtr punkDocDataExisting,
out IntPtr ppunkDocView,
out IntPtr ppunkDocData,
out string pbstrEditorCaption,
out Guid pguidCmdUI,
out int pgrfCDW)
{
ppunkDocView = IntPtr.Zero;
ppunkDocData = IntPtr.Zero;
pbstrEditorCaption = string.Empty;
pguidCmdUI = Guid.Empty;
pgrfCDW = 0;
var physicalView = pszPhysicalView == null
? "Code"
: pszPhysicalView;
IVsTextBuffer textBuffer = null;
// Is this document already open? If so, let's see if it's a IVsTextBuffer we should re-use. This allows us
// to properly handle multiple windows open for the same document.
if (punkDocDataExisting != IntPtr.Zero)
{
object docDataExisting = Marshal.GetObjectForIUnknown(punkDocDataExisting);
textBuffer = docDataExisting as IVsTextBuffer;
if (textBuffer == null)
{
// We are incompatible with the existing doc data
return(VSConstants.VS_E_INCOMPATIBLEDOCDATA);
}
}
// Do we need to create a text buffer?
if (textBuffer == null)
{
var contentType = _contentTypeRegistryService.GetContentType(ContentTypeName);
textBuffer = _editorAdaptersFactoryService.CreateVsTextBufferAdapter(_oleServiceProvider, contentType);
if (_encoding)
{
var userData = textBuffer as IVsUserData;
if (userData != null)
{
// The editor shims require that the boxed value when setting the PromptOnLoad flag is a uint
int hresult = userData.SetData(
VSConstants.VsTextBufferUserDataGuid.VsBufferEncodingPromptOnLoad_guid,
(uint)__PROMPTONLOADFLAGS.codepagePrompt);
if (ErrorHandler.Failed(hresult))
{
return(hresult);
}
}
}
}
// If the text buffer is marked as read-only, ensure that the padlock icon is displayed
// next the new window's title and that [Read Only] is appended to title.
READONLYSTATUS readOnlyStatus = READONLYSTATUS.ROSTATUS_NotReadOnly;
uint textBufferFlags;
if (ErrorHandler.Succeeded(textBuffer.GetStateFlags(out textBufferFlags)) &&
0 != (textBufferFlags & ((uint)BUFFERSTATEFLAGS.BSF_FILESYS_READONLY | (uint)BUFFERSTATEFLAGS.BSF_USER_READONLY)))
{
readOnlyStatus = READONLYSTATUS.ROSTATUS_ReadOnly;
}
switch (physicalView)
{
case "Form":
// We must create the WinForms designer here
const string LoaderName = "Microsoft.VisualStudio.Design.Serialization.CodeDom.VSCodeDomDesignerLoader";
var designerService = (IVSMDDesignerService)ServiceProvider.GetService(typeof(SVSMDDesignerService));
var designerLoader = (IVSMDDesignerLoader)designerService.CreateDesignerLoader(LoaderName);
try
{
designerLoader.Initialize(_oleServiceProvider, vsHierarchy, (int)itemid, (IVsTextLines)textBuffer);
pbstrEditorCaption = designerLoader.GetEditorCaption((int)readOnlyStatus);
var designer = designerService.CreateDesigner(_oleServiceProvider, designerLoader);
ppunkDocView = Marshal.GetIUnknownForObject(designer.View);
pguidCmdUI = designer.CommandGuid;
}
catch
{
designerLoader.Dispose();
throw;
}
break;
case "Code":
var codeWindow = _editorAdaptersFactoryService.CreateVsCodeWindowAdapter(_oleServiceProvider);
codeWindow.SetBuffer((IVsTextLines)textBuffer);
codeWindow.GetEditorCaption(readOnlyStatus, out pbstrEditorCaption);
ppunkDocView = Marshal.GetIUnknownForObject(codeWindow);
pguidCmdUI = VSConstants.GUID_TextEditorFactory;
break;
default:
return(VSConstants.E_INVALIDARG);
}
ppunkDocData = Marshal.GetIUnknownForObject(textBuffer);
return(VSConstants.S_OK);
}
private void WmGetObject(ref Message m)
{
if (m.LParam == (IntPtr)NativeMethods.UiaRootObjectId)
{
AccessibleObject uiaProvider = GetChildAccessibleObject(_childWindowType);
// If the requested object identifier is UiaRootObjectId,
// we should return an UI Automation provider using the UiaReturnRawElementProvider function.
InternalAccessibleObject internalAccessibleObject = new InternalAccessibleObject(uiaProvider);
m.Result = UiaCore.UiaReturnRawElementProvider(
new HandleRef(this, Handle),
m.WParam,
m.LParam,
internalAccessibleObject);
return;
}
// See "How to Handle WM_GETOBJECT" in MSDN
//
if (unchecked ((int)(long)m.LParam) == OBJID.CLIENT)
{
// Get the IAccessible GUID
//
Guid IID_IAccessible = new Guid(NativeMethods.uuid_IAccessible);
// Get an Lresult for the accessibility Object for this control
//
IntPtr punkAcc;
try
{
AccessibleObject wfAccessibleObject = null;
UiaCore.IAccessibleInternal iacc = null;
if (_accessibilityObject is null)
{
wfAccessibleObject = GetChildAccessibleObject(_childWindowType);
_accessibilityObject = new InternalAccessibleObject(wfAccessibleObject);
}
iacc = (UiaCore.IAccessibleInternal)_accessibilityObject;
// Obtain the Lresult
//
punkAcc = Marshal.GetIUnknownForObject(iacc);
try
{
m.Result = Oleacc.LresultFromObject(ref IID_IAccessible, m.WParam, new HandleRef(this, punkAcc));
}
finally
{
Marshal.Release(punkAcc);
}
}
catch (Exception e)
{
throw new InvalidOperationException(SR.RichControlLresult, e);
}
}
else
{ // m.lparam != OBJID_CLIENT, so do default message processing
DefWndProc(ref m);
}
}
public void CreateWindowSizeDependentResources()
{
WaitForGpu();
for (int n = 0; n < FrameCount; n++)
{
DirectXHelper.ReleaseCom(_renderTargets[n]);
_renderTargets[n] = null;
_fenceValues[n] = _fenceValues[_currentFrame];
}
UpdateRenderTargetSize();
DXGI_MODE_ROTATION displayRotation = ComputeDisplayRotation();
bool swapDimensions =
displayRotation == DXGI_MODE_ROTATION.DXGI_MODE_ROTATION_ROTATE90 ||
displayRotation == DXGI_MODE_ROTATION.DXGI_MODE_ROTATION_ROTATE270;
_d3dRenderTargetSize.Width = swapDimensions ? _outputSize.Height : _outputSize.Width;
_d3dRenderTargetSize.Height = swapDimensions ? _outputSize.Width : _outputSize.Height;
uint backBufferWidth = (uint)Math.Round(_d3dRenderTargetSize.Width, MidpointRounding.AwayFromZero);
uint backBufferHeight = (uint)Math.Round(_d3dRenderTargetSize.Height, MidpointRounding.AwayFromZero);
if (_swapChain != null)
{
HRESULT hr = _swapChain.Ptr->ResizeBuffers(FrameCount, backBufferWidth, backBufferHeight, _backBufferFormat,
0);
if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)
{
_deviceRemoved = true;
return;
}
else
{
DirectXHelper.ThrowIfFailed(hr);
}
}
else
{
DXGI_SCALING scaling = DisplayMetrics.SupportHighResolutions
? DXGI_SCALING.DXGI_SCALING_NONE
: DXGI_SCALING.DXGI_SCALING_STRETCH;
DXGI_SWAP_CHAIN_DESC1 swapChainDesc;
swapChainDesc.Width = backBufferWidth;
swapChainDesc.Height = backBufferHeight;
swapChainDesc.Format = _backBufferFormat;
swapChainDesc.Stereo = 0;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.BufferUsage = DXGI.DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount = FrameCount;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT.DXGI_SWAP_EFFECT_FLIP_DISCARD;
swapChainDesc.Flags = 0;
swapChainDesc.Scaling = scaling;
swapChainDesc.AlphaMode = DXGI_ALPHA_MODE.DXGI_ALPHA_MODE_IGNORE;
{
using ComPtr <IDXGISwapChain1> swapChain = null;
IntPtr pWindow = Marshal.GetIUnknownForObject(_window);
DirectXHelper.ThrowIfFailed(
_dxgiFactory.Ptr->CreateSwapChainForCoreWindow(
_commandQueue,
(IUnknown *)pWindow,
&swapChainDesc,
null,
swapChain.GetAddressOf()));
IDXGISwapChain3 *swapChain3;
Guid iid = DXGI.IID_IDXGISwapChain3;
DirectXHelper.ThrowIfFailed(swapChain.Ptr->QueryInterface(&iid, (void **)&swapChain3));
_swapChain = swapChain3;
}
}
switch (displayRotation)
{
case DXGI_MODE_ROTATION.DXGI_MODE_ROTATION_IDENTITY:
_orientationTransform3D = ScreenRotation.Rotation0;
break;
case DXGI_MODE_ROTATION.DXGI_MODE_ROTATION_ROTATE90:
_orientationTransform3D = ScreenRotation.Rotation270;
break;
case DXGI_MODE_ROTATION.DXGI_MODE_ROTATION_ROTATE180:
_orientationTransform3D = ScreenRotation.Rotation180;
break;
case DXGI_MODE_ROTATION.DXGI_MODE_ROTATION_ROTATE270:
_orientationTransform3D = ScreenRotation.Rotation90;
break;
}
DirectXHelper.ThrowIfFailed(_swapChain.Ptr->SetRotation(displayRotation));
{
_currentFrame = (int)_swapChain.Ptr->GetCurrentBackBufferIndex();
D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor = _rtvHeap.Ptr->GetCPUDescriptorHandleForHeapStart();
fixed(void *pBuffer = & _renderTargets)
{
var p = (ID3D12Resource **)pBuffer;
Guid iid = D3D12.IID_ID3D12Resource;
for (var n = 0; n < FrameCount; n++)
{
DirectXHelper.ThrowIfFailed(_swapChain.Ptr->GetBuffer((uint)n, &iid, (void **)&p[n]));
_d3dDevice.Ptr->CreateRenderTargetView(
_renderTargets[n],
null,
rtvDescriptor);
rtvDescriptor.Offset((int)_rtvDescriptorSize);
DirectXHelper.NameObject(_renderTargets[n], $"{nameof(_renderTargets)}[{n}]"); // _renderTargets[n]
}
}
}
{
D3D12_HEAP_PROPERTIES depthHeapProperties = CD3DX12_HEAP_PROPERTIES.Create(D3D12_HEAP_TYPE.D3D12_HEAP_TYPE_DEFAULT);
D3D12_RESOURCE_DESC depthResourceDesc =
CD3DX12_RESOURCE_DESC.Tex2D(_depthBufferFormat, backBufferWidth, backBufferHeight, 1, 1);
depthResourceDesc.Flags |= D3D12_RESOURCE_FLAGS.D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
D3D12_CLEAR_VALUE depthOptimizedClearValue = CD3DX12_CLEAR_VALUE.Create(_depthBufferFormat, 1, 0);
fixed(ID3D12Resource **p = _depthStencil)
{
Guid iid = D3D12.IID_ID3D12Resource;
DirectXHelper.ThrowIfFailed(_d3dDevice.Ptr->CreateCommittedResource(
&depthHeapProperties,
D3D12_HEAP_FLAGS.D3D12_HEAP_FLAG_NONE,
&depthResourceDesc,
D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_DEPTH_WRITE,
&depthOptimizedClearValue,
&iid,
(void **)p
));
DirectXHelper.NameObject(_depthStencil, nameof(_depthStencil));
D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc = default;
dsvDesc.Format = _depthBufferFormat;
dsvDesc.ViewDimension = D3D12_DSV_DIMENSION.D3D12_DSV_DIMENSION_TEXTURE2D;
dsvDesc.Flags = D3D12_DSV_FLAGS.D3D12_DSV_FLAG_NONE;
D3D12_CPU_DESCRIPTOR_HANDLE handle = _dsvHeap.Ptr->GetCPUDescriptorHandleForHeapStart();
_d3dDevice.Ptr->CreateDepthStencilView(_depthStencil.Ptr, &dsvDesc, handle);
}
}
// 0.0f, 0.0f, m_d3dRenderTargetSize.Width, m_d3dRenderTargetSize.Height, 0.0f, 1.0f
_screenViewport = new D3D12_VIEWPORT
{
TopLeftX = 0,
TopLeftY = 0,
Width = (float)_d3dRenderTargetSize.Width,
Height = (float)_d3dRenderTargetSize.Height,
MinDepth = 0,
MaxDepth = 1
};
}
public int CreateEditorInstance(uint grfCreateDoc, string pszMkDocument, string pszPhysicalView,
IVsHierarchy pvHier, uint itemid, IntPtr punkDocDataExisting, out IntPtr ppunkDocView,
out IntPtr ppunkDocData, out string pbstrEditorCaption, out Guid pguidCmdUI, out int pgrfCDW)
{
// Initialize to null
ppunkDocView = IntPtr.Zero;
ppunkDocData = IntPtr.Zero;
pguidCmdUI = new Guid("D0481CA6-C9E2-4852-A60D-A7C0AE6AFB99");
pgrfCDW = 0;
pbstrEditorCaption = null;
// Validate inputs
if ((grfCreateDoc & (VSConstants.CEF_OPENFILE | VSConstants.CEF_SILENT)) == 0)
{
return(VSConstants.E_INVALIDARG);
}
IVsTextLines textBuffer = null;
if (punkDocDataExisting == IntPtr.Zero)
{
// punkDocDataExisting is null which means the file is not yet open.
// We need to create a new text buffer object
// get the ILocalRegistry interface so we can use it to
// create the text buffer from the shell's local registry
try
{
ILocalRegistry localRegistry = (ILocalRegistry)GetService(typeof(SLocalRegistry));
if (localRegistry != null)
{
Guid iid = typeof(IVsTextLines).GUID;
Guid CLSID_VsTextBuffer = typeof(VsTextBufferClass).GUID;
localRegistry.CreateInstance(CLSID_VsTextBuffer, null, ref iid, 1 /*CLSCTX_INPROC_SERVER*/, out IntPtr ptr);
try
{
textBuffer = Marshal.GetObjectForIUnknown(ptr) as IVsTextLines;
}
finally
{
Marshal.Release(ptr); // Release RefCount from CreateInstance call
}
// It is important to site the TextBuffer object
IObjectWithSite objWSite = (IObjectWithSite)textBuffer;
if (objWSite != null)
{
IOleServiceProvider oleServiceProvider = (IOleServiceProvider)GetService(typeof(IOleServiceProvider));
objWSite.SetSite(oleServiceProvider);
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Can not get IVsCfgProviderEventsHelper" + ex.Message);
throw;
}
}
else
{
// punkDocDataExisting is *not* null which means the file *is* already open.
// We need to verify that the open document is in fact a TextBuffer. If not
// then we need to return the special error code VS_E_INCOMPATIBLEDOCDATA which
// causes the user to be prompted to close the open file. If the user closes the
// file then we will be called again with punkDocDataExisting as null
// QI existing buffer for text lines
textBuffer = Marshal.GetObjectForIUnknown(punkDocDataExisting) as IVsTextLines;
if (textBuffer == null || IsInit == false)
{
return(VSConstants.VS_E_INCOMPATIBLEDOCDATA);
}
}
string filename = System.IO.Path.GetFileName(pszMkDocument);
if (string.IsNullOrEmpty(filename) == false)
{
if (filename.Equals(FileName) && ExcuteToCheckXmlRule(pszMkDocument))
{
ManifestEditorPane NewEditor = new ManifestEditorPane(editorPackage, pszMkDocument, textBuffer);
IsInit = true;
ppunkDocView = Marshal.GetIUnknownForObject(NewEditor);
ppunkDocData = Marshal.GetIUnknownForObject(textBuffer);
pbstrEditorCaption = "";
return(VSConstants.S_OK);
}
else
{
Guid clsidCodeWindow = typeof(VsCodeWindowClass).GUID;
Guid iidCodeWindow = typeof(IVsCodeWindow).GUID;
IVsCodeWindow pCodeWindow = (IVsCodeWindow)editorPackage.CreateInstance(ref clsidCodeWindow, ref iidCodeWindow, typeof(IVsCodeWindow));
if (pCodeWindow != null)
{
// Give the text buffer to the code window.
// We are giving up ownership of the text buffer!
pCodeWindow.SetBuffer((IVsTextLines)textBuffer);
// Now tell the caller about all this new stuff
// that has been created.
ppunkDocView = Marshal.GetIUnknownForObject(pCodeWindow);
ppunkDocData = Marshal.GetIUnknownForObject(textBuffer);
// Specify the command UI to use so keypresses are
// automatically dealt with.
pguidCmdUI = VSConstants.GUID_TextEditorFactory;
// This caption is appended to the filename and
// lets us know our invocation of the core editor
// is up and running.
//pbstrEditorCaption = " [MyPackage]";
return(VSConstants.S_OK);
}
}
}
return(VSConstants.S_FALSE);
}
private async Task <IVsWindowFrame> CreateDocWindowAsync(
Project project,
string documentName,
IVsHierarchy hier,
uint itemId)
{
uint windowFlags =
(uint)_VSRDTFLAGS.RDT_DontAddToMRU |
(uint)_VSRDTFLAGS.RDT_DontSaveAs;
var solutionManager = ServiceLocator.GetInstance <ISolutionManager>();
if (!solutionManager.IsSolutionAvailable)
{
throw new InvalidOperationException(Strings.SolutionIsNotSaved);
}
var nugetProject = solutionManager.GetNuGetProject(EnvDTEProjectUtility.GetCustomUniqueName(project));
// If we failed to generate a cache entry in the solution manager something went wrong.
if (nugetProject == null)
{
throw new InvalidOperationException(
string.Format(Resources.ProjectHasAnInvalidNuGetConfiguration, project.Name));
}
// load packages.config. This makes sure that an exception will get thrown if there
// are problems with packages.config, such as duplicate packages. When an exception
// is thrown, an error dialog will pop up and this doc window will not be created.
var installedPackages = await nugetProject.GetInstalledPackagesAsync(CancellationToken.None);
var uiContextFactory = ServiceLocator.GetInstance <INuGetUIContextFactory>();
var uiContext = uiContextFactory.Create(this, new[] { nugetProject });
var uiFactory = ServiceLocator.GetInstance <INuGetUIFactory>();
var uiController = uiFactory.Create(uiContext, _uiProjectContext);
var model = new PackageManagerModel(uiController, uiContext, isSolution: false, editorFactoryGuid: GuidList.guidNuGetEditorType);
var vsWindowSearchHostfactory = ServiceLocator.GetGlobalService <SVsWindowSearchHostFactory, IVsWindowSearchHostFactory>();
var vsShell = ServiceLocator.GetGlobalService <SVsShell, IVsShell4>();
var control = new PackageManagerControl(model, Settings, vsWindowSearchHostfactory, vsShell, _outputConsoleLogger);
var windowPane = new PackageManagerWindowPane(control);
var guidEditorType = GuidList.guidNuGetEditorType;
var guidCommandUI = Guid.Empty;
var caption = String.Format(
CultureInfo.CurrentCulture,
Resx.Label_NuGetWindowCaption,
project.Name);
IVsWindowFrame windowFrame;
IVsUIShell uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
IntPtr ppunkDocView = IntPtr.Zero;
IntPtr ppunkDocData = IntPtr.Zero;
int hr = 0;
try
{
ppunkDocView = Marshal.GetIUnknownForObject(windowPane);
ppunkDocData = Marshal.GetIUnknownForObject(model);
hr = uiShell.CreateDocumentWindow(
windowFlags,
documentName,
(IVsUIHierarchy)hier,
itemId,
ppunkDocView,
ppunkDocData,
ref guidEditorType,
null,
ref guidCommandUI,
null,
caption,
string.Empty,
null,
out windowFrame);
}
finally
{
if (ppunkDocView != IntPtr.Zero)
{
Marshal.Release(ppunkDocData);
}
if (ppunkDocData != IntPtr.Zero)
{
Marshal.Release(ppunkDocView);
}
}
ErrorHandler.ThrowOnFailure(hr);
return(windowFrame);
}
public void GetIUnknownForObject_Unix_ThrowsPlatformNotSupportedException()
{
Assert.Throws <PlatformNotSupportedException>(() => Marshal.GetIUnknownForObject(null));
}
private async Task <IVsWindowFrame> CreateDocWindowForSolutionAsync()
{
IVsWindowFrame windowFrame = null;
IVsSolution solution = ServiceLocator.GetInstance <IVsSolution>();
IVsUIShell uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
uint windowFlags =
(uint)_VSRDTFLAGS.RDT_DontAddToMRU |
(uint)_VSRDTFLAGS.RDT_DontSaveAs;
var solutionManager = ServiceLocator.GetInstance <ISolutionManager>();
if (!solutionManager.IsSolutionAvailable)
{
throw new InvalidOperationException(Strings.SolutionIsNotSaved);
}
var projects = solutionManager.GetNuGetProjects();
if (!projects.Any())
{
// NOTE: The menu 'Manage NuGet Packages For Solution' will be disabled in this case.
// But, it is possible, that, before NuGetPackage is loaded in VS, the menu is enabled and used.
// For once, this message will be shown. Once the package is loaded, the menu will get disabled as appropriate
MessageHelper.ShowWarningMessage(Resources.NoSupportedProjectsInSolution, Resources.ErrorDialogBoxTitle);
return(null);
}
// load packages.config. This makes sure that an exception will get thrown if there
// are problems with packages.config, such as duplicate packages. When an exception
// is thrown, an error dialog will pop up and this doc window will not be created.
foreach (var project in projects)
{
await project.GetInstalledPackagesAsync(CancellationToken.None);
}
var uiContextFactory = ServiceLocator.GetInstance <INuGetUIContextFactory>();
var uiContext = uiContextFactory.Create(this, projects);
var uiFactory = ServiceLocator.GetInstance <INuGetUIFactory>();
var uiController = uiFactory.Create(uiContext, _uiProjectContext);
var solutionName = (string)_dte.Solution.Properties.Item("Name").Value;
var model = new PackageManagerModel(uiController, uiContext, isSolution: true, editorFactoryGuid: GuidList.guidNuGetEditorType);
model.SolutionName = solutionName;
var vsWindowSearchHostfactory = ServiceLocator.GetGlobalService <SVsWindowSearchHostFactory, IVsWindowSearchHostFactory>();
var vsShell = ServiceLocator.GetGlobalService <SVsShell, IVsShell4>();
var control = new PackageManagerControl(model, Settings, vsWindowSearchHostfactory, vsShell, _outputConsoleLogger);
var windowPane = new PackageManagerWindowPane(control);
var guidEditorType = GuidList.guidNuGetEditorType;
var guidCommandUI = Guid.Empty;
var caption = Resx.Label_SolutionNuGetWindowCaption;
var documentName = _dte.Solution.FullName;
IntPtr ppunkDocView = IntPtr.Zero;
IntPtr ppunkDocData = IntPtr.Zero;
int hr = 0;
try
{
ppunkDocView = Marshal.GetIUnknownForObject(windowPane);
ppunkDocData = Marshal.GetIUnknownForObject(model);
hr = uiShell.CreateDocumentWindow(
windowFlags,
documentName,
(IVsUIHierarchy)solution,
(uint)VSConstants.VSITEMID.Root,
ppunkDocView,
ppunkDocData,
ref guidEditorType,
null,
ref guidCommandUI,
null,
caption,
string.Empty,
null,
out windowFrame);
}
finally
{
if (ppunkDocView != IntPtr.Zero)
{
Marshal.Release(ppunkDocData);
}
if (ppunkDocData != IntPtr.Zero)
{
Marshal.Release(ppunkDocView);
}
}
ErrorHandler.ThrowOnFailure(hr);
return(windowFrame);
}
private static HRESULT GetData(IntPtr thisPtr, FORMATETC *format, STGMEDIUM_Raw *pMedium)
{
var instance = ComInterfaceDispatch.GetInstance <IDataObject>((ComInterfaceDispatch *)thisPtr);
try
{
instance.GetData(ref *format, out var medium);
pMedium->pUnkForRelease = medium.pUnkForRelease == null ? IntPtr.Zero : Marshal.GetIUnknownForObject(medium.pUnkForRelease);
pMedium->tymed = medium.tymed;
pMedium->unionmember = medium.unionmember;
return(HRESULT.S_OK);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return((HRESULT)ex.HResult);
}
}
public PropVariant(object value, PropertyType?type = null)
{
if (value == null)
{
_vt = PropertyType.VT_NULL;
return;
}
if (Marshal.IsComObject(value))
{
_ptr = Marshal.GetIUnknownForObject(value);
_vt = PropertyType.VT_UNKNOWN;
return;
}
if (value is PropVariant pv)
{
value = pv.Value;
}
if (value is char[] chars)
{
value = new string(chars);
}
if (value is char[][])
{
var charray = value as char[][];
var strings = new string[charray.GetLength(0)];
for (var i = 0; i < charray.Length; i++)
{
strings[i] = new string(charray[i]);
}
value = strings;
}
if (value is Array array)
{
ConstructArray(array, type);
return;
}
if (!(value is string) && value is IEnumerable enumerable)
{
ConstructEnumerable(enumerable, type);
return;
}
var tc = Type.GetTypeCode(value.GetType());
switch (tc)
{
case TypeCode.Boolean:
_boolean = (bool)value ? (short)(-1) : (short)0;
break;
case TypeCode.Byte:
_byte = (byte)value;
break;
case TypeCode.Char:
chars = new[] { (char)value };
_ptr = MarshalString(new string(chars), FromType(typeof(string), type));
break;
case TypeCode.DateTime:
var ft = ToPositiveFileTime((DateTime)value);
if (ft == 0)
{
break; // stay empty
}
InitPropVariantFromFileTime(ref ft, this);
break;
case TypeCode.Empty:
case TypeCode.DBNull:
break;
case TypeCode.Decimal:
_decimal = (decimal)value;
break;
case TypeCode.Double:
_double = (double)value;
break;
case TypeCode.Int16:
_int16 = (short)value;
break;
case TypeCode.Int32:
_int32 = (int)value;
break;
case TypeCode.Int64:
_int64 = (long)value;
break;
case TypeCode.SByte:
_sbyte = (sbyte)value;
break;
case TypeCode.Single:
_single = (float)value;
break;
case TypeCode.String:
_ptr = MarshalString((string)value, FromType(typeof(string), type));
break;
case TypeCode.UInt16:
_uint16 = (ushort)value;
break;
case TypeCode.UInt32:
_uint32 = (uint)value;
break;
case TypeCode.UInt64:
_uint64 = (ulong)value;
break;
//case TypeCode.Object:
default:
if (value is Guid guid)
{
_ptr = Marshal.AllocCoTaskMem(16);
Marshal.Copy(guid.ToByteArray(), 0, _ptr, 16);
break;
}
if (value is System.Runtime.InteropServices.ComTypes.FILETIME filetime)
{
_filetime = filetime;
break;
}
throw new ArgumentException("Value of type '" + value.GetType().FullName + "' is not supported.", nameof(value));
}
_vt = FromType(value.GetType(), type);
}
