+ Merged driver support from fixbranch

rtl/go32v2/keyboard.pp

@@ -26,118 +26,72 @@ uses
 
 {$i keyboard.inc}
 
-procedure InitKeyboard;
-begin
-end;
 
-procedure DoneKeyboard;
-begin
-end;
+function SysGetKeyEvent: TKeyEvent;
 
-function GetKeyEvent: TKeyEvent;
 var
   regs : trealregs;
 begin
-  if PendingKeyEvent<>0 then
-   begin
-     GetKeyEvent:=PendingKeyEvent;
-     PendingKeyEvent:=0;
-     exit;
-   end;
   regs.ah:=$10;
   realintr($16,regs);
   if (regs.al=$e0) and (regs.ah<>0) then
    regs.al:=0;
-  GetKeyEvent:=regs.ax or ((mem[$40:$17] and $f) shl 16);
+  SysGetKeyEvent:=regs.ax or ((mem[$40:$17] and $f) shl 16);
 end;
 
 
-function PollKeyEvent: TKeyEvent;
+function SysPollKeyEvent: TKeyEvent;
 var
   regs : trealregs;
 begin
-  if PendingKeyEvent<>0 then
-   exit(PendingKeyEvent);
   regs.ah:=$11;
   realintr($16,regs);
   if (regs.realflags and zeroflag<>0) then
    exit(0);
   if (regs.al=$e0) and (regs.ah<>0) then
    regs.al:=0;
-  PollKeyEvent:=regs.ax or ((mem[$40:$17] and $f) shl 16);
+  SysPollKeyEvent:=regs.ax or ((mem[$40:$17] and $f) shl 16);
 end;
 
 
-function PollShiftStateEvent: TKeyEvent;
+function SysGetShiftState: Byte;
 begin
-  PollShiftStateEvent:=((mem[$40:$17] and $f) shl 16);
+  SysGetShiftState:=(mem[$40:$17] and $f);
 end;
 
 
-{ Function key translation }
-type
-  TTranslationEntry = packed record
-    Min, Max: Byte;
-    Offset: Word;
-  end;
-const
-  TranslationTableEntries = 12;
-  TranslationTable: array [1..TranslationTableEntries] of TTranslationEntry =
-    ((Min: $3B; Max: $44; Offset: kbdF1),   { function keys F1-F10 }
-     (Min: $54; Max: $5D; Offset: kbdF1),   { Shift fn keys F1-F10 }
-     (Min: $5E; Max: $67; Offset: kbdF1),   { Ctrl fn keys F1-F10 }
-     (Min: $68; Max: $71; Offset: kbdF1),   { Alt fn keys F1-F10 }
-     (Min: $85; Max: $86; Offset: kbdF11),  { function keys F11-F12 }
-     (Min: $87; Max: $88; Offset: kbdF11),  { Shift+function keys F11-F12 }
-     (Min: $89; Max: $8A; Offset: kbdF11),  { Ctrl+function keys F11-F12 }
-     (Min: $8B; Max: $8C; Offset: kbdF11),  { Alt+function keys F11-F12 }
-     (Min:  71; Max:  73; Offset: kbdHome), { Keypad keys kbdHome-kbdPgUp }
-     (Min:  75; Max:  77; Offset: kbdLeft), { Keypad keys kbdLeft-kbdRight }
-     (Min:  79; Max:  81; Offset: kbdEnd),  { Keypad keys kbdEnd-kbdPgDn }
-     (Min: $52; Max: $53; Offset: kbdInsert));
-
-
-function TranslateKeyEvent(KeyEvent: TKeyEvent): TKeyEvent;
-var
-  I: Integer;
-  ScanCode: Byte;
-begin
-  if KeyEvent and $03000000 = $03000000 then
-   begin
-     if KeyEvent and $000000FF <> 0 then
-      begin
-        TranslateKeyEvent := KeyEvent and $00FFFFFF;
-        exit;
-      end
-     else
-      begin
-        { This is a function key }
-        ScanCode := (KeyEvent and $0000FF00) shr 8;
-        for I := 1 to TranslationTableEntries do
-         begin
-           if (TranslationTable[I].Min <= ScanCode) and (ScanCode <= TranslationTable[I].Max) then
-            begin
-              TranslateKeyEvent := $02000000 + (KeyEvent and $00FF0000) +
-                (ScanCode - TranslationTable[I].Min) + TranslationTable[I].Offset;
-              exit;
-            end;
-         end;
-      end;
-   end;
-  TranslateKeyEvent := KeyEvent;
-end;
-
-
-function TranslateKeyEventUniCode(KeyEvent: TKeyEvent): TKeyEvent;
-begin
-  TranslateKeyEventUniCode := KeyEvent;
-  ErrorCode:=errKbdNotImplemented;
-end;
+Const
+  SysKeyboardDriver : TKeyboardDriver = (
+    InitDriver : Nil;
+    DoneDriver : Nil;
+    GetKeyevent : @SysGetKeyEvent;
+    PollKeyEvent : @SysPollKeyEvent;
+    GetShiftState : @SysGetShiftState;
+    TranslateKeyEvent : Nil;
+    TranslateKeyEventUnicode : Nil; 
+  );
 
+begin 
+  SetKeyBoardDriver(SysKeyBoardDriver);
 end.
+
 {
   $Log$
-  Revision 1.1  2001-01-13 11:03:57  peter
+  Revision 1.2  2001-09-21 21:33:35  michael
+  + Merged driver support from fixbranch
+
+  Revision 1.1.2.2  2001/09/21 21:20:43  michael
+  + Added support for keyboard driver.
+  + Added DefaultTranslateKeyEvent,DefaultTranslateKeyEventUnicode
+  + PendingKeyEvent variable no longer public. Handling of this variable is
+    now done entirely by global functions. System dependent code should not
+    need it, it is set automatically.
+  + InitVideo DoneVideo will check whether the keyboard is initialized or not.
+
+  Revision 1.1.2.1  2001/01/30 21:52:01  peter
+    * moved api utils to rtl
+
+  Revision 1.1  2001/01/13 11:03:57  peter
     * API 2 RTL commit
 
 }

rtl/inc/keyboard.inc

@@ -12,6 +12,9 @@
 
  **********************************************************************}
 
+var
+  PendingKeyEvent : TKeyEvent;
+
 procedure PutKeyEvent(KeyEvent: TKeyEvent);
 begin
   PendingKeyEvent := KeyEvent;
@@ -53,9 +56,256 @@ begin
   IsFunctionKey := KeyEvent and $03000000 = $02000000;
 end;
 
