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.

[Sir Rufo]

Zitat von 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

Schon klar, aber im Prinzip ist es eine Zeile Code mehr und die Klasse wird auch nicht durch eine wirklich Zusatzfunktion erweitert. Von daher passt es IMHO schon

Und ja, diesen Wartungs-Status würde ich auch beim Start des Programms anhand des Keyboard-States setzen, danach aber nicht mehr über einen irgendwie gespeicherten Keyboard-State abfragen.

[mm1256]

Zitat von 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

Absolute Zustimmung....auf den ersten Blick. Wenn man aber gerade mit einem Kunden eine Fernwartungs-Session offen hat, und zusätzliche Debug-Info-Meldungen am Bildschirm die Suche nach einem (möglichen) Problem erleichtern, dann ist diese Variante extrem praktisch. Spart oft eine Menge Zeit (und Geld...der Kunde muss es ja letztendlich bezahlen).

Hab ich z.B. ein Problem in der Auftragsbearbeitung (WWS) dann öffne ich diese einfach mit gedrückter Shift-Taste und schon sind die zusätzlichen Meldungen die ich brauche da. Bei gedrückter linker Shift-Taste nur für das aktuelle Fenster, bei gedrückter rechter Shift-Taste nur für das aktuelle Fenster. Die Option ist natürlich nur verfügbar, wenn das Programm mit "Administrator-Tasten-Kombination" gestartet wird, welche ich natürlich hier nicht verrate

Insgesamt gesehen geht das aber einfacher, als das Programm mit neuen Parametern oder gedrückten Tasten zu starten. Sogar bei der Programmierung/Entwicklung ist das nützlich, weil man nicht immer den Debugger bemühen muss.

Klar, für's Debuggen oder für die Fehlersuche gibt's eigene Möglichkeiten. Das muss bzw. kann ja jeder für sich selbst entscheiden. Und was für den Einen sich als sehr praktisch erweist, muss für den Anderen nicht zwangsläufig auch nützlich sein. Ich wollte damit auch keine Grundsatzdiskussion entfachen. Dachte nur, dass es für den TE hilfreich ist.

EDIT:

Zitat von Sir Rufo:

Und ja, diesen Wartungs-Status würde ich auch beim Start des Programms anhand des Keyboard-States setzen, danach aber nicht mehr über einen irgendwie gespeicherten Keyboard-State abfragen.

Na ja, praktisch kann es schon sein, wenn man den "Wartungsmodus" im laufenden Betrieb wieder "deaktivieren" kann, ohne irgend einen Menüpunkt aufrufen zu müssen. Stichwort: Der Kunde sieht ja mit