Programm mit gedrückter Shift-Taste starten

[Popov]

Ich würde mein Programm gerne mit gedrückter Shift-Taste starten. In diesem Fall soll das Programm in einem Wartungs-Modus starten. Das habe ich mal so gesehen und ich glaube es schon mal gemacht zu haben.

Nur dieses Mal klappt es irgendwie nicht, denn das Programm reagiert erst auf die Tasten wenn es gestartet ist.

Eine Idee wie ich die Tasten direkt beim Start abfragen kann?

[Sir Rufo]

Wie machst du es denn aktuell?

Ich würde dafür GetAsyncKeyState oder GetKeyState verwenden.

So als Minimalst-Ansatz

Delphi-Quellcode:

unit Unit1;

interface

uses
  {Winapi.}Windows;

var
  ShiftStartMode : Boolean = False;

implementation

initialization

ShiftStartMode := ( GetKeyState(VK_LSHIFT) and $80 ) = $80;

end.

[mm1256]

Ich merke mir lieber den kompletten Status mit GetKeyboardState gleich als ersten Aufruf in der Projektdatei, weil ich damit den kompletten Status bekomme, und an beliebigen Programmstellen später in der Anwendung nochmals abfragen kann.

[Popov]

Danke, damit klappt es wunderbar.

Zitat von Sir Rufo:

Wie machst du es denn aktuell?

Über Parameter.

[mm1256]

Zitat von Popov:

Danke, damit klappt es wunderbar.

Schön! Noch ein Tipp am Rande: Wenn der "Wartungs-Modus" aktiviert ist (bei mir mit VK_LSHIFT beim Programmstart) dann zeige ich noch einen Menüpunkt im Hauptmenü unter "Hilfe" an, mit dem man dann den Modus auch im laufenden Betrieb aus/einschalten kann. Oder erweitern bzw. reduzieren. Das ist extrem praktisch bei Hotline via Fernwartung.

Das Hilfe-Menü bietet sich deswegen an, weil es i.d.R. im gesamten Programm zur Verfügung steht

Hinzu kommt noch: Wenn man wie ich Formulare zur Laufzeit erzeugt (was ja irgendwie Sinn macht) dann kann man je nach Belieben (z.B. im OnCreate-Event) den "Wartungs-Status" aktualisieren, auch ohne dass der globale Menüpunkt im Hilfemenü vorhanden ist, indem man einfach den global gespeicherten KeyBoardState aktualisiert (MyKey_StoreKeyboardState)

Auszug aus der unit:

Delphi-Quellcode:

interface

uses Windows, Classes;

var
  MyKey_KeyboardState : TKeyBoardState;

procedure MyKey_StoreKeyboardState;
function MyKey_KeyPressed(VirtualKeyCode: Byte) : boolean;

implementation

procedure MyKey_StoreKeyboardState;
begin
  GetKeyboardState(MyKey_KeyboardState);
end;

function MyKey_KeyPressed(VirtualKeyCode: Byte) : boolean;
begin
  Result := ((MyKey_KeyboardState[VirtualKeyCode] and 128) <> 0);
end;

Ich weiß, ist primitiv, aber funzt. SirRufo würde hierfür vermutlich eine Klasse basteln. (@SirRufo: ist jetzt nicht bös gemeint!) Wäre programmiertechnisch auch sinnvoller, keine Frage, aber das ist mir in diesem Fall ehrlich gesagt so was von...

[Sir Rufo]

Zitat von mm1256:

Ich weiß, ist primitiv, aber funzt. SirRufo würde hierfür vermutlich eine Klasse basteln. (@SirRufo: ist jetzt nicht bös gemeint!) Wäre programmiertechnisch auch sinnvoller, keine Frage, aber das ist mir in diesem Fall ehrlich gesagt so was von...

Schon ok, aber ja, ich würde das in eine Klasse (Struktur) packen, die dann den Zugriff vereinfacht.

Delphi-Quellcode:

unit KeyStateSnapshot;

interface

uses
  Winapi.Windows;

type
  TKeyState = ( ksPressed, ksToggled );
  TKeyStates = set of TKeyState;

  IKeyStateSnapshot = interface
    ['{83675AEC-1F42-44CD-84F3-0B7EED2EE186}']
    function GetKeyStates( Key: Byte ): TKeyStates;
    property KeyStates[Key: Byte]: TKeyStates read GetKeyStates; default;
  end;

  TKeyStateSnapshot = class( TInterfacedObject, IKeyStateSnapshot )
  private const
    BITMASK_KEY_ISPRESSED = $80;
    BITMASK_KEY_ISTOGGLED = $01;
  private
    class var _Startup: IKeyStateSnapshot;
    class constructor Create;
  private
    FKeyboardState: TKeyboardState;
    function GetKeyStates( Key: Byte ): TKeyStates;
  protected
    constructor Create;
  public
    class function Current: IKeyStateSnapshot;
    class function Startup: IKeyStateSnapshot;
  end;

implementation

{ TKeyStateSnapshot }

class constructor TKeyStateSnapshot.Create;
begin
  _Startup := TKeyStateSnapshot.Create;
end;

constructor TKeyStateSnapshot.Create;
var
  LResult: LongBool;
begin
  inherited Create;
  LResult := GetKeyboardState( FKeyboardState );
end;

class function TKeyStateSnapshot.Current: IKeyStateSnapshot;
begin
  Result := TKeyStateSnapshot.Create;
end;

function TKeyStateSnapshot.GetKeyStates( Key: Byte ): TKeyStates;
var
  LState: Byte;
begin
  Result := [];
  LState := FKeyboardState[Key];
  if ( LState and BITMASK_KEY_ISPRESSED ) = BITMASK_KEY_ISPRESSED
  then
    Result := Result + [ksPressed];
  if ( LState and BITMASK_KEY_ISTOGGLED ) = BITMASK_KEY_ISTOGGLED
  then
    Result := Result + [ksToggled];
end;

class function TKeyStateSnapshot.Startup: IKeyStateSnapshot;
begin
  Result := _Startup;
end;

end.

[BUG]

Man könnte sich noch darüber streiten, ob das Erstellen des Snapshots zu Programmstart in diese Klasse gehört

Die Verbindung zwischen Shift beim Programmstart und dem Wartungsmodus sollte man imho nur an einer Stelle im Code machen. Das Umschalten von irgendwelchen gespeicherten Tastenstatus mitten im Programm würde mich etwas verwirren. No offence

[SMO]

if GetKeyState(VK_LSHIFT) < 0 then // key is pressed ... tut es übrigens auch und ist dabei kürzer. GetKeyState gibt ein SHORT zurück, das entspricht einem SmallInt in Delphi. Und MSDN sagt nicht "Bit 7 gesetzt" ($80), sondern "If the high-order bit is 1, the key is down; otherwise, it is up." Ja, ich weiß, mit $80 geht es auch, denn im Endeffekt ist der Rückgabewert ein ShortInt (8 Bit), der mit Vorzeichen auf SmallInt (16 Bit) erweitert wird.