+Var 
+  KeyBoardInitialized : Boolean;
+  CurrentKeyboardDriver : TKeyboardDriver;
+  
+procedure InitKeyboard;
+
+begin
+  If Not KeyboardInitialized then
+    begin
+    If Assigned(CurrentKeyBoardDriver.InitDriver) Then
+      CurrentKeyBoardDriver.InitDriver();
+    KeyboardInitialized:=True;  
+    end;  
+end;
+
+procedure DoneKeyboard;
+
+begin
+  If KeyboardInitialized then
+    begin
+    If Assigned(CurrentKeyBoardDriver.DoneDriver) Then
+      CurrentKeyBoardDriver.DoneDriver();
+    KeyboardInitialized:=False;  
+    end;  
+end;
+
+
+function GetKeyEvent: TKeyEvent;
+
+begin
+  if PendingKeyEvent<>0 then
+    begin
+    GetKeyEvent:=PendingKeyEvent;
+    PendingKeyEvent:=0;
+    exit;
+    end;
+  If Assigned(CurrentKeyBoardDriver.GetKeyEvent) Then
+    GetKeyEvent:=CurrentKeyBoardDriver.GetKeyEvent()
+  else
+    GetKeyEvent:=0;
+end;
+
+function PollKeyEvent: TKeyEvent;
+
+begin
+  if PendingKeyEvent<>0 then
+   exit(PendingKeyEvent);
+  If Assigned(CurrentKeyBoardDriver.PollKeyEvent) Then
+    begin
+    PendingKeyEvent:=CurrentKeyBoardDriver.PollKeyEvent();
+    PollKeyEvent:=PendingKeyEvent;
+    end
+  else
+    PollKeyEvent:=0;
+end;
+
+Procedure SetKeyboardDriver (Const Driver : TKeyboardDriver);
+
+begin
+  If Not KeyBoardInitialized then
+    CurrentKeyBoardDriver:=Driver;
+end;
+
+Procedure GetKeyboardDriver (Var Driver : TKeyboardDriver);
+
+begin
+  Driver:=CurrentKeyBoardDriver;
+end;
+
+function PollShiftStateEvent: TKeyEvent;                                        
+
+begin
+  If Assigned(CurrentKeyBoardDriver.GetShiftState) then
+    PollShiftStateEvent:=CurrentKeyBoardDriver.GetShiftState() shl 16
+  else
+    PollShiftStateEvent:=0;  
+end;
+
+function DefaultTranslateKeyEventUniCode(KeyEvent: TKeyEvent): TKeyEvent;
+
+begin
+  DefaultTranslateKeyEventUniCode:=KeyEvent;
+  ErrorCode:=errKbdNotImplemented;
+end;
+
+
+function TranslateKeyEventUniCode(KeyEvent: TKeyEvent): TKeyEvent;
+
+begin
+  if Assigned(CurrentKeyBoardDriver.TranslateKeyEventUnicode) then
+    TranslateKeyEventUnicode:=CurrentKeyBoardDriver.TranslateKeyEventUnicode(KeyEvent)
+  else
+    TranslateKeyEventUnicode:=DefaultTranslateKeyEventUnicode(KeyEvent);  
+end;
+
+type
+  TTranslationEntry = packed record
+    Min, Max: Byte;
+    Offset: Word;
+  end;
+const
+  TranslationTableEntries = 12;
+  TranslationTable: array [1..TranslationTableEntries] of TTranslationEntry =
+    ((Min: $3B; Max: $44; Offset: kbdF1),   { function keys F1-F10 }
+     (Min: $54; Max: $5D; Offset: kbdF1),   { Shift fn keys F1-F10 }
+     (Min: $5E; Max: $67; Offset: kbdF1),   { Ctrl fn keys F1-F10 }
+     (Min: $68; Max: $71; Offset: kbdF1),   { Alt fn keys F1-F10 }
+     (Min: $85; Max: $86; Offset: kbdF11),  { function keys F11-F12 }
+     (Min: $87; Max: $88; Offset: kbdF11),  { Shift+function keys F11-F12 }
+     (Min: $89; Max: $8A; Offset: kbdF11),  { Ctrl+function keys F11-F12 }
+     (Min: $8B; Max: $8C; Offset: kbdF11),  { Alt+function keys F11-F12 }
+     (Min: $47; Max: $49; Offset: kbdHome), { Keypad keys kbdHome-kbdPgUp }
+     (Min: $4B; Max: $4D; Offset: kbdLeft), { Keypad keys kbdLeft-kbdRight }
+     (Min: $4F; Max: $51; Offset: kbdEnd),  { Keypad keys kbdEnd-kbdPgDn }
+     (Min: $52; Max: $53; Offset: kbdInsert));
+ 
+
+function DefaultTranslateKeyEvent(KeyEvent: TKeyEvent): TKeyEvent;
+
+var
+  I: Integer;
+  ScanCode: Byte;
+begin
+  if KeyEvent and $03000000 = $03000000 then
+   begin
+     if KeyEvent and $000000FF <> 0 then
+      begin
+        DefaultTranslateKeyEvent := KeyEvent and $00FFFFFF;
+        exit;
+      end
+     else
+      begin
+        { This is a function key }
+        ScanCode := (KeyEvent and $0000FF00) shr 8;
+        for I := 1 to TranslationTableEntries do
+         begin
+           if (TranslationTable[I].Min <= ScanCode) and (ScanCode <= TranslationTable[I].Max) then
+            begin
+              DefaultTranslateKeyEvent := $02000000 + (KeyEvent and $00FF0000) +
+                (ScanCode - TranslationTable[I].Min) + TranslationTable[I].Offset;
+              exit;
+            end;
+         end;
+      end;
+   end;
+  DefaultTranslateKeyEvent := KeyEvent;                                                                                    
+end;
+
+function TranslateKeyEvent(KeyEvent: TKeyEvent): TKeyEvent;
+
+begin
+  if Assigned(CurrentKeyBoardDriver.TranslateKeyEvent) then
+    TranslateKeyEvent:=CurrentKeyBoardDriver.TranslateKeyEvent(KeyEvent)
+  else
+    TranslateKeyEvent:=DefaultTranslateKeyEvent(KeyEvent);  
+end;
+
+{ ---------------------------------------------------------------------
+    KeyEvent to String representation section.
+  ---------------------------------------------------------------------}
+  
+Procedure AddToString (Var S : String; Const A : String);
+
+begin
+  If Length(S)=0 then
+    S:=A
+  else
+    S:=S+' '+A;  
+end;
+
+Function IntToStr(Int : Longint) : String;
+
+begin
+  Str(Int,IntToStr);  
+end;
+  
+Function ShiftStateToString(KeyEvent : TKeyEvent; UseLeftRight : Boolean) : String;
+
+Var
+  S : Integer;
+  T : String;
+  
+begin
+  S:=GetKeyEventShiftState(KeyEvent);
+  T:='';
+  If (S and kbShift)<>0 then
+    begin
+    if UseLeftRight then
+      case (S and kbShift) of
+        kbShift      : AddToString(T,SLeftRight[1]+' '+SAnd+' '+SLeftRight[2]);
+        kbLeftShift  : AddToString(T,SLeftRight[1]);
+        kbRightShift : AddToString(T,SLeftRight[2]);
+      end;
+    AddToString(T,SShift[1]);
+    end;
+  If (S and kbCtrl)<>0 Then
+    AddToString(T,SShift[2]);
+  If (S and kbAlt)<>0 Then  
+    AddToString(T,SShift[3]);
+  ShiftStateToString:=T;  
+end;
+
+Function FunctionKeyName (KeyCode : Word) : String;
+
+begin
+  If ((KeyCode-KbdF1)<$1F) Then 
+    FunctionKeyName:='F'+IntToStr((KeyCode-KbdF1+1))
+  else
+    begin
+    If (KeyCode-kbdHome)<($2F-$1F) then
+      FunctionKeyName:=SKeyPad[(KeyCode-kbdHome)]
+    else
+      FunctionKeyName:=SUnknownFunctionKey + IntToStr(KeyCode);
+    end;  
+end;
+
+Function KeyEventToString(KeyEvent : TKeyEvent) : String;
+
+Var
+  T : String;
+
+begin
+  T:=ShiftStateToString(KeyEvent,False);
+  Case GetKeyEventFlags(KeyEvent) of
+    kbASCII   : AddToString(T,GetKeyEventChar(KeyEvent));
+    kbUniCode : AddToString(T,SUniCodeChar+IntToStr(GetKeyEventUniCode(Keyevent)));
+    kbFnKey   : AddToString(T,FunctionKeyName(GetKeyEventCode(KeyEvent)));
+                // Not good, we need a GetKeyEventScanCode function !!
+    kbPhys    : AddToString(T,SScanCode+IntToStr(KeyEvent and $ffff));
+  end;
+  KeyEventToString:=T;
+end;
+
 {
   $Log$
-  Revision 1.1  2001-01-13 11:13:12  peter
+  Revision 1.2  2001-09-21 21:33:36  michael
+  + Merged driver support from fixbranch
+
+  Revision 1.1.2.2  2001/09/21 21:20:43  michael
+  + Added support for keyboard driver.
+  + Added DefaultTranslateKeyEvent,DefaultTranslateKeyEventUnicode
+  + PendingKeyEvent variable no longer public. Handling of this variable is
+    now done entirely by global functions. System dependent code should not
+    need it, it is set automatically.
+  + InitVideo DoneVideo will check whether the keyboard is initialized or not.
+
+  Revision 1.1.2.1  2001/01/30 22:21:22  peter
+    * move api to rtl
+
+  Revision 1.1  2001/01/13 11:13:12  peter
     * API 2 RTL
 
 }

