Key Kombination abfragen

  • C#

Es gibt 19 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    Key Kombination abfragen

    Hallo zusammen,

    ich arbeite gerade an einem Programm mit dem ich Windows Fenster bewegen kann. Mein Ziel ist es ein beliebiges Windows Fenster zu verschieben während ich dabei eine Key Kombination drücke. Dies kann man sich etwa so vorstellen: Ich halte z.B. Strg + Alt + L gedrückt und kann mithilfe der (unbetätigten) Maus das Fenster verschieben. Was ich bereits schaffe ist die Abfrage des aktuellen Fensters MIttels GetForegroundWindow(), auch kann ich die Fenster Position setzen (das wird später aber durch die MoveWindow() Funktion ersetzt).

    Was mir noch Fehlt wäre eine Methode mit der ich die Möglichkeit habe die gedrückten Tasten zu ermitteln, sodass ich dann bei Strg + Alt + L das Fenster bewegen kann. Meine Frage richtet sich primär darauf, wie man diese Kombination ermitteln kann? Außerdem habe ich noch eine Subfrage, ich habe das Ganze zunächst in einem Windows Forms Projekt gestartet, ist das eine Gute Idee? Oder ginge auch eine Konsolen Applikation dafür?

    Der Code ist aktuell noch Quick&Dirty aber es ist zumindest ein Anfang mit dem sich arbeiten lässt :)

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Drawing;
    6. using System.Linq;
    7. using System.Runtime.InteropServices;
    8. using System.Text;
    9. using System.Threading.Tasks;
    10. using System.Windows.Forms;
    12. namespace MoveActivatedWindow
    13. {
    14. public partial class Form1 : Form
    15. {
    16. int counter = 0;
    18. [DllImport("user32.dll")]
    19. private static extern IntPtr GetForegroundWindow();
    21. [DllImport("user32.dll", EntryPoint = "SetWindowPos")]
    22. public static extern IntPtr SetWindowPos(IntPtr hWnd, int hWndInsertAfter, int X, int Y, int cx, int cy, int wFlags);
    24. [DllImport("user32.dll", SetLastError = true)]
    25. static extern bool GetWindowRect(IntPtr hwnd, out RECT lpRect);
    27. [StructLayout(LayoutKind.Sequential)]
    28. public struct RECT
    29. {
    30. public int Left; // x position of upper-left corner
    31. public int Top; // y position of upper-left corner
    32. public int Right; // x position of lower-right corner
    33. public int Bottom; // y position of lower-right corner
    34. }
    36. [DllImport("user32.dll", SetLastError = true)]
    37. internal static extern bool MoveWindow(IntPtr hWnd, int X, int Y, int nWidth, int nHeight, bool bRepaint);
    39. public Form1()
    40. {
    41. InitializeComponent();
    42. }
    44. private void button1_Click(object sender, EventArgs e)
    45. {
    46. counter = 0;
    47. timer1.Start();
    48. }
    50. private void timer1_Tick(object sender, EventArgs e)
    51. {
    52. if (counter >= 5) return;
    54. IntPtr selectedWindow = GetForegroundWindow();
    55. textBox1.AppendText(selectedWindow + "\n");
    57. const short SWP_NOSIZE = 0x0001; // Retains the current size (ignores the cx and cy parameters).
    58. const short SWP_NOZORDER = 0x0004; // Retains the current Z order (ignores the hWndInsertAfter parameter).
    59. const int SWP_SHOWWINDOW = 0x0040; // Displays the window
    61. SetWindowPos(selectedWindow, 0, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_SHOWWINDOW);
    63. RECT windowRect = new RECT();
    64. GetWindowRect(selectedWindow, out windowRect);
    66. textBox1.AppendText(windowRect.Right + " " + windowRect.Left + "\n");
    68. // TODO:
    69. // Berechnen der Breite & Höhe (verwende RECT dazu...)
    70. // Positioniere den Cursor auf die Mitte des akutellen Fensters (verwende zuvor berechnete Höhe/2 & Breite/2)
    71. // SetCursorPos() ...
    72. // GetCursorPos() ... Point(x,y)
    73. // Verwende dann MoveWindow ggf. noch ein Thread ...
    75. }
    76. }
    77. }

    @VB.neter0101 So was:

    VB.NET-Quellcode

    1. Private Sub Form1_KeyDown(sender As Object, e As KeyEventArgs) Handles MyBase.KeyDown
    2. If e.Alt AndAlso e.Control AndAlso e.KeyCode = Keys.L Then
    3. Label1.Text = "Strg + Alt + L"
    4. Else
    5. Label1.Text = ""
    6. End If
    7. End Sub
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @Gonger96 Jou.
    @VB.neter0101 Probierma
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Runtime.InteropServices;
    3. using System.Windows.Forms;
    5. namespace WindowsFormsApplication1
    6. {
    7. public partial class Form1 : Form
    8. {
    9. [DllImport("user32.dll")]
    10. internal static extern ushort GetAsyncKeyState(Keys key);
    11. public Form1()
    12. {
    13. this.InitializeComponent();
    14. }
    16. private void timer1_Tick(object sender, EventArgs e)
    17. {
    18. bool b1 = (Form1.GetAsyncKeyState(Keys.LMenu) == 0x8001);
    19. bool b2 = (Form1.GetAsyncKeyState(Keys.LControlKey) == 0x8001);
    20. bool b3 = (Form1.GetAsyncKeyState(Keys.L) == 0x8001);
    21. if (b1 && b2 && b3)
    22. {
    23. this.label1.Text = "Strg + Alt + L";
    24. }
    25. else
    26. {
    27. this.label1.Text = "";
    28. }
    29. }
    31. private void checkBox1_CheckedChanged(object sender, EventArgs e)
    32. {
    33. this.timer1.Enabled = this.checkBox1.Checked;
    34. }
    36. private void Form1_KeyDown(object sender, KeyEventArgs e)
    37. {
    38. this.label2.Text = e.KeyCode.ToString();
    39. }
    40. }
    41. }

    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @Gonger96, was heißt registrieren hier?
    @RodFromGermany danke das teste ich mal. Ich habe eher in diese Richtung gedacht: docs.microsoft.com/de-de/dotne…roc?view=netframework-4.8 bzw. https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-hotkey

    Edit: Ich habe es mal getestet, es scheint nicht richtig zu funktionieren, von diesem hier hätte ich erwartet, dass es anstandslos funktioniert label2.Text = e.KeyCode.ToString();, aber das tut es nicht. Kann das sein, dass die Keys nicht registriert werden wenn man VS in einer VM laufen hat?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VB.neter0101“ ()

    vbp-Suche "hotkey registrieren", dann kommst Du bei mikeb69s Thread raus
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Kommt da gar nichts raus? Oder was anderes als erwartet? Laut stackoverflow kann es sein, dass ein anderes Keyboard-Layout in der VM zu überraschenden Resultaten führt.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Bei dem Codeschnipsel label2.Text = e.KeyCode.ToString(); kommt nix heraus. Ich habe aber vor kurzem selbst genau das gleiche auf einem Dienstrechner ohne VM programmiert und da ging das ohne Probleme, daher schiebe ich das voll und ganz auf die VM, ich meine bei dem Teil mit this.label1.Text = "Strg + Alt + L"; einmal kurz erhascht zu haben, dass das Label so ausgesehen hat. Aber wie gesagt ich denke die VM ist schuld, was eigentlich sehr schade ist, das ich es nicht leiden kann eine Entwicklungsumgebung aktiv in mein System eingreifen zu lassen, bzw die dort entwickelten Programme (das kann mitunter sehr problematisch werden File.IO ) :)

    @VB.neter0101 Mit ner VM kann ich erst wieder auf Arbeit testen, muss ich mir auf einen Zettel schreiben.
    Was hast Du für ein Host-System?
    Bei mir läuft ein UBuntu.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @VB.neter0101 Ich hab mal noch ein wenig gespielt, das hier läuft sicherer:

    C#-Quellcode

    1. private void timer1_Tick(object sender, EventArgs e)
    2. {
    3. bool b1 = (Form1.GetAsyncKeyState(Keys.Menu) != 0);
    4. bool b2 = (Form1.GetAsyncKeyState(Keys.ControlKey) != 0);
    5. bool b3 = (Form1.GetAsyncKeyState(Keys.L) != 0);
    6. if (b1 && b2 && b3)
    7. {
    8. this.label1.Text = "Strg + Alt + L";
    9. }
    10. else
    11. {
    12. this.label1.Text = "";
    13. }
    14. }
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Es macht was es soll:

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Drawing;
    6. using System.Linq;
    7. using System.Runtime.InteropServices;
    8. using System.Text;
    9. using System.Threading;
    10. using System.Threading.Tasks;
    11. using System.Windows.Forms;
    13. namespace MoveWindowsWithHotkeys
    14. {
    15. public partial class Form1 : Form
    16. {
    17. [DllImport("user32.dll")]
    18. private static extern int RegisterHotKey(IntPtr hWnd, int id, int fsModifier, int vk);
    19. [DllImport("user32.dll")]
    20. private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
    21. [DllImport("user32.dll")]
    22. private static extern IntPtr GetForegroundWindow();
    23. [DllImport("user32.dll", EntryPoint = "SetWindowPos")]
    24. public static extern IntPtr SetWindowPos(IntPtr hWnd, int hWndInsertAfter, int X, int Y, int cx, int cy, int wFlags);
    25. [DllImport("user32.dll", SetLastError = true)]
    26. internal static extern bool MoveWindow(IntPtr hWnd, int X, int Y, int nWidth, int nHeight, bool bRepaint);
    27. [DllImport("user32.dll")]
    28. internal static extern ushort GetAsyncKeyState(Keys key);
    29. [DllImport("user32.dll")]
    30. static extern bool ClientToScreen(IntPtr hWnd, ref Point lpPoint);
    31. [DllImport("user32.dll")]
    32. static extern bool SetCursorPos(int X, int Y);
    33. [DllImport("user32.dll", SetLastError = true)]
    34. static extern bool GetCursorPos(out Point lpPoint);
    35. [DllImport("user32.dll", SetLastError = true)]
    36. static extern bool GetWindowRect(IntPtr hwnd, out RECT lpRect);
    37. [StructLayout(LayoutKind.Sequential)]
    38. public struct RECT
    39. {
    40. public int Left; // x position of upper-left corner
    41. public int Top; // y position of upper-left corner
    42. public int Right; // x position of lower-right corner
    43. public int Bottom; // y position of lower-right corner
    44. }
    46. private const int Key_NONE = 0x0000;
    47. private const int WM_HOTKEY = 0x312; // 0x201 for left key from mouse
    49. public Form1()
    50. {
    51. InitializeComponent();
    52. }
    54. private void MoveTheSelectedWindow()
    55. {
    56. IntPtr selectedWindow = GetForegroundWindow();
    58. RECT windowRect = new RECT();
    60. GetWindowRect(selectedWindow, out windowRect);
    62. int selectedWindowWidth = windowRect.Right - windowRect.Left;
    63. int selectedWindowHeight = windowRect.Bottom - windowRect.Top;
    65. Point cursorPosition = new Point();
    66. GetCursorPos(out cursorPosition);
    67. int xOffset = cursorPosition.X - selectedWindowWidth / 2;
    68. int yOffset = cursorPosition.Y - selectedWindowHeight / 2;
    69. MoveWindow(selectedWindow, xOffset, yOffset, selectedWindowWidth, selectedWindowHeight, true);
    71. //const short SWP_NOSIZE = 0x0001; // Retains the current size (ignores the cx and cy parameters).
    72. //const short SWP_NOZORDER = 0x0004; // Retains the current Z order (ignores the hWndInsertAfter parameter).
    73. //const int SWP_SHOWWINDOW = 0x0040; // Displays the window
    75. //SetWindowPos(selectedWindow, 0, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_SHOWWINDOW);
    77. //GetWindowRect(selectedWindow, out windowRect);
    78. }
    80. private void timer1_Tick_1(object sender, EventArgs e)
    81. {
    82. bool b1 = (GetAsyncKeyState(Keys.Menu) != 0);
    83. bool b2 = (GetAsyncKeyState(Keys.ControlKey) != 0);
    84. bool b3 = (GetAsyncKeyState(Keys.Q) != 0);
    85. if (b1 && b2 && b3)
    86. {
    87. //this.label1.Text = "Strg + Alt + Q";
    88. MoveTheSelectedWindow();
    89. }
    90. else
    91. {
    92. //this.label1.Text = "";
    93. }
    94. }
    95. }
    96. }


    Damit kann ich bei gedrückter Tasten Kombi von Strg + Alt + Q ein ausgewähltes Fenster bewegen :)

    Das war mal wieder sehr aufschlussreich :)

    Mal angenommen ich möchte nicht immer die Tasten Kombi gedrückt halten, sondern einmal betätigen, um das Fenster zu bewegen und ein erneutes betätigen der Tasten Kombi führt dazu, dass das Fenster nicht mehr bewegt würde, wie könnte man das in den Timer einbauen?

    PS: Codekorrekturen sind gerne erwünscht!!!

    PPS: Außerdem habe ich ein interessantes Verhalten beobachtet, wenn ich z.B. Notepad++ verschiebe schreibt er mir die Qs ins Dokument :D

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „VB.neter0101“ ()

    Das geht über ein Flag (= Boolean Variable). Wenn die Tastenkombi gedrückt wird, wird das Flag zwischen True und False hin- und hergeschaltet. Und wenn es auf True ist, wird dies in Zeile #85 geprüft und der Fensterverschiebecode wird ausgeführt. Du solltest dies aber ggf. irgendwo anzeigen, ggf. als Symbol im Traybereich, Ob der Verschiebemodus aktiv oder inaktiv ist.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    VB.neter0101 schrieb:

    wenn ich z.B. Notepad++ verschiebe schreibt er mir die Qs ins Dokument
    GetAsyncKeyState() leert die Queue nicht.
    Wenn das Notepad den Folus hat, kommt da halt ein Q rein.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @VB.neter0101 Ich weiß nicht, wie die Fremd-Queue geleert werden kann.
    Da hat das System die Hand drauf, zumal Du das fremde ForegroundWindow bedienst, das das Ziel der Queue ist.
    Verhindern kannst Du das, wenn Dein Programm seine eigene Queue leert, und das passiert, wenn Dein Fenster selbst das ForegroundWindow ist.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Ich grabe hier mal wieder diesen Thread aus, da mich interessiert, wie man eine Key Kombination systemweit registriert, Bzw. wie man dies verallgemeinert mit weiteren Hotkeys.

    Wichtig wäre die Hotkeys als global zu setzen, dass sobald der Hotkey betätigt wird eine Subsequenz im Programm ausgeführt wird und das unabhängig davon ob meine Windows Form aktiv ist oder nicht.

    Hat hier schon mal Jemand erste Ergebnisse erzielt?

    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

Facebook
Telefonspende