public static ComPtr<IDiaSymbol> GetSymbol(this IDiaSymbol symbol, SymTagEnum symTag, string name, Predicate<IDiaSymbol> filter = null) { var result = new ComPtr<IDiaSymbol>(); IDiaEnumSymbols enumSymbols; symbol.findChildren(symTag, name, 1, out enumSymbols); using (ComPtr.Create(enumSymbols)) { int n = enumSymbols.count; if (n == 0) { Debug.Fail("Symbol '" + name + "' was not found."); throw new ArgumentException(); } try { for (int i = 0; i < n; ++i) { using (var item = ComPtr.Create(enumSymbols.Item((uint)i))) { if (filter == null || filter(item.Object)) { if (result.Object == null) { result = item.Detach(); } else { Debug.Fail("Found more than one symbol named '" + name + "' and matching the filter."); throw new ArgumentException(); } } } } } catch { result.Dispose(); throw; } } return result; }
public void Dispose() { if (_inputStream != null) Xpcom.DisposeObject( ref _inputStream ); _inputStream = null; GC.SuppressFinalize(this); }
internal GeckoNode(object domObject) { if (domObject is nsIDOMNode) _domNode = new ComPtr<nsIDOMNode>((nsIDOMNode)domObject); else throw new ArgumentException("domObject is not a nsIDOMNode"); }
public StorageStream() { _storageStream = Xpcom.CreateInstance2<nsIStorageStream>( Contracts.StorageStream ); _storageStream.Instance.Init( 1024 * 32, 1024 * 1024 * 16 ); }
public ChromeContext() { using (var appShallSvc = Xpcom.GetService2<nsIAppShellService>(Contracts.AppShellService)) { webNav = appShallSvc.Instance.CreateWindowlessBrowser(true).AsComPtr(); webNav.Instance.LoadURI("chrome://global/content/alerts/alert.xul", 0, null, null, null); } }
private GeckoSelection(nsISelection selection) { // selection is always NOT null, when we use Create function //if (selection == null) // throw new ArgumentException("selection"); _selection = new ComPtr<nsISelection>(selection); }
internal InputStream(nsIInputStream inputStream) { _inputStream = new ComPtr<nsIInputStream>( inputStream ); var seekableStream = Xpcom.QueryInterface<nsISeekableStream>(inputStream); if ( _seekable = seekableStream != null ) { _seekableStream = new ComPtr<nsISeekableStream>( seekableStream ); } }
internal OutputStream(nsIOutputStream outputStream) { _outputStream = new ComPtr<nsIOutputStream>( outputStream ); var seekableStream = Xpcom.QueryInterface<nsISeekableStream>( outputStream ); if ( _seekable = (seekableStream != null) ) { _seekableStream = new ComPtr<nsISeekableStream>( seekableStream ); } _binaryOutputStream = Xpcom.CreateInstance2<nsIBinaryOutputStream>(Contracts.BinaryOutputStream); _binaryOutputStream.Instance.SetOutputStream( _outputStream.Instance ); }
static public void Shutdown() { if (_prefService != null) _prefService.Dispose(); if (_user != null) _user.Dispose(); if (_default != null) _default.Dispose(); _prefService = null; _user = null; _default = null; }
/// <param name="flags">see nsICertOverrideServiceConsts</param> public static void RememberValidityOverride(Uri url, ComPtr<nsIX509Cert> cert, int flags) { if (url == null) throw new ArgumentNullException("url"); using (var aHostName = new nsACString(url.Host)) { using (var svc = GetService()) { svc.Instance.RememberValidityOverride(aHostName, url.Port, cert.Instance, (uint)flags, true); } } }
public static ComPtr<IDiaSymbol> FindChildSymbol(ComPtr<IDiaSymbol> parent, SymTagEnum tag, string name) { var result = new ComPtr<IDiaSymbol>(); IDiaEnumSymbols enumerator; parent.Ptr.findChildren(tag, name, 1, out enumerator); using (ComPtr.Create(enumerator)) { if (enumerator.count == 0) return new ComPtr<IDiaSymbol>(); result = ComPtr.Create(enumerator.Item((uint)0)); } return result; }
public static int GetActiveObject(string progID, out ComPtr p) { int hr = 0; Guid clsid = Guid.Empty; IntPtr pUnk = IntPtr.Zero; p = IntPtr.Zero; if (Succeeded(hr = GetActiveObject(progID, out pUnk))) { p = new ComPtr(pUnk); Marshal.Release(pUnk); } return hr; }
public static int CreateInstance(string progID, out ComPtr p) { int hr = 0; Guid clsid = Guid.Empty; IntPtr pUnk = IntPtr.Zero; p = IntPtr.Zero; if (Succeeded(hr = CreateInstance(progID, out pUnk))) { p = new ComPtr(pUnk); Marshal.Release(pUnk); } return hr; }
public static bool HasMatchingOverride(Uri url, ComPtr<nsIX509Cert> cert) { if (url == null) throw new ArgumentNullException("url"); using (var aHostName = new nsACString(url.Host)) { uint flags = 0; bool isTemp = false; using (var overrideSvc = GetService()) { return overrideSvc.Instance.HasMatchingOverride(aHostName, url.Port, cert.Instance, ref flags, ref isTemp); } } }
/// <summary/> private void Dispose(bool fDisposing) { System.Diagnostics.Debug.WriteLineIf(!fDisposing, "****** Missing Dispose() call for " + GetType() + ". *******"); if (fDisposing && !IsDisposed) { // dispose managed and unmanaged objects if (webNav != null) webNav.Dispose(); if (command != null) command.Dispose(); _isInitialized = false; } webNav = null; command = null; IsDisposed = true; }
public static ComPtr<IDiaSymbol>[] GetSymbols(this IDiaSymbol symbol, SymTagEnum symTag, string name) { IDiaEnumSymbols enumSymbols; symbol.findChildren(symTag, name, 1, out enumSymbols); using (ComPtr.Create(enumSymbols)) { int n = enumSymbols.count; var result = new ComPtr<IDiaSymbol>[n]; try { for (int i = 0; i < n; ++i) { result[i] = ComPtr.Create(enumSymbols.Item((uint)i)); } } catch { foreach (var item in result) { item.Dispose(); } throw; } return result; } }
protected override void OnHandleCreated(EventArgs e) { #if GTK if (Xpcom.IsMono) { base.OnHandleCreated(e); m_wrapper.Init(); } #endif if (!this.DesignMode) { Xpcom.Initialize(); WindowCreator.Register(); #if !GTK LauncherDialogFactory.Register(); #endif WebBrowser = Xpcom.CreateInstance <nsIWebBrowser>(Contracts.WebBrowser); WebBrowserFocus = ( nsIWebBrowserFocus )WebBrowser; BaseWindow = ( nsIBaseWindow )WebBrowser; WebNav = ( nsIWebNavigation )WebBrowser; WebBrowser.SetContainerWindowAttribute(this); #if GTK if (Xpcom.IsMono) { BaseWindow.InitWindow(m_wrapper.BrowserWindow.Handle, IntPtr.Zero, 0, 0, this.Width, this.Height); } else #endif BaseWindow.InitWindow(this.Handle, IntPtr.Zero, 0, 0, this.Width, this.Height); BaseWindow.Create(); Guid nsIWebProgressListenerGUID = typeof(nsIWebProgressListener).GUID; Guid nsIWebProgressListener2GUID = typeof(nsIWebProgressListener2).GUID; WebBrowser.AddWebBrowserListener(this.GetWeakReference(), ref nsIWebProgressListenerGUID); WebBrowser.AddWebBrowserListener(this.GetWeakReference(), ref nsIWebProgressListener2GUID); if (UseHttpActivityObserver) { ObserverService.AddObserver(this, ObserverNotifications.HttpRequests.HttpOnModifyRequest, false); Net.HttpActivityDistributor.AddObserver(this); } // var domEventListener = new GeckoDOMEventListener(this); { var domWindow = WebBrowser.GetContentDOMWindowAttribute(); EventTarget = domWindow.GetWindowRootAttribute().AsComPtr(); Marshal.ReleaseComObject(domWindow); } foreach (string sEventName in this.DefaultEvents) { using (var eventType = new nsAString(sEventName)) { EventTarget.Instance.AddEventListener(eventType, this, true, true, 2); } } // history { var sessionHistory = WebNav.GetSessionHistoryAttribute(); if (sessionHistory != null) { sessionHistory.AddSHistoryListener(this); } } BaseWindow.SetVisibilityAttribute(true); // this fix prevents the browser from crashing if the first page loaded is invalid (missing file, invalid URL, etc) if (Document != null) { // only for html documents Document.Cookie = ""; } } base.OnHandleCreated(e); }
internal CertificateValidity(nsIX509CertValidity validity) { _validity = new ComPtr <nsIX509CertValidity>(validity); }
public GeckoWindow(nsIDOMWindow window) { //Interop.ComDebug.WriteDebugInfo( window ); _domWindow = new ComPtr <nsIDOMWindow>(window); }
public GeckoWindow(mozIDOMWindowProxy window, nsISupports innerWindow, bool?ownRCW = null) { _domWindowProxy = new ComPtr <mozIDOMWindowProxy> (window, ownRCW ?? !Xpcom.GCFreesRCWsByDefault); _innerWindow = new ComPtr <nsISupports>(innerWindow, ownRCW ?? !Xpcom.GCFreesRCWsByDefault); _window = new Lazy <Window>(() => new WebIDL.Window(_domWindowProxy.Instance, _innerWindow?.Instance ?? (nsISupports)_domWindowProxy.Instance)); }
/// <summary> /// Creates a new <see cref="PipelineData"/> instance with the specified parameters. /// </summary> /// <param name="d3D12RootSignature">The <see cref="ID3D12RootSignature"/> value for the current shader.</param> /// <param name="d3D12PipelineState">The compiled pipeline state to reuse for the current shader.</param> public PipelineData(ID3D12RootSignature *d3D12RootSignature, ID3D12PipelineState *d3D12PipelineState) { this.d3D12RootSignature = new ComPtr <ID3D12RootSignature>(d3D12RootSignature); this.d3D12PipelineState = new ComPtr <ID3D12PipelineState>(d3D12PipelineState); }
static WindowWatcher() { _watcher = Xpcom.GetService2 <nsIWindowWatcher>(Contracts.WindowWatcher); }
internal CertTreeItem(nsICertTreeItem certTreeItem) { _certTreeItem = new ComPtr<nsICertTreeItem>(certTreeItem); }
public Screen(nsIScreen screen) { _screen = new ComPtr<nsIScreen>( screen ); }
private GeckoWindow(nsIDOMWindow window) { //Interop.ComDebug.WriteDebugInfo( window ); _domWindow = new ComPtr<nsIDOMWindow>(window); }
public WicImageFrame(WicImageContainer decoder, uint index) { Container = decoder; using var frame = default(ComPtr <IWICBitmapFrameDecode>); HRESULT.Check(decoder.WicDecoder->GetFrame(index, frame.GetAddressOf())); using var source = new ComPtr <IWICBitmapSource>((IWICBitmapSource *)frame.Get()); double dpix, dpiy; HRESULT.Check(frame.Get()->GetResolution(&dpix, &dpiy)); (DpiX, DpiY) = (dpix, dpiy); uint frameWidth, frameHeight; HRESULT.Check(frame.Get()->GetSize(&frameWidth, &frameHeight)); using var metareader = default(ComPtr <IWICMetadataQueryReader>); if (SUCCEEDED(frame.Get()->GetMetadataQueryReader(metareader.GetAddressOf()))) { string orientationPath = MagicImageProcessor.EnableXmpOrientation ? Wic.Metadata.OrientationWindowsPolicy : Container.ContainerFormat == FileFormat.Jpeg ? Wic.Metadata.OrientationJpeg : Wic.Metadata.OrientationExif; ExifOrientation = ((Orientation)metareader.GetValueOrDefault <ushort>(orientationPath)).Clamp(); WicMetadataReader = metareader.Detach(); } using var preview = default(ComPtr <IWICBitmapSource>); if (decoder.IsRawContainer && index == 0 && SUCCEEDED(decoder.WicDecoder->GetPreview(preview.GetAddressOf()))) { uint pw, ph; HRESULT.Check(preview.Get()->GetSize(&pw, &ph)); if (pw == frameWidth && ph == frameHeight) { source.Attach(preview.Detach()); } } using var transform = default(ComPtr <IWICBitmapSourceTransform>); if (SUCCEEDED(source.Get()->QueryInterface(__uuidof <IWICBitmapSourceTransform>(), (void **)transform.GetAddressOf()))) { uint tw = 1, th = 1; HRESULT.Check(transform.Get()->GetClosestSize(&tw, &th)); SupportsNativeScale = tw < frameWidth || th < frameHeight; } using var ptransform = default(ComPtr <IWICPlanarBitmapSourceTransform>); if (SUCCEEDED(source.Get()->QueryInterface(__uuidof <IWICPlanarBitmapSourceTransform>(), (void **)ptransform.GetAddressOf()))) { var fmts = WicTransforms.PlanarPixelFormats; var desc = stackalloc WICBitmapPlaneDescription[fmts.Length]; fixed(Guid *pfmt = fmts) { uint tw = frameWidth, th = frameHeight, st = 0; HRESULT.Check(ptransform.Get()->DoesSupportTransform( &tw, &th, WICBitmapTransformOptions.WICBitmapTransformRotate0, WICPlanarOptions.WICPlanarOptionsDefault, pfmt, desc, (uint)fmts.Length, (int *)&st )); SupportsPlanarProcessing = st != 0; } ChromaSubsampling = desc[1].Width < desc[0].Width && desc[1].Height < desc[0].Height ? WICJpegYCrCbSubsamplingOption.WICJpegYCrCbSubsampling420 : desc[1].Width < desc[0].Width ? WICJpegYCrCbSubsamplingOption.WICJpegYCrCbSubsampling422 : desc[1].Height < desc[0].Height ? WICJpegYCrCbSubsamplingOption.WICJpegYCrCbSubsampling440 : WICJpegYCrCbSubsamplingOption.WICJpegYCrCbSubsampling444; } var guid = default(Guid); HRESULT.Check(source.Get()->GetPixelFormat(&guid)); if (PixelFormat.FromGuid(guid).NumericRepresentation == PixelNumericRepresentation.Indexed) { var newFormat = PixelFormat.Bgr24Bpp; if (Container.ContainerFormat == FileFormat.Gif && Container.FrameCount > 1) { newFormat = PixelFormat.Bgra32Bpp; } else { using var pal = default(ComPtr <IWICPalette>); HRESULT.Check(Wic.Factory->CreatePalette(pal.GetAddressOf())); HRESULT.Check(source.Get()->CopyPalette(pal)); int bval; if (SUCCEEDED(pal.Get()->HasAlpha(&bval)) && bval != 0) { newFormat = PixelFormat.Bgra32Bpp; } else if ((SUCCEEDED(pal.Get()->IsGrayscale(&bval)) && bval != 0) || (SUCCEEDED(pal.Get()->IsBlackWhite(&bval)) && bval != 0)) { newFormat = PixelFormat.Grey8Bpp; } } var nfmt = newFormat.FormatGuid; using var conv = default(ComPtr <IWICFormatConverter>); HRESULT.Check(Wic.Factory->CreateFormatConverter(conv.GetAddressOf())); HRESULT.Check(conv.Get()->Initialize(source, &nfmt, WICBitmapDitherType.WICBitmapDitherTypeNone, null, 0.0, WICBitmapPaletteType.WICBitmapPaletteTypeCustom)); source.Attach((IWICBitmapSource *)conv.Detach()); } WicFrame = frame.Detach(); WicSource = source.Detach(); }
internal SearchSubmission(nsISearchSubmission searchSubmission) { _searchSubmission = new ComPtr<nsISearchSubmission>(searchSubmission); //??? _searchSubmission.Instance.GetPostDataAttribute(); }
public WinTaskbar() { _winTaskbar = Xpcom.CreateInstance2 <nsIWinTaskbar>(Contracts.WindowsTaskbar); }
static ConsoleService() { _consoleService = Xpcom.GetService2<nsIConsoleService>(Contracts.ConsoleService); }
static DnsService() { _dnsService = Xpcom.GetService2 <nsIDNSService>(Contracts.DnsService); }
static VersionComparator() { _versionComparator = Xpcom.GetService2 <nsIVersionComparator>(Contracts.VersionComparator); }
/// <summary> /// Returns the address of the underlying pointer in the <see cref="ComPtr{T}"/>. /// </summary> /// <param name="comPtr">A pointer to the encapsulated pointer to take the address of</param> /// <typeparam name="T">The type of the underlying pointer</typeparam> /// <returns>A pointer to the underlying pointer</returns> public static T **GetAddressOf <T>(ComPtr <T> *comPtr) where T : unmanaged => (T **)comPtr;
/// <summary> /// Creates a new <see cref="Buffer{T}"/> instance with the specified parameters. /// </summary> /// <param name="device">The <see cref="GraphicsDevice"/> associated with the current instance.</param> /// <param name="length">The number of items to store in the current buffer.</param> /// <param name="elementSizeInBytes">The size in bytes of each buffer item (including padding, if any).</param> /// <param name="resourceType">The resource type for the current buffer.</param> /// <param name="allocationMode">The allocation mode to use for the new resource.</param> private protected Buffer(GraphicsDevice device, int length, uint elementSizeInBytes, ResourceType resourceType, AllocationMode allocationMode) { device.ThrowIfDisposed(); if (resourceType == ResourceType.Constant) { Guard.IsBetweenOrEqualTo(length, 1, D3D12.D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT, nameof(length)); } else { // The maximum length is set such that the aligned buffer size can't exceed uint.MaxValue Guard.IsBetweenOrEqualTo(length, 1, (uint.MaxValue / elementSizeInBytes) & ~255, nameof(length)); } if (TypeInfo <T> .IsDoubleOrContainsDoubles && device.D3D12Device->CheckFeatureSupport <D3D12_FEATURE_DATA_D3D12_OPTIONS>(D3D12_FEATURE_D3D12_OPTIONS).DoublePrecisionFloatShaderOps == 0) { UnsupportedDoubleOperationsException.Throw <T>(); } nint usableSizeInBytes = checked ((nint)(length * elementSizeInBytes)); nint effectiveSizeInBytes = resourceType == ResourceType.Constant ? AlignmentHelper.Pad(usableSizeInBytes, D3D12.D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT) : usableSizeInBytes; SizeInBytes = usableSizeInBytes; GraphicsDevice = device; Length = length; #if NET6_0_OR_GREATER this.allocation = device.Allocator->CreateResource(device.Pool, resourceType, allocationMode, (ulong)effectiveSizeInBytes); this.d3D12Resource = new ComPtr <ID3D12Resource>(this.allocation.Get()->GetResource()); #else this.d3D12Resource = device.D3D12Device->CreateCommittedResource(resourceType, (ulong)effectiveSizeInBytes, device.IsCacheCoherentUMA); #endif device.RegisterAllocatedResource(); device.RentShaderResourceViewDescriptorHandles(out this.d3D12ResourceDescriptorHandles); device.RentShaderResourceViewDescriptorHandles(out this.d3D12ResourceDescriptorHandlesForTypedUnorderedAccessView); switch (resourceType) { case ResourceType.Constant: device.D3D12Device->CreateConstantBufferView(this.d3D12Resource.Get(), effectiveSizeInBytes, this.d3D12ResourceDescriptorHandles.D3D12CpuDescriptorHandle); break; case ResourceType.ReadOnly: device.D3D12Device->CreateShaderResourceView(this.d3D12Resource.Get(), (uint)length, elementSizeInBytes, this.d3D12ResourceDescriptorHandles.D3D12CpuDescriptorHandle); break; case ResourceType.ReadWrite: device.D3D12Device->CreateUnorderedAccessView(this.d3D12Resource.Get(), (uint)length, elementSizeInBytes, this.d3D12ResourceDescriptorHandles.D3D12CpuDescriptorHandle); device.D3D12Device->CreateUnorderedAccessViewForClear( this.d3D12Resource.Get(), DXGI_FORMAT_R32_UINT, (uint)(usableSizeInBytes / sizeof(uint)), this.d3D12ResourceDescriptorHandlesForTypedUnorderedAccessView.D3D12CpuDescriptorHandle, this.d3D12ResourceDescriptorHandlesForTypedUnorderedAccessView.D3D12CpuDescriptorHandleNonShaderVisible); break; } this.d3D12Resource.Get()->SetName(this); }
/// <summary> /// Returns the address of the underlying pointer in the <see cref="ComPtr{T}"/>. /// This operation is only defined if <paramref name="comPtr"/> is pinned in memory for duration between the /// invocation of this method and the final use of the return /// </summary> /// <param name="comPtr">A pointer to the encapsulated pointer to take the address of</param> /// <typeparam name="T">The type of the underlying pointer</typeparam> /// <returns>A pointer to the underlying pointer</returns> public static void **GetVoidAddressOf <T>(ComPtr <T> *comPtr) where T : unmanaged => (void **)comPtr;
public GeckoNamedNodeMap(nsIDOMMozNamedAttrMap map) { // map should be not null this._map = new ComPtr <nsIDOMMozNamedAttrMap>(map); }
internal TraceableChannel(nsITraceableChannel traceableChannel) { _traceableChannel = new ComPtr <nsITraceableChannel>(traceableChannel); }
internal RentedCommandAllocator(ComPtr <ID3D12CommandAllocator> value) { Debug.Assert(value.Get() != null); _value = value; }
static CertificateDatabase() { _certDb = Xpcom.GetService2 <nsIX509CertDB>(Contracts.X509CertDb); _certDb2 = Xpcom.GetService2 <nsIX509CertDB2>(Contracts.X509CertDb); }
//For debugging window leak //private static int _windowCount = 0; static WindowMediator() { _windowMediator = Xpcom.GetService2 <nsIWindowMediator>(Contracts.WindowMediator); }
static CookieManager() { _cookieManager = Xpcom.GetService2 <nsICookieManager2>(Contracts.CookieManager); }
/// <inheritdoc/> public bool MoveNext() { if (!this.isInitialized) { this.isInitialized = true; fixed(IDXGIFactory6 **dxgiFactory6 = this.dxgiFactory6) { CreateDXGIFactory6(dxgiFactory6); } } if (this.isCompleted) { return(false); } while (true) { using ComPtr <IDXGIAdapter1> dxgiAdapter1 = default; HRESULT enumAdapters1Result = this.dxgiFactory6.Get()->EnumAdapterByGpuPreference( this.index, DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE, Windows.__uuidof <IDXGIAdapter1>(), dxgiAdapter1.GetVoidAddressOf()); if (enumAdapters1Result == DXGI.DXGI_ERROR_NOT_FOUND) { this.dxgiFactory6.Get()->EnumWarpAdapter(Windows.__uuidof <IDXGIAdapter1>(), dxgiAdapter1.GetVoidAddressOf()).Assert(); DXGI_ADAPTER_DESC1 dxgiDescription1; dxgiAdapter1.Get()->GetDesc1(&dxgiDescription1).Assert(); HRESULT createDeviceResult = DirectX.D3D12CreateDevice( dxgiAdapter1.AsIUnknown().Get(), D3D_FEATURE_LEVEL_11_0, Windows.__uuidof <ID3D12Device>(), null); if (Windows.SUCCEEDED(createDeviceResult) && this.predicate?.Invoke(new GraphicsDeviceInfo(&dxgiDescription1)) != false) { using ComPtr <ID3D12Device> d3D12Device = default; DirectX.D3D12CreateDevice( dxgiAdapter1.AsIUnknown().Get(), D3D_FEATURE_LEVEL_11_0, Windows.__uuidof <ID3D12Device>(), d3D12Device.GetVoidAddressOf()).Assert(); this.graphicsDevice = GetOrCreateDevice(d3D12Device.Get(), (IDXGIAdapter *)dxgiAdapter1.Get(), &dxgiDescription1); this.isCompleted = true; return(true); } return(false); } else { enumAdapters1Result.Assert(); this.index++; DXGI_ADAPTER_DESC1 dxgiDescription1; dxgiAdapter1.Get()->GetDesc1(&dxgiDescription1).Assert(); if (dxgiDescription1.VendorId == MicrosoftVendorId && dxgiDescription1.DeviceId == WarpDeviceId) { continue; } HRESULT createDeviceResult = DirectX.D3D12CreateDevice( dxgiAdapter1.AsIUnknown().Get(), D3D_FEATURE_LEVEL_11_0, Windows.__uuidof <ID3D12Device>(), null); if (Windows.SUCCEEDED(createDeviceResult) && this.predicate?.Invoke(new GraphicsDeviceInfo(&dxgiDescription1)) != false) { using ComPtr <ID3D12Device> d3D12Device = default; DirectX.D3D12CreateDevice( dxgiAdapter1.AsIUnknown().Get(), D3D_FEATURE_LEVEL_11_0, Windows.__uuidof <ID3D12Device>(), d3D12Device.GetVoidAddressOf()).Assert(); if (d3D12Device.Get()->IsShaderModelSupported(D3D_SHADER_MODEL_6_0)) { this.graphicsDevice = GetOrCreateDevice(d3D12Device.Get(), (IDXGIAdapter *)dxgiAdapter1.Get(), &dxgiDescription1); return(true); } } } } }
static AppShellService() { _appShellService = Xpcom.GetService2 <nsIAppShellService>(Contracts.AppShellService); }
protected override void OnHandleDestroyed(EventArgs e) { if (BaseWindow != null) { this.Stop(); nsIDocShell docShell = Xpcom.QueryInterface <nsIDocShell>(BaseWindow); if (docShell != null && !docShell.IsBeingDestroyed()) { try { var window = Xpcom.QueryInterface <nsIDOMWindow>(docShell); if (window != null) { try { if (!window.GetClosedAttribute()) { window.Close(); } } finally { Xpcom.FreeComObject(ref window); } } } finally { Xpcom.FreeComObject(ref docShell); } } if (EventTarget != null) { //Remove Event Listener foreach (string sEventType in this.DefaultEvents) { using (var eventType = new nsAString(sEventType)) { EventTarget.Instance.RemoveEventListener(eventType, this, true); } } EventTarget.Dispose(); EventTarget = null; } BaseWindow.Destroy(); Xpcom.FreeComObject(ref CommandParams); var webBrowserFocus = this.WebBrowserFocus; this.WebBrowserFocus = null; Xpcom.FreeComObject(ref webBrowserFocus); Xpcom.FreeComObject(ref WebNav); Xpcom.FreeComObject(ref BaseWindow); Xpcom.FreeComObject(ref WebBrowser); #if GTK if (m_wrapper != null) { m_wrapper.Dispose(); } #endif } base.OnHandleDestroyed(e); }
public ComPtrTreeNode(ComPropertyInfo comPropertyInfo, ComPtr comPtr) : this(comPropertyInfo.Name, comPtr) { _comPropertyInfo = comPropertyInfo; if ((_comPropertyInfo != null) && (_comPropertyInfo.GetFunction != null)) { _comFunctionInfo = _comPropertyInfo.GetFunction; _getFunctionHasParameters = _comPropertyInfo.GetFunctionHasParameters; } }
public void CompileTest_Ok() { using ComPtr <IDxcBlob> dxcBlob = ShaderCompiler.Instance.CompileShader(ShaderSource.AsSpan()); }
private ComTreeNode GetChild(ComPtr comPtr, ComPropertyInfo comPropertyInfo) { if (comPtr == null) return null; if (comPropertyInfo == null) return null; if (comPtr.IsInvalid) return null; ComFunctionInfo getFunctionInfo = comPropertyInfo.GetFunction; if (getFunctionInfo == null) return null; if (getFunctionInfo.IsRestricted) return null; ComTreeNode comTreeNode = null; object propertyValue = null; if (getFunctionInfo.Parameters.Length == 0) { try { comPtr.TryInvokePropertyGet(getFunctionInfo.DispId, out propertyValue); } catch { GlobalExceptionHandler.HandleException(); } if (propertyValue == null) { switch (getFunctionInfo.ReturnParameter.VariantType) { case VarEnum.VT_DISPATCH: case VarEnum.VT_PTR: case VarEnum.VT_ARRAY: case VarEnum.VT_UNKNOWN: propertyValue = new ComPtr(IntPtr.Zero); break; } } if (propertyValue is ComPtr) { comTreeNode = new ComPtrTreeNode(comPropertyInfo, (ComPtr)propertyValue); if (((ComPtr)propertyValue).IsInvalid == false) { comTreeNode.Nodes.Add(String.Empty); } } else { comTreeNode = new ComPropertyTreeNode(comPropertyInfo, propertyValue); } } else { switch (getFunctionInfo.ReturnParameter.VariantType) { case VarEnum.VT_DISPATCH: case VarEnum.VT_PTR: case VarEnum.VT_ARRAY: case VarEnum.VT_UNKNOWN: comTreeNode = new ComPtrTreeNode(comPropertyInfo, new ComPtr()); break; default: comTreeNode = new ComPropertyTreeNode(comPropertyInfo, null); break; } } return comTreeNode; }
public ComTreeNode AddRootNode(ComPtr p, string caption) { ComPtrTreeNode comObjectRootTreeNode = new ComPtrTreeNode(caption, p); comObjectRootTreeNode.Nodes.Add("..."); Nodes.Add(comObjectRootTreeNode); SelectedNode = comObjectRootTreeNode; comObjectRootTreeNode.Expand(); return comObjectRootTreeNode; }
public void CompileTest_Fail() { var faultyShader = ShaderSource.Replace("ids.x", "ids.X"); using ComPtr <IDxcBlob> dxcBlob = ShaderCompiler.Instance.CompileShader(faultyShader.AsSpan()); }
private ComTreeNode[] GetChildren(ComPtr comPtr) { if (comPtr == null) return new ComTreeNode[] { }; ComTypeInfo comTypeInfo = comPtr.TryGetComTypeInfo(); if (comTypeInfo == null) return new ComTreeNode[] { }; List<ComTreeNode> childNodes = new List<ComTreeNode>(); try { foreach (ComPropertyInfo comPropertyInfo in comTypeInfo.Properties) { // Special case. MailSession is a PITA property that causes modal dialog. if (comPropertyInfo.Name.Equals("MailSession")) { continue; } ComTreeNode comTreeNode = GetChild(comPtr, comPropertyInfo); if (comTreeNode != null) { if ((comTreeNode is ComPropertyTreeNode) && (_showProperties == false)) { continue; } childNodes.Add(comTreeNode); } } if (comPtr.TryIsCollection()) { int count = comPtr.TryGetItemCount(); try { ComFunctionInfo comFunctionInfo = comTypeInfo.Methods.Where(x => x.Name.Equals("Item", StringComparison.OrdinalIgnoreCase)).FirstOrDefault(); if (comFunctionInfo != null) { // Solid Edge is supposed to be 1 based index but some collections are 0 based. // Application->Customization->RibbonBarThemes seems to be 0 based. for (int i = 0; i <= count; i++) { object returnValue = null; if (MarshalEx.Succeeded(comPtr.TryInvokeMethod("Item", new object[] { i }, out returnValue))) { ComPtr pItem = returnValue as ComPtr; if ((pItem != null) && (pItem.IsInvalid == false)) { ComPtrItemTreeNode comPtrItemTreeNode = new ComPtrItemTreeNode((ComPtr)returnValue, comFunctionInfo); comPtrItemTreeNode.Caption = String.Format("{0}({1})", comFunctionInfo.Name, i); comPtrItemTreeNode.Nodes.Add("..."); childNodes.Add(comPtrItemTreeNode); } } } } } catch { GlobalExceptionHandler.HandleException(); } } if (_showMethods) { foreach (ComFunctionInfo comFunctionInfo in comTypeInfo.GetMethods(true)) { if (comFunctionInfo.IsRestricted) continue; ComMethodTreeNode comMethodTreeNode = new ComMethodTreeNode(comFunctionInfo); childNodes.Add(comMethodTreeNode); } } } catch { GlobalExceptionHandler.HandleException(); } return childNodes.ToArray(); }
static ScreenManager() { _screenManager = Xpcom.GetService2 <nsIScreenManager>(Contracts.ScreenManager); }
internal CertificateValidity( nsIX509CertValidity validity ) { _validity = new ComPtr<nsIX509CertValidity>( validity ); }
static CategoryManager() { _categoryManager = Xpcom.GetService2 <nsICategoryManager>(Contracts.CategoryManager); }
static ScreenManager() { _screenManager = Xpcom.GetService2<nsIScreenManager>(Contracts.ScreenManager); }
static IOService() { _service = Xpcom.GetService2 <nsIIOService2>(Contracts.NetworkIOService); }
static PrivateBrowsingService() { _privateBrowsingService = Xpcom.GetService2<nsIPrivateBrowsingService>(Contracts.PrivateBrowsing); }
/// <inheritdoc/> public override unsafe void OnUpdate(TimeSpan time) { if (this.isResizePending) { ApplyResize(); this.isResizePending = false; } // Generate the new frame GraphicsDevice.Default.ForEach(this.texture !, this.shaderFactory(time)); using ComPtr <ID3D12Resource> d3D12Resource = default; // Get the underlying ID3D12Resource pointer for the texture _ = InteropServices.TryGetID3D12Resource(this.texture !, Windows.__uuidof <ID3D12Resource>(), (void **)d3D12Resource.GetAddressOf()); // Get the target back buffer to update ID3D12Resource *d3D12ResourceBackBuffer = this.currentBufferIndex switch { 0 => this.d3D12Resource0.Get(), 1 => this.d3D12Resource1.Get(), _ => null }; this.currentBufferIndex ^= 1; // Reset the command list and command allocator this.d3D12CommandAllocator.Get()->Reset(); this.d3D12GraphicsCommandList.Get()->Reset(this.d3D12CommandAllocator.Get(), null); D3D12_RESOURCE_BARRIER *d3D12ResourceBarriers = stackalloc D3D12_RESOURCE_BARRIER[] { D3D12_RESOURCE_BARRIER.InitTransition( d3D12Resource.Get(), D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_COPY_SOURCE), D3D12_RESOURCE_BARRIER.InitTransition( d3D12ResourceBackBuffer, D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_COPY_DEST) }; // Transition the resources to COPY_DEST and COPY_SOURCE respectively d3D12GraphicsCommandList.Get()->ResourceBarrier(2, d3D12ResourceBarriers); // Copy the generated frame to the target back buffer d3D12GraphicsCommandList.Get()->CopyResource(d3D12ResourceBackBuffer, d3D12Resource.Get()); d3D12ResourceBarriers[0] = D3D12_RESOURCE_BARRIER.InitTransition( d3D12Resource.Get(), D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_UNORDERED_ACCESS); d3D12ResourceBarriers[1] = D3D12_RESOURCE_BARRIER.InitTransition( d3D12ResourceBackBuffer, D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_COMMON); // Transition the resources back to COMMON and UNORDERED_ACCESS respectively d3D12GraphicsCommandList.Get()->ResourceBarrier(2, d3D12ResourceBarriers); d3D12GraphicsCommandList.Get()->Close(); // Execute the command list to perform the copy this.d3D12CommandQueue.Get()->ExecuteCommandLists(1, (ID3D12CommandList **)d3D12GraphicsCommandList.GetAddressOf()); this.d3D12CommandQueue.Get()->Signal(this.d3D12Fence.Get(), this.nextD3D12FenceValue); // Present the new frame this.dxgiSwapChain1.Get()->Present(0, 0); if (this.nextD3D12FenceValue > this.d3D12Fence.Get()->GetCompletedValue()) { this.d3D12Fence.Get()->SetEventOnCompletion(this.nextD3D12FenceValue, default); } this.nextD3D12FenceValue++; } }
static CategoryManager() { _categoryManager = Xpcom.GetService2<nsICategoryManager>(Contracts.CategoryManager); }
/// <inheritdoc/> public override unsafe void OnInitialize(HWND hwnd) { // Get the underlying ID3D12Device in use fixed(ID3D12Device **d3D12Device = this.d3D12Device) { _ = InteropServices.TryGetID3D12Device(GraphicsDevice.Default, Windows.__uuidof <ID3D12Device>(), (void **)d3D12Device); } // Create the direct command queue to use fixed(ID3D12CommandQueue **d3D12CommandQueue = this.d3D12CommandQueue) { D3D12_COMMAND_QUEUE_DESC d3D12CommandQueueDesc; d3D12CommandQueueDesc.Type = D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_DIRECT; d3D12CommandQueueDesc.Priority = (int)D3D12_COMMAND_QUEUE_PRIORITY.D3D12_COMMAND_QUEUE_PRIORITY_NORMAL; d3D12CommandQueueDesc.Flags = D3D12_COMMAND_QUEUE_FLAGS.D3D12_COMMAND_QUEUE_FLAG_NONE; d3D12CommandQueueDesc.NodeMask = 0; _ = d3D12Device.Get()->CreateCommandQueue( &d3D12CommandQueueDesc, Windows.__uuidof <ID3D12CommandQueue>(), (void **)d3D12CommandQueue); } // Create the direct fence fixed(ID3D12Fence **d3D12Fence = this.d3D12Fence) { _ = this.d3D12Device.Get()->CreateFence( 0, D3D12_FENCE_FLAGS.D3D12_FENCE_FLAG_NONE, Windows.__uuidof <ID3D12Fence>(), (void **)d3D12Fence); } // Create the swap chain to display frames fixed(IDXGISwapChain1 **dxgiSwapChain1 = this.dxgiSwapChain1) { using ComPtr <IDXGIFactory2> dxgiFactory2 = default; _ = DirectX.CreateDXGIFactory2(DXGI.DXGI_CREATE_FACTORY_DEBUG, Windows.__uuidof <IDXGIFactory2>(), (void **)dxgiFactory2.GetAddressOf()); DXGI_SWAP_CHAIN_DESC1 dxgiSwapChainDesc1 = default; dxgiSwapChainDesc1.AlphaMode = DXGI_ALPHA_MODE.DXGI_ALPHA_MODE_IGNORE; dxgiSwapChainDesc1.BufferCount = 2; dxgiSwapChainDesc1.Flags = 0; dxgiSwapChainDesc1.Format = DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM; dxgiSwapChainDesc1.Width = 0; dxgiSwapChainDesc1.Height = 0; dxgiSwapChainDesc1.SampleDesc = new DXGI_SAMPLE_DESC(count: 1, quality: 0); dxgiSwapChainDesc1.Scaling = DXGI_SCALING.DXGI_SCALING_STRETCH; dxgiSwapChainDesc1.Stereo = 0; dxgiSwapChainDesc1.SwapEffect = DXGI_SWAP_EFFECT.DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; _ = dxgiFactory2.Get()->CreateSwapChainForHwnd( (IUnknown *)d3D12CommandQueue.Get(), hwnd, &dxgiSwapChainDesc1, null, null, dxgiSwapChain1); } // Create the command allocator to use fixed(ID3D12CommandAllocator **d3D12CommandAllocator = this.d3D12CommandAllocator) { this.d3D12Device.Get()->CreateCommandAllocator( D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_DIRECT, Windows.__uuidof <ID3D12CommandAllocator>(), (void **)d3D12CommandAllocator); } // Create the reusable command list to copy data to the back buffers fixed(ID3D12GraphicsCommandList **d3D12GraphicsCommandList = this.d3D12GraphicsCommandList) { this.d3D12Device.Get()->CreateCommandList( 0, D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_DIRECT, d3D12CommandAllocator, null, Windows.__uuidof <ID3D12GraphicsCommandList>(), (void **)d3D12GraphicsCommandList); } // Close the command list to prepare it for future use this.d3D12GraphicsCommandList.Get()->Close(); }
internal CacheDeviceInfo(nsICacheDeviceInfo cacheDeviceInfo) { _cacheDeviceInfo = new ComPtr<nsICacheDeviceInfo>(cacheDeviceInfo); }
protected override void CreateAssets() { _inputLayout = CreateInputLayout(); CreateBuffers(); base.CreateAssets(); ID3D11InputLayout *CreateInputLayout() { using ComPtr <ID3DBlob> vertexShaderBlob = null; using ComPtr <ID3DBlob> pixelShaderBlob = null; fixed(char *fileName = GetAssetFullPath(@"D3D11\Assets\Shaders\HelloTriangle.hlsl")) fixed(ID3D11VertexShader **vertexShader = &_vertexShader) fixed(ID3D11PixelShader **pixelShader = &_pixelShader) { var entryPoint = 0x00006E69614D5356; // VSMain var target = 0x0000305F345F7376; // vs_4_0 ThrowIfFailed(D3DCompileFromFile((ushort *)fileName, null, null, (sbyte *)&entryPoint, (sbyte *)&target, 0, 0, vertexShaderBlob.GetAddressOf(), null)); ThrowIfFailed(D3DDevice->CreateVertexShader(vertexShaderBlob.Get()->GetBufferPointer(), vertexShaderBlob.Get()->GetBufferSize(), pClassLinkage: null, vertexShader)); entryPoint = 0x00006E69614D5350; // PSMain target = 0x0000305F345F7370; // ps_4_0 ThrowIfFailed(D3DCompileFromFile((ushort *)fileName, null, null, (sbyte *)&entryPoint, (sbyte *)&target, 0, 0, pixelShaderBlob.GetAddressOf(), null)); ThrowIfFailed(D3DDevice->CreatePixelShader(pixelShaderBlob.Get()->GetBufferPointer(), pixelShaderBlob.Get()->GetBufferSize(), pClassLinkage: null, pixelShader)); } var inputElementDescs = stackalloc D3D11_INPUT_ELEMENT_DESC[2]; { var semanticName0 = stackalloc sbyte[9]; { ((ulong *)semanticName0)[0] = 0x4E4F495449534F50; // POSITION } inputElementDescs[0] = new D3D11_INPUT_ELEMENT_DESC { SemanticName = semanticName0, SemanticIndex = 0, Format = DXGI_FORMAT_R32G32B32_FLOAT, InputSlot = 0, AlignedByteOffset = 0, InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA, InstanceDataStepRate = 0 }; var semanticName1 = 0x000000524F4C4F43; // COLOR inputElementDescs[1] = new D3D11_INPUT_ELEMENT_DESC { SemanticName = (sbyte *)&semanticName1, SemanticIndex = 0, Format = DXGI_FORMAT_R32G32B32A32_FLOAT, InputSlot = 0, AlignedByteOffset = 12, InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA, InstanceDataStepRate = 0 }; } ID3D11InputLayout *inputLayout; ThrowIfFailed(D3DDevice->CreateInputLayout(inputElementDescs, NumElements: 2, vertexShaderBlob.Get()->GetBufferPointer(), vertexShaderBlob.Get()->GetBufferSize(), &inputLayout)); return(inputLayout); } }