rtl/inc/keybrdh.inc

@@ -20,6 +20,10 @@ const
 
 type
   TKeyEvent = Longint;
+  TKeyRecord = packed record
+    KeyCode : Word;
+    ShiftState, Flags : Byte;
+  end;
 
 { The structure of a TKeyEvent follows in LSB-MSB order:
   2 bytes: depending on flags either the physical representation of a key
@@ -98,9 +102,31 @@ const
   kbCtrl        = 4;
   kbAlt         = 8;
 
-var
-  PendingKeyEvent : TKeyEvent;
-
+{ ---------------------------------------------------------------------
+    Key names. Can be localized if needed.
+  ---------------------------------------------------------------------}
+  SShift       : Array [1..3] of string[5] = ('SHIFT','CTRL','ALT');
+  SLeftRight   : Array [1..2] of string[5] = ('LEFT','RIGHT');
+  SUnicodeChar : String = 'Unicode character ';
+  SScanCode    : String = 'Key with scancode ';
+  SUnknownFunctionKey : String = 'Unknown function key : ';
+  SAnd         : String = 'AND';
+  SKeyPad      : Array [0..($FF2F-kbdHome)] of string[6] = 
+                 ('Home','Up','PgUp','Left',
+                  'Middle','Right','End','Down',
+                  'PgDn','Insert','Delete','',
+                  '','','','');
+
+Type 
+  TKeyboardDriver = Record
+    InitDriver : Procedure;
+    DoneDriver : Procedure;
+    GetKeyEvent : Function : TKeyEvent;
+    PollKeyEvent : Function : TKeyEvent;
+    GetShiftState : Function : Byte;
+    TranslateKeyEvent : Function (KeyEvent: TKeyEvent): TKeyEvent;
+    TranslateKeyEventUniCode : Function (KeyEvent: TKeyEvent): TKeyEvent;
+  end;
 
 procedure InitKeyboard;
 { Initializes the keyboard interface, additional platform specific parameters
@@ -151,9 +177,37 @@ function GetKeyEventShiftState(KeyEvent: TKeyEvent): Byte;
 function IsFunctionKey(KeyEvent: TKeyEvent): Boolean;
 { Returns true if the given key was a function key or not }
 
+Procedure SetKeyboardDriver (Const Driver : TKeyboardDriver);
+{ Sets the keyboard driver to use }
+
+Procedure GetKeyboardDriver (Var Driver : TKeyboardDriver);
+{ Returns the currently active keyboard driver }
+
+Function ShiftStateToString(KeyEvent : TKeyEvent; UseLeftRight : Boolean) : String;
+{ Returns a string representation of a shift state as returned by 
+  pollshiftstate }
+Function FunctionKeyName (KeyCode : Word) : String;
+{ Returns the name of a function key if the key is one of the special keys . }
+Function KeyEventToString(KeyEvent : TKeyEvent) : String;
+{ Returns a string representation of the pressed key }
+
 {
   $Log$
-  Revision 1.1  2001-01-13 11:13:12  peter
+  Revision 1.2  2001-09-21 21:33:36  michael
+  + Merged driver support from fixbranch
+
+  Revision 1.1.2.2  2001/09/21 21:20:43  michael
+  + Added support for keyboard driver.
+  + Added DefaultTranslateKeyEvent,DefaultTranslateKeyEventUnicode
+  + PendingKeyEvent variable no longer public. Handling of this variable is
+    now done entirely by global functions. System dependent code should not
+    need it, it is set automatically.
+  + InitVideo DoneVideo will check whether the keyboard is initialized or not.
+
+  Revision 1.1.2.1  2001/01/30 22:21:22  peter
+    * move api to rtl
+
+  Revision 1.1  2001/01/13 11:13:12  peter
     * API 2 RTL
 
 }

rtl/os2/keyboard.pp

@@ -30,7 +30,7 @@ const
  DefaultKeyboard = 0;
  Handle: word = DefaultKeyboard;
 
-procedure InitKeyboard;
+procedure SysInitKeyboard;
 var
  K: TKbdInfo;
 begin
@@ -47,7 +47,7 @@ begin
  end;
 end;
 
-procedure DoneKeyboard;
+procedure SysDoneKeyboard;
 begin
  KbdFreeFocus (Handle);
  if KbdGetFocus (IO_Wait, DefaultKeyboard) = No_Error then
@@ -58,114 +58,87 @@ begin
  end;
 end;
 
-function GetKeyEvent: TKeyEvent;
+function SysGetKeyEvent: TKeyEvent;
 var
  K: TKbdKeyInfo;
 begin
- if PendingKeyEvent <> 0 then
- begin
-  GetKeyEvent := PendingKeyEvent;
-  PendingKeyEvent := 0;
- end else
- begin
   KbdGetFocus (IO_Wait, Handle);
   while (KbdCharIn (K, IO_Wait, Handle) <> No_Error)
-                                   or (K.fbStatus and $40 = 0) do DosSleep (5);
+        or (K.fbStatus and $40 = 0) do 
+    DosSleep (5);
   with K do
-  begin
-   if (byte (chChar) = $E0) and (fbStatus and 2 <> 0) then chChar := #0;
-   GetKeyEvent := cardinal ($0300 or fsState and $F) shl 16 or
-                               cardinal (byte (chScan)) shl 8 or byte (chChar);
-  end;
- end;
+    begin
+    if (byte (chChar) = $E0) and (fbStatus and 2 <> 0) then chChar := #0;
+    SysGetKeyEvent := cardinal ($0300 or fsState and $F) shl 16 or
+                      cardinal (byte (chScan)) shl 8 or byte (chChar);
+    end;
 end;
 
-function PollKeyEvent: TKeyEvent;
+function SysPollKeyEvent: TKeyEvent;
 var
  K: TKbdKeyInfo;
+ key : TKeyEvent;
+ 
 begin
- if PendingKeyEvent = 0 then
- begin
+  Key:=0;
   KbdGetFocus (IO_NoWait, Handle);
   if (KbdCharIn (K, IO_NoWait, Handle) <> No_Error) or
-                 (K.fbStatus and $40 = 0) then FillChar (K, SizeOf (K), 0) else
-  with K do
-  begin
-   if (byte (chChar) = $E0) and (fbStatus and 2 <> 0) then chChar := #0;
-   PendingKeyEvent := cardinal ($0300 or fsState and $F) shl 16 or
-                               cardinal (byte (chScan)) shl 8 or byte (chChar);
-  end;
- end;
- PollKeyEvent := PendingKeyEvent;
- if PendingKeyEvent and $FFFF = 0 then PendingKeyEvent := 0;
+     (K.fbStatus and $40 = 0) then 
+    FillChar (K, SizeOf (K), 0) 
+  else
+    with K do
+      begin
+      if (byte (chChar) = $E0) and (fbStatus and 2 <> 0) then 
+        chChar := #0;
+      Key:= cardinal ($0300 or fsState and $F) shl 16 or
+            cardinal (byte (chScan)) shl 8 or byte (chChar);
+      end;
+  if (Key and $FFFF)=0 then 
+   Key := 0;
+  SysPollKeyEvent:=Key;
 end;
 
-function PollShiftStateEvent: TKeyEvent;
+function SysGetShiftState: Byte;
+
 var
  K: TKbdInfo;
 begin
  KbdGetFocus (IO_NoWait, Handle);
  KbdGetStatus (K, Handle);
- PollShiftStateEvent := cardinal (K.fsState and $F) shl 16;
-end;
-
-type
- TTranslationEntry = packed record
-  Min, Max: byte;
-  Offset: word;
- end;
-
-const
- TranslationTableEntries = 12;
- TranslationTable: array [1..TranslationTableEntries] of TTranslationEntry =
-    ((Min: $3B; Max: $44; Offset: kbdF1),   { function keys F1-F10 }
-     (Min: $54; Max: $5D; Offset: kbdF1),   { Shift fn keys F1-F10 }
-     (Min: $5E; Max: $67; Offset: kbdF1),   { Ctrl fn keys F1-F10 }
-     (Min: $68; Max: $71; Offset: kbdF1),   { Alt fn keys F1-F10 }
-     (Min: $85; Max: $86; Offset: kbdF11),  { function keys F11-F12 }
-     (Min: $87; Max: $88; Offset: kbdF11),  { Shift+function keys F11-F12 }
-     (Min: $89; Max: $8A; Offset: kbdF11),  { Ctrl+function keys F11-F12 }
-     (Min: $8B; Max: $8C; Offset: kbdF11),  { Alt+function keys F11-F12 }
-     (Min:  71; Max:  73; Offset: kbdHome), { Keypad keys kbdHome-kbdPgUp }
-     (Min:  75; Max:  77; Offset: kbdLeft), { Keypad keys kbdLeft-kbdRight }
-     (Min:  79; Max:  81; Offset: kbdEnd),  { Keypad keys kbdEnd-kbdPgDn }
-     (Min: $52; Max: $53; Offset: kbdInsert));
-
-
-function TranslateKeyEvent (KeyEvent: TKeyEvent): TKeyEvent;
-var
- I: integer;
- ScanCode: byte;
-begin
- if KeyEvent and $03000000 = $03000000 then
- begin
-  if (KeyEvent and $000000FF <> 0) and (KeyEvent and $000000FF <> $E0) then
-                               TranslateKeyEvent := KeyEvent and $00FFFFFF else
-  begin
-{ This is a function key }
-   ScanCode := (KeyEvent and $0000FF00) shr 8;
-   I := 1;
-   while (I <= TranslationTableEntries) and
-       ((TranslationTable [I].Min > ScanCode) or
-                             (ScanCode > TranslationTable [I].Max)) do Inc (I);
-   if I > TranslationTableEntries then TranslateKeyEvent := KeyEvent else
-           TranslateKeyEvent := $02000000 + (KeyEvent and $00FF0000) +
-             (ScanCode - TranslationTable[I].Min) + TranslationTable[I].Offset;
-  end;
- end else TranslateKeyEvent := KeyEvent;
-end;
-
-function TranslateKeyEventUniCode (KeyEvent: TKeyEvent): TKeyEvent;
-begin
- TranslateKeyEventUniCode := KeyEvent;
- ErrorCode := errKbdNotImplemented;
-(* ErrorHandler (errKbdNotImplemented, nil);*)
+ SysGetShiftState:=(K.fsState and $F);
 end;
 
+Const
+  SysKeyboardDriver : TKeyboardDriver = (
+    InitDriver : @SysInitKeyBoard;
+    DoneDriver : @SysDoneKeyBoard;
+    GetKeyevent : @SysGetKeyEvent;
+    PollKeyEvent : @SysPollKeyEvent;
+    GetShiftState : @SysGetShiftState;
+    TranslateKeyEvent : Nil;
+    TranslateKeyEventUnicode : Nil; 
+  );
+
+begin 
+  SetKeyBoardDriver(SysKeyBoardDriver);
 end.
 {
   $Log$
-  Revision 1.2  2001-01-13 12:01:07  hajny
+  Revision 1.3  2001-09-21 21:33:36  michael
+  + Merged driver support from fixbranch
+
+  Revision 1.2.2.2  2001/09/21 21:20:43  michael
+  + Added support for keyboard driver.
+  + Added DefaultTranslateKeyEvent,DefaultTranslateKeyEventUnicode
+  + PendingKeyEvent variable no longer public. Handling of this variable is
+    now done entirely by global functions. System dependent code should not
+    need it, it is set automatically.
+  + InitVideo DoneVideo will check whether the keyboard is initialized or not.
+
+  Revision 1.2.2.1  2001/01/30 21:52:02  peter
+    * moved api utils to rtl
+
+  Revision 1.2  2001/01/13 12:01:07  hajny
     * ErrorHandler correction
 
   Revision 1.1  2001/01/13 11:03:58  peter

rtl/unix/keyboard.pp

@@ -51,151 +51,7 @@ var
 {$ifdef logging}
   f : text;
 {$endif logging}
-
-{ list of all dos scancode for key giving 0 as char }
-Const
-   kbNoKey       = $00;
-   kbAltEsc      = $01;
-   kbAltSpace    = $02;
-   kbCtrlIns     = $04;
-   kbShiftIns    = $05;
-   kbCtrlDel     = $06;
-   kbShiftDel    = $07;
-   kbAltBack     = $08;
-   kbAltShiftBack= $09;
-   kbShiftTab    = $0F;
-   kbAltQ        = $10;
-   kbAltW        = $11;
-   kbAltE        = $12;
-   kbAltR        = $13;
-   kbAltT        = $14;
-   kbAltY        = $15;
-   kbAltU        = $16;
-   kbAltI        = $17;
-   kbAltO        = $18;
-   kbAltP        = $19;
-   kbAltLftBrack = $1A;
-   kbAltRgtBrack = $1B;
-   kbAltA        = $1E;
-   kbAltS        = $1F;
-   kbAltD        = $20;
-   kbAltF        = $21;
-   kbAltG        = $22;
-   kbAltH        = $23;
-   kbAltJ        = $24;
-   kbAltK        = $25;
-   kbAltL        = $26;
-   kbAltSemiCol  = $27;
-   kbAltQuote    = $28;
-   kbAltOpQuote  = $29;
-   kbAltBkSlash  = $2B;
-   kbAltZ        = $2C;
-   kbAltX        = $2D;
-   kbAltC        = $2E;
-   kbAltV        = $2F;
-   kbAltB        = $30;
-   kbAltN        = $31;
-   kbAltM        = $32;
-   kbAltComma    = $33;
-   kbAltPeriod   = $34;
-   kbAltSlash    = $35;
-   kbAltGreyAst  = $37;
-   kbF1          = $3B;
-   kbF2          = $3C;
-   kbF3          = $3D;
-   kbF4          = $3E;
-   kbF5          = $3F;
-   kbF6          = $40;
-   kbF7          = $41;
-   kbF8          = $42;
-   kbF9          = $43;
-   kbF10         = $44;
-   kbHome        = $47;
-   kbUp          = $48;
-   kbPgUp        = $49;
-   kbLeft        = $4B;
-   kbCenter      = $4C;
-   kbRight       = $4D;
-   kbAltGrayPlus = $4E;
-   kbend         = $4F;
-   kbDown        = $50;
-   kbPgDn        = $51;
-   kbIns         = $52;
-   kbDel         = $53;
-   kbShiftF1     = $54;
-   kbShiftF2     = $55;
-   kbShiftF3     = $56;
-   kbShiftF4     = $57;
-   kbShiftF5     = $58;
-   kbShiftF6     = $59;
-   kbShiftF7     = $5A;
-   kbShiftF8     = $5B;
-   kbShiftF9     = $5C;
-   kbShiftF10    = $5D;
-   kbCtrlF1      = $5E;
-   kbCtrlF2      = $5F;
-   kbCtrlF3      = $60;
-   kbCtrlF4      = $61;
-   kbCtrlF5      = $62;
-   kbCtrlF6      = $63;
-   kbCtrlF7      = $64;
-   kbCtrlF8      = $65;
-   kbCtrlF9      = $66;
-   kbCtrlF10     = $67;
-   kbAltF1       = $68;
-   kbAltF2       = $69;
-   kbAltF3       = $6A;
-   kbAltF4       = $6B;
-   kbAltF5       = $6C;
-   kbAltF6       = $6D;
-   kbAltF7       = $6E;
-   kbAltF8       = $6F;
-   kbAltF9       = $70;
-   kbAltF10      = $71;
-   kbCtrlPrtSc   = $72;
-   kbCtrlLeft    = $73;
-   kbCtrlRight   = $74;
-   kbCtrlend     = $75;
-   kbCtrlPgDn    = $76;
-   kbCtrlHome    = $77;
-   kbAlt1        = $78;
-   kbAlt2        = $79;
-   kbAlt3        = $7A;
-   kbAlt4        = $7B;
-   kbAlt5        = $7C;
-   kbAlt6        = $7D;
-   kbAlt7        = $7E;
-   kbAlt8        = $7F;
-   kbAlt9        = $80;
-   kbAlt0        = $81;
-   kbAltMinus    = $82;
-   kbAltEqual    = $83;
-   kbCtrlPgUp    = $84;
-   kbF11         = $85;
-   kbF12         = $86;
-   kbShiftF11    = $87;
-   kbShiftF12    = $88;
-   kbCtrlF11     = $89;
-   kbCtrlF12     = $8A;
-   kbAltF11      = $8B;
-   kbAltF12      = $8C;
-   kbCtrlUp      = $8D;
-   kbCtrlMinus   = $8E;
-   kbCtrlCenter  = $8F;
-   kbCtrlGreyPlus= $90;
-   kbCtrlDown    = $91;
-   kbCtrlTab     = $94;
-   kbAltHome     = $97;
-   kbAltUp       = $98;
-   kbAltPgUp     = $99;
-   kbAltLeft     = $9B;
-   kbAltRight    = $9D;
-   kbAltend      = $9F;
-   kbAltDown     = $A0;
-   kbAltPgDn     = $A1;
-   kbAltIns      = $A2;
-   kbAltDel      = $A3;
-   kbAltTab      = $A5;
+{$i keyscan.inc}
 
 {$ifdef Unused}
 type
@@ -1401,7 +1257,7 @@ end;
 
 { Exported functions }
 
-procedure InitKeyboard;
+procedure SysInitKeyboard;
 begin
   SetRawMode(true);
   patchkeyboard;
@@ -1428,7 +1284,7 @@ begin
 end;
 
 
-procedure DoneKeyboard;
+procedure SysDoneKeyboard;
 begin
   unpatchkeyboard;
   SetRawMode(false);
@@ -1438,7 +1294,7 @@ begin
 end;
 
 
-function GetKeyEvent: TKeyEvent;
+function SysGetKeyEvent: TKeyEvent;
 
   function EvalScan(b:byte):byte;
   const
@@ -1494,13 +1350,6 @@ var
   MyChar : char;
   EscUsed,AltPrefixUsed,CtrlPrefixUsed,ShiftPrefixUsed,IsAlt,Again : boolean;
 begin {main}
-  if PendingKeyEvent<>0 then
-   begin
-     GetKeyEvent:=PendingKeyEvent;
-     PendingKeyEvent:=0;
-     exit;
-   end;
-
   MyChar:=Readkey(IsAlt);
   MyScan:=ord(MyChar);
   SState:=ShiftState;
@@ -1551,9 +1400,9 @@ begin {main}
              end;
          end;
         if (MyChar<>#0) or (MyScan<>0) or (SState<>0) then
-          GetKeyEvent:=$3000000 or ord(MyChar) or (MyScan shl 8) or (SState shl 16)
+          SysGetKeyEvent:=$3000000 or ord(MyChar) or (MyScan shl 8) or (SState shl 16)
         else
-          GetKeyEvent:=0;
+          SysGetKeyEvent:=0;
         exit;
       end
     else if MyChar=#27 then
@@ -1627,104 +1476,54 @@ begin {main}
       end;
     until not Again;
   if (MyChar<>#0) or (MyScan<>0) or (SState<>0) then
-    GetKeyEvent:=$3000000 or ord(MyChar) or (MyScan shl 8) or (SState shl 16)
+    SysGetKeyEvent:=$3000000 or ord(MyChar) or (MyScan shl 8) or (SState shl 16)
   else
-    GetKeyEvent:=0;
+    SysGetKeyEvent:=0;
 end;
 
 
-function PollKeyEvent: TKeyEvent;
+function SysPollKeyEvent: TKeyEvent;
 begin
-  if PendingKeyEvent<>0 then
-   exit(PendingKeyEvent);
   if keypressed then
-   begin
-     { just get the key and place it in the pendingkeyevent }
-     PendingKeyEvent:=GetKeyEvent;
-     PollKeyEvent:=PendingKeyEvent;
-   end
+    SysPollKeyEvent:=SysGetKeyEvent
   else
-   PollKeyEvent:=0;
+    SysPollKeyEvent:=0;
 end;
 
 
-function PollShiftStateEvent: TKeyEvent;
-begin
-  PollShiftStateEvent:=ShiftState shl 16;
-end;
-
-
-{ Function key translation }
-type
-  TTranslationEntry = packed record
-    Min, Max: Byte;
-    Offset: Word;
-  end;
-const
-  TranslationTableEntries = 12;
-  TranslationTable: array [1..TranslationTableEntries] of TTranslationEntry =
-    ((Min: $3B; Max: $44; Offset: kbdF1),   { function keys F1-F10 }
-     (Min: $54; Max: $5D; Offset: kbdF1),   { Shift fn keys F1-F10 }
-     (Min: $5E; Max: $67; Offset: kbdF1),   { Ctrl fn keys F1-F10 }
-     (Min: $68; Max: $71; Offset: kbdF1),   { Alt fn keys F1-F10 }
-     (Min: $85; Max: $86; Offset: kbdF11),  { function keys F11-F12 }
-     (Min: $87; Max: $88; Offset: kbdF11),  { Shift+function keys F11-F12 }
-     (Min: $89; Max: $8A; Offset: kbdF11),  { Ctrl+function keys F11-F12 }
-     (Min: $8B; Max: $8C; Offset: kbdF11),  { Alt+function keys F11-F12 }
-     (Min: $47; Max: $49; Offset: kbdHome), { Keypad keys kbdHome-kbdPgUp }
-     (Min: $4B; Max: $4D; Offset: kbdLeft), { Keypad keys kbdLeft-kbdRight }
-     (Min: $4F; Max: $51; Offset: kbdEnd),  { Keypad keys kbdEnd-kbdPgDn }
-     (Min: $52; Max: $53; Offset: kbdInsert));
-
-function TranslateKeyEvent(KeyEvent: TKeyEvent): TKeyEvent;
-var
-  I: Integer;
-  ScanCode: Byte;
+function SysGetShiftState  : Byte;
 begin
-  if KeyEvent and $03000000 = $03000000 then
-   begin
-     if KeyEvent and $000000FF <> 0 then
-      begin
-        TranslateKeyEvent := KeyEvent and $00FFFFFF;
-        exit;
-      end
-     else
-      begin
-        { This is a function key }
-        ScanCode := (KeyEvent and $0000FF00) shr 8;
-        for I := 1 to TranslationTableEntries do
-         begin
-           if (TranslationTable[I].Min <= ScanCode) and (ScanCode <= TranslationTable[I].Max) then
-            begin
-              TranslateKeyEvent := $02000000 + (KeyEvent and $00FF0000) +
-                (ScanCode - TranslationTable[I].Min) + TranslationTable[I].Offset;
-              exit;
-            end;
-         end;
-      end;
-   end;
-  TranslateKeyEvent := KeyEvent;
-end;
-
-
-function TranslateKeyEventUniCode(KeyEvent: TKeyEvent): TKeyEvent;
-begin
-  TranslateKeyEventUniCode := KeyEvent;
-  ErrorCode:=errKbdNotImplemented;
+  SysGetShiftState:=ShiftState;
 end;
 
 
 procedure RestoreStartMode;
+
 begin
   TCSetAttr(1,TCSANOW,StartTio);
 end;
 
-begin
+Const
+  SysKeyboardDriver : TKeyboardDriver = (
+    InitDriver : @SysInitKeyBoard;
+    DoneDriver : @SysDoneKeyBoard;
+    GetKeyevent : @SysGetKeyEvent;
+    PollKeyEvent : @SysPollKeyEvent;
+    GetShiftState : @SysGetShiftState;
+    TranslateKeyEvent : Nil;
+    TranslateKeyEventUnicode : Nil; 
+  );
+
+begin 
+  SetKeyBoardDriver(SysKeyBoardDriver);
   TCGetAttr(1,StartTio);
 end.
 {
   $Log$
-  Revision 1.7  2001-08-30 20:55:08  peter
+  Revision 1.8  2001-09-21 21:33:36  michael
+  + Merged driver support from fixbranch
+
+  Revision 1.7  2001/08/30 20:55:08  peter
     * v10 merges
 
   Revision 1.6  2001/08/04 11:05:21  peter
@@ -1746,6 +1545,39 @@ end.
   Revision 1.2.2.3  2001/03/24 22:38:46  pierre
    * fix bug with AltGr keys
 
+  Revision 1.2.2.11  2001/09/21 21:20:43  michael
+  + Added support for keyboard driver.
+  + Added DefaultTranslateKeyEvent,DefaultTranslateKeyEventUnicode
+  + PendingKeyEvent variable no longer public. Handling of this variable is
+    now done entirely by global functions. System dependent code should not
+    need it, it is set automatically.
+  + InitVideo DoneVideo will check whether the keyboard is initialized or not.
+
+  Revision 1.2.2.10  2001/08/28 12:27:10  pierre
+   * second change to the char restore into InBuf array in ReadKey function
+
+  Revision 1.2.2.9  2001/08/03 14:46:50  pierre
+   * push the unused char at correct location into syskeypressed buffer
+
+  Revision 1.2.2.8  2001/08/02 13:23:55  pierre
+   * avoid several keys to be read and cause overflows
+
+  Revision 1.2.2.7  2001/06/17 22:56:24  pierre
+  * preserve KDGKBMETA
+
+  Revision 1.2.2.6  2001/04/10 23:22:25  peter
+    * merged fixes
+    * fixed argument name
+
+  Revision 1.2.2.5  2001/03/27 12:38:10  pierre
+   + RestoreStartMode function
+
+  Revision 1.2.2.4  2001/03/27 11:41:03  pierre
+   * fix the special handler case to avoid waiting for one more char
+
+  Revision 1.2.2.3  2001/03/24 22:38:46  pierre
+   * fix bug with AltGr keys
+
   Revision 1.2.2.2  2001/01/30 22:23:44  peter
     * unix back to linux
 

rtl/win32/keyboard.pp

@@ -36,7 +36,7 @@ uses
 
 const MaxQueueSize = 120;
       FrenchKeyboard = $040C040C;
-      KeyboardActive : boolean =false;
+
 var
    keyboardeventqueue : array[0..maxqueuesize] of TKeyEventRecord;
    nextkeyevent,nextfreekeyevent : longint;
@@ -181,10 +181,8 @@ begin
            end;
 end;
 
-procedure InitKeyboard;
+procedure SysInitKeyboard;
 begin
-   if KeyboardActive then
-     exit;
    KeyBoardLayout:=GetKeyboardLayout(0);
    lastShiftState := 0;
    FlushConsoleInputBuffer(StdInputHandle);
@@ -204,18 +202,14 @@ begin
    nextkeyevent:=0;
    nextfreekeyevent:=0;
    SetKeyboardEventHandler (@HandleKeyboard);
-   KeyboardActive:=true;
 end;
 
-procedure DoneKeyboard;
+procedure SysDoneKeyboard;
 begin
-   if not KeyboardActive then
-     exit;
-   SetKeyboardEventHandler(nil);     {hangs???}
-   DeleteCriticalSection (lockVar);
-   FlushConsoleInputBuffer(StdInputHandle);
-   closeHandle (newKeyEvent);
-   KeyboardActive:=false;
+  SetKeyboardEventHandler(nil);     {hangs???}
+  DeleteCriticalSection (lockVar);
+  FlushConsoleInputBuffer(StdInputHandle);
+  closeHandle (newKeyEvent);
 end;
 
 {$define USEKEYCODES}
@@ -550,7 +544,7 @@ CONST
    (n : $00; s : $0F; c : $94; a: $00));     {0F Tab }
 
 
-function translateKey (t : TKeyEventRecord) : TKeyEvent;
+function TranslateKey (t : TKeyEventRecord) : TKeyEvent;
 var key : TKeyEvent;
     ss  : byte;
 {$ifdef  USEKEYCODES}
@@ -679,31 +673,26 @@ begin
   translateKey := Key;
 end;
 
-function GetKeyEvent: TKeyEvent;
+function SysGetKeyEvent: TKeyEvent;
 var t   : TKeyEventRecord;
     key : TKeyEvent;
 begin
-  if PendingKeyEvent<>0 then
-  begin
-    GetKeyEvent:=PendingKeyEvent;
-    PendingKeyEvent:=0;
-    exit;
-  end;
   key := 0;
   repeat
      if getKeyEventFromQueueWait (t) then
        key := translateKey (t);
   until key <> 0;
-  GetKeyEvent := key;
+{$ifdef DEBUG}
+  last_ir.Event.KeyEvent:=t;
+{$endif DEBUG}
+  SysGetKeyEvent := key;
 end;
 
-function PollKeyEvent: TKeyEvent;
+function SysPollKeyEvent: TKeyEvent;
 var t   : TKeyEventRecord;
     k   : TKeyEvent;
 begin
-  if PendingKeyEvent<>0 then
-    exit(PendingKeyEvent);
-  PollKeyEvent := 0;
+  SysPollKeyEvent := 0;
   if getKeyEventFromQueue (t, true) then
   begin
     { we get an enty for shift, ctrl, alt... }
@@ -714,76 +703,102 @@ begin
       if not getKeyEventFromQueue (t, true) then exit;
       k := translateKey (t)
     end;
-    PollKeyEvent := k;
+    SysPollKeyEvent := k;
   end;
 end;
 
 
-function TranslateKeyEvent(KeyEvent: TKeyEvent): TKeyEvent;
+function SysTranslateKeyEvent(KeyEvent: TKeyEvent): TKeyEvent;
 begin
   if KeyEvent and $03000000 = $03000000 then
    begin
      if KeyEvent and $000000FF <> 0 then
      begin
-       TranslateKeyEvent := KeyEvent and $00FFFFFF;
+       SysTranslateKeyEvent := KeyEvent and $00FFFFFF;
        exit;
      end;
      {translate function-keys and other specials, ascii-codes are already ok}
      case (KeyEvent AND $0000FF00) shr 8 of
        {F1..F10}
-       $3B..$44     : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF1 + ((KeyEvent AND $0000FF00) SHR 8) - $3B + $02000000;
+       $3B..$44     : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF1 + ((KeyEvent AND $0000FF00) SHR 8) - $3B + $02000000;
        {F11,F12}
-       $85..$86     : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF11 + ((KeyEvent AND $0000FF00) SHR 8) - $85 + $02000000;
+       $85..$86     : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF11 + ((KeyEvent AND $0000FF00) SHR 8) - $85 + $02000000;
        {Shift F1..F10}
-       $54..$5D     : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF1 + ((KeyEvent AND $0000FF00) SHR 8) - $54 + $02000000;
+       $54..$5D     : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF1 + ((KeyEvent AND $0000FF00) SHR 8) - $54 + $02000000;
        {Shift F11,F12}
-       $87..$88     : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF11 + ((KeyEvent AND $0000FF00) SHR 8) - $87 + $02000000;
+       $87..$88     : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF11 + ((KeyEvent AND $0000FF00) SHR 8) - $87 + $02000000;
        {Alt F1..F10}
-       $68..$71     : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF1 + ((KeyEvent AND $0000FF00) SHR 8) - $68 + $02000000;
+       $68..$71     : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF1 + ((KeyEvent AND $0000FF00) SHR 8) - $68 + $02000000;
        {Alt F11,F12}
-       $8B..$8C     : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF11 + ((KeyEvent AND $0000FF00) SHR 8) - $8B + $02000000;
+       $8B..$8C     : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF11 + ((KeyEvent AND $0000FF00) SHR 8) - $8B + $02000000;
        {Ctrl F1..F10}
-       $5E..$67     : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF1 + ((KeyEvent AND $0000FF00) SHR 8) - $5E + $02000000;
+       $5E..$67     : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF1 + ((KeyEvent AND $0000FF00) SHR 8) - $5E + $02000000;
        {Ctrl F11,F12}
-       $89..$8A     : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF11 + ((KeyEvent AND $0000FF00) SHR 8) - $89 + $02000000;
+       $89..$8A     : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdF11 + ((KeyEvent AND $0000FF00) SHR 8) - $89 + $02000000;
 
        {normal,ctrl,alt}
-       $47,$77,$97  : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdHome + $02000000;
-       $48,$8D,$98  : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdUp + $02000000;
-       $49,$84,$99  : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdPgUp + $02000000;
-       $4b,$73,$9B  : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdLeft + $02000000;
-       $4d,$74,$9D  : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdRight + $02000000;
-       $4f,$75,$9F  : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdEnd + $02000000;
-       $50,$91,$A0  : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdDown + $02000000;
-       $51,$76,$A1  : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdPgDn + $02000000;
-       $52,$92,$A2  : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdInsert + $02000000;
-       $53,$93,$A3  : TranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdDelete + $02000000;
+       $47,$77,$97  : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdHome + $02000000;
+       $48,$8D,$98  : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdUp + $02000000;
+       $49,$84,$99  : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdPgUp + $02000000;
+       $4b,$73,$9B  : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdLeft + $02000000;
+       $4d,$74,$9D  : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdRight + $02000000;
+       $4f,$75,$9F  : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdEnd + $02000000;
+       $50,$91,$A0  : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdDown + $02000000;
+       $51,$76,$A1  : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdPgDn + $02000000;
+       $52,$92,$A2  : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdInsert + $02000000;
+       $53,$93,$A3  : SysTranslateKeyEvent := (KeyEvent AND $FCFF0000) + kbdDelete + $02000000;
      else
-       TranslateKeyEvent := KeyEvent;
+       SysTranslateKeyEvent := KeyEvent;
      end;
    end else
-     TranslateKeyEvent := KeyEvent;
+     SysTranslateKeyEvent := KeyEvent;
 end;
 
-function TranslateKeyEventUniCode(KeyEvent: TKeyEvent): TKeyEvent;
-begin
-  exit (KeyEvent);  {???}
-end;
 
-function PollShiftStateEvent: TKeyEvent;
-var t : TKeyEvent;
+function SysGetShiftState: Byte;
+
 begin
   {may be better to save the last state and return that if no key is in buffer???}
-  t := lastShiftState;
-  PollShiftStateEvent := t shl 16;
+  SysGetShiftState:= lastShiftState;
 end;
 
+Const
+  SysKeyboardDriver : TKeyboardDriver = (
+    InitDriver : @SysInitKeyBoard;
+    DoneDriver : @SysDoneKeyBoard;
+    GetKeyevent : @SysGetKeyEvent;
+    PollKeyEvent : @SysPollKeyEvent;
+    GetShiftState : @SysGetShiftState;
+    TranslateKeyEvent : @SysTranslateKeyEvent;
+    TranslateKeyEventUnicode : Nil; 
+  );
+
+
+begin 
+  SetKeyBoardDriver(SysKeyBoardDriver);
 end.
 {
   $Log$
-  Revision 1.4  2001-08-05 12:23:57  peter
+  Revision 1.5  2001-09-21 21:33:36  michael
+  + Merged driver support from fixbranch
+
+  Revision 1.4  2001/08/05 12:23:57  peter
     * fixed for new input_record
 
+  Revision 1.2.2.4  2001/09/21 21:20:43  michael
+  + Added support for keyboard driver.
+  + Added DefaultTranslateKeyEvent,DefaultTranslateKeyEventUnicode
+  + PendingKeyEvent variable no longer public. Handling of this variable is
+    now done entirely by global functions. System dependent code should not
+    need it, it is set automatically.
+  + InitVideo DoneVideo will check whether the keyboard is initialized or not.
+
+  Revision 1.2.2.3  2001/08/05 12:24:37  peter
+    * fixed for new input_record
+
+  Revision 1.2.2.2  2001/02/05 15:30:06  pierre
+   * fix compiliing with -dDEBUG
+
   Revision 1.3  2001/05/20 12:08:17  peter
     * fixed to compile with debug