Eine fremde, nicht C# Anwendung davon abhalten mit Alt + F4 geschlossen zu werden. Ist es möglich?

  • C#

Es gibt 10 Antworten in diesem Thema. Der letzte Beitrag () ist von VaporiZed.

    Eine fremde, nicht C# Anwendung davon abhalten mit Alt + F4 geschlossen zu werden. Ist es möglich?

    Hallo,

    ist es möglich, eine fremde Anwendung vom schließen via Alt + F4 abzuhalten?
    Ich würde dies gerne erzielen da ich gerne den Benutzer erst fragen möchte ob er diese Anwendung wirklich beenden möchte, da die Anwendung sonst immer sofort geschlossen wird.

    Kann man die Tastenkombination vielleicht in einem C# Programm abfangen and da dann weiter verarbeiten?

    Die Anwendung ist übrigens eine Vollbildanwendung.
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    Ich habe einen systemweiten Hotkey für die Tastenkombi Alt+F4 registriert mit einem C# Programm.
    Aber was ist der nächste Schritt? Wie kann ich diese Tastenkombi "verwerfen" so das sie nicht mehr zur Vollbildanwendung gelangt?

    Das hört sich so an als ob das eher mit einer Sprache funtkionieren würde die "tiefer" ins System eingreift.
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    Das passende Stichwort wurde dir doch schon gegeben !
    "Keyboard Hook", oder besser "Global Keyboard Hook" !

    Polemik an dieser Stelle entfernt ~VaporiZed

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    Ist ja gut, ich schrei hier auch nicht direkt so rum.
    Habs selbstständig herausgefunden.
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    ClonkAndre schrieb:

    Habs selbstständig herausgefunden.
    Lässt Du uns an Deiner Lösung teilhaben?
    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!

    RodFromGermany schrieb:

    Lässt Du uns an Deiner Lösung teilhaben?

    Gerne.

    Dies ist die Klasse. Gefunden habe ich sie auf codeproject.
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Runtime.InteropServices;
    4. using System.Windows.Forms;
    6. namespace PlayGTAIVOnline {
    7. /// <summary>
    8. /// A class that manages a global low level keyboard hook
    9. /// </summary>
    10. public class GlobalKeyboardHook {
    12. #region DLL imports
    13. /// <summary>
    14. /// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
    15. /// </summary>
    16. /// <param name="idHook">The id of the event you want to hook</param>
    17. /// <param name="callback">The callback.</param>
    18. /// <param name="hInstance">The handle you want to attach the event to, can be null</param>
    19. /// <param name="threadId">The thread you want to attach the event to, can be null</param>
    20. /// <returns>a handle to the desired hook</returns>
    21. [DllImport("user32.dll")]
    22. static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);
    24. /// <summary>
    25. /// Unhooks the windows hook.
    26. /// </summary>
    27. /// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
    28. /// <returns>True if successful, false otherwise</returns>
    29. [DllImport("user32.dll")]
    30. static extern bool UnhookWindowsHookEx(IntPtr hInstance);
    32. /// <summary>
    33. /// Calls the next hook.
    34. /// </summary>
    35. /// <param name="idHook">The hook id</param>
    36. /// <param name="nCode">The hook code</param>
    37. /// <param name="wParam">The wparam.</param>
    38. /// <param name="lParam">The lparam.</param>
    39. /// <returns></returns>
    40. [DllImport("user32.dll")]
    41. static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);
    43. /// <summary>
    44. /// Loads the library.
    45. /// </summary>
    46. /// <param name="lpFileName">Name of the library</param>
    47. /// <returns>A handle to the library</returns>
    48. [DllImport("kernel32.dll")]
    49. static extern IntPtr LoadLibrary(string lpFileName);
    51. /// <summary>
    52. /// Gets the state of modifier keys for a given keycode.
    53. /// </summary>
    54. /// <param name="keyCode">The keyCode</param>
    55. /// <returns></returns>
    56. [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true, CallingConvention = CallingConvention.Winapi)]
    57. private static extern short GetKeyState(int keyCode);
    58. #endregion
    60. #region Constant, Structure and Delegate Definitions
    61. /// <summary>
    62. /// defines the callback type for the hook
    63. /// </summary>
    64. public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);
    66. public struct keyboardHookStruct {
    67. public int vkCode;
    68. public int scanCode;
    69. public int flags;
    70. public int time;
    71. public int dwExtraInfo;
    72. }
    74. const int WH_KEYBOARD_LL = 13;
    75. const int WM_KEYDOWN = 0x100;
    76. const int WM_KEYUP = 0x101;
    77. const int WM_SYSKEYDOWN = 0x104;
    78. const int WM_SYSKEYUP = 0x105;
    80. //Modifier key vkCode constants
    81. private const int VK_SHIFT = 0x10;
    82. private const int VK_CONTROL = 0x11;
    83. private const int VK_MENU = 0x12;
    84. private const int VK_CAPITAL = 0x14;
    85. #endregion
    87. #region Instance Variables
    88. /// <summary>
    89. /// The collections of keys to watch for
    90. /// </summary>
    91. public List<Keys> HookedKeys = new List<Keys>();
    92. /// <summary>
    93. /// Handle to the hook, need this to unhook and call the next hook
    94. /// </summary>
    95. IntPtr hhook = IntPtr.Zero;
    96. #endregion
    98. #region Events
    99. /// <summary>
    100. /// Occurs when one of the hooked keys is pressed
    101. /// </summary>
    102. public event KeyEventHandler KeyDown;
    103. /// <summary>
    104. /// Occurs when one of the hooked keys is released
    105. /// </summary>
    106. public event KeyEventHandler KeyUp;
    107. #endregion
    109. #region Constructors and Destructors
    110. /// <summary>
    111. /// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
    112. /// </summary>
    113. public GlobalKeyboardHook() {
    114. Hook();
    115. }
    117. /// <summary>
    118. /// Releases unmanaged resources and performs other cleanup operations before the
    119. /// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
    120. /// </summary>
    121. ~GlobalKeyboardHook() {
    122. Unhook();
    123. }
    124. #endregion
    126. #region Public Methods
    127. /// <summary>
    128. /// Installs the global hook
    129. /// </summary>
    130. public void Hook() {
    131. IntPtr hInstance = LoadLibrary("User32");
    132. hhook = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0);
    133. }
    135. /// <summary>
    136. /// Uninstalls the global hook
    137. /// </summary>
    138. public void Unhook() {
    139. UnhookWindowsHookEx(hhook);
    140. }
    142. /// <summary>
    143. /// The callback for the keyboard hook
    144. /// </summary>
    145. /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
    146. /// <param name="wParam">The event type</param>
    147. /// <param name="lParam">The keyhook event information</param>
    148. /// <returns></returns>
    149. private int hookProc(int code, int wParam, ref keyboardHookStruct lParam) {
    150. if (code >= 0) {
    151. Keys key = (Keys)lParam.vkCode;
    152. if (HookedKeys.Contains(key)) {
    153. key = AddModifiers(key);
    154. KeyEventArgs kea = new KeyEventArgs(key);
    155. if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null)) {
    156. KeyDown(this, kea) ;
    157. } else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null)) {
    158. KeyUp(this, kea);
    159. }
    160. if (kea.Handled)
    161. return 1;
    162. }
    163. }
    164. return CallNextHookEx(hhook, code, wParam, ref lParam);
    165. }
    167. /// <summary>
    168. /// Checks whether Alt, Shift, Control or CapsLock
    169. /// is pressed at the same time as the hooked key.
    170. /// Modifies the keyCode to include the pressed keys.
    171. /// </summary>
    172. private Keys AddModifiers(Keys key)
    173. {
    174. //CapsLock
    175. if ((GetKeyState(VK_CAPITAL) & 0x0001) != 0) key = key | Keys.CapsLock;
    177. //Shift
    178. if ((GetKeyState(VK_SHIFT) & 0x8000) != 0) key = key | Keys.Shift;
    180. //Ctrl
    181. if ((GetKeyState(VK_CONTROL) & 0x8000) != 0) key = key | Keys.Control;
    183. //Alt
    184. if ((GetKeyState(VK_MENU) & 0x8000) != 0) key = key | Keys.Alt;
    186. return key;
    187. }
    188. #endregion
    190. }
    191. }



    Anwendung:
    Spoiler anzeigen

    C#-Quellcode

    1. private GlobalKeyboardHook globalKeyboardHook;
    3. public Main()
    4. {
    5. globalKeyboardHook = new GlobalKeyboardHook();
    6. globalKeyboardHook.HookedKeys.Add(System.Windows.Forms.Keys.Alt);
    7. globalKeyboardHook.HookedKeys.Add(System.Windows.Forms.Keys.F4);
    8. globalKeyboardHook.KeyDown += GlobalKeyboardHook_KeyDown;
    9. }
    11. private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
    12. {
    13. globalKeyboardHook.KeyDown -= GlobalKeyboardHook_KeyDown;
    14. globalKeyboardHook.Unhook();
    15. }
    17. private void GlobalKeyboardHook_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
    18. {
    19. if (e.Alt && e.KeyCode == System.Windows.Forms.Keys.F4) { // Alt + F4
    20. // Check if window is open and maximized then prevent it from closing
    21. e.Handled = true;
    22. }
    23. }



    Dies funktioniert genau so wie ich das gerne möchte. Die Vollbildanwendung wird nicht mehr durch Alt + F4 geschlossen.
    Andere Anwendungen können zwar jetzt auch nicht mehr durch Alt + F4 geschlossen werden wenn der Hook aktiv ist, aber da habe ich eine Idee um dies zu verhindern.
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    Reaktion auf Polemik an dieser Stelle entfernt ~VaporiZed

    Noch zum Thema vom Threadersteller:
    Es gibt da etwas ganz tolles, ich bin mir sicher es würde dir all dies ermöglichen und mit hoher Warscheinlichkeit noch mehr.
    Es gibt da dieses kleine Werkzeug mit dem Namen AutoHotKey, dafür schreibt man das eine oder andere Skriptchen.

    Mit jene welchen kannst du dann bestimmt so etwas in der Art bewerkstelligen.
    Das besondere, man findet bereits sehr sehr viele Skripte wenn man mal danach auf Google sucht.
    Ich bezweifle stark, dass es Dinge gibt die noch nicht jemand irgendwo im Internet veröffentlicht hat die für AHK bestimmt waren.

    Probiers einfach mal aus :D
    ----------------------------------------------------------------------------------------------------------------------

    Hier könnte meine Signatur stehen, aber die ist mir abfußen gekommen.

    ----------------------------------------------------------------------------------------------------------------------

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    Da damit zu rechnen ist, dass hier nicht mehr zum eigentlichen Thema beigetragen wird, wurde hier aufgeräumt und dichtgemacht. Führt Eure Diskussion notfalls in privater Konversation weiter.
    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.

Facebook
Telefonspende