static void InitWithContentRectStyleMaskBackingDefer(ref IntPtr nativePointer, Rectangle contentRect, WindowStyle windowStyle, SafeNativeMethods.BackingStoreType bufferingType, bool deferCreation) { nativePointer = ObjectiveC.LP64 ? objc_msgSend_initWithContentRect_styleMask_backing_defer_64( nativePointer, Selectors.InitWithContentRectStyleMaskBackingDefer, contentRect, (long)windowStyle, (long)bufferingType, deferCreation) : objc_msgSend_initWithContentRect_styleMask_backing_defer_32( nativePointer, Selectors.InitWithContentRectStyleMaskBackingDefer, contentRect, (int)windowStyle, (int)bufferingType, deferCreation); }
public unsafe static int MQReceiveMessageByLookupId(MessageQueueHandle handle, long lookupId, int action, MessagePropertyVariants.MQPROPS properties, NativeOverlapped* overlapped, SafeNativeMethods.ReceiveCallback receiveCallback, ITransaction transaction) { try { return IntMQReceiveMessageByLookupId(handle, lookupId, action, properties, overlapped, receiveCallback, transaction); } catch (EntryPointNotFoundException) { throw new PlatformNotSupportedException(Res.GetString(Res.PlatformNotSupported)); } }
static internal DbConnectionPoolIdentity GetCurrent() { // DEVNOTE: GetTokenInfo and EqualSID do not work on 9x. WindowsIdentity does not // work either on 9x. In fact, after checking with native there is no way // to validate the user on 9x, so simply don't. It is a known issue in // native, and we will handle this the same way. if (!ADP.s_isWindowsNT) { return(NoIdentity); } WindowsIdentity identity = GetCurrentWindowsIdentity(); IntPtr token = GetWindowsIdentityToken(identity); // Free'd by WindowsIdentity. uint bufferLength = 2048; // Suggested default given by Greg Fee. uint lengthNeeded = 0; IntPtr tokenStruct = IntPtr.Zero; IntPtr SID; IntPtr sidStringBuffer = IntPtr.Zero; bool isNetwork; // Win32NativeMethods.IsTokenRestricted will raise exception if the native call fails bool isRestricted = Win32NativeMethods.IsTokenRestrictedWrapper(token); DbConnectionPoolIdentity current = null; RuntimeHelpers.PrepareConstrainedRegions(); try { if (!UnsafeNativeMethods.CheckTokenMembership(token, NetworkSid, out isNetwork)) { // will always fail with 0x8007051D if token is not an impersonation token IntegratedSecurityError(Win32_CheckTokenMembership); } RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { // allocating memory and assigning to tokenStruct must happen tokenStruct = SafeNativeMethods.LocalAlloc(DbBuffer.LMEM_FIXED, (IntPtr)bufferLength); } if (IntPtr.Zero == tokenStruct) { throw new OutOfMemoryException(); } if (!UnsafeNativeMethods.GetTokenInformation(token, 1, tokenStruct, bufferLength, ref lengthNeeded)) { if (lengthNeeded > bufferLength) { bufferLength = lengthNeeded; RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { // freeing token struct and setting tokenstruct to null must happen together // allocating memory and assigning to tokenStruct must happen SafeNativeMethods.LocalFree(tokenStruct); tokenStruct = IntPtr.Zero; // protect against LocalAlloc throwing an exception tokenStruct = SafeNativeMethods.LocalAlloc(DbBuffer.LMEM_FIXED, (IntPtr)bufferLength); } if (IntPtr.Zero == tokenStruct) { throw new OutOfMemoryException(); } if (!UnsafeNativeMethods.GetTokenInformation(token, 1, tokenStruct, bufferLength, ref lengthNeeded)) { IntegratedSecurityError(Win32_GetTokenInformation_1); } } else { IntegratedSecurityError(Win32_GetTokenInformation_2); } } identity.Dispose(); // Keep identity variable alive until after GetTokenInformation calls. SID = Marshal.ReadIntPtr(tokenStruct, 0); if (!UnsafeNativeMethods.ConvertSidToStringSidW(SID, out sidStringBuffer)) { IntegratedSecurityError(Win32_ConvertSidToStringSidW); } if (IntPtr.Zero == sidStringBuffer) { throw ADP.InternalError(ADP.InternalErrorCode.ConvertSidToStringSidWReturnedNull); } string sidString = Marshal.PtrToStringUni(sidStringBuffer); var lastIdentity = _lastIdentity; if ((lastIdentity != null) && (lastIdentity._sidString == sidString) && (lastIdentity._isRestricted == isRestricted) && (lastIdentity._isNetwork == isNetwork)) { current = lastIdentity; } else { current = new DbConnectionPoolIdentity(sidString, isRestricted, isNetwork); } } finally { // Marshal.FreeHGlobal does not have a ReliabilityContract if (IntPtr.Zero != tokenStruct) { SafeNativeMethods.LocalFree(tokenStruct); tokenStruct = IntPtr.Zero; } if (IntPtr.Zero != sidStringBuffer) { SafeNativeMethods.LocalFree(sidStringBuffer); sidStringBuffer = IntPtr.Zero; } } _lastIdentity = current; return(current); }
public static void SetFileOutput(bool on) { int status = SafeNativeMethods.xnLogSetFileOutput(on); WrapperUtils.ThrowOnError(status); }
public static void SetMaskState(string maskName, bool on) { int status = SafeNativeMethods.xnLogSetMaskState(maskName, on); WrapperUtils.ThrowOnError(status); }
public static void InitFromXmlFile(string xmlFile) { int status = SafeNativeMethods.xnLogInitFromXmlFile(xmlFile); WrapperUtils.ThrowOnError(status); }
public virtual extern void GetOptions( out SafeNativeMethods.LIBRARYOPTIONFLAGS lofOptions);
internal static extern bool CreateProcessWithLogonW(string userName, string domain, IntPtr password, NativeMethods.LogonFlags logonFlags, [MarshalAs(UnmanagedType.LPTStr)] string appName, StringBuilder cmdLine, int creationFlags, IntPtr environmentBlock, [MarshalAs(UnmanagedType.LPTStr)] string lpCurrentDirectory, NativeMethods.STARTUPINFO lpStartupInfo, SafeNativeMethods.PROCESS_INFORMATION lpProcessInformation);
public static bool LogoffSession(int sessionId) { return(SafeNativeMethods.WTSLogoffSession(SafeNativeMethods.WTS_CURRENT_SERVER_HANDLE, sessionId, false)); }
public void StopGenerating() { int status = SafeNativeMethods.xnStopGenerating(this.InternalObject); WrapperUtils.ThrowOnError(status); }
public void WaitAndUpdateData() { int status = SafeNativeMethods.xnWaitAndUpdateData(this.InternalObject); WrapperUtils.ThrowOnError(status); }
private unsafe static extern int IntMQReceiveMessageByLookupId(MessageQueueHandle handle, long lookupId, int action, MessagePropertyVariants.MQPROPS properties, NativeOverlapped* overlapped, SafeNativeMethods.ReceiveCallback receiveCallback, ITransaction transaction);
public unsafe static extern int MQReceiveMessage(MessageQueueHandle handle, uint timeout, int action, MessagePropertyVariants.MQPROPS properties, NativeOverlapped* overlapped, SafeNativeMethods.ReceiveCallback receiveCallback, CursorHandle cursorHandle, ITransaction transaction);
private bool IsSelectable() { return(SafeNativeMethods.IsWindowEnabled(_hwnd) && SafeNativeMethods.IsWindowVisible(_hwnd)); }
public void SetViewpoint(ProductionNode other) { int status = SafeNativeMethods.xnSetViewPoint(this.InternalObject, other.InternalObject); WrapperUtils.ThrowOnError(status); }
public static bool DeleteProfile(SecurityIdentifier sid) { return(SafeNativeMethods.DeleteProfile(sid.ToString(), null, null)); }
public void ResetViewpoint() { int status = SafeNativeMethods.xnResetViewPoint(this.InternalObject); WrapperUtils.ThrowOnError(status); }
public static extern bool CreateProcess([MarshalAs(UnmanagedType.LPTStr)] string lpApplicationName, StringBuilder lpCommandLine, NativeMethods.SECURITY_ATTRIBUTES lpProcessAttributes, NativeMethods.SECURITY_ATTRIBUTES lpThreadAttributes, bool bInheritHandles, int dwCreationFlags, IntPtr lpEnvironment, [MarshalAs(UnmanagedType.LPTStr)] string lpCurrentDirectory, NativeMethods.STARTUPINFO lpStartupInfo, SafeNativeMethods.PROCESS_INFORMATION lpProcessInformation);
public bool IsViewpointAs(ProductionNode other) { return(SafeNativeMethods.xnIsViewPointAs(this.InternalObject, other.InternalObject)); }
private PaperSource PaperSourceFromMode(SafeNativeMethods.DEVMODE mode) { PaperSource[] sources = printerSettings.Get_PaperSources(); if ((mode.dmFields & SafeNativeMethods.DM_DEFAULTSOURCE) == SafeNativeMethods.DM_DEFAULTSOURCE) { for (int i = 0; i < sources.Length; i++) { // the dmDefaultSource == to the RawKind in the Papersource.. and Not the Kind... // if the PaperSource is populated with CUSTOM values... if (unchecked((short)sources[i].RawKind) == mode.dmDefaultSource) { return sources[i]; } } } return new PaperSource((PaperSourceKind) mode.dmDefaultSource, "unknown"); }
private static bool IsTabletOrMediaCenter() { return((SafeNativeMethods.GetSystemMetrics(SystemMetric.SM_TABLETPC) != 0) || (SafeNativeMethods.GetSystemMetrics(SystemMetric.SM_MEDIACENTER) != 0)); }
public static extern IPicture OleCreatePictureIndirect(SafeNativeMethods.PICTDESC pictdesc, [In]ref Guid refiid, bool fOwn);
public void QRSolveFactored(Complex[] q, Complex[] r, int rowsA, int columnsA, Complex[] tau, Complex[] b, int columnsB, Complex[] x, QRMethod method = QRMethod.Full) { if (r == null) { throw new ArgumentNullException(nameof(r)); } if (q == null) { throw new ArgumentNullException(nameof(q)); } if (b == null) { throw new ArgumentNullException(nameof(q)); } if (x == null) { throw new ArgumentNullException(nameof(q)); } int rowsQ, columnsQ, rowsR, columnsR; if (method == QRMethod.Full) { rowsQ = columnsQ = rowsR = rowsA; columnsR = columnsA; } else { rowsQ = rowsA; columnsQ = rowsR = columnsR = columnsA; } if (r.Length != rowsR * columnsR) { throw new ArgumentException($"The given array has the wrong length. Should be {rowsR * columnsR}.", nameof(r)); } if (q.Length != rowsQ * columnsQ) { throw new ArgumentException($"The given array has the wrong length. Should be {rowsQ * columnsQ}.", nameof(q)); } if (b.Length != rowsA * columnsB) { throw new ArgumentException($"The given array has the wrong length. Should be {rowsA * columnsB}.", nameof(b)); } if (x.Length != columnsA * columnsB) { throw new ArgumentException($"The given array has the wrong length. Should be {columnsA * columnsB}.", nameof(x)); } if (method == QRMethod.Full) { var info = SafeNativeMethods.z_qr_solve_factored(rowsA, columnsA, columnsB, r, b, tau, x); if (info == (int)MklError.MemoryAllocation) { throw new MemoryAllocationException(); } if (info < 0) { throw new InvalidParameterException(Math.Abs(info)); } } else { // we don't have access to the raw Q matrix any more(it is stored in R in the full QR), need to think about this. // let just call the managed version in the meantime. The heavy lifting has already been done. -marcus ManagedLinearAlgebraProvider.Instance.QRSolveFactored(q, r, rowsA, columnsA, tau, b, columnsB, x, QRMethod.Thin); } }
public static void Close() { int status = SafeNativeMethods.xnLogClose(); WrapperUtils.ThrowOnError(status); }
private static bool EqualConnectedState(SafeNativeMethods.InternetConnectionState expected) { SafeNativeMethods.InternetConnectionState state = 0; SafeNativeMethods.InternetGetConnectedState(ref state, 0); return (state & expected) != 0; }
public static void SetSeverityFilter(LogSeverity severity) { int status = SafeNativeMethods.xnLogSetSeverityFilter(severity); WrapperUtils.ThrowOnError(status); }
public async Task ApplyProxyConfAsync(ProxyConfiguration proxyConfiguration, IProgress <ProgressReport> progress) { ProgressReport prgReport = new ProgressReport { ProgressMessage = "Applying Proxy Configuration", ProgressValue = 0 }; progress.Report(prgReport); await Task.Run(async() => { _registry = Registry.CurrentUser.OpenSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", true); prgReport.ProgressMessage = "Applying Proxy IP address and port"; prgReport.ProgressValue = ((1 * 100 / 5)); progress.Report(prgReport); await Task.Delay(1000); _registry.SetValue("ProxyServer", string.Format("{0}:{1}", proxyConfiguration.ProxyAddress, proxyConfiguration.ProxyPort.ToString())); prgReport.ProgressMessage = "Clearing Advanced settings"; prgReport.ProgressValue = ((2 * 100 / 5)); progress.Report(prgReport); await Task.Delay(1000); _registry.SetValue("ProxyOverride", string.Empty); string proxyExceptions = proxyConfiguration.ProxyExceptions == null ? string.Empty : proxyConfiguration.ProxyExceptions; if (proxyConfiguration.UseProxyForLocalAddresses) { if (string.IsNullOrEmpty(proxyExceptions)) { proxyExceptions += "<local>"; } else { proxyExceptions += ";<local>"; } } prgReport.ProgressMessage = "Applying configuration advanced settings"; prgReport.ProgressValue = ((3 * 100 / 5)); progress.Report(prgReport); await Task.Delay(1000); _registry.SetValue("ProxyOverride", proxyExceptions); prgReport.ProgressMessage = "Enabling Proxy Server"; prgReport.ProgressValue = ((4 * 100 / 5)); progress.Report(prgReport); await Task.Delay(1000); _registry.SetValue("ProxyEnable", 1); _registry.Close(); _registry.Dispose(); await Task.Delay(1000); await Task.Run(() => { settingsReturn = SafeNativeMethods.InternetSetOption(IntPtr.Zero, INTERNET_OPTION_SETTINGS_CHANGED, IntPtr.Zero, 0); refreshReturn = SafeNativeMethods.InternetSetOption(IntPtr.Zero, INTERNET_OPTION_REFRESH, IntPtr.Zero, 0); }); prgReport.ProgressMessage = "Proxy Configuration Applied"; prgReport.ProgressValue = ((5 * 100 / 5)); progress.Report(prgReport); }); }
public static void SetOutputFolder(string folder) { int status = SafeNativeMethods.xnLogSetOutputFolder(folder); WrapperUtils.ThrowOnError(status); }
public static BitmapSource GetIcon(string path, int size = 16, bool thumbnail = false, bool cache = false) { // Create a native shellitem from our path int retCode = SafeNativeMethods.SHCreateItemFromParsingNameIShellItemImageFactory(path, IntPtr.Zero, typeof(SafeNativeMethods.IShellItemImageFactory).GUID, out SafeNativeMethods.IShellItemImageFactory imageFactory); if (retCode != 0 || imageFactory == null) { //return new BitmapImage(new Uri("pack://application:,,,/SizeOnDisk;component/Icons/File.png")); return(null); } //throw new ExternalException("ShellObjectFactoryUnableToCreateItem", Marshal.GetExceptionForHR(retCode)); Size nativeSIZE = new Size( Convert.ToInt32(size), Convert.ToInt32(size) ); SIIGBF options = SIIGBF.ResizeToFit; if (!thumbnail) { options = SIIGBF.IconOnly; } if (cache) { options |= SIIGBF.MemoryOnly; } IntPtr hBitmap = IntPtr.Zero; try { imageFactory.GetImage(nativeSIZE, options, out hBitmap); } finally { Marshal.ReleaseComObject(imageFactory); } if (hBitmap == IntPtr.Zero) { return(null); } try { // return a System.Media.Imaging.BitmapSource // Use interop to create a BitmapSource from hBitmap. BitmapSource returnValue = Imaging.CreateBitmapSourceFromHBitmap( hBitmap, IntPtr.Zero, System.Windows.Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions()); returnValue.Freeze(); return(returnValue); } finally { // delete HBitmap to avoid memory leaks SafeNativeMethods.DeleteObject(hBitmap); } }
// ------------------------------------------------------ // // Private Methods // // ------------------------------------------------------ #region Private Methods private void Invoke() { // Check that button can be clicked // This state could change anytime if (!SafeNativeMethods.IsWindowEnabled(_hwnd)) { throw new ElementNotEnabledException(); } // Moved this outside the if block because it's needed for WinForms, which uses _acc.DoDefaultAction() if (!IsShowAllProgramsButton()) { // SetFocus is needed here to workaround a bug Misc.SetFocus(_hwnd); } if (_acc == null) { switch (_style) { case NativeMethods.BS_PUSHBUTTON: case NativeMethods.BS_DEFPUSHBUTTON: case NativeMethods.BS_PUSHBOX: case NativeMethods.BS_OWNERDRAW: case NativeMethods.BS_USERBUTTON: case NativeMethods.BS_CHECKBOX: case NativeMethods.BS_AUTOCHECKBOX: case NativeMethods.BS_RADIOBUTTON: case NativeMethods.BS_AUTORADIOBUTTON: case NativeMethods.BS_3STATE: case NativeMethods.BS_AUTO3STATE: case NativeMethods.BS_SPLITBUTTON: // explore back and forward buttons if (IsStartButton()) { // You can't just click the start button; it won't do // anything if the tray isn't active except take focus Misc.PostMessage(_hwnd, NativeMethods.WM_SYSCOMMAND, new IntPtr(NativeMethods.SC_TASKLIST), IntPtr.Zero); break; } if (_type == ButtonType.PushButton && !IsStartButton()) { // For the Invoke event to work, there needs to be time between the OBJ_STATECHANGE // for pushing the button and the OBJ_STATECHANGE for releasing the button. // For buttons the OBJ_STATECHANGE is caused by the BM_SETSTATE message. // The BM_CLICK causes these BM_SETSTATE's to happen to fast, the OBJ_STATECHANGES // are received simultaneous. This does not give enough time to check the button pushed // state in the event handler, cause the state to be missed and the Invoke event not // being raised. Send an extra BM_SETSTATE to allow the event handler to be able to // see the state change and raise the Invoke event. Misc.ProxySendMessage(_hwnd, NativeMethods.BM_SETSTATE, new IntPtr(1), IntPtr.Zero, true); System.Threading.Thread.Sleep(1); } try { // Now cause the button click. Misc.ProxySendMessage(_hwnd, NativeMethods.BM_CLICK, IntPtr.Zero, IntPtr.Zero, true); } catch (ElementNotAvailableException) { // There is a timing issue with the SendMessage and // the Cancel button on the Log Off Dialog box. The button with be invoked but sometimes // the SendMessage will return a failure that will cause the ElementNotAvailableException // to be thrown. return; } break; } } else { _acc.DoDefaultAction(); } }
private static ShellCommandVerb GetVerb(RegistryKey verbkey, string id, string appUserModeId) { if (id.ToUpperInvariant() == "RUNAS") { return(null); } //We are not taking DDE RegistryKey cmd = verbkey.OpenSubKey("ddeexec"); if (cmd != null && !string.IsNullOrEmpty(cmd.GetValue(string.Empty, string.Empty).ToString())) { return(null); } ShellCommandVerb verb = new ShellCommandVerb { Verb = id, Name = id }; string name = verbkey.GetValue("MUIVerb", string.Empty).ToString(); if (string.IsNullOrEmpty(name)) { name = verbkey.GetValue(string.Empty, string.Empty).ToString(); } if (name.StartsWith("@", StringComparison.Ordinal)) { StringBuilder outBuff = new StringBuilder(1024); if (SafeNativeMethods.SHLoadIndirectString(name, outBuff, outBuff.Capacity, IntPtr.Zero) == 0) { verb.Name = outBuff.ToString(); } } else { string locname = LocExtension.GetLocalizedValue <string>($"PresentationCore:ExceptionStringTable:{id}Text"); if (string.IsNullOrEmpty(locname)) { locname = LocExtension.GetLocalizedValue <string>(id); } if (!string.IsNullOrEmpty(locname)) { verb.Name = locname; } else if (!string.IsNullOrEmpty(name)) { verb.Name = name; } } if (id.ToUpperInvariant() == "RUNASUSER") { verb.Command = "cmd:runasuser"; return(verb); } cmd = verbkey.OpenSubKey("command"); if (cmd != null) { verb.Command = cmd.GetValue(string.Empty, string.Empty).ToString(); if (string.IsNullOrEmpty(verb.Command)) { name = cmd.GetValue("DelegateExecute", string.Empty).ToString(); if (!string.IsNullOrEmpty(name)) { cmd = Registry.ClassesRoot.OpenSubKey("CLSID\\" + name); if (cmd != null) { cmd = cmd.OpenSubKey("LocalServer32"); if (cmd != null) { name = cmd.GetValue(string.Empty, string.Empty).ToString(); if (!string.IsNullOrEmpty(name)) { verb.Command = name; } } if (string.IsNullOrEmpty(name)) { cmd = cmd.OpenSubKey("InProcServer32"); if (cmd != null) { name = cmd.GetValue(string.Empty, string.Empty).ToString(); if (!string.IsNullOrEmpty(name)) { verb.Command = "dll:" + name; } } } } } } } if (string.IsNullOrEmpty(verb.Command)) { if (!string.IsNullOrEmpty(appUserModeId)) { verb.Command = "Id:" + appUserModeId; } } if (string.IsNullOrEmpty(verb.Command)) { } return(verb); }
public int Compare(T x, T y) { return(SafeNativeMethods.StrCmpLogicalW(KeySelector(x), KeySelector(y))); }
protected override bool ReleaseHandle() { return(SafeNativeMethods.FindClose(base.handle)); }
public static bool CloseHandle(IntPtr handle) { return(SafeNativeMethods.CloseHandle(handle)); }
public void Sit(PhysicsActor actor, Vector3 avPos, Vector3 avCameraPosition, Vector3 offset, Vector3 avOffset, SitAvatarCallback PhysicsSitResponse) { if (!m_scene.haveActor(actor) || !(actor is OdePrim) || ((OdePrim)actor).prim_geom == IntPtr.Zero) { PhysicsSitResponse(-1, actor.LocalID, offset, Quaternion.Identity); return; } IntPtr geom = ((OdePrim)actor).prim_geom; Vector3 geopos = SafeNativeMethods.GeomGetPositionOMV(geom); Quaternion geomOri = SafeNativeMethods.GeomGetQuaternionOMV(geom); // Vector3 geopos = actor.Position; // Quaternion geomOri = actor.Orientation; Quaternion geomInvOri = Quaternion.Conjugate(geomOri); Quaternion ori = Quaternion.Identity; Vector3 rayDir = geopos + offset - avCameraPosition; float raylen = rayDir.Length(); if (raylen < 0.001f) { PhysicsSitResponse(-1, actor.LocalID, offset, Quaternion.Identity); return; } float t = 1 / raylen; rayDir.X *= t; rayDir.Y *= t; rayDir.Z *= t; raylen += 30f; // focal point may be far List <ContactResult> rayResults; rayResults = m_scene.RaycastActor(actor, avCameraPosition, rayDir, raylen, 1, RaySitFlags); if (rayResults.Count == 0) { /* if this fundamental ray failed, then just fail so user can try another spot and not be sitted far on a big prim * d.AABB aabb; * d.GeomGetAABB(geom, out aabb); * offset = new Vector3(avOffset.X, 0, aabb.MaxZ + avOffset.Z - geopos.Z); * ori = geomInvOri; * offset *= geomInvOri; * PhysicsSitResponse(1, actor.LocalID, offset, ori); */ PhysicsSitResponse(0, actor.LocalID, offset, ori); return; } int status = 1; offset = rayResults[0].Pos - geopos; SafeNativeMethods.GeomClassID geoclass = SafeNativeMethods.GeomGetClass(geom); if (geoclass == SafeNativeMethods.GeomClassID.SphereClass) { float r = SafeNativeMethods.GeomSphereGetRadius(geom); offset.Normalize(); offset *= r; RotAroundZ(offset.X, offset.Y, ref ori); if (r < 0.4f) { offset = new Vector3(0, 0, r); } else { if (offset.Z < 0.4f) { t = offset.Z; float rsq = r * r; t = 1.0f / (rsq - t * t); offset.X *= t; offset.Y *= t; offset.Z = 0.4f; t = rsq - 0.16f; offset.X *= t; offset.Y *= t; } else if (r > 0.8f && offset.Z > 0.8f * r) { status = 3; avOffset.X = -avOffset.X; avOffset.Z *= 1.6f; } } offset += avOffset * ori; ori = geomInvOri * ori; offset *= geomInvOri; PhysicsSitResponse(status, actor.LocalID, offset, ori); return; } Vector3 norm = rayResults[0].Normal; if (norm.Z < -0.4f) { PhysicsSitResponse(0, actor.LocalID, offset, Quaternion.Identity); return; } float SitNormX = -rayDir.X; float SitNormY = -rayDir.Y; Vector3 pivot = geopos + offset; float edgeNormalX = norm.X; float edgeNormalY = norm.Y; float edgeDirX = -rayDir.X; float edgeDirY = -rayDir.Y; Vector3 edgePos = rayResults[0].Pos; float edgeDist = float.MaxValue; bool foundEdge = false; if (norm.Z < 0.5f) { float rayDist = 4.0f; for (int i = 0; i < 6; i++) { pivot.X -= 0.01f * norm.X; pivot.Y -= 0.01f * norm.Y; pivot.Z -= 0.01f * norm.Z; rayDir.X = -norm.X * norm.Z; rayDir.Y = -norm.Y * norm.Z; rayDir.Z = 1.0f - norm.Z * norm.Z; rayDir.Normalize(); rayResults = m_scene.RaycastActor(actor, pivot, rayDir, rayDist, 1, RayFilterFlags.AllPrims); if (rayResults.Count == 0) { break; } if (Math.Abs(rayResults[0].Normal.Z) < 0.7f) { rayDist -= rayResults[0].Depth; if (rayDist < 0f) { break; } pivot = rayResults[0].Pos; norm = rayResults[0].Normal; edgeNormalX = norm.X; edgeNormalY = norm.Y; edgeDirX = -rayDir.X; edgeDirY = -rayDir.Y; } else { foundEdge = true; edgePos = rayResults[0].Pos; break; } } if (!foundEdge) { PhysicsSitResponse(0, actor.LocalID, offset, ori); return; } avOffset.X *= 0.5f; } else if (norm.Z > 0.866f) { float toCamBaseX = avCameraPosition.X - pivot.X; float toCamBaseY = avCameraPosition.Y - pivot.Y; float toCamX = toCamBaseX; float toCamY = toCamBaseY; for (int j = 0; j < 4; j++) { float rayDist = 1.0f; float curEdgeDist = 0.0f; for (int i = 0; i < 3; i++) { pivot.Z -= 0.01f; rayDir.X = toCamX; rayDir.Y = toCamY; rayDir.Z = (-toCamX * norm.X - toCamY * norm.Y) / norm.Z; rayDir.Normalize(); rayResults = m_scene.RaycastActor(actor, pivot, rayDir, rayDist, 1, RayFilterFlags.AllPrims); if (rayResults.Count == 0) { break; } curEdgeDist += rayResults[0].Depth; if (rayResults[0].Normal.Z > 0.5f) { rayDist -= rayResults[0].Depth; if (rayDist < 0f) { break; } pivot = rayResults[0].Pos; norm = rayResults[0].Normal; } else { foundEdge = true; if (curEdgeDist < edgeDist) { edgeDist = curEdgeDist; edgeNormalX = rayResults[0].Normal.X; edgeNormalY = rayResults[0].Normal.Y; edgeDirX = rayDir.X; edgeDirY = rayDir.Y; edgePos = rayResults[0].Pos; } break; } } if (foundEdge && edgeDist < 0.2f) { break; } pivot = geopos + offset; switch (j) { case 0: toCamX = -toCamBaseY; toCamY = toCamBaseX; break; case 1: toCamX = toCamBaseY; toCamY = -toCamBaseX; break; case 2: toCamX = -toCamBaseX; toCamY = -toCamBaseY; break; default: break; } } if (!foundEdge) { avOffset.X = -avOffset.X; avOffset.Z *= 1.6f; RotAroundZ(SitNormX, SitNormY, ref ori); offset += avOffset * ori; ori = geomInvOri * ori; offset *= geomInvOri; PhysicsSitResponse(3, actor.LocalID, offset, ori); return; } avOffset.X *= 0.5f; } SitNormX = edgeNormalX; SitNormY = edgeNormalY; if (edgeDirX * SitNormX + edgeDirY * SitNormY < 0) { SitNormX = -SitNormX; SitNormY = -SitNormY; } RotAroundZ(SitNormX, SitNormY, ref ori); offset = edgePos + avOffset * ori; offset -= geopos; ori = geomInvOri * ori; offset *= geomInvOri; PhysicsSitResponse(1, actor.LocalID, offset, ori); return; }
public override bool EditComponent(ITypeDescriptorContext context, object obj, IWin32Window parent) { IntPtr handle = (parent == null ? IntPtr.Zero : parent.Handle); // try to get the page guid if (obj is NativeMethods.IPerPropertyBrowsing) { // check for a property page Guid guid = Guid.Empty; int hr = ((NativeMethods.IPerPropertyBrowsing)obj).MapPropertyToPage(NativeMethods.MEMBERID_NIL, out guid); if (hr == NativeMethods.S_OK) { if (!guid.Equals(Guid.Empty)) { object o = obj; SafeNativeMethods.OleCreatePropertyFrame(new HandleRef(parent, handle), 0, 0, "PropertyPages", 1, ref o, 1, new Guid[] { guid }, Application.CurrentCulture.LCID, 0, IntPtr.Zero); return(true); } } } if (obj is NativeMethods.ISpecifyPropertyPages) { try { NativeMethods.tagCAUUID uuids = new NativeMethods.tagCAUUID(); try { ((NativeMethods.ISpecifyPropertyPages)obj).GetPages(uuids); if (uuids.cElems <= 0) { return(false); } } catch (Exception) { return(false); } try { object o = obj; SafeNativeMethods.OleCreatePropertyFrame(new HandleRef(parent, handle), 0, 0, "PropertyPages", 1, ref o, uuids.cElems, new HandleRef(uuids, uuids.pElems), Application.CurrentCulture.LCID, 0, IntPtr.Zero); return(true); } finally { if (uuids.pElems != IntPtr.Zero) { Marshal.FreeCoTaskMem(uuids.pElems); } } } catch (Exception ex1) { IUIService uiSvc = null; if (context != null) { uiSvc = (IUIService)context.GetService(typeof(IUIService)); } String errString = SR.GetString(SR.ErrorPropertyPageFailed); if (uiSvc != null) { uiSvc.ShowError(ex1, errString); } else { MessageBox.Show(errString, "PropertyGrid"); } } } return(false); }
/// <summary> /// ini寫值 /// </summary> /// <param name="Section">集合</param> /// <param name="Key">索引</param> /// <param name="Value">值</param> /// <param name="inipath">ini路徑</param> public void IniWriteValue(string Section, string Key, string Value, string inipath) { SafeNativeMethods.WritePrivateProfileString(Section, Key, Value, Path.Combine(App.Root, inipath)); }
public static extern bool CreateProcessAsUser(SafeHandle hToken, string lpApplicationName, string lpCommandLine, NativeMethods.SECURITY_ATTRIBUTES lpProcessAttributes, NativeMethods.SECURITY_ATTRIBUTES lpThreadAttributes, bool bInheritHandles, int dwCreationFlags, HandleRef lpEnvironment, string lpCurrentDirectory, NativeMethods.STARTUPINFO lpStartupInfo, SafeNativeMethods.PROCESS_INFORMATION lpProcessInformation);
private static unsafe void GetRegionScans(IntPtr hRgn, out Rectangle[] scans) { uint bytes = 0; int countdown = 100; int error = 0; // HACK: It seems that sometimes the GetRegionData will return ERROR_INVALID_HANDLE // even though the handle (the HRGN) is fine. Maybe the function is not // re-entrant? I'm not sure, but trying it again seems to fix it. while (countdown > 0) { bytes = SafeNativeMethods.GetRegionData(hRgn, 0, (NativeStructs.RGNDATA *)IntPtr.Zero); error = Marshal.GetLastWin32Error(); if (bytes == 0) { --countdown; System.Threading.Thread.Sleep(5); } else { break; } } // But if we retry several times and it still messes up then we will finally give up. if (bytes == 0) { throw new Win32Exception(error, "GetRegionData returned " + bytes.ToString(CultureInfo.CurrentCulture) + ", GetLastError() = " + error.ToString(CultureInfo.CurrentCulture)); } byte *data; // Up to 512 bytes, allocate on the stack. Otherwise allocate from the heap. if (bytes <= 512) { byte *data1 = stackalloc byte[(int)bytes]; data = data1; } else { data = (byte *)Memory.Allocate(bytes, false).ToPointer(); } try { NativeStructs.RGNDATA *pRgnData = (NativeStructs.RGNDATA *)data; uint result = SafeNativeMethods.GetRegionData(hRgn, bytes, pRgnData); if (result != bytes) { throw new OutOfMemoryException("SafeNativeMethods.GetRegionData returned 0"); } NativeStructs.RECT *pRects = NativeStructs.RGNDATA.GetRectsPointer(pRgnData); scans = new Rectangle[pRgnData->rdh.nCount]; for (int i = 0; i < scans.Length; ++i) { scans[i] = Rectangle.FromLTRB(pRects[i].left, pRects[i].top, pRects[i].right, pRects[i].bottom); } pRects = null; pRgnData = null; } finally { if (bytes > 512) { Memory.Free(new IntPtr(data)); } } }
private PaperSize PaperSizeFromMode(SafeNativeMethods.DEVMODE mode) { PaperSize[] sizes = printerSettings.Get_PaperSizes(); if ((mode.dmFields & SafeNativeMethods.DM_PAPERSIZE) == SafeNativeMethods.DM_PAPERSIZE) { for (int i = 0; i < sizes.Length; i++) { if ((int)sizes[i].RawKind == mode.dmPaperSize) return sizes[i]; } } return new PaperSize(PaperKind.Custom, "custom", //mode.dmPaperWidth, mode.dmPaperLength); PrinterUnitConvert.Convert(mode.dmPaperWidth, PrinterUnit.TenthsOfAMillimeter, PrinterUnit.Display), PrinterUnitConvert.Convert(mode.dmPaperLength, PrinterUnit.TenthsOfAMillimeter, PrinterUnit.Display)); }
public int Compare(string a, string b) { return(SafeNativeMethods.StrCmpLogicalW(a, b)); }
private PrinterResolution PrinterResolutionFromMode(SafeNativeMethods.DEVMODE mode) { PrinterResolution[] resolutions = printerSettings.Get_PrinterResolutions(); for (int i = 0; i < resolutions.Length; i++) { if (mode.dmPrintQuality >= 0 && ((mode.dmFields & SafeNativeMethods.DM_PRINTQUALITY) == SafeNativeMethods.DM_PRINTQUALITY) && ((mode.dmFields & SafeNativeMethods.DM_YRESOLUTION) == SafeNativeMethods.DM_YRESOLUTION)) { if (resolutions[i].X == unchecked((int)(PrinterResolutionKind) mode.dmPrintQuality) && resolutions[i].Y == unchecked((int)(PrinterResolutionKind) mode.dmYResolution)) return resolutions[i]; } else { if ((mode.dmFields & SafeNativeMethods.DM_PRINTQUALITY) == SafeNativeMethods.DM_PRINTQUALITY) { if (resolutions[i].Kind == (PrinterResolutionKind) mode.dmPrintQuality) return resolutions[i]; } } } return new PrinterResolution(PrinterResolutionKind.Custom, mode.dmPrintQuality, mode.dmYResolution); }
public static void Init() { int status = SafeNativeMethods.xnLogInitSystem(); WrapperUtils.ThrowOnError(status); }
private static void ImportPathElement(IntPtr info, ref SafeNativeMethods.CGPathElement element) { var handle = GCHandle.FromIntPtr(info); var @this = handle.Target as PathData; int pointCount; @this.commandList.Add(element.type); switch ((int)element.type) { case (int)PathCommand.MoveTo: case (int)PathCommand.LineTo: pointCount = 1; break; case (int)PathCommand.QuaddraticCurveTo: pointCount = 2; break; case (int)PathCommand.CubicCurveTo: pointCount = 3; break; default: return; } if (ObjectiveC.LP64) @this.AppendPointList(element.points, pointCount); else @this.ApendPointFList(element.points, pointCount); }
public static int GetObject(HandleRef hObject, SafeNativeMethods.LOGFONT lp) { return GetObject(hObject, System.Runtime.InteropServices.Marshal.SizeOf(typeof(SafeNativeMethods.LOGFONT)), lp); }