internal void Reload(string path, string searchPattern, FileDialogBehavior behavior) { this.Items.Clear(); if (string.IsNullOrEmpty(path)) { return; } string solvedPath = path; FileInfo fileInfo = new FileInfo(path); if (fileInfo.Attributes.HasFlag(FileAttributes.ReparsePoint)) { solvedPath = WinApi.GetReparsePointFileName(path); } DirectoryInfo parentDirectory = Directory.GetParent(path); if (parentDirectory != null) { this.Items.Add(new FileDialogItem(FileDialogItemType.Directory, "..", parentDirectory.FullName)); } try { ReloadDirectories(solvedPath, behavior); ReloadFiles(solvedPath, searchPattern, behavior); } catch (Exception ex) { this.Items.Add(new FileDialogItem(FileDialogItemType.Directory, ex.Message, string.Empty)); } this.OnCollectionChanged(new System.Collections.Specialized.NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction.Reset)); }
public static LoginInformation AuthWindows(string username, string password) { var info = new LoginInformation(); try { var domainName = Environment.UserDomainName; if (username.IsValidEmail()) { domainName = "MicrosoftAccount"; } if (username.Contains("\\")) { var splitName = username.Split('\\'); domainName = splitName[0]; username = splitName[1]; } using (var wim = new WindowsIdentityImpersonator(domainName, username, password)) { wim.BeginImpersonate(); { info.IsAdmin = WinApi.IsAdministratorByToken(WindowsIdentity.GetCurrent()); info.LoggedIn = true; info.Message = $"Logged in successfully as {username}"; } wim.EndImpersonate(); } } catch (Exception ex) { info.IsAdmin = false; info.LoggedIn = false; info.Message = ex.Message; } return(info); }
/// <summary> /// This method disconnects the class from the shared memory block and if this /// is the last instance referencing the block, then the block will be /// deleted. Note that it's OK to call Close() even if the object isn't /// currently open. This method is thread safe. /// </summary> public void Close() { lock (syncLock) { if (m_hMap == IntPtr.Zero) { return; } // Unlock the memory if (m_pvBlock != null) { while (m_cLock > 0) { Unlock(); } } // Free the map if (m_hMap != IntPtr.Zero) { #if SHAREDMEM_DRIVER WinApi.MEM_Close(m_hMap); #else WinApi.CloseHandle(m_hMap); #endif m_hMap = IntPtr.Zero; } // Free the mutex m_mutex.Close(); } }
/// <summary> /// 将窗体内置到面板工作区中,设置窗体大小自适应、面板和窗体互相关闭 /// </summary> /// <param name="form"></param> /// <param name="dockPanel"></param> private void FormIntoDockPanel(Form form, DockPanel dockPanel) { //将窗体内置到面板工作区中 int dockPanelWnd = dockPanel.ControlContainer.Handle.ToInt32(); WinApi.SetParent(form.Handle.ToInt32(), dockPanelWnd); OnResize(dockPanelWnd, form.Handle, 4, 3); //窗体自适应停靠面板大小 dockPanel.ControlContainer.SizeChanged += (sender, e) => OnResize(dockPanelWnd, form.Handle, 4, 3); //关闭面板时关闭窗体 dockPanel.ClosingPanel += (sender, e) => { if (!IsCloseDockPanel) { dockPanel.Hide(); return; } if (!form.IsDisposed && IsCloseDockPanel) { form.Close(); } if (!form.IsDisposed) { e.Cancel = true; } }; //关闭窗体时关闭面板 form.FormClosed += (sender, e) => { FloatLocation = dockPanel.FloatLocation; dockManager1.RemovePanel(dockPanel); }; }
protected override bool InsertUnlessFull(int index, TKey key, TValue value) { if (RecordCount >= m_maxRecordsPerNode) { return(false); } byte *start = GetWritePointerAfterHeader() + index * KeyValueSize; if (index != RecordCount) { WinApi.MoveMemory(start + KeyValueSize, start, (RecordCount - index) * KeyValueSize); } //Insert the data m_encoding.Encode(start, null, null, key, value); //key.Write(start); //value.Write(start + KeySize); //save the header IncrementOneRecord(KeyValueSize); return(true); }
public HiddenWindowMessages() { messageHooks = new List <HwndSourceHook>(); //generate a unique ID for the window WindowId = "WClipboard_" + Guid.NewGuid(); //register window message handler messageHandler = OnWindowMessageReceived; // Create a simple window class which is reference through //the messageHandler delegate WindowClass wc; wc.style = 0; wc.lpfnWndProc = messageHandler; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = IntPtr.Zero; wc.hIcon = IntPtr.Zero; wc.hCursor = IntPtr.Zero; wc.hbrBackground = IntPtr.Zero; wc.lpszMenuName = string.Empty; wc.lpszClassName = WindowId; // Register the window class WinApi.RegisterClass(ref wc); // Create the message window Handle = WinApi.CreateWindowEx(0, WindowId, "", 0, 0, 0, 1, 1, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); if (Handle == IntPtr.Zero) { throw new Win32Exception("Message window handle was not a valid pointer"); } }
public override void Render() { base.Render(); if (!Settings.Enable || WinApi.IsKeyDown(Keys.F10) || !Settings.ShowInTown && GameController.Area.CurrentArea.IsTown || !Settings.ShowInTown && GameController.Area.CurrentArea.IsHideout) { return; } List <EntityWrapper> deadEntities = aliveEntities.Where(entity => !entity.IsAlive).ToList(); foreach (EntityWrapper entity in deadEntities) { Calc(entity); aliveEntities.Remove(entity); } Vector2 position = StartDrawPointFunc(); var size = new Size2(); if (Settings.ShowDetail) { size = DrawCounters(position); } var session = $"({sessionCounter + summaryCounter})"; Size2 size2 = Graphics.DrawText($"kills: {summaryCounter} {session}", Settings.KillsTextSize, position.Translate(0, size.Height), Settings.TextColor, FontDrawFlags.Right); int width = Math.Max(size.Width, size2.Width); var bounds = new RectangleF(position.X - width - 46, position.Y - 5, width + 50, size.Height + size2.Height + 10); Graphics.DrawImage("preload-start.png", bounds, Settings.BackgroundColor); Graphics.DrawImage("preload-end.png", bounds, Settings.BackgroundColor); Size = bounds.Size; Margin = new Vector2(0, 5); }
/// <summary> /// Feeds a click generated on the mouse hook /// </summary> /// <param name="e"></param> internal static bool FeedHookClick(MouseEventArgs e) { //Al-74 fix (see GitHub issue #10): //Starting from Windows 10 April 2018 Update (version 1803) with display scaling above 100%, e.Location is the physical mouse location, //not scaled according to display scaling, so the Contains function fails check and no events fires when clicking RibbonButtons dropdown items. //Use GetCursorPos api instead of e.Location seems to solve the problem. WinApi.POINT pos; if (WinApi.GetCursorPos(out pos)) { foreach (RibbonPopup p in pops) { if (p.WrappedDropDown.Bounds.Contains(pos.x, pos.y)) //if (p.WrappedDropDown.Bounds.Contains(e.Location)) { return(true); } } } //If click was in no dropdown, let's go everyone Dismiss(DismissReason.AppClicked); return(false); }
private FREObject Capture(FREContext ctx, uint argc, FREObject[] argv) { var rect = new WinApi.Rect(); WinApi.GetWindowRect(_webViewWindow, ref rect); var x = 0; var y = 0; var width = rect.right - rect.left; var height = rect.bottom - rect.top; try { var freCropTo = argv[0]; if (freCropTo != FREObject.Zero) { var cropTo = freCropTo.AsRect(); x = Convert.ToInt32(cropTo.X); y = Convert.ToInt32(cropTo.Y); var freW = Convert.ToInt32(cropTo.Width); var freH = Convert.ToInt32(cropTo.Height); width = freW > 0 ? freW : width; height = freH > 0 ? freH : height; } _capturedBitmapData = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format32bppArgb); var graphics = Graphics.FromImage(_capturedBitmapData); graphics.CopyFromScreen(rect.left + x, rect.top + y, 0, 0, new Size(width, height), CopyPixelOperation.SourceCopy); DispatchEvent(OnCaptureComplete, ""); } catch (Exception e) { return(new FreException(e).RawValue); } return(FREObject.Zero); }
/// <summary> /// 开始模拟鼠标操作桌面微信,(微信聊天列表不能有置顶聊天) /// </summary> public void StartSimulateWeChat() { IntPtr awin = WinApi.GetWeChatWindow(); if (awin == IntPtr.Zero) { MessageBox.Show("获取微信主窗口句柄失败", "提示"); return; } WinApi.CloseWindow(awin); WinApi.ShowWindow(awin, WinApi.NCmdShowFlag.SW_SHOWNORMAL);//在显示 RECT rc = new RECT(); WinApi.GetWindowRect(awin, ref rc); endPosition.X = rc.Left; endPosition.Y = rc.Top; if (true) { //应该打开窗口有延迟,所以需要定时去操作 ////暂停2秒 Thread.Sleep(2000); moveMouseToWeChatSeachBox(endPosition); } }
private void DoInjection() { handles = new UIntPtr[processes.Length]; try { // Inject into the desired process IDs for (int i = 0; i < processes.Length; i++) { int percentComplete = (int)(((float)(i + 1) / (float)processes.Length) * 100.0f); progress.ProgressUpdate("Injecting logging agents", percentComplete); handles[i] = InjectDll(processes[i].Id); } } catch { // Roll back if needed for (int i = 0; i < handles.Length; i++) { if (handles[i] != UIntPtr.Zero) { try { UnInjectDll(processes[i].Id, handles[i]); } catch { } } } throw; } WinApi.SetEvent(startReqEvent); }
public override bool IsTransitionAvailable(out string availableState) { availableTransitionState = StateName; availableState = StateName; if (!main.IsTimerPausedByUser() && main.InputReceivedThisTick) { string titlee = WinApi.GetWindowTitle().ToString().ToLowerInvariant(); if (!main.IsTitleSameTitleAsPrevious(titlee)) { if (main.IsTitleValidWindowTitleCapture(titlee)) { if (Data.Settings.Blacklist.IsTitleAllowed(titlee, out BlacklistItem blacklistItem)) { availableTransitionState = "Resumed"; availableState = "Resumed"; //main.ArtistResume.Execute(null); return(true); } } } } return(false); }
public CVP(string path, float scale = 1) { vReader = new VideoFileReader(); vReader.Open(path); consoleFontSize = Util.GetConsoleFontSize(); totalFrames = vReader.FrameCount; this.scale = scale; if (Math.Abs(scale - 1) > 1e-6) { shouldRescale = true; } if (shouldRescale) { vidSize = new Size((int)(vReader.Width * scale), (int)(vReader.Height * scale)); } else { vidSize = new Size(vReader.Width, vReader.Height); } consoleSize = vidSize + new Size(consoleFontSize.Width * 2 - 1, consoleFontSize.Height * 4); Util.FixConsoleWindowSize(); Util.AdjustConsoleWindowSize(consoleSize); Console.SetBufferSize(Console.WindowWidth, Console.WindowHeight); vidPos = new Point(0, consoleFontSize.Height); fr = vReader.FrameRate; frRnd = (int)Math.Round(fr.Value); ticksPerFrame = (long)(1e7 / fr.Value); playThread = new Thread(InternalPlay); workThread = new Thread(PreloadFrames); g = Graphics.FromHwnd(WinApi.GetConsoleWindow()); }
public static Client OpenMC(string path, string arguments) { var fileVersion = FileVersionInfo.GetVersionInfo(path).FileVersion; var version = ClientVersion.GetFromFileVersion(fileVersion); if (version == null) { throw new Exception("The version " + fileVersion + " is not supported."); } WinApi.PROCESS_INFORMATION pi = new WinApi.PROCESS_INFORMATION(); WinApi.STARTUPINFO si = new WinApi.STARTUPINFO(); if (arguments == null) { arguments = ""; } WinApi.CreateProcess(path, " " + arguments, IntPtr.Zero, IntPtr.Zero, false, WinApi.CREATE_SUSPENDED, IntPtr.Zero, Path.GetDirectoryName(path), ref si, out pi); Process p = Process.GetProcessById(Convert.ToInt32(pi.dwProcessId)); var client = new Client(p, version, Path.GetDirectoryName(path)); Memory.WriteByte(client.ProcessHandle, client.MemoryAddresses.ClientMultiClient, client.MemoryAddresses.ClientMultiClientJMP); WinApi.ResumeThread(pi.hThread); p.WaitForInputIdle(); Memory.WriteByte(client.ProcessHandle, client.MemoryAddresses.ClientMultiClient, client.MemoryAddresses.ClientMultiClientJNZ); WinApi.CloseHandle(pi.hProcess); WinApi.CloseHandle(pi.hThread); return(client); }
protected void NotifyNotDetectableWindows() { try { var windowsToNotify = new List <IntPtr>(); foreach (ProcessThread thread in pokerClientProcess.Threads) { WinApi.EnumThreadWindows(thread.Id, (hWnd, lParam) => { var sb = new StringBuilder(256); if (hWnd != IntPtr.Zero && WinApi.GetClassName(hWnd, sb, sb.Capacity) != 0 && sb.ToString().Contains(WindowClassName)) { var windowTitle = WinApi.GetWindowText(hWnd); var titleInfo = new IgnitionTableTitle(windowTitle); if (titleInfo.IsValid && !titleInfo.IsZone) { windowsToNotify.Add(hWnd); } } return(true); }, IntPtr.Zero); } NotifyNotDetectableWindows(windowsToNotify); } catch (Exception e) { LogProvider.Log.Error(this, $"Could not notify not detectable windows. [{Identifier}]", e); } }
private void FindUpDown() { bool bFound = false; IntPtr pWnd = WinApi.GetWindow(Handle, WinApi.GW_CHILD); while (pWnd != IntPtr.Zero) { char[] className = new char[33]; int length = WinApi.GetClassName(pWnd, className, 32); string s = new string(className, 0, length); if (s == "msctls_updown32") { bFound = true; if (!bUpDown) { this.scUpDown = new SubClass(pWnd, true); this.scUpDown.SubClassedWndProc += new SubClass.SubClassWndProcEventHandler(scUpDown_SubClassedWndProc); bUpDown = true; } break; } pWnd = WinApi.GetWindow(pWnd, WinApi.GW_HWNDNEXT); } if ((!bFound) && (bUpDown)) { bUpDown = false; } }
/// <summary> /// This method releases the lock on the shared memory block. This method /// is threadsafe. /// </summary> public void Unlock() { Assertion.Test(m_hMap != IntPtr.Zero); Assertion.Test(m_mutex != null); Assertion.Test(m_cLock != 0); Assertion.Test(m_pvBlock != null); if (m_cLock == 0) { return; } m_cLock--; if (m_cLock == 0) { #if SHAREDMEM_DRIVER WinApi.MEM_Unlock(m_hMap, m_cbBlock); #else WinApi.UnmapViewOfFile(m_pvBlock); #endif } m_mutex.ReleaseMutex(); }
private void Render() { var screenDc = WinApi.GetDC(WinApi.NullHandleRef); if (screenDc == IntPtr.Zero) { return; } try { var memDc = WinApi.CreateCompatibleDC(new HandleRef(null, screenDc)); if (memDc == IntPtr.Zero) { return; } try { using (Bitmap bmp = GetWindowBitmap(Size.Width, Size.Height)) { IntPtr hBitmap = bmp.GetHbitmap(_transparent); IntPtr hOldBitmap = WinApi.SelectObject(memDc, hBitmap); WinApi.POINT newLocation = new WinApi.POINT(Location); WinApi.SIZE newSize = new WinApi.SIZE(Size); WinApi.UpdateLayeredWindow(Handle, screenDc, ref newLocation, ref newSize, memDc, ref _ptZero, 0, ref _blend, WinApi.BlendingFlags.ULW_ALPHA); if (hBitmap != IntPtr.Zero) { WinApi.SelectObject(memDc, hOldBitmap); WinApi.DeleteObject(hBitmap); } } } finally { WinApi.DeleteDC(new HandleRef(null, memDc)); } } finally { WinApi.ReleaseDC(WinApi.NullHandleRef, new HandleRef(null, screenDc)); } }
private void UpdateAppBarState() { if (_suppressingUIToSysUpdate) { return; } var autohide = ChkAutoHide.Checked; var alwaysOnTop = ChkAlwaysOnTop.Checked; var abd = new WinApi.APPBARDATA(); abd.hWnd = _taskBarHwnd; if (autohide) { abd.lParam = (int)(alwaysOnTop ? WinApi.ABState.ABS_AUTOHIDEANDONTOP : WinApi.ABState.ABS_AUTOHIDE); } else { abd.lParam = (int)(alwaysOnTop ? WinApi.ABState.ABS_ALWAYSONTOP : WinApi.ABState.ABS_MANUAL); } WinApi.SHAppBarMessage((uint)WinApi.ABMsg.ABM_SETSTATE, ref abd); }
/// <summary> /// Handles the EXCEPTION_DATATYPE_MISALIGNMENT debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnDatatypeMisalignmentDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the EXCEPTION_BREAKPOINT debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnBreakpointDebugException(ref WinApi.DEBUG_EVENT de) { if (!this.InitialBreakpointHit) { this.InitialBreakpointHit = true; return WinApi.DbgCode.CONTINUE; } else { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; } }
/// <summary> /// Handles the EXCEPTION_ARRAY_BOUNDS_EXCEEDED debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnArrayBoundsExceededDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the EXCEPTION_ACCESS_VIOLATION debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnAccessViolationDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the RIP_EVENT debug event. /// </summary> /// <param name="de">The debug event that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnRipEvent(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.CONTINUE; }
public override void Render() { if (!holdKey && WinApi.IsKeyDown(Keys.F10)) { holdKey = true; Settings.Enable.Value = !Settings.Enable.Value; SettingsHub.Save(settingsHub); } else if (holdKey && !WinApi.IsKeyDown(Keys.F10)) { holdKey = false; } if (!Settings.Enable) { return; } if (Settings.Enable) { Positioned pos = GameController.Player.GetComponent <Positioned>(); if (pos == null) { return; } Vector2 playerPos = pos.GridPos; Vector2 position = StartDrawPointFunc(); const int BOTTOM_MARGIN = 2; bool shouldUpdate = false; if (Settings.BorderSettings.Enable) { Dictionary <EntityWrapper, AlertDrawStyle> tempCopy = new Dictionary <EntityWrapper, AlertDrawStyle>(currentAlerts); var keyValuePairs = tempCopy.AsParallel().Where(x => x.Key != null && x.Key.Address != 0 && x.Key.IsValid).ToList(); foreach (var kv in keyValuePairs) { if (DrawBorder(kv.Key.Address) && !shouldUpdate) { shouldUpdate = true; } } } foreach (KeyValuePair <EntityWrapper, AlertDrawStyle> kv in currentAlerts.Where(x => x.Key != null && x.Key.Address != 0 && x.Key.IsValid)) { string text = GetItemName(kv); if (text == null) { continue; } ItemsOnGroundLabelElement entityLabel; if (!currentLabels.TryGetValue(kv.Key.Address, out entityLabel)) { shouldUpdate = true; } else { if (Settings.ShowText && (!Settings.HideOthers || entityLabel.CanPickUp || entityLabel.MaxTimeForPickUp.TotalSeconds == 0)) { position = DrawText(playerPos, position, BOTTOM_MARGIN, kv, text); } } } Size = new Size2F(0, position.Y); //bug absent width if (shouldUpdate) { currentLabels = GameController.Game.IngameState.IngameUi.ItemsOnGroundLabels .GroupBy(y => y.ItemOnGround.Address).ToDictionary(y => y.Key, y => y.First()); } } }
private void MoveControl() { WinApi.ReleaseCapture(); WinApi.SendMessage(Handle, (int)WinApi.Messages.WM_NCLBUTTONDOWN, (int)WinApi.HitTest.HTCAPTION, 0); }
/// <summary> /// Handles the EXCEPTION_PRIV_INSTRUCTION debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnPrivInstructionDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
private void p_Title_MouseDown(object sender, MouseEventArgs e) { WinApi.ReleaseCapture(); WinApi.SendMessage(this.Handle, WinApi.WM_SYSCOMMAND, WinApi.SC_MOVE + WinApi.HTCAPTION, 0); }
/// <summary> /// Processes mouse events, which are bubbled /// through the class' routed events, trigger /// certain actions (e.g. show a popup), or /// both. /// </summary> /// <param name="me">Event flag.</param> private void OnMouseEvent(MouseEvent me) { if (this.IsDisposed) { return; } switch (me) { case MouseEvent.MouseMove: this.RaiseTrayMouseMoveEvent(); //immediately return - there's nothing left to evaluate return; case MouseEvent.IconRightMouseDown: this.RaiseTrayRightMouseDownEvent(); break; case MouseEvent.IconLeftMouseDown: this.RaiseTrayLeftMouseDownEvent(); break; case MouseEvent.IconRightMouseUp: this.RaiseTrayRightMouseUpEvent(); break; case MouseEvent.IconLeftMouseUp: this.RaiseTrayLeftMouseUpEvent(); break; case MouseEvent.IconMiddleMouseDown: this.RaiseTrayMiddleMouseDownEvent(); break; case MouseEvent.IconMiddleMouseUp: this.RaiseTrayMiddleMouseUpEvent(); break; case MouseEvent.IconDoubleClick: //cancel single click timer this.singleClickTimer.Change(Timeout.Infinite, Timeout.Infinite); //bubble event this.RaiseTrayMouseDoubleClickEvent(); break; case MouseEvent.BalloonToolTipClicked: this.RaiseTrayBalloonTipClickedEvent(); break; //default: // throw new ArgumentOutOfRangeException("me", "Missing handler for mouse event flag: " + me); } //get mouse coordinates Point cursorPosition = new Point(); if (messageSink.Version == NotifyIconVersion.Vista) { //physical cursor position is supported for Vista and above WinApi.GetPhysicalCursorPos(ref cursorPosition); } else { WinApi.GetCursorPos(ref cursorPosition); } cursorPosition = this.GetDeviceCoordinates(cursorPosition); bool isLeftClickCommandInvoked = false; //show popup, if requested if (me.IsMatch(this.PopupActivation)) { if (me == MouseEvent.IconLeftMouseUp) { //show popup once we are sure it's not a double click singleClickTimerAction = () => { this.LeftClickCommand.ExecuteIfEnabled(LeftClickCommandParameter, LeftClickCommandTarget ?? this); this.ShowTrayPopup(cursorPosition); }; this.singleClickTimer.Change(WinApi.GetDoubleClickTime(), Timeout.Infinite); isLeftClickCommandInvoked = true; } else { //show popup immediately this.ShowTrayPopup(cursorPosition); } } //show context menu, if requested if (me.IsMatch(this.MenuActivation)) { if (me == MouseEvent.IconLeftMouseUp) { //show context menu once we are sure it's not a double click singleClickTimerAction = () => { LeftClickCommand.ExecuteIfEnabled(LeftClickCommandParameter, LeftClickCommandTarget ?? this); ShowContextMenu(cursorPosition); }; singleClickTimer.Change(WinApi.GetDoubleClickTime(), Timeout.Infinite); isLeftClickCommandInvoked = true; } else { //show context menu immediately ShowContextMenu(cursorPosition); } } //make sure the left click command is invoked on mouse clicks if (me == MouseEvent.IconLeftMouseUp && !isLeftClickCommandInvoked) { //show context menu once we are sure it's not a double click this.singleClickTimerAction = () => { this.LeftClickCommand.ExecuteIfEnabled(LeftClickCommandParameter, LeftClickCommandTarget ?? this); }; this.singleClickTimer.Change(WinApi.GetDoubleClickTime(), Timeout.Infinite); } }
public bool FocusMe() { return(WinApi.SetForegroundWindow(Handle)); }
public void BeginUpdate() { WinApi.SendMessage(Handle, (int)WinApi.Messages.WM_SETREDRAW, false, 0); inUpdate = true; }
public static void InputLoop() { uint toRead = 128; var records = new INPUT_RECORD[toRead]; int prevWidth = MyConsole.Width; int prevHeight = MyConsole.Height; MouseButton prevMouseState = MouseButton.None; COORD prevMouseLocation = new COORD(); while (!MyConsole.Exiting) { WinApi.ReadConsoleInput(inputHandle, records, toRead, out uint recordLen); for (int i = 0; i < recordLen; i++) { var record = records[i]; switch (record.EventType) { case EventType.Mouse: { var mouseEvent = record.Event.MouseEvent; var button = mouseEvent.ButtonState; var flags = mouseEvent.EventFlags; var location = mouseEvent.MousePosition; bool mousePressed = prevMouseState == MouseButton.None && button != MouseButton.None; bool mouseReleased = prevMouseState != MouseButton.None && button == MouseButton.None; bool mouseHeld = prevMouseState != MouseButton.None && button != MouseButton.None; var args = new MouseEventArgs { Button = button, Location = location, ControlKeyState = mouseEvent.ControlKeyState }; bool sameLocation = location.Equals(prevMouseLocation); if (mousePressed && flags.HasFlag(MouseState.DoubleClick)) { MouseDoubleClick?.Invoke(null, args); } else if (mousePressed) { MousePressed?.Invoke(null, args); } else if (mouseReleased) { MouseReleased?.Invoke(null, args); } else if (mouseHeld && flags.HasFlag(MouseState.Moved) && !sameLocation) { MouseDragged?.Invoke(null, args); } else if (flags.HasFlag(MouseState.Moved) && !sameLocation) { MouseMoved?.Invoke(null, args); } prevMouseState = button; prevMouseLocation = location; } break; case EventType.Key: { var keyEvent = record.Event.KeyEvent; var eventArgs = new KeyEventArgs { Key = (ConsoleKey)keyEvent.VirtualKeyCode, ControlKeyState = keyEvent.ControlKeyState }; bool currState = keyEvent.KeyDown; bool prevState = keyStates[keyEvent.VirtualKeyCode]; if (currState && !prevState) { KeyPressed?.Invoke(eventArgs); } else if (prevState && !currState) { KeyReleased?.Invoke(eventArgs); } else if (prevState && currState) { KeyHeld?.Invoke(eventArgs); } keyStates[keyEvent.VirtualKeyCode] = keyEvent.KeyDown; } break; case EventType.Resize: { var clientSize = MyConsole.GetClientSize(); var fontSize = MyConsole.GetFontSize(); int w = clientSize.X / fontSize.X; int h = clientSize.Y / fontSize.Y; if (prevWidth != w || prevHeight != h) { MyConsole.SetSize(w, h); MyConsole.HideCursor(); Drawing.ConsoleRenderer.Resize(w, h); Resized?.Invoke(new ResizedEventArgs { Width = w, Height = h }); prevWidth = w; prevHeight = h; } } break; case EventType.Menu: { var id = record.Event.MenuEvent.dwCommandId; Debug.WriteLine(id); } break; case EventType.Focus: { var focused = record.Event.FocusEvent.bSetFocus; } break; default: Debug.WriteLine("Unhandled event: " + record.EventType); break; } } } }
private void DropToStash() { var cursorPosPreMoving = Mouse.GetCursorPosition(); if (Settings.BlockInput.Value) { WinApi.BlockInput(true); } if (_dropItems.Count > 0) { // Dictionary where key is the index (stashtab index) and Value is the items to drop. var itemsToDrop = (from dropItem in _dropItems group dropItem by dropItem.StashNode.VisibleIndex into itemsToDropByTab select itemsToDropByTab).ToDictionary(tab => tab.Key, tab => tab.ToList()); var latency = (int)_ingameState.CurLatency; foreach (var stashResults in itemsToDrop) { // If we are more than 2 tabs away from our target, then use dropdown approach if // user has it. if (!Keyboard.IsKeyToggled(Settings.DropHotkey.Value)) { return; } if (!SwitchToTab(stashResults.Value[0].StashNode)) { continue; } try { Keyboard.KeyDown(Keys.LControlKey); Thread.Sleep(INPUT_DELAY); foreach (var stashResult in stashResults.Value) { Mouse.SetCursorPosAndLeftClick(stashResult.ClickPos, Settings.ExtraDelay, _windowOffset); Thread.Sleep(latency + Settings.ExtraDelay.Value); } } catch { Keyboard.KeyUp(Keys.LControlKey); } // QVIN's version of Hud doesn't support Subscription events, so we use reflection. if (_callPluginEventMethod != null) { _callPluginEventMethod.Invoke(API, new object[] { "StashUpdate", new object[0] }); } } Keyboard.KeyUp(Keys.LControlKey); } ProcessRefills(); Mouse.SetCursorPos(cursorPosPreMoving.X, cursorPosPreMoving.Y); // TODO:Go back to a specific tab, if user has that setting enabled. if (Settings.VisitTabWhenDone.Value) { SwitchToTab(Settings.TabToVisitWhenDone); } if (Settings.BlockInput.Value) { WinApi.BlockInput(false); Thread.Sleep(INPUT_DELAY); } }
/// <summary> /// Handles the EXCEPTION_STACK_OVERFLOW debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnStackOverflowDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the EXCEPTION_INVALID_DISPOSITION debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnInvalidDispositionDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the EXCEPTION_SINGLE_STEP debug exception. /// Logs information about the thread state when the exception is hit. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected override WinApi.DbgCode OnSingleStepDebugException(ref WinApi.DEBUG_EVENT de) { IntPtr threadHandle; WinApi.CONTEXT cx; this.BeginEditThread(de.dwThreadId, out threadHandle, out cx); if (this.LogRegistersOnBreakpoint) { this.LogRegisters(ref cx); } uint prevInstSize = this.GetPreviousInstructionSize(new IntPtr((long)cx._ip)); IntPtr prevInstruction = new IntPtr((long)cx._ip - prevInstSize); if (this.LogBreakpointAccesses) { this.Status.Log( "Modifying address is " + this.IntPtrToFormattedAddress(prevInstruction) + " with instruction length " + prevInstSize); } if (this.RestoreBreakpointOnExceptionSingleStep == true) { // TODO: eventually replace breakpointAddressJustHit with a check of Dr6. if (this.BreakpointAddressJustHit != IntPtr.Zero) { this.Write(this.BreakpointAddressJustHit, (byte)0xcc, WriteOptions.None); this.Status.Log( "Restoring breakpoint at " + this.IntPtrToFormattedAddress(this.BreakpointAddressJustHit)); this.BreakpointAddressJustHit = IntPtr.Zero; } else { this.Status.Log( "Unexpected series of events during breakpoint restoration.", Logger.Logger.Level.HIGH); } this.RestoreBreakpointOnExceptionSingleStep = false; } return base.OnSingleStepDebugException(ref de); }
public GatewayService(StatelessServiceContext context) : base(context) { WinApi.TimeBeginPeriod(1); //improve sleep precision for polling type transports float timeoutDebugMultiplier = 1; var builder = new ContainerBuilder(); var esLogsConfig = new FabricConfigProvider <ElasticSearchOutputConfig>("ElasticSearchLogs").Config; var esMetricsConfig = new FabricConfigProvider <ElasticSearchOutputConfig>("ElasticSearchMetrics").Config; var logger = new LoggerConfiguration() .ConfigureMOUSETypesDestructure() .MinimumLevel.Error() .Enrich.With(new AzureServiceFabricSerilogEnricher(context)) .Enrich.With <ExceptionEnricher>() .Enrich.With <ActivityIdSerilogEnricher>() .WriteTo.Elasticsearch( new ElasticsearchSinkOptions(new Uri(esLogsConfig.ElasticSearchUri)) { IndexFormat = $"{esLogsConfig.ElasticSearchIndexName}-{{0:yyyy.MM.dd}}" }) .CreateLogger(); Log.Logger = logger; builder.RegisterInstance(logger).As <ILogger>(); builder.RegisterType <SerilogCoreEvents>().As <ICoreEvents>(); builder.RegisterType <SerilogActorCoreEvents>().As <IActorCoreEvents>(); builder.RegisterType <SerilogLidgrenEvents>().As <ILidgrenEvents>(); Metric.Config.WithAllCounters(); _metricsSubscription = new TelemetryPipe() .CollectMetricsNet(5, ServiceFabricHelpers.GetEnvironmentProperties(context), true) .SendToElasticSearch(esMetricsConfig) .Start(); builder.Register( c => new ProtobufMessageSerializer(typeof(Message).Assembly, typeof(TestStateless).Assembly)) .As <IMessageSerializer>(); var publicEndpoint = FabricRuntime.GetActivationContext().GetEndpoint("Public"); var public2Endpoint = FabricRuntime.GetActivationContext().GetEndpoint("Public2"); var public3Endpoint = FabricRuntime.GetActivationContext().GetEndpoint("Public3"); var nodeIP = Dns.GetHostAddresses(FabricRuntime.GetNodeContext().IPAddressOrFQDN).First(x => x.AddressFamily == AddressFamily.InterNetwork); var publicNetConfig = new NetPeerConfiguration("PublicNet") { LocalAddress = nodeIP, MaximumConnections = 10000, AcceptIncomingConnections = true, Port = publicEndpoint.Port, ConnectionTimeout = 10 * timeoutDebugMultiplier }; var public2NetConfig = new NetPeerConfiguration("PublicNet") { LocalAddress = nodeIP, MaximumConnections = 10000, AcceptIncomingConnections = true, Port = public2Endpoint.Port, ConnectionTimeout = 10 * timeoutDebugMultiplier }; var public3NetConfig = new NetPeerConfiguration("PublicNet") { LocalAddress = nodeIP, MaximumConnections = 10000, AcceptIncomingConnections = true, Port = public3Endpoint.Port, ConnectionTimeout = 10 * timeoutDebugMultiplier }; var testActorsNetConfig = new NetPeerConfiguration("TestActors") { LocalAddress = nodeIP, AcceptIncomingConnections = false, Port = 0, ConnectionTimeout = 10 * timeoutDebugMultiplier }; builder.RegisterType <WcfBufferPool>().As <IBufferPool>(); builder.Register(c => { var messageSerialer = c.Resolve <IMessageSerializer>(); var coreLogger = c.Resolve <ICoreEvents>(); var nedNodeConfig = c.Resolve <INetNodeConfig>(); var bufferPool = c.Resolve <IBufferPool>(); return(new NetNode <SFActorsBackendClientNetChannel>("PublicNet", new LidgrenNetProvider(publicNetConfig, c.Resolve <ILidgrenEvents>()), coreLogger, messageSerialer, (node, transport) => new SFActorsBackendClientNetChannel(node, transport, messageSerialer, coreLogger, nedNodeConfig, bufferPool), nedNodeConfig)); }) .As <INetNode>() .SingleInstance(); builder.Register(c => { var actorSystem = c.Resolve <IActorSystem <ITestActor> >(); var messageSerialer = c.Resolve <IMessageSerializer>(); var coreLogger = c.Resolve <ICoreEvents>(); var netNodeConfig = c.Resolve <INetNodeConfig>(); var bufferPool = c.Resolve <IBufferPool>(); return(new NetNode <MouseActorsBackendClientNetChannel>("PublicNet2", new LidgrenNetProvider(public2NetConfig, c.Resolve <ILidgrenEvents>()), coreLogger, messageSerialer, (node, transport) => new MouseActorsBackendClientNetChannel(actorSystem, node, transport, messageSerialer, coreLogger, netNodeConfig, bufferPool), netNodeConfig)); }) .As <INetNode>() .SingleInstance(); builder.Register(c => { var messageSerialer = c.Resolve <IMessageSerializer>(); var coreLogger = c.Resolve <ICoreEvents>(); var netNodeConfig = c.Resolve <INetNodeConfig>(); var bufferPool = c.Resolve <IBufferPool>(); return(new NetNode <OrleansBackendClientNetChannel>("PublicNet3", new LidgrenNetProvider(public3NetConfig, c.Resolve <ILidgrenEvents>()), coreLogger, messageSerialer, (node, transport) => new OrleansBackendClientNetChannel(node, transport, messageSerialer, coreLogger, netNodeConfig, bufferPool), netNodeConfig)); }) .As <INetNode>() .SingleInstance(); builder.Register(c => new ServiceFabricActorSystemNetNode <ITestActor>("TestActors", new Uri("fabric:/MouseTestActor.Deploy/MouseTestActor"), new LidgrenNetProvider(testActorsNetConfig, c.Resolve <ILidgrenEvents>()), c.Resolve <IActorCoreEvents>(), c.Resolve <ICoreEvents>(), c.Resolve <IMessageSerializer>(), c.Resolve <INetNodeConfig>(), c.Resolve <IBufferPool>())) .As <INetNode>() .As <IActorSystem <ITestActor> >() .SingleInstance(); builder.Register(c => new NetNodeConfig() { SendTimeoutSec = (int)(10.0 * timeoutDebugMultiplier), ConnectTimeoutSec = (int)(10 * timeoutDebugMultiplier) }).As <INetNodeConfig>(); var container = builder.Build(); _netNodes = container.Resolve <IEnumerable <INetNode> >(); var config = new ClientConfiguration { //DataConnectionString = "DefaultEndpointsProtocol=https;AccountName=actorchatstorage;AccountKey=1hCY/Ak2TFrqE61cMhbPU5rkv9PuDfX7QQFU4tXCSc2AO78hLdm6u3PrGrZbUzOj7OkIZ93YKbU81VSVnBMbPg==", DataConnectionString = "UseDevelopmentStorage=true", PropagateActivityId = true, DefaultTraceLevel = Severity.Info, GatewayProvider = ClientConfiguration.GatewayProviderType.AzureTable, TraceToConsole = true, StatisticsCollectionLevel = StatisticsLevel.Critical, StatisticsLogWriteInterval = TimeSpan.FromDays(6), TraceFileName = null, TraceFilePattern = null, ResponseTimeout = TimeSpan.FromSeconds(90), StatisticsMetricsTableWriteInterval = TimeSpan.FromDays(6), StatisticsPerfCountersWriteInterval = TimeSpan.FromDays(6), }; OrleansFabricClient.Initialize(new Uri("fabric:/OrleansTest/OrleansTestActor"), config); }
private static extern int SetWinEventHook(int eventMin, int eventMax, IntPtr hmodWinEventProc, WinApi.WinEventHookProc lpfnWinEventProc, int idProcess, int idThread, int dwflags);
/// <summary> /// Returns true if the cursor is within the form window /// </summary> public static bool IsMouseIn() { return(WinApi.IsCursorIn(_form.Handle)); }
// Sends input (keyboard/mouse) to screen which has focus (top-most) public void HandleInput() { ProfilerShort.Begin("MyGuiManager.HandleInput"); try { if (MyInput.Static.IsAnyAltKeyPressed() && MyInput.Static.IsNewKeyPressed(MyKeys.F4)) { MyAnalyticsTracker.SendGameEnd("Alt+F4", MySandboxGame.TotalTimeInMilliseconds / 1000); // Exit application MySandboxGame.ExitThreadSafe(); return; } // Screenshot(s) if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.SCREENSHOT)) { MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick); TakeScreenshot(); } bool newPressf12 = MyInput.Static.IsNewKeyPressed(MyKeys.F12); bool newPressf2 = MyInput.Static.IsNewKeyPressed(MyKeys.F2); if ((newPressf2 || newPressf12) && MyInput.Static.IsAnyShiftKeyPressed() && MyInput.Static.IsAnyAltKeyPressed()) { if (MySession.Static != null && MySession.Static.CreativeMode) { if (newPressf12) { MyDebugDrawSettings.DEBUG_DRAW_PHYSICS = !MyDebugDrawSettings.DEBUG_DRAW_PHYSICS; if (!m_shapeRenderingMessageBoxShown) { m_shapeRenderingMessageBoxShown = true; AddScreen(MyGuiSandbox.CreateMessageBox( messageCaption: new StringBuilder("PHYSICS SHAPES"), messageText: new StringBuilder("Enabled physics shapes rendering. This feature is for modders only and is not part of the gameplay."))); } } } else { AddScreen(MyGuiSandbox.CreateMessageBox( messageCaption: new StringBuilder("MODDING HELPER KEYS"), messageText: new StringBuilder("Use of helper key combinations for modders is only allowed in creative mode."))); } return; } if (MyInput.Static.IsNewKeyPressed(MyKeys.H) && MyInput.Static.IsAnyCtrlKeyPressed()) { if (MyFakes.ENABLE_NETGRAPH) { MyHud.IsNetgraphVisible = !MyHud.IsNetgraphVisible; } } if (MyInput.Static.IsNewKeyPressed(MyKeys.F11)) { if (MyInput.Static.IsAnyShiftKeyPressed() && !MyInput.Static.IsAnyCtrlKeyPressed()) { SwitchTimingScreen(); } } if (MyFakes.ENABLE_MISSION_SCREEN && MyInput.Static.IsNewKeyPressed(MyKeys.U)) { MyScreenManager.AddScreen(new MyGuiScreenMission()); } if (!MyInput.Static.ENABLE_DEVELOPER_KEYS && Sync.MultiplayerActive && m_currentDebugScreen is MyGuiScreenDebugOfficial) { RemoveScreen(m_currentDebugScreen); m_currentDebugScreen = null; } bool inputHandled = false; if (MySession.Static != null && MySession.Static.CreativeMode || MyInput.Static.ENABLE_DEVELOPER_KEYS) { F12Handling(); } if (MyInput.Static.ENABLE_DEVELOPER_KEYS) { // Statistics screen if (MyInput.Static.IsNewKeyPressed(MyKeys.F11) && !MyInput.Static.IsAnyShiftKeyPressed() && MyInput.Static.IsAnyCtrlKeyPressed()) { SwitchStatisticsScreen(); } if (MyInput.Static.IsAnyShiftKeyPressed() && MyInput.Static.IsAnyAltKeyPressed() && MyInput.Static.IsAnyCtrlKeyPressed() && MyInput.Static.IsNewKeyPressed(MyKeys.Home)) { throw new InvalidOperationException("Controlled crash"); } // Forge GC to run if (MyInput.Static.IsNewKeyPressed(MyKeys.Pause) && MyInput.Static.IsAnyShiftKeyPressed()) { GC.Collect(GC.MaxGeneration); } if (MyInput.Static.IsAnyCtrlKeyPressed() && MyInput.Static.IsNewKeyPressed(MyKeys.F2)) { //Reload textures if (MyInput.Static.IsKeyPress(MyKeys.LeftShift)) { MyDefinitionManager.Static.ReloadDecalMaterials(); VRageRender.MyRenderProxy.ReloadTextures(); } else if (MyInput.Static.IsKeyPress(MyKeys.LeftAlt)) { VRageRender.MyRenderProxy.ReloadModels(); } else { VRageRender.MyRenderProxy.ReloadEffects(); } } //WS size if (MyInput.Static.IsNewKeyPressed(MyKeys.F3) && MyInput.Static.IsKeyPress(MyKeys.LeftShift)) { #if !XB1 WinApi.SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1); #endif // !XB1 } inputHandled = HandleDebugInput(); } if (!inputHandled) { MyScreenManager.HandleInput(); } } finally { ProfilerShort.End(); } }
public void DetachDialog(WinApi.Button btn) { try { btn.ClickAsync(); } catch (Exception ex) { MessageBox.Show("发生异常,请截图并发至ydwe论坛:" + Environment.NewLine + "原文本框句柄:" + hEdit.ToString() + Environment.NewLine + "确认按钮句柄:" + hBtnOk.ToString() + Environment.NewLine + "取消按钮句柄:" + hBtnCancel.ToString() + Environment.NewLine + "异常信息:" + ex.ToString()); } Config.SaveColor(btn1stColor); Config.SaveColor(btn2ndColor); Config.SaveColor(btn3rdColor); Config.SaveColor(btn4thColor); Config.SaveDialogSize(this); this.txtEdit.undoStack.Clear();// 清空撤销信息 this.btnUndo.Enabled = false; this.txtEdit.redoStack.Clear();// 清空重做信息 this.btnRedo.Enabled = false; this.Hide();// 隐藏模拟窗口 //this.Dispose();// 销毁模拟窗口 this.hWnd = IntPtr.Zero; }
public void WinApi_ListWinData_Test() { var api = new WinApi(); foreach(var win in api.GetWindows(true)) { Console.WriteLine(win); } }
/// <summary> /// Initializes a new instance of the Region class. /// </summary> /// <param name="baseAddress">The base address of the region.</param> /// <param name="size">The size of the region.</param> /// <param name="protection">The protection settings on this region.</param> /// <param name="type">The type of the memory region.</param> public Region(IntPtr baseAddress, uint size, WinApi.MemoryProtect protection, WinApi.MemoryType type) { this.Size = size; this.BaseAddress = new Address(baseAddress, this.Size); this.matches = new bool[this.Size]; this.Protect = protection; this.Type = type; // might want to import and use memset, if this for loop is really slow for (uint i = 0; i < this.Size; ++i) { this.matches[i] = true; } }
private Device (IntPtr devInfo, WinApi.SP_DEVINFO_DATA devInfoData, string name, string hardwareId, string physicalDeviceObjectName, UInt32 capabilities) { this.devInfo = devInfo; this.devInfoData = devInfoData; this.name = name; this.hardwareId = hardwareId; this.physicalDeviceObjectName = physicalDeviceObjectName; this.capabilities = capabilities; }
public static Device FromDevInfo (IntPtr devInfo, WinApi.SP_DEVINFO_DATA devInfoData) { Device device = null; string name = null; string hardwareId = null; string physicalDeviceObjectName = null; UInt32 capabilities = 0; byte[] buf = new byte[1024]; uint reqBufSize; if (WinApi.SetupDiGetDeviceRegistryProperty (devInfo, ref devInfoData, WinApi.SPDRP_FRIENDLYNAME, IntPtr.Zero, buf, (uint) buf.Length, out reqBufSize)) { name = WinApi.ByteArrayToString (buf); } if (name == null) { if (WinApi.SetupDiGetDeviceRegistryProperty (devInfo, ref devInfoData, WinApi.SPDRP_DEVICEDESC, IntPtr.Zero, buf, (uint)buf.Length, out reqBufSize)) { name = WinApi.ByteArrayToString (buf); } } if (WinApi.SetupDiGetDeviceRegistryProperty (devInfo, ref devInfoData, WinApi.SPDRP_HARDWAREID, IntPtr.Zero, buf, (uint)buf.Length, out reqBufSize)) { string[] tokens = WinApi.MarshalMultiStringToStringArray (buf); hardwareId = String.Join (";", tokens); } if (WinApi.SetupDiGetDeviceRegistryProperty (devInfo, ref devInfoData, WinApi.SPDRP_PHYSICAL_DEVICE_OBJECT_NAME, IntPtr.Zero, buf, (uint)buf.Length, out reqBufSize)) { physicalDeviceObjectName = WinApi.ByteArrayToString (buf); } if (WinApi.SetupDiGetDeviceRegistryProperty (devInfo, ref devInfoData, WinApi.SPDRP_CAPABILITIES, IntPtr.Zero, buf, (uint)buf.Length, out reqBufSize)) { capabilities = BitConverter.ToUInt32 (buf, 0); } if (name != null && hardwareId != null) { device = new Device (devInfo, devInfoData, name, hardwareId, physicalDeviceObjectName, capabilities); } return device; }
/// <summary> /// Handles the OUTPUT_DEBUG_STRING_EVENT debug event. /// </summary> /// <param name="de">The debug event that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnOutputDebugStringEvent(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.CONTINUE; }
/// <summary> /// Apply the thread context modification and resume the thread. /// </summary> /// <param name="threadId">The ID of the thread to be modified.</param> /// <param name="threadHandle">A handle of the thread to be modified.</param> /// <param name="cx">The context of the thread to be modified.</param> protected void EndEditThread(uint threadId, ref IntPtr threadHandle, ref WinApi.CONTEXT cx) { // TODO: get the most context data from the thread, if FULL cannot get the most. cx.ContextFlags = WinApi.CONTEXT_FLAGS.FULL; if (!WinApi.SetThreadContext(threadHandle, ref cx)) { string msg = "Unable to set thread context for TID: " + threadId + ". Error: " + Marshal.GetLastWin32Error(); WinApi.CloseHandle(threadHandle); throw new InvalidOperationException(msg); } uint res = WinApi.ResumeThread(threadHandle); unchecked { if (res == (uint)(-1)) { string msg = "Unable to resume thread, TID: " + threadId + ". Error: " + Marshal.GetLastWin32Error(); WinApi.CloseHandle(threadHandle); throw new InvalidOperationException(msg); } } }
/// <summary> /// Handles the CREATE_THREAD_DEBUG_EVENT debug event. /// </summary> /// <param name="de">The debug event that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnCreateThreadDebugEvent(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.CONTINUE; }
/// <summary> /// Handles the EXIT_PROCESS_DEBUG_EVENT debug event. /// </summary> /// <param name="de">The debug event that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnExitProcessDebugEvent(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.CONTINUE; }
/// <summary> /// Handles the UNLOAD_DLL_DEBUG_EVENT debug event. /// </summary> /// <param name="de">The debug event that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnUnloadDllDebugEvent(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.CONTINUE; }
/// <summary> /// Handles the EXCEPTION_BREAKPOINT debug exception. /// Causes the process to trigger a single step debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected override WinApi.DbgCode OnBreakpointDebugException(ref WinApi.DEBUG_EVENT de) { if (this.InitialBreakpointHit) { this.Restore(de.Exception.ExceptionRecord.ExceptionAddress, false); //this.SetIP(de.Exception.ExceptionRecord.ExceptionAddress); //this.PrepareForSingleStep(de.Exception.ExceptionRecord.ExceptionAddress); this.BreakpointAddressJustHit = de.Exception.ExceptionRecord.ExceptionAddress; this.RestoreBreakpointOnExceptionSingleStep = true; } return base.OnBreakpointDebugException(ref de); }
/// <summary> /// Handles the EXCEPTION_FLT_DENORMAL_OPERAND debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnFltDenormalOperandDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the EXCEPTION_FLT_INEXACT_RESULT debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnFltInexactResultDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the EXCEPTION_SINGLE_STEP debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnSingleStepDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the EXCEPTION_IN_PAGE_ERROR debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnInPageErrorDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the EXCEPTION_NONCONTINUABLE_EXCEPTION debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnNoncontinuableExceptionDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Suspend the thread and prepare the thread context to be modified. /// </summary> /// <param name="threadId">The ID of the thread to be modified.</param> /// <param name="threadHandle">A handle of the thread to be modified.</param> /// <param name="cx">The context of the thread to be modified.</param> protected void BeginEditThread(uint threadId, out IntPtr threadHandle, out WinApi.CONTEXT cx) { WinApi.ThreadAccess threadRights = WinApi.ThreadAccess.SET_CONTEXT | WinApi.ThreadAccess.GET_CONTEXT | WinApi.ThreadAccess.SUSPEND_RESUME; threadHandle = WinApi.OpenThread(threadRights, false, threadId); if (threadHandle == null || threadHandle.Equals(IntPtr.Zero)) { string msg = "Unable to obtain a thread handle for TID: " + threadId + ". Error: " + Marshal.GetLastWin32Error(); WinApi.CloseHandle(threadHandle); throw new InvalidOperationException(msg); } uint result = WinApi.SuspendThread(threadHandle); unchecked { if (result == (uint)(-1)) { string msg = "Unable to suspend thread, TID: " + threadId + ". Error: " + Marshal.GetLastWin32Error(); WinApi.CloseHandle(threadHandle); throw new InvalidOperationException(msg); } } WinApi.CONTEXT context = new WinApi.CONTEXT(); context.ContextFlags = WinApi.CONTEXT_FLAGS.FULL; if (!WinApi.GetThreadContext(threadHandle, ref context)) { string msg = "Unable to get thread context, TID: " + threadId + ". Error: " + Marshal.GetLastWin32Error(); WinApi.CloseHandle(threadHandle); throw new InvalidOperationException(msg); } cx = context; }
/// <summary> /// Handles the EXCEPTION_INT_DIVIDE_BY_ZERO debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnIntDivideByZeroDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the default case where no debug exception can handle this debug event. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnUnhandledDebugException(ref WinApi.DEBUG_EVENT de) { this.Status.Log( "An unhandled (default) debug exception occurred. " + "Exception code: 0x" + de.Exception.ExceptionRecord.ExceptionCode.ToString("x"), Logger.Level.DEBUG); return WinApi.DbgCode.EXCEPTION_NOT_HANDLED; }
/// <summary> /// Handles the EXCEPTION_GUARD_PAGE debug exception. /// </summary> /// <param name="de">The debug exception that was caught by the debugger.</param> /// <returns>Returns the continue debugging status code.</returns> protected virtual WinApi.DbgCode OnGuardPageDebugException(ref WinApi.DEBUG_EVENT de) { return WinApi.DbgCode.CONTINUE; }