private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam) { if (nCode >= 0) if (wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_KEYDOWN || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_KEYUP || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_SYSKEYDOWN || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_SYSKEYUP) _hookedKeyboardCallbackAsync.BeginInvoke((InterceptKeys.KeyEvent)wParam.ToUInt32(), Marshal.ReadInt32(lParam), null, null); return InterceptKeys.CallNextHookEx(_hookId, nCode, wParam, lParam); }
/// <summary> /// Decompresses data with <paramref name="size"/> at <paramref name="offset"/> in <paramref name="buffer"/> /// </summary> /// <param name="buffer">The compressed data buffer</param> /// <param name="offset">The offset of the compressed data</param> /// <param name="size">The size of the compressed data</param> /// <param name="uncompressedSize">Uncompressed size of <paramref name="buffer"/></param> /// <returns>The uncompressed buffer</returns> /// <remarks>If you do not know the uncompressed size then it is recommended to use <see cref="ZstdStream"/></remarks> public static byte[] Decompress(byte[] buffer, int offset, int size, int uncompressedSize) { ValidateDecompressionArguments(buffer.Length, offset, size, uncompressedSize); // Allocate uncompressed buffer byte[] uncompressedBuffer = new byte[uncompressedSize]; Size uncompressedBufferSize = Size.Zero; unsafe { fixed(byte *uncompressedBufferPtr = uncompressedBuffer) fixed(byte *compressedBufferPtr = buffer) { uncompressedBufferSize = Native.ZSTD_decompress( (IntPtr)uncompressedBufferPtr, (Size)uncompressedSize, (IntPtr)(compressedBufferPtr + offset), (Size)size); } } // Check for errors ThrowOnError(uncompressedBufferSize); // Check for possiblity that user passed in higher than required uncompressed size if (uncompressedSize != uncompressedBufferSize.ToUInt32()) { Array.Resize(ref uncompressedBuffer, (int)uncompressedBufferSize); } return(uncompressedBuffer); }
public static UIntPtr KeyboardHook(int nCode, UIntPtr wParam, IntPtr lParam) { try { if (nCode == 0) { var wm = (WinAPI.WM)wParam.ToUInt32(); Mubox.WinAPI.WindowHook.KBDLLHOOKSTRUCT keyboardHookStruct = (Mubox.WinAPI.WindowHook.KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(Mubox.WinAPI.WindowHook.KBDLLHOOKSTRUCT)); if (OnKeyboardInputReceived(wm, keyboardHookStruct)) { return new UIntPtr(1); } } } catch (Exception ex) { ex.Log(); } try { return Mubox.WinAPI.WindowHook.CallNextHookEx(hHook, nCode, wParam, lParam); } catch (Exception ex) { ex.Log(); } return new UIntPtr(1); }
/// <include file='ManagedHooks.xml' path='Docs/KeyboardHook/HookCallback/*'/> protected override void HookCallback(int code, UIntPtr wparam, IntPtr lparam) { if (KeyboardEvent == null) { return; } int vkCode = 0; KeyboardEvents kEvent = (KeyboardEvents)wparam.ToUInt32(); if (kEvent != KeyboardEvents.KeyDown && kEvent != KeyboardEvents.KeyUp && kEvent != KeyboardEvents.SystemKeyDown && kEvent != KeyboardEvents.SystemKeyUp) { return; } GetKeyboardReading(wparam, lparam, ref vkCode); VirtualKeys vk = (VirtualKeys)vkCode; System.Windows.Forms.Keys key = ConvertKeyCode(vk); if (key == System.Windows.Forms.Keys.Attn) { return; } KeyboardEvent(kEvent, key); }
public static StatusMode ToStatus(UIntPtr wParam) { if (!Enum.IsDefined(StatusEnumType, (int)wParam.ToUInt32())) throw new ArgumentException("wParam", TextResources.ExceptionMsg_InvalidValueToTranslate); return (StatusMode)(wParam); }
/// <summary> /// Compresses data in <paramref name="memory"/> starting at <paramref name="offset"/> with <paramref name="size"/> /// using the specified <paramref name="compressionLevel"/> /// </summary> /// <param name="memory">The buffer to compress</param> /// <param name="offset">The offset at which the data to compress starts</param> /// <param name="size">The size of the data to compress</param> /// <param name="compressionLevel">The compression level to use</param> /// <returns>The compressed buffer wrapped in <see cref="Memory{Byte}"/></returns> public static Memory <byte> Compress(ReadOnlyMemory <byte> memory, int offset, int size, int compressionLevel = Native.ZSTD_CLEVEL_DEFAULT) { ValidateCompressionArguments(memory.Length, offset, size, compressionLevel); // Allocate compressed buffer Size compressionBound = Native.ZSTD_compressBound(new Size((uint)size)); byte[] compressedBuffer = new byte[compressionBound.ToUInt32()]; // Get handles to buffers using MemoryHandle compressedBufferHandle = compressedBuffer.AsMemory().Pin(); using MemoryHandle uncompressedBufferHandle = memory.Pin(); unsafe { // Get raw pointers from handles IntPtr compressedBufferPointer = new IntPtr(compressedBufferHandle.Pointer); IntPtr uncompressedBufferPointer = new IntPtr(uncompressedBufferHandle.Pointer); Size compressedBufferSize = Native.ZSTD_compress( compressedBufferPointer, compressionBound, uncompressedBufferPointer + offset, (Size)size, compressionLevel); // Check for errors ThrowOnError(compressedBufferSize); return(compressedBuffer.AsMemory(0, (int)compressedBufferSize.ToUInt32())); } }
private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam) { bool continues = true; if (nCode >= 0) { if (wParam.ToUInt32() == (int)KeyEvent.WM_KEYDOWN || wParam.ToUInt32() == (int)KeyEvent.WM_KEYUP || wParam.ToUInt32() == (int)KeyEvent.WM_SYSKEYDOWN || wParam.ToUInt32() == (int)KeyEvent.WM_SYSKEYUP) { if (hookedKeyboardCallback != null) continues = hookedKeyboardCallback((KeyEvent)wParam.ToUInt32(), Marshal.ReadInt32(lParam), CheckModifiers()); } } if (continues) { return InterceptKeys.CallNextHookEx(hookId, nCode, wParam, lParam); } return (IntPtr)1; }
/// <summary> /// Compresses data in <paramref name="buffer"/> starting at <paramref name="offset"/> with <paramref name="size"/> /// using the specified <paramref name="compressionLevel"/> and parameters set on this <see cref="ZstdCompressionContext"/> /// </summary> /// <param name="buffer">The buffer to compress</param> /// <param name="offset">The offset at which the data to compress starts</param> /// <param name="size">The size of the data to compress</param> /// <param name="compressionLevel">The compression level to use</param> /// <returns>The compressed buffer</returns> /// <remarks> /// This method will usually cause a double heap allocation of the compressed buffer, /// it is recommended to use <see cref="Compress(ReadOnlyMemory{byte}, int, int, int)"/> if you want to avoid this /// </remarks> public byte[] Compress(byte[] buffer, int offset, int size, int compressionLevel = Native.ZSTD_CLEVEL_DEFAULT) { if (buffer == null) { throw new ArgumentNullException(nameof(buffer), $"{nameof(buffer)} cannot be null"); } Zstd.ValidateCompressionArguments(buffer.Length, offset, size, compressionLevel); // Allocate compressed buffer Size compressionBound = Native.ZSTD_compressBound(new Size((uint)size)); byte[] compressedBuffer = new byte[compressionBound.ToUInt32()]; Size compressedBufferSize = Size.Zero; unsafe { fixed(byte *compressedBufferPointer = compressedBuffer) fixed(byte *uncompressedBufferPointer = buffer) { if (this.Dictionary == null) { compressedBufferSize = Native.ZSTD_compress2( this._context, (IntPtr)compressedBufferPointer, compressionBound, (IntPtr)(uncompressedBufferPointer + offset), (Size)size); } else { compressedBufferSize = Native.ZSTD_compress_usingCDict( this._context, (IntPtr)compressedBufferPointer, compressionBound, (IntPtr)(uncompressedBufferPointer + offset), (Size)size, this.Dictionary.GetCompressionDictionary(compressionLevel)); } } } // Check for errors Zstd.ThrowOnError(compressedBufferSize); // If compressionBound is same as the amount of compressed bytes then we can return the same array // otherwise we need to allocate a new one :/ if (compressionBound != compressedBufferSize) { Array.Resize(ref compressedBuffer, (int)compressedBufferSize); } return(compressedBuffer); }
internal static void InternalOnDataReceived( IntPtr room, IntPtr participant, IntPtr data, UIntPtr dataLength, bool isReliable, IntPtr userData) { GooglePlayGames.OurUtils.Logger.d("Entering InternalOnDataReceived: " + userData.ToInt64()); var callback = Callbacks.IntPtrToPermanentCallback <Action<NativeRealTimeRoom, MultiplayerParticipant, byte[], bool>>(userData); using (var nativeRoom = NativeRealTimeRoom.FromPointer(room)) { using (var nativeParticipant = MultiplayerParticipant.FromPointer(participant)) { if (callback == null) { return; } byte[] convertedData = null; if (dataLength.ToUInt64() != 0) { convertedData = new byte[dataLength.ToUInt32()]; Marshal.Copy(data, convertedData, 0, (int)dataLength.ToUInt32()); } try { callback(nativeRoom, nativeParticipant, convertedData, isReliable); } catch (Exception e) { GooglePlayGames.OurUtils.Logger.e("Error encountered executing InternalOnDataReceived. " + "Smothering to avoid passing exception into Native: " + e); } } } }
/// <summary> /// Decompresses data with <paramref name="size"/> at <paramref name="offset"/> in <paramref name="buffer"/> using this <see cref="ZstdDecompressionContext"/> /// </summary> /// <param name="buffer">The compressed data buffer</param> /// <param name="offset">The offset of the compressed data</param> /// <param name="size">The size of the compressed data</param> /// <param name="uncompressedSize">Uncompressed size of <paramref name="buffer"/></param> /// <returns>The uncompressed buffer</returns> /// <remarks>If you do not know the uncompressed size then it is recommended to use <see cref="ZstdStream"/></remarks> public byte[] Decompress(byte[] buffer, int offset, int size, int uncompressedSize) { Zstd.ValidateDecompressionArguments(buffer.Length, offset, size, uncompressedSize); // Allocate uncompressed buffer byte[] uncompressedBuffer = new byte[uncompressedSize]; Size uncompressedBufferSize = Size.Zero; unsafe { fixed(byte *uncompressedBufferPtr = uncompressedBuffer) fixed(byte *compressedBufferPtr = buffer) { if (this.Dictionary == null) { uncompressedBufferSize = Native.ZSTD_decompressDCtx( this._context, (IntPtr)uncompressedBufferPtr, (Size)uncompressedSize, (IntPtr)(compressedBufferPtr + offset), (Size)size); } else { uncompressedBufferSize = Native.ZSTD_decompress_usingDDict( this._context, (IntPtr)uncompressedBufferPtr, (Size)uncompressedSize, (IntPtr)(compressedBufferPtr + offset), (Size)size, this.Dictionary.GetDecompressionDictionary()); } } } // Check for errors Zstd.ThrowOnError(uncompressedBufferSize); // Check for possiblity that user passed in higher than required uncompressed size if (uncompressedSize != uncompressedBufferSize.ToUInt32()) { Array.Resize(ref uncompressedBuffer, (int)uncompressedBufferSize); } return(uncompressedBuffer); }
private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam) { string chars = ""; if (nCode >= 0) if (wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_KEYDOWN || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_KEYUP || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_SYSKEYDOWN || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_SYSKEYUP) { // Captures the character(s) pressed only on WM_KEYDOWN chars = InterceptKeys.VKCodeToString((uint)Marshal.ReadInt32(lParam), (wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_KEYDOWN || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_SYSKEYDOWN)); hookedKeyboardCallbackAsync.BeginInvoke((InterceptKeys.KeyEvent)wParam.ToUInt32(), Marshal.ReadInt32(lParam), chars, null, null); } return InterceptKeys.CallNextHookEx(hookId, nCode, wParam, lParam); }
public void GetCommandString( UIntPtr idCmd, uint uFlags, IntPtr pReserved, StringBuilder pszName, uint cchMax) { int index = Convert.ToInt32(idCmd.ToUInt32()); String[] texts = Constants.getLabels(currentActionDispacher.CurrentActions[index]); // To change switch ((GCS)uFlags) { case GCS.VERBW: pszName.Clear(); pszName.Append(texts[1]); break; case GCS.HELPTEXTW: pszName.Clear(); pszName.Append(texts[2]); break; } }
public static UIntPtr MouseHook(int nCode, UIntPtr wParam, IntPtr lParam) { try { if (nCode == 0) { var wm = (WinAPI.WM)wParam.ToUInt32(); if (wm == WinAPI.WM.MOUSEMOVE) { if (DateTime.Now.Ticks <= _nextMouseMoveAccept) { // a.k.a not handled return Mubox.WinAPI.WindowHook.CallNextHookEx(hHook, nCode, wParam, lParam); } _nextMouseMoveAccept = DateTime.Now.AddMilliseconds(50).Ticks; // 20fps - we limit this to ease off of network and cpu utilization for mousemove, the framerate choice here is arbitrary } Mubox.WinAPI.WindowHook.MSLLHOOKSTRUCT mouseHookStruct = (Mubox.WinAPI.WindowHook.MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(Mubox.WinAPI.WindowHook.MSLLHOOKSTRUCT)); if (OnMouseInputReceived(wm, mouseHookStruct)) { return new UIntPtr(1); // handled } } } catch (Exception ex) { ex.Log(); } try { return Mubox.WinAPI.WindowHook.CallNextHookEx(hHook, nCode, wParam, lParam); } catch (Exception ex) { ex.Log(); } return UIntPtr.Zero; }
unsafe public byte *DecByteArr(byte[] inarr, ref int outLength) { byte[] outdata; byte *data = (byte *)Marshal.AllocHGlobal(inarr.Length);//stackalloc byte[inarr.Length] for (int i = 0; i < inarr.Length; i++) { data[i] = inarr[i]; } size_t outLen = (size_t)0; size_t *outLenP = &outLen; uint lessLen = 0; uint *lessLenP = &lessLen; byte *os = decodeXOR(data, inarr.Length, outLenP, lessLenP); if (os == null) { return(null); } outLength = Convert.ToInt32(outLen.ToUInt32()); outdata = new byte[outLength]; for (int i = 0; i < outLength; i++) { outdata[i] = os[i]; } if (outLength == inarr.Length) { textBox1.AppendText("Wtf?\r\n"); } return(os); }
/// <include file='ManagedHooks.xml' path='Docs/MouseHook/HookCallback/*'/> protected override void HookCallback(int code, UIntPtr wparam, IntPtr lparam) { if (MouseEvent == null) { return; } int x = 0, y = 0; MouseEvents mEvent = (MouseEvents)wparam.ToUInt32(); switch(mEvent) { case MouseEvents.LeftButtonDown: GetMousePosition(wparam, lparam, ref x, ref y); break; case MouseEvents.LeftButtonUp: GetMousePosition(wparam, lparam, ref x, ref y); break; case MouseEvents.MouseWheel: break; case MouseEvents.Move: GetMousePosition(wparam, lparam, ref x, ref y); break; case MouseEvents.RightButtonDown: GetMousePosition(wparam, lparam, ref x, ref y); break; case MouseEvents.RightButtonUp: GetMousePosition(wparam, lparam, ref x, ref y); break; default: //System.Diagnostics.Trace.WriteLine("Unrecognized mouse event"); break; } MouseEvent(mEvent, new Point(x, y)); }
/// <summary> /// Write /// </summary> /// <param name="dataBuffer">Data buffer</param> /// <param name="numBytesToWrite">Number bytes to write</param> /// <param name="numBytesWritten">Number bytes written</param> /// <returns>A <see cref="FT_STATUS"/></returns> public FT_STATUS Write(byte[] dataBuffer, int numBytesToWrite, ref uint numBytesWritten) { FT_STATUS status = FT_STATUS.FT_OTHER_ERROR; UIntPtr written = new UIntPtr(0); try { status = FT_Write(_currentHandle, dataBuffer, numBytesToWrite, out written); } catch { } numBytesWritten = written.ToUInt32(); return status; }
private IntPtr LowLevelKeyboardCallback(int code, UIntPtr wParam, IntPtr lParam) { //catch the timing. if the call took too long, then there's a good chance we have disconnected the hook. var startTime = DateTime.UtcNow; var block = false; if (code >= 0 && ( wParam.ToUInt32() == (int)KeyEvent.WM_KEYDOWN || wParam.ToUInt32() == (int)KeyEvent.WM_KEYUP || wParam.ToUInt32() == (int)KeyEvent.WM_SYSKEYDOWN || wParam.ToUInt32() == (int)KeyEvent.WM_SYSKEYUP)) { var keyEvent = (KeyEvent)wParam.ToUInt32(); var virtualKeyCode = Marshal.ReadInt32(lParam); var key = KeyInterop.KeyFromVirtualKey(virtualKeyCode); switch (keyEvent) { case KeyEvent.WM_KEYDOWN: if (KeyDown != null) { KeyDown(this, new KeyEventArgument(virtualKeyCode), ref block); } break; case KeyEvent.WM_KEYUP: if (KeyDown != null) { KeyUp(this, new KeyEventArgument(virtualKeyCode), ref block); } break; } } var endTime = DateTime.UtcNow; var executionTime = endTime - startTime; const int Overhead = 25; if (executionTime.TotalMilliseconds + Overhead >= configuration.HookTimeout) { //reconnect the hook. Disconnect(); Connect(); //attempt to block the keystroke anyway. block = true; //signal the event. if (HookRecovered != null) { HookRecovered(this, new HookRecoveredEventArgument()); } } if (block) { return new IntPtr(-1); } return CallNextHookEx(hookId, code, wParam, lParam); }
/// <summary> /// Gets a human-readable name for the protocol. /// </summary> /// <param name="capacity">The number of characters in the buffer.</param> /// <param name="pBuffer">Buffer pointer.</param> /// <returns>Returns 0 on success, nonzero on failure.</returns> private unsafe int PSGetName(UIntPtr capacity, IntPtr pBuffer) { if (namePtr == IntPtr.Zero) { byte[] nameBytes = Encoding.Default.GetBytes(Name ?? String.Empty); NameCapacity = nameBytes.Length + 1; namePtr = Marshal.AllocHGlobal(NameCapacity); Marshal.Copy(nameBytes, 0, namePtr, nameBytes.Length); *(((byte*)namePtr) + nameBytes.Length) = 0; } uint count = capacity.ToUInt32(); for (long i = 0; i < count && i < NameCapacity; i++) *(byte*)(pBuffer.ToInt64() + i) = *(byte*)(namePtr.ToInt64() + i); return 0; }
private static void VerifyPointer(UIntPtr ptr, ulong expected) { Assert.Equal(expected, ptr.ToUInt64()); uint expected32 = (uint)expected; if (expected32 != expected) { Assert.Throws<OverflowException>(() => ptr.ToUInt32()); return; } Assert.Equal(expected32, ptr.ToUInt32()); Assert.Equal(expected.ToString(), ptr.ToString()); Assert.Equal(ptr, new UIntPtr(expected)); Assert.True(ptr == new UIntPtr(expected)); Assert.False(ptr != new UIntPtr(expected)); Assert.NotEqual(ptr, new UIntPtr(expected + 1)); Assert.False(ptr == new UIntPtr(expected + 1)); Assert.True(ptr != new UIntPtr(expected + 1)); }
private int LowLevelKeyboardProc(int nCode, UIntPtr wParam, ref InterceptKeys.KBDLLHOOKSTRUCT lParam) { string chars = ""; if (nCode >= 0) if (wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_KEYDOWN || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_KEYUP || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_SYSKEYDOWN || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_SYSKEYUP) { // Captures the character(s) pressed only on WM_KEYDOWN chars = InterceptKeys.VKCodeToString((uint)lParam.vkCode, (wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_KEYDOWN || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_SYSKEYDOWN)); hookedKeyboardCallbackAsync.BeginInvoke((InterceptKeys.KeyEvent)wParam.ToUInt32(), lParam.vkCode, chars, null, null); } //---My Block uint iwParam = wParam.ToUInt32(); Debug.WriteLine(iwParam); if (iwParam == 256) // key down message { if (lParam.vkCode == 162) // control key down { ctrl_pressed = true; } } if (iwParam == 257) // key up message { if (lParam.vkCode == 162) // control key up { ctrl_pressed = false; } } bool forbidden = ForbiddenInput(lParam.vkCode, lParam.flags); if (ForbiddenInput(lParam.vkCode, lParam.flags)) return 1; //---end return InterceptKeys.CallNextHookEx(hookId, nCode, wParam, ref lParam); }
/// <summary> /// Read /// </summary> /// <param name="dataBuffer">Data buffer</param> /// <param name="numBytesToRead">Number bytes to read</param> /// <param name="numBytesRead">Number bytes read</param> /// <returns>A <see cref="FT_STATUS"/></returns> public FT_STATUS Read(byte[] dataBuffer, uint numBytesToRead, ref uint numBytesRead) { FT_STATUS status = FT_STATUS.FT_OTHER_ERROR; UIntPtr read = new UIntPtr(0); try { status = FT_Read(_currentHandle, dataBuffer, numBytesToRead, out read); } catch { } numBytesRead = read.ToUInt32(); return status; }
/// <summary> /// GetDeviceList /// </summary> /// <param name="deviceList">Device list</param> /// <returns>A <see cref="FT_STATUS"/></returns> public FT_STATUS GetDeviceList(FT_DEVICE_INFO_NODE[] deviceList) { FT_STATUS status = FT_STATUS.FT_OTHER_ERROR; UIntPtr flags = new UIntPtr(0); UIntPtr type = new UIntPtr(0); UIntPtr id = new UIntPtr(0); UIntPtr locId = new UIntPtr(0); byte[] description = new byte[64]; byte[] serialNumber = new byte[16]; IntPtr handle = new IntPtr(0); if (deviceList != null && deviceList.Length == _devicesCount) { for (uint i = 0; i < _devicesCount; i++) { FT_DEVICE_INFO_NODE newNode = new FT_DEVICE_INFO_NODE(); try { status = FT_GetDeviceInfoDetail(i, out flags, out type, out id, out locId, serialNumber, description, handle); newNode.Flags = flags.ToUInt32(); newNode.Type = type.ToUInt32(); newNode.ID = id.ToUInt32(); newNode.LocId = locId.ToUInt32(); newNode.SerialNumber = System.Text.ASCIIEncoding.Default.GetString(serialNumber); newNode.Description = System.Text.ASCIIEncoding.Default.GetString(description); newNode.ftHandle = handle; } catch { } deviceList[i] = newNode; } } return status; }
public void Refresh() { StringBuilder sb = new StringBuilder(); // get caption sb.EnsureCapacity(10240); bool WindowTimedOut = false; UIntPtr lRes = new UIntPtr(1860); int lResult = SendMessageTimeout(Handle, WM_GETTEXT, 10240, sb, SMTO_ABORTIFHUNG, 1000, out lRes); if (lResult == 0) { Trace.TraceError("SendMessageTimeout() failed with {0}", Marshal.GetLastWin32Error()); WindowTimedOut = true; Objects[(int)WindowItemTypes.Title] = "?"; } else { //Trace.TraceInformation("lResult: {0}, lRes: {1}", lResult, lRes.ToUInt32()); Objects[(int)WindowItemTypes.Title] = sb.ToString(); } // get class name sb = new StringBuilder(); sb.EnsureCapacity(10240); GetClassName(Handle, sb, 10240); Objects[(int)WindowItemTypes.Class] = sb.ToString(); uint style = GetWindowLong(Handle, GWL_STYLE); Objects[(int)WindowItemTypes.Style] = DecodeWindowStyle(style); Objects[(int)WindowItemTypes.ExStyle] = GetWindowLong(Handle, GWL_EXSTYLE); Objects[(int)WindowItemTypes.ID] = GetWindowLong(Handle, GWL_ID); RECT r = new RECT(); GetWindowRect(Handle, ref r); Objects[(int)WindowItemTypes.Size] = string.Format("({0}, {1})", r.Width, r.Height); Objects[(int)WindowItemTypes.Position] = string.Format("({0}, {1})", r.Top, r.Left); UIntPtr ProcessID = new UIntPtr(0); uint ThreadID = GetWindowThreadProcessId(Handle, out ProcessID); Objects[(int)WindowItemTypes.TID] = ThreadID; Objects[(int)WindowItemTypes.PID] = ProcessID.ToUInt32(); ForegroundColor = Color.Black; if ((r.Width == r.Height) && (r.Width == 0)) { ForegroundColor = Color.Gray; } if ((style & WS_VISIBLE) == 0) { ForegroundColor = Color.Gray; } if (WindowTimedOut) { ForegroundColor = Color.Red; } }
public override void EnumCodeContextsOfPosition(UIntPtr sourceContext, uint offset, uint length, out IEnumDebugCodeContexts enumContexts) { var del = RawCOMHelpers.GetMethodDelegate<RawEnumCodeContextsOfPosition>(pActiveScriptDebug, 5); RawCOMHelpers.HResult.Check(del(pActiveScriptDebug, sourceContext.ToUInt32(), offset, length, out enumContexts)); }
public IDebuggerValue CreateBox(UIntPtr value) { return debugger.Dispatcher.UI(() => { var refBoxValue = CreateNoConstructorUI(appDomain.UIntPtr); if (value != UIntPtr.Zero) { var boxedValue = refBoxValue.CorValue.DereferencedValue.BoxedValue; var bytes = UIntPtr.Size == 4 ? BitConverter.GetBytes(value.ToUInt32()) : BitConverter.GetBytes(value.ToUInt64()); boxedValue.WriteGenericValue(bytes); } return refBoxValue; }); }
public IDebuggerValue Create(UIntPtr value) { return debugger.Dispatcher.UI(() => { var res = CreateNoConstructorUI(appDomain.UIntPtr).CorValue; Keep(res); Debug.Assert(res.DereferencedValue != null && res.DereferencedValue.BoxedValue != null); res = res.DereferencedValue.BoxedValue; if (value != UIntPtr.Zero) { var bytes = UIntPtr.Size == 4 ? BitConverter.GetBytes(value.ToUInt32()) : BitConverter.GetBytes(value.ToUInt64()); res.WriteGenericValue(bytes); } return new DebuggerValue(debugger, res); }); }
private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam) { /* TODO: Change BeginInvoke to Invoke to block windows from handling things like the start key */ if (nCode >= 0) if (wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_KEYDOWN || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_KEYUP || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_SYSKEYDOWN || wParam.ToUInt32() == (int)InterceptKeys.KeyEvent.WM_SYSKEYUP) hookedKeyboardCallbackAsync.BeginInvoke((InterceptKeys.KeyEvent)wParam.ToUInt32(), Marshal.ReadInt32(lParam), null, null); return InterceptKeys.CallNextHookEx(hookId, nCode, wParam, lParam); }
private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam) { bool block = false; if (nCode >= 0) { if (wParam.ToUInt32() == (int)KeyEvent.WM_KEYDOWN || wParam.ToUInt32() == (int)KeyEvent.WM_KEYUP || wParam.ToUInt32() == (int)KeyEvent.WM_SYSKEYDOWN || wParam.ToUInt32() == (int)KeyEvent.WM_SYSKEYUP) { _hookedKeyboardCallback((KeyEvent)wParam.ToUInt32(), Marshal.ReadInt32(lParam), ref block); } } if (block) { return new IntPtr(-1); } return CallNextHookEx(_hookId, nCode, wParam, lParam); }
private void OnWmDeviceChange(UIntPtr wParam, IntPtr lParam) { DEV_BROADCAST_HDR dbh = (DEV_BROADCAST_HDR)Marshal.PtrToStructure(lParam, typeof(DEV_BROADCAST_HDR)); if (dbh.dbch_devicetype != DBT_DEVTYP_DEVICEINTERFACE) { return; } DEV_BROADCAST_DEVICEINTERFACE dbi = (DEV_BROADCAST_DEVICEINTERFACE)Marshal.PtrToStructure(lParam, typeof(DEV_BROADCAST_DEVICEINTERFACE)); UInt32 eventType = wParam.ToUInt32(); if (DBT_DEVICEARRIVAL == eventType) { if (this.DeviceConnected != null) { this.DeviceConnected(this, new DeviceManagementNotificationsEventArgs(true, dbi.dbcc_classguid, dbi.dbcc_name)); } } else if (DBT_DEVICEREMOVECOMPLETE == eventType) { if (this.DeviceDisconnected != null) { this.DeviceDisconnected(this, new DeviceManagementNotificationsEventArgs(false, dbi.dbcc_classguid, dbi.dbcc_name)); } } }
public override void ParseScriptText(string code, string itemName, object context, string delimiter, UIntPtr sourceContext, uint startingLineNumber, ScriptTextFlags flags, IntPtr pVarResult, out EXCEPINFO excepInfo) { activeScriptParse.ParseScriptText(code, itemName, context, delimiter, sourceContext.ToUInt32(), startingLineNumber, flags, pVarResult, out excepInfo); }
public static IntPtr SetWindowLongPtr (HandleRef hWnd, int nIndex, UIntPtr dwNewLong) { if (IntPtr.Size == 8) return SetWindowLongPtr64(hWnd, nIndex, dwNewLong); else return new IntPtr(SetWindowLong32(hWnd, nIndex, dwNewLong.ToUInt32())); }
public static void GetWindowThreadProcessId(int hwnd, out int ProcessID, out int ThreadID) { UIntPtr _ProcessID = new UIntPtr(0); ThreadID = (int) GetWindowThreadProcessId(hwnd, out _ProcessID); ProcessID = (int) _ProcessID.ToUInt32(); }
/// <summary> /// Get information about a shortcut menu command, including the help string /// and the language-independent, or canonical, name for the command. /// </summary> /// <param name="idCmd">Menu command identifier offset.</param> /// <param name="uFlags"> /// Flags specifying the information to return. This parameter can have one /// of the following values: GCS_HELPTEXTA, GCS_HELPTEXTW, GCS_VALIDATEA, /// GCS_VALIDATEW, GCS_VERBA, GCS_VERBW. /// </param> /// <param name="pReserved">Reserved. Must be IntPtr.Zero</param> /// <param name="pszName"> /// The address of the buffer to receive the null-terminated string being /// retrieved. /// </param> /// <param name="cchMax"> /// Size of the buffer, in characters, to receive the null-terminated string. /// </param> public void GetCommandString( UIntPtr idCmd, uint uFlags, IntPtr pReserved, StringBuilder pszName, uint cchMax) { var menu = MenuManager.Instance.Menus.Find(f => f.Id == idCmd.ToUInt32()); if (menu != null) { switch ((GCS)uFlags) { case GCS.GCS_VERBW: if (menu.VerbCanonicalName.Length > cchMax - 1) { Marshal.ThrowExceptionForHR(WinError.STRSAFE_E_INSUFFICIENT_BUFFER); } else { pszName.Clear(); pszName.Append(menu.VerbCanonicalName); } break; case GCS.GCS_HELPTEXTW: if (menu.VerbHelpText.Length > cchMax - 1) { Marshal.ThrowExceptionForHR(WinError.STRSAFE_E_INSUFFICIENT_BUFFER); } else { pszName.Clear(); pszName.Append(menu.VerbHelpText); } break; } } }
/// <summary> /// Get information about a shortcut menu command, including the help string /// and the language-independent, or canonical, name for the command. /// </summary> /// <param name="idCmd">Menu command identifier offset.</param> /// <param name="uFlags"> /// Flags specifying the information to return. This parameter can have one /// of the following values: GCS_HELPTEXTA, GCS_HELPTEXTW, GCS_VALIDATEA, /// GCS_VALIDATEW, GCS_VERBA, GCS_VERBW. /// </param> /// <param name="pReserved">Reserved. Must be IntPtr.Zero</param> /// <param name="pszName"> /// The address of the buffer to receive the null-terminated string being /// retrieved. /// </param> /// <param name="cchMax"> /// Size of the buffer, in characters, to receive the null-terminated string. /// </param> public void GetCommandString( UIntPtr idCmd, uint uFlags, IntPtr pReserved, StringBuilder pszName, uint cchMax) { if (idCmd.ToUInt32() == IDM_DISPLAY) { switch ((GCS)uFlags) { case GCS.GCS_VERBW: if (this.verbCanonicalName.Length > cchMax - 1) { Marshal.ThrowExceptionForHR(WinError.STRSAFE_E_INSUFFICIENT_BUFFER); } else { pszName.Clear(); pszName.Append(this.verbCanonicalName); } break; case GCS.GCS_HELPTEXTW: if (this.verbHelpText.Length > cchMax - 1) { Marshal.ThrowExceptionForHR(WinError.STRSAFE_E_INSUFFICIENT_BUFFER); } else { pszName.Clear(); pszName.Append(this.verbHelpText); } break; } } }
/// <summary> /// Get information about a shortcut menu command, including the help string /// and the language-independent, or canonical, name for the command. /// </summary> /// <param name="idCmd">Menu command identifier offset.</param> /// <param name="uFlags"> /// Flags specifying the information to return. This parameter can have one /// of the following values: GCS_HELPTEXTA, GCS_HELPTEXTW, GCS_VALIDATEA, /// GCS_VALIDATEW, GCS_VERBA, GCS_VERBW. /// </param> /// <param name="pReserved">Reserved. Must be IntPtr.Zero</param> /// <param name="pszName"> /// The address of the buffer to receive the null-terminated string being /// retrieved. /// </param> /// <param name="cchMax"> /// Size of the buffer, in characters, to receive the null-terminated string. /// </param> public void GetCommandString( UIntPtr idCmd, uint uFlags, IntPtr pReserved, StringBuilder pszName, uint cchMax) { return; Debug.WriteLine("Get Command String"); // MessageBox(0, "GetCommandString", "Information", 0); // MessageBox(0, idCmd.ToString(), "Information", 0); //if (idCmd.ToUInt32() == IDM_DISPLAY) if (idCmd.ToUInt32() < 10) { Debug.WriteLine("Switch Get Command String"); switch ((GCS)uFlags) { case GCS.GCS_VERBW: if (this.verbCanonicalName.Length > cchMax - 1) { Marshal.ThrowExceptionForHR(WinError.STRSAFE_E_INSUFFICIENT_BUFFER); } else { pszName.Clear(); pszName.Append(this.syncVerbCanonicalName[idCmd.ToUInt32()]); } break; case GCS.GCS_HELPTEXTW: if (this.verbHelpText.Length > cchMax - 1) { Marshal.ThrowExceptionForHR(WinError.STRSAFE_E_INSUFFICIENT_BUFFER); } else { pszName.Clear(); pszName.Append(this.verbHelpText); } break; } } // MessageBox(0, pszName.ToString(), "Info", 0); }