API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 27th, 2020
561
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Pascal 30.61 KB | None | 0 0
raw download clone embed print report
  1. unit iupkey;
  2.  
  3. interface
  4.      
  5.      
  6.     // from 32 to 126, all character sets are equal,
  7.     // the key code is the same as the ASCii character code.
  8.      
  9.     const
  10.       K_SP            =  ' ' ; //  32 (0x20)
  11.       K_exclam        =  '!' ; //  33
  12.       K_quotedbl      =  '"'; //  34  { !! removed backslash }
  13.       K_numbersign    =  '#' ; //  35
  14.       K_dollar        =  '$' ; //  36
  15.       K_percent       =  '%' ; //  37
  16.       K_ampersand     =  '&' ; //  38
  17.       K_apostrophe    =  ''''; //  39
  18.       K_parentleft    =  '(' ; //  40
  19.       K_parentright   =  ')' ; //  41
  20.       K_asterisk      =  '*' ; //  42
  21.       K_plus          =  '+' ; //  43
  22.       K_comma         =  ',' ; //  44
  23.       K_minus         =  '-' ; //  45
  24.       K_period        =  '.' ; //  46
  25.       K_slash         =  '/' ; //  47
  26.       K_0             =  '0' ; //  48 (0x30)
  27.       K_1             =  '1' ; //  49
  28.       K_2             =  '2' ; //  50
  29.       K_3             =  '3' ; //  51
  30.       K_4             =  '4' ; //  52
  31.       K_5             =  '5' ; //  53
  32.       K_6             =  '6' ; //  54
  33.       K_7             =  '7' ; //  55
  34.       K_8             =  '8' ; //  56
  35.       K_9             =  '9' ; //  57
  36.       K_colon         =  ':' ; //  58
  37.       K_semicolon     =  ';' ; //  59
  38.       K_less          =  '<' ; //  60
  39.       K_equal         =  '=' ; //  61
  40.       K_greater       =  '>' ; //  62
  41.       K_question      =  '?' ; //  63
  42.       K_at            =  '@' ; //  64
  43.       K_ucA           =  'A' ; //  65 (0x41)    !! added "uc" to elimiate duplicate
  44.       K_ucB           =  'B' ; //  66           !! added "uc" to elimiate duplicate
  45.       K_ucC           =  'C' ; //  67           !! added "uc" to elimiate duplicate
  46.       K_ucD           =  'D' ; //  68           !! added "uc" to elimiate duplicate
  47.       K_ucE           =  'E' ; //  69           !! added "uc" to elimiate duplicate
  48.       K_ucF           =  'F' ; //  70           !! added "uc" to elimiate duplicate
  49.       K_ucG           =  'G' ; //  71           !! added "uc" to elimiate duplicate
  50.       K_ucH           =  'H' ; //  72           !! added "uc" to elimiate duplicate
  51.       K_ucI           =  'I' ; //  73           !! added "uc" to elimiate duplicate
  52.       K_ucJ           =  'J' ; //  74           !! added "uc" to elimiate duplicate
  53.       K_ucK           =  'K' ; //  75           !! added "uc" to elimiate duplicate
  54.       K_ucL           =  'L' ; //  76           !! added "uc" to elimiate duplicate
  55.       K_ucM           =  'M' ; //  77           !! added "uc" to elimiate duplicate
  56.       K_ucN           =  'N' ; //  78           !! added "uc" to elimiate duplicate
  57.       K_ucO           =  'O' ; //  79           !! added "uc" to elimiate duplicate
  58.       K_ucP           =  'P' ; //  80           !! added "uc" to elimiate duplicate
  59.       K_ucQ           =  'Q' ; //  81           !! added "uc" to elimiate duplicate
  60.       K_ucR           =  'R' ; //  82           !! added "uc" to elimiate duplicate
  61.       K_ucS           =  'S' ; //  83           !! added "uc" to elimiate duplicate
  62.       K_ucT           =  'T' ; //  84           !! added "uc" to elimiate duplicate
  63.       K_ucU           =  'U' ; //  85           !! added "uc" to elimiate duplicate
  64.       K_ucV           =  'V' ; //  86           !! added "uc" to elimiate duplicate
  65.       K_ucW           =  'W' ; //  87           !! added "uc" to elimiate duplicate
  66.       K_ucX           =  'X' ; //  88           !! added "uc" to elimiate duplicate
  67.       K_ucY           =  'Y' ; //  89           !! added "uc" to elimiate duplicate
  68.       K_ucZ           =  'Z' ; //  90           !! added "uc" to elimiate duplicate
  69.       K_bracketleft   =  '[' ; //  91
  70.       K_backslash     =  '\' ; //  92
  71.       K_bracketright  =   ']'; //  93
  72.       K_circum        =  '^' ; //  94
  73.       K_underscore    =  '_' ; //  95
  74.       K_grave         =  '`' ; //  96
  75.       K_lca           =  'a' ; //  97 (0x61)    !! added "lc" to elimiate duplicate
  76.       K_lcb           =  'b' ; //  98           !! added "lc" to elimiate duplicate
  77.       K_lcc           =  'c' ; //  99           !! added "lc" to elimiate duplicate
  78.       K_lcd           =  'd' ; // 100           !! added "lc" to elimiate duplicate
  79.       K_lce           =  'e' ; // 101           !! added "lc" to elimiate duplicate
  80.       K_lcf           =  'f' ; // 102           !! added "lc" to elimiate duplicate
  81.       K_lcg           =  'g' ; // 103           !! added "lc" to elimiate duplicate
  82.       K_lch           =  'h' ; // 104           !! added "lc" to elimiate duplicate
  83.       K_lci           =  'i' ; // 105           !! added "lc" to elimiate duplicate
  84.       K_lcj           =  'j' ; // 106           !! added "lc" to elimiate duplicate
  85.       K_lck           =  'k' ; // 107           !! added "lc" to elimiate duplicate
  86.       K_lcl           =  'l' ; // 108           !! added "lc" to elimiate duplicate
  87.       K_lcm           =  'm' ; // 109           !! added "lc" to elimiate duplicate
  88.       K_lcn           =  'n' ; // 110           !! added "lc" to elimiate duplicate
  89.       K_lco           =  'o' ; // 111           !! added "lc" to elimiate duplicate
  90.       K_lcp           =  'p' ; // 112           !! added "lc" to elimiate duplicate
  91.       K_lcq           =  'q' ; // 113           !! added "lc" to elimiate duplicate
  92.       K_lcr           =  'r' ; // 114           !! added "lc" to elimiate duplicate
  93.       K_lcs           =  's' ; // 115           !! added "lc" to elimiate duplicate
  94.       K_lct           =  't' ; // 116           !! added "lc" to elimiate duplicate
  95.       K_lcu           =  'u' ; // 117           !! added "lc" to elimiate duplicate
  96.       K_lcv           =  'v' ; // 118           !! added "lc" to elimiate duplicate
  97.       K_lcw           =  'w' ; // 119           !! added "lc" to elimiate duplicate
  98.       K_lcx           =  'x' ; // 120           !! added "lc" to elimiate duplicate
  99.       K_lcy           =  'y' ; // 121           !! added "lc" to elimiate duplicate
  100.       K_lcz           =  'z' ; // 122           !! added "lc" to elimiate duplicate
  101.       K_braceleft     =  '{' ; // 123
  102.       K_bar           =  '|' ; // 124
  103.       K_braceright    =  '}' ; // 125
  104.       K_tilde         =  '~' ; // 126 (0x7E)
  105.      
  106.     // Printable ASCii keys
  107.      
  108.     // #define iup_isprint(_c) ((_c) > 31 && (_c) < 127)
  109.      
  110.     function iup_isprint(_c : DWORD)
  111.            : boolean32; inline;
  112.     begin
  113.       result := (_c > 31) and (_c < 127);
  114.     end;
  115.      
  116.      
  117.     // also define the escape sequences that have keys associated
  118.      
  119.     const
  120.       K_eBS           = 8 ;    // '\b' 8
  121.       K_eTAB          = 9 ;    // '\t' 9
  122.      
  123.       K_eLF           = 10;    // '\n' 10 (0Ah) not a real key, is a combination of
  124.                                //               CR with a modifier, just to document
  125.      
  126.       K_eCR           = 13;    // '\r' 13 (0Dh)
  127.      
  128.      
  129.      
  130.     // backward compatible definitions
  131.      
  132.     const
  133.       K_quoteleft     = K_grave     ;
  134.       K_quoteright    = K_apostrophe;
  135.      
  136.       { this synonym can be implemented as an FPC macro or as a repeat of the     }
  137.       { iup_isXkey function                                                       }
  138.       {                                                                           }
  139.       { isxkey          = iup_isXkey;                                             }
  140.      
  141.      
  142.      
  143.     // IUP Extended Key Codes, range start at 128      */
  144.      
  145.     // #define iup_isXkey(_c)      ((_c) >= 128)
  146.     // same as isxkey
  147.      
  148.     function iup_isXkey(_c : DWORD)
  149.            : boolean32; inline;
  150.     begin
  151.       result := (_c > 128);
  152.     end;
  153.      
  154.     function isxkey(_c : DWORD) : boolean32; inline;
  155.     begin
  156.       result := iup_isXkey(_c);
  157.     end;
  158.      
  159.      
  160.     // These use the same definition as X11 and GDK.
  161.     // This also means that any X11 or GDK definition can also be used.
  162.      
  163.     const
  164.       K_PAUSE         = DWORD($FF13);
  165.       K_ESC           = DWORD($FF1B);
  166.       K_HOME          = DWORD($FF50);
  167.       K_LEFT          = DWORD($FF51);
  168.       K_UP            = DWORD($FF52);
  169.       K_RIGHT         = DWORD($FF53);
  170.       K_DOWN          = DWORD($FF54);
  171.       K_PGUP          = DWORD($FF55);
  172.       K_PGDN          = DWORD($FF56);
  173.       K_END           = DWORD($FF57);
  174.       K_MIDDLE        = DWORD($FF0B);
  175.       K_Print         = DWORD($FF61);
  176.       K_INS           = DWORD($FF63);
  177.       K_Menu          = DWORD($FF67);
  178.       K_DEL           = DWORD($FFFF);
  179.       K_F1            = DWORD($FFBE);
  180.       K_F2            = DWORD($FFBF);
  181.       K_F3            = DWORD($FFC0);
  182.       K_F4            = DWORD($FFC1);
  183.       K_F5            = DWORD($FFC2);
  184.       K_F6            = DWORD($FFC3);
  185.       K_F7            = DWORD($FFC4);
  186.       K_F8            = DWORD($FFC5);
  187.       K_F9            = DWORD($FFC6);
  188.       K_F10           = DWORD($FFC7);
  189.       K_F11           = DWORD($FFC8);
  190.       K_F12           = DWORD($FFC9);
  191.      
  192.     // no Shift/Ctrl/Alt
  193.      
  194.     const
  195.       K_LSHIFT        = DWORD($FFE1);
  196.       K_RSHIFT        = DWORD($FFE2);
  197.       K_LCTRL         = DWORD($FFE3);
  198.       K_RCTRL         = DWORD($FFE4);
  199.       K_LALT          = DWORD($FFE9);
  200.       K_RALT          = DWORD($FFEA);
  201.      
  202.       K_NUM           = DWORD($FF7F);
  203.       K_SCROLL        = DWORD($FF14);
  204.       K_CAPS          = DWORD($FFE5);
  205.      
  206.      
  207.     // Also, these are the same as the Latin-1 definition
  208.      
  209.     const
  210.       K_lccedilla     = DWORD($00E7);  // duplicate identifier - changed to lc..
  211.       K_uCcedilla     = DWORD($00C7);  //    "          "                to uC..
  212.      
  213.       K_acute         = DWORD($00B4);  // no Shift/Ctrl/Alt
  214.       K_diaeresis     = DWORD($00A8);
  215.      
  216.     //
  217.     // Modifiers use last 4 bits. Since IUP 3.9
  218.     // These modifiers definitions are specific to IUP
  219.     //
  220.      
  221.     // #define iup_isShiftXkey(_c) ((_c) & 0x10000000)
  222.      
  223.     function iup_isShiftXkey(_c : DWORD)
  224.            : boolean32; inline;
  225.     begin
  226.       result := _c and DWORD($10000000) > 0;
  227.     end;
  228.      
  229.      
  230.     // #define iup_isCtrlXkey(_c)  ((_c) & 0x20000000)
  231.      
  232.     function iup_isCtrlXkey(_c : DWORD)
  233.            : boolean32; inline;
  234.     begin
  235.       result := _c and DWORD($20000000) > 0;
  236.     end;
  237.      
  238.      
  239.     // #define iup_isAltXkey(_c)   ((_c) & 0x40000000)
  240.      
  241.     function iup_isAltXkey(_c : DWORD)
  242.            : boolean32; inline;
  243.     begin
  244.       result := _c and DWORD($40000000) > 0;
  245.     end;
  246.      
  247.      
  248.     // #define iup_isSysXkey(_c)   ((_c) & 0x80000000)
  249.      
  250.     function iup_isSysXkey(_c : DWORD)
  251.            : boolean32; inline;
  252.     begin
  253.       result := _c and DWORD($80000000) > 0;
  254.     end;
  255.      
  256.      
  257.     // #define iup_XkeyBase(_c)  ((_c) & 0x0FFFFFFF)
  258.     // #define iup_XkeyShift(_c) ((_c) | 0x10000000)   // Shift
  259.     // #define iup_XkeyCtrl(_c)  ((_c) | 0x20000000)   // Ctrl
  260.     // #define iup_XkeyAlt(_c)   ((_c) | 0x40000000)   // Alt
  261.     // #define iup_XkeySys(_c)   ((_c) | 0x80000000)   // Sys (Win or Apple)
  262.      
  263.     // These definitions are here for backward compatibility
  264.     // and to simplify some key combination usage.
  265.     // But since IUP 3.9, modifiers can be combined with any key
  266.     // and they can be mixed together. */
  267.      
  268.      
  269.     const
  270.       K_sHOME         = DWORD(K_HOME        ) or $10000000;   // Shift
  271.       K_sUP           = DWORD(K_UP          ) or $10000000;   // Shift
  272.       K_sPGUP         = DWORD(K_PGUP        ) or $10000000;   // Shift
  273.       K_sLEFT         = DWORD(K_LEFT        ) or $10000000;   // Shift
  274.       K_sMIDDLE       = DWORD(K_MIDDLE      ) or $10000000;   // Shift
  275.       K_sRIGHT        = DWORD(K_RIGHT       ) or $10000000;   // Shift
  276.       K_sEND          = DWORD(K_END         ) or $10000000;   // Shift
  277.       K_sDOWN         = DWORD(K_DOWN        ) or $10000000;   // Shift
  278.       K_sPGDN         = DWORD(K_PGDN        ) or $10000000;   // Shift
  279.       K_sINS          = DWORD(K_INS         ) or $10000000;   // Shift
  280.       K_sDEL          = DWORD(K_DEL         ) or $10000000;   // Shift
  281.       K_sSP           = DWORD(K_SP          ) or $10000000;   // Shift
  282.       K_sTAB          = DWORD(K_eTAB        ) or $10000000;   // Shift
  283.       K_sCR           = DWORD(K_eCR         ) or $10000000;   // Shift
  284.       K_sBS           = DWORD(K_eBS         ) or $10000000;   // Shift
  285.       K_sPAUSE        = DWORD(K_PAUSE       ) or $10000000;   // Shift
  286.       K_sESC          = DWORD(K_ESC         ) or $10000000;   // Shift
  287.       K_sF1           = DWORD(K_F1          ) or $10000000;   // Shift
  288.       K_sF2           = DWORD(K_F2          ) or $10000000;   // Shift
  289.       K_sF3           = DWORD(K_F3          ) or $10000000;   // Shift
  290.       K_sF4           = DWORD(K_F4          ) or $10000000;   // Shift
  291.       K_sF5           = DWORD(K_F5          ) or $10000000;   // Shift
  292.       K_sF6           = DWORD(K_F6          ) or $10000000;   // Shift
  293.       K_sF7           = DWORD(K_F7          ) or $10000000;   // Shift
  294.       K_sF8           = DWORD(K_F8          ) or $10000000;   // Shift
  295.       K_sF9           = DWORD(K_F9          ) or $10000000;   // Shift
  296.       K_sF10          = DWORD(K_F10         ) or $10000000;   // Shift
  297.       K_sF11          = DWORD(K_F11         ) or $10000000;   // Shift
  298.       K_sF12          = DWORD(K_F12         ) or $10000000;   // Shift
  299.       K_sPrint        = DWORD(K_Print       ) or $10000000;   // Shift
  300.       K_sMenu         = DWORD(K_Menu        ) or $10000000;   // Shift
  301.      
  302.       K_cHOME         = DWORD(K_HOME        ) or $20000000;   // Ctrl
  303.       K_cUP           = DWORD(K_UP          ) or $20000000;   // Ctrl
  304.       K_cPGUP         = DWORD(K_PGUP        ) or $20000000;   // Ctrl
  305.       K_cLEFT         = DWORD(K_LEFT        ) or $20000000;   // Ctrl
  306.       K_cMIDDLE       = DWORD(K_MIDDLE      ) or $20000000;   // Ctrl
  307.       K_cRIGHT        = DWORD(K_RIGHT       ) or $20000000;   // Ctrl
  308.       K_cEND          = DWORD(K_END         ) or $20000000;   // Ctrl
  309.       K_cDOWN         = DWORD(K_DOWN        ) or $20000000;   // Ctrl
  310.       K_cPGDN         = DWORD(K_PGDN        ) or $20000000;   // Ctrl
  311.       K_cINS          = DWORD(K_INS         ) or $20000000;   // Ctrl
  312.       K_cDEL          = DWORD(K_DEL         ) or $20000000;   // Ctrl
  313.       K_cSP           = DWORD(K_SP          ) or $20000000;   // Ctrl
  314.       K_cTAB          = DWORD(K_eTAB        ) or $20000000;   // Ctrl
  315.       K_cCR           = DWORD(K_eCR         ) or $20000000;   // Ctrl
  316.       K_cBS           = DWORD(K_eBS         ) or $20000000;   // Ctrl
  317.       K_cPAUSE        = DWORD(K_PAUSE       ) or $20000000;   // Ctrl
  318.       K_cESC          = DWORD(K_ESC         ) or $20000000;   // Ctrl
  319.       K_cCcedilla     = DWORD(K_uCcedilla   ) or $20000000;   // Ctrl
  320.       K_cF1           = DWORD(K_F1          ) or $20000000;   // Ctrl
  321.       K_cF2           = DWORD(K_F2          ) or $20000000;   // Ctrl
  322.       K_cF3           = DWORD(K_F3          ) or $20000000;   // Ctrl
  323.       K_cF4           = DWORD(K_F4          ) or $20000000;   // Ctrl
  324.       K_cF5           = DWORD(K_F5          ) or $20000000;   // Ctrl
  325.       K_cF6           = DWORD(K_F6          ) or $20000000;   // Ctrl
  326.       K_cF7           = DWORD(K_F7          ) or $20000000;   // Ctrl
  327.       K_cF8           = DWORD(K_F8          ) or $20000000;   // Ctrl
  328.       K_cF9           = DWORD(K_F9          ) or $20000000;   // Ctrl
  329.       K_cF10          = DWORD(K_F10         ) or $20000000;   // Ctrl
  330.       K_cF11          = DWORD(K_F11         ) or $20000000;   // Ctrl
  331.       K_cF12          = DWORD(K_F12         ) or $20000000;   // Ctrl
  332.       K_cPrint        = DWORD(K_Print       ) or $20000000;   // Ctrl
  333.       K_cMenu         = DWORD(K_Menu        ) or $20000000;   // Ctrl
  334.      
  335.       K_mHOME         = DWORD(K_HOME        ) or $40000000;   // Alt
  336.       K_mUP           = DWORD(K_UP          ) or $40000000;   // Alt
  337.       K_mPGUP         = DWORD(K_PGUP        ) or $40000000;   // Alt
  338.       K_mLEFT         = DWORD(K_LEFT        ) or $40000000;   // Alt
  339.       K_mMIDDLE       = DWORD(K_MIDDLE      ) or $40000000;   // Alt
  340.       K_mRIGHT        = DWORD(K_RIGHT       ) or $40000000;   // Alt
  341.       K_mEND          = DWORD(K_END         ) or $40000000;   // Alt
  342.       K_mDOWN         = DWORD(K_DOWN        ) or $40000000;   // Alt
  343.       K_mPGDN         = DWORD(K_PGDN        ) or $40000000;   // Alt
  344.       K_mINS          = DWORD(K_INS         ) or $40000000;   // Alt
  345.       K_mDEL          = DWORD(K_DEL         ) or $40000000;   // Alt
  346.       K_mSP           = DWORD(K_SP          ) or $40000000;   // Alt
  347.       K_mTAB          = DWORD(K_eTAB        ) or $40000000;   // Alt
  348.       K_mCR           = DWORD(K_eCR         ) or $40000000;   // Alt
  349.       K_mBS           = DWORD(K_eBS         ) or $40000000;   // Alt
  350.       K_mPAUSE        = DWORD(K_PAUSE       ) or $40000000;   // Alt
  351.       K_mESC          = DWORD(K_ESC         ) or $40000000;   // Alt
  352.       K_mCcedilla     = DWORD(K_uCcedilla   ) or $40000000;   // Alt
  353.       K_mF1           = DWORD(K_F1          ) or $40000000;   // Alt
  354.       K_mF2           = DWORD(K_F2          ) or $40000000;   // Alt
  355.       K_mF3           = DWORD(K_F3          ) or $40000000;   // Alt
  356.       K_mF4           = DWORD(K_F4          ) or $40000000;   // Alt
  357.       K_mF5           = DWORD(K_F5          ) or $40000000;   // Alt
  358.       K_mF6           = DWORD(K_F6          ) or $40000000;   // Alt
  359.       K_mF7           = DWORD(K_F7          ) or $40000000;   // Alt
  360.       K_mF8           = DWORD(K_F8          ) or $40000000;   // Alt
  361.       K_mF9           = DWORD(K_F9          ) or $40000000;   // Alt
  362.       K_mF10          = DWORD(K_F10         ) or $40000000;   // Alt
  363.       K_mF11          = DWORD(K_F11         ) or $40000000;   // Alt
  364.       K_mF12          = DWORD(K_F12         ) or $40000000;   // Alt
  365.       K_mPrint        = DWORD(K_Print       ) or $40000000;   // Alt
  366.       K_mMenu         = DWORD(K_Menu        ) or $40000000;   // Alt
  367.      
  368.       K_yHOME         = DWORD(K_HOME        ) or $80000000;   // Sys (Win or Apple;
  369.       K_yUP           = DWORD(K_UP          ) or $80000000;   // Sys (Win or Apple;
  370.       K_yPGUP         = DWORD(K_PGUP        ) or $80000000;   // Sys (Win or Apple;
  371.       K_yLEFT         = DWORD(K_LEFT        ) or $80000000;   // Sys (Win or Apple;
  372.       K_yMIDDLE       = DWORD(K_MIDDLE      ) or $80000000;   // Sys (Win or Apple;
  373.       K_yRIGHT        = DWORD(K_RIGHT       ) or $80000000;   // Sys (Win or Apple;
  374.       K_yEND          = DWORD(K_END         ) or $80000000;   // Sys (Win or Apple;
  375.       K_yDOWN         = DWORD(K_DOWN        ) or $80000000;   // Sys (Win or Apple;
  376.       K_yPGDN         = DWORD(K_PGDN        ) or $80000000;   // Sys (Win or Apple;
  377.       K_yINS          = DWORD(K_INS         ) or $80000000;   // Sys (Win or Apple;
  378.       K_yDEL          = DWORD(K_DEL         ) or $80000000;   // Sys (Win or Apple;
  379.       K_ySP           = DWORD(K_SP          ) or $80000000;   // Sys (Win or Apple;
  380.       K_yTAB          = DWORD(K_eTAB        ) or $80000000;   // Sys (Win or Apple;
  381.       K_yCR           = DWORD(K_eCR         ) or $80000000;   // Sys (Win or Apple;
  382.       K_yBS           = DWORD(K_eBS         ) or $80000000;   // Sys (Win or Apple;
  383.       K_yPAUSE        = DWORD(K_PAUSE       ) or $80000000;   // Sys (Win or Apple;
  384.       K_yESC          = DWORD(K_ESC         ) or $80000000;   // Sys (Win or Apple;
  385.       K_yCcedilla     = DWORD(K_uCcedilla   ) or $80000000;   // Sys (Win or Apple;
  386.       K_yF1           = DWORD(K_F1          ) or $80000000;   // Sys (Win or Apple;
  387.       K_yF2           = DWORD(K_F2          ) or $80000000;   // Sys (Win or Apple;
  388.       K_yF3           = DWORD(K_F3          ) or $80000000;   // Sys (Win or Apple;
  389.       K_yF4           = DWORD(K_F4          ) or $80000000;   // Sys (Win or Apple;
  390.       K_yF5           = DWORD(K_F5          ) or $80000000;   // Sys (Win or Apple;
  391.       K_yF6           = DWORD(K_F6          ) or $80000000;   // Sys (Win or Apple;
  392.       K_yF7           = DWORD(K_F7          ) or $80000000;   // Sys (Win or Apple;
  393.       K_yF8           = DWORD(K_F8          ) or $80000000;   // Sys (Win or Apple;
  394.       K_yF9           = DWORD(K_F9          ) or $80000000;   // Sys (Win or Apple;
  395.       K_yF10          = DWORD(K_F10         ) or $80000000;   // Sys (Win or Apple;
  396.       K_yF11          = DWORD(K_F11         ) or $80000000;   // Sys (Win or Apple;
  397.       K_yF12          = DWORD(K_F12         ) or $80000000;   // Sys (Win or Apple;
  398.       K_yPrint        = DWORD(K_Print       ) or $80000000;   // Sys (Win or Apple;
  399.       K_yMenu         = DWORD(K_Menu        ) or $80000000;   // Sys (Win or Apple;
  400.      
  401.       K_sPlus         = DWORD(K_plus        ) or $10000000;   // Shift
  402.       K_sComma        = DWORD(K_comma       ) or $10000000;   // Shift
  403.       K_sMinus        = DWORD(K_minus       ) or $10000000;   // Shift
  404.       K_sPeriod       = DWORD(K_period      ) or $10000000;   // Shift
  405.       K_sSlash        = DWORD(K_slash       ) or $10000000;   // Shift
  406.       K_sAsterisk     = DWORD(K_asterisk    ) or $10000000;   // Shift
  407.      
  408.       K_cA            = DWORD(K_ucA         ) or $20000000;   // Ctrl
  409.       K_cB            = DWORD(K_ucB         ) or $20000000;   // Ctrl
  410.       K_cC            = DWORD(K_ucC         ) or $20000000;   // Ctrl
  411.       K_cD            = DWORD(K_ucD         ) or $20000000;   // Ctrl
  412.       K_cE            = DWORD(K_ucE         ) or $20000000;   // Ctrl
  413.       K_cF            = DWORD(K_ucF         ) or $20000000;   // Ctrl
  414.       K_cG            = DWORD(K_ucG         ) or $20000000;   // Ctrl
  415.       K_cH            = DWORD(K_ucH         ) or $20000000;   // Ctrl
  416.       K_cI            = DWORD(K_ucI         ) or $20000000;   // Ctrl
  417.       K_cJ            = DWORD(K_ucJ         ) or $20000000;   // Ctrl
  418.       K_cK            = DWORD(K_ucK         ) or $20000000;   // Ctrl
  419.       K_cL            = DWORD(K_ucL         ) or $20000000;   // Ctrl
  420.       K_cM            = DWORD(K_ucM         ) or $20000000;   // Ctrl
  421.       K_cN            = DWORD(K_ucN         ) or $20000000;   // Ctrl
  422.       K_cO            = DWORD(K_ucO         ) or $20000000;   // Ctrl
  423.       K_cP            = DWORD(K_ucP         ) or $20000000;   // Ctrl
  424.       K_cQ            = DWORD(K_ucQ         ) or $20000000;   // Ctrl
  425.       K_cR            = DWORD(K_ucR         ) or $20000000;   // Ctrl
  426.       K_cS            = DWORD(K_ucS         ) or $20000000;   // Ctrl
  427.       K_cT            = DWORD(K_ucT         ) or $20000000;   // Ctrl
  428.       K_cU            = DWORD(K_ucU         ) or $20000000;   // Ctrl
  429.       K_cV            = DWORD(K_ucV         ) or $20000000;   // Ctrl
  430.       K_cW            = DWORD(K_ucW         ) or $20000000;   // Ctrl
  431.       K_cX            = DWORD(K_ucX         ) or $20000000;   // Ctrl
  432.       K_cY            = DWORD(K_ucY         ) or $20000000;   // Ctrl
  433.       K_cZ            = DWORD(K_ucZ         ) or $20000000;   // Ctrl
  434.       K_c1            = DWORD(K_1           ) or $20000000;   // Ctrl
  435.       K_c2            = DWORD(K_2           ) or $20000000;   // Ctrl
  436.       K_c3            = DWORD(K_3           ) or $20000000;   // Ctrl
  437.       K_c4            = DWORD(K_4           ) or $20000000;   // Ctrl
  438.       K_c5            = DWORD(K_5           ) or $20000000;   // Ctrl
  439.       K_c6            = DWORD(K_6           ) or $20000000;   // Ctrl
  440.       K_c7            = DWORD(K_7           ) or $20000000;   // Ctrl
  441.       K_c8            = DWORD(K_8           ) or $20000000;   // Ctrl
  442.       K_c9            = DWORD(K_9           ) or $20000000;   // Ctrl
  443.       K_c0            = DWORD(K_0           ) or $20000000;   // Ctrl
  444.       K_cPlus         = DWORD(K_plus        ) or $20000000;   // Ctrl
  445.       K_cComma        = DWORD(K_comma       ) or $20000000;   // Ctrl
  446.       K_cMinus        = DWORD(K_minus       ) or $20000000;   // Ctrl
  447.       K_cPeriod       = DWORD(K_period      ) or $20000000;   // Ctrl
  448.       K_cSlash        = DWORD(K_slash       ) or $20000000;   // Ctrl
  449.       K_cSemicolon    = DWORD(K_semicolon   ) or $20000000;   // Ctrl
  450.       K_cEqual        = DWORD(K_equal       ) or $20000000;   // Ctrl
  451.       K_cBracketleft  = DWORD(K_bracketleft ) or $20000000;   // Ctrl
  452.       K_cBracketright = DWORD(K_bracketright) or $20000000;   // Ctrl
  453.       K_cBackslash    = DWORD(K_backslash   ) or $20000000;   // Ctrl
  454.       K_cAsterisk     = DWORD(K_asterisk    ) or $20000000;   // Ctrl
  455.      
  456.       K_mA            = DWORD(K_ucA         ) or $40000000;   // Alt
  457.       K_mB            = DWORD(K_ucB         ) or $40000000;   // Alt
  458.       K_mC            = DWORD(K_ucC         ) or $40000000;   // Alt
  459.       K_mD            = DWORD(K_ucD         ) or $40000000;   // Alt
  460.       K_mE            = DWORD(K_ucE         ) or $40000000;   // Alt
  461.       K_mF            = DWORD(K_ucF         ) or $40000000;   // Alt
  462.       K_mG            = DWORD(K_ucG         ) or $40000000;   // Alt
  463.       K_mH            = DWORD(K_ucH         ) or $40000000;   // Alt
  464.       K_mI            = DWORD(K_ucI         ) or $40000000;   // Alt
  465.       K_mJ            = DWORD(K_ucJ         ) or $40000000;   // Alt
  466.       K_mK            = DWORD(K_ucK         ) or $40000000;   // Alt
  467.       K_mL            = DWORD(K_ucL         ) or $40000000;   // Alt
  468.       K_mM            = DWORD(K_ucM         ) or $40000000;   // Alt
  469.       K_mN            = DWORD(K_ucN         ) or $40000000;   // Alt
  470.       K_mO            = DWORD(K_ucO         ) or $40000000;   // Alt
  471.       K_mP            = DWORD(K_ucP         ) or $40000000;   // Alt
  472.       K_mQ            = DWORD(K_ucQ         ) or $40000000;   // Alt
  473.       K_mR            = DWORD(K_ucR         ) or $40000000;   // Alt
  474.       K_mS            = DWORD(K_ucS         ) or $40000000;   // Alt
  475.       K_mT            = DWORD(K_ucT         ) or $40000000;   // Alt
  476.       K_mU            = DWORD(K_ucU         ) or $40000000;   // Alt
  477.       K_mV            = DWORD(K_ucV         ) or $40000000;   // Alt
  478.       K_mW            = DWORD(K_ucW         ) or $40000000;   // Alt
  479.       K_mX            = DWORD(K_ucX         ) or $40000000;   // Alt
  480.       K_mY            = DWORD(K_ucY         ) or $40000000;   // Alt
  481.       K_mZ            = DWORD(K_ucZ         ) or $40000000;   // Alt
  482.       K_m1            = DWORD(K_1           ) or $40000000;   // Alt
  483.       K_m2            = DWORD(K_2           ) or $40000000;   // Alt
  484.       K_m3            = DWORD(K_3           ) or $40000000;   // Alt
  485.       K_m4            = DWORD(K_4           ) or $40000000;   // Alt
  486.       K_m5            = DWORD(K_5           ) or $40000000;   // Alt
  487.       K_m6            = DWORD(K_6           ) or $40000000;   // Alt
  488.       K_m7            = DWORD(K_7           ) or $40000000;   // Alt
  489.       K_m8            = DWORD(K_8           ) or $40000000;   // Alt
  490.       K_m9            = DWORD(K_9           ) or $40000000;   // Alt
  491.       K_m0            = DWORD(K_0           ) or $40000000;   // Alt
  492.       K_mPlus         = DWORD(K_plus        ) or $40000000;   // Alt
  493.       K_mComma        = DWORD(K_comma       ) or $40000000;   // Alt
  494.       K_mMinus        = DWORD(K_minus       ) or $40000000;   // Alt
  495.       K_mPeriod       = DWORD(K_period      ) or $40000000;   // Alt
  496.       K_mSlash        = DWORD(K_slash       ) or $40000000;   // Alt
  497.       K_mSemicolon    = DWORD(K_semicolon   ) or $40000000;   // Alt
  498.       K_mEqual        = DWORD(K_equal       ) or $40000000;   // Alt
  499.       K_mBracketleft  = DWORD(K_bracketleft ) or $40000000;   // Alt
  500.       K_mBracketright = DWORD(K_bracketright) or $40000000;   // Alt
  501.       K_mBackslash    = DWORD(K_backslash   ) or $40000000;   // Alt
  502.       K_mAsterisk     = DWORD(K_asterisk    ) or $40000000;   // Alt
  503.      
  504.       K_yA            = DWORD(K_ucA         ) or $80000000;   // Sys
  505.       K_yB            = DWORD(K_ucB         ) or $80000000;   // Sys
  506.       K_yC            = DWORD(K_ucC         ) or $80000000;   // Sys
  507.       K_yD            = DWORD(K_ucD         ) or $80000000;   // Sys
  508.       K_yE            = DWORD(K_ucE         ) or $80000000;   // Sys
  509.       K_yF            = DWORD(K_ucF         ) or $80000000;   // Sys
  510.       K_yG            = DWORD(K_ucG         ) or $80000000;   // Sys
  511.       K_yH            = DWORD(K_ucH         ) or $80000000;   // Sys
  512.       K_yI            = DWORD(K_ucI         ) or $80000000;   // Sys
  513.       K_yJ            = DWORD(K_ucJ         ) or $80000000;   // Sys
  514.       K_yK            = DWORD(K_ucK         ) or $80000000;   // Sys
  515.       K_yL            = DWORD(K_ucL         ) or $80000000;   // Sys
  516.       K_yM            = DWORD(K_ucM         ) or $80000000;   // Sys
  517.       K_yN            = DWORD(K_ucN         ) or $80000000;   // Sys
  518.       K_yO            = DWORD(K_ucO         ) or $80000000;   // Sys
  519.       K_yP            = DWORD(K_ucP         ) or $80000000;   // Sys
  520.       K_yQ            = DWORD(K_ucQ         ) or $80000000;   // Sys
  521.       K_yR            = DWORD(K_ucR         ) or $80000000;   // Sys
  522.       K_yS            = DWORD(K_ucS         ) or $80000000;   // Sys
  523.       K_yT            = DWORD(K_ucT         ) or $80000000;   // Sys
  524.       K_yU            = DWORD(K_ucU         ) or $80000000;   // Sys
  525.       K_yV            = DWORD(K_ucV         ) or $80000000;   // Sys
  526.       K_yW            = DWORD(K_ucW         ) or $80000000;   // Sys
  527.       K_yX            = DWORD(K_ucX         ) or $80000000;   // Sys
  528.       K_yY            = DWORD(K_ucY         ) or $80000000;   // Sys
  529.       K_yZ            = DWORD(K_ucZ         ) or $80000000;   // Sys
  530.       K_y1            = DWORD(K_1           ) or $80000000;   // Sys
  531.       K_y2            = DWORD(K_2           ) or $80000000;   // Sys
  532.       K_y3            = DWORD(K_3           ) or $80000000;   // Sys
  533.       K_y4            = DWORD(K_4           ) or $80000000;   // Sys
  534.       K_y5            = DWORD(K_5           ) or $80000000;   // Sys
  535.       K_y6            = DWORD(K_6           ) or $80000000;   // Sys
  536.       K_y7            = DWORD(K_7           ) or $80000000;   // Sys
  537.       K_y8            = DWORD(K_8           ) or $80000000;   // Sys
  538.       K_y9            = DWORD(K_9           ) or $80000000;   // Sys
  539.       K_y0            = DWORD(K_0           ) or $80000000;   // Sys
  540.       K_yPlus         = DWORD(K_plus        ) or $80000000;   // Sys
  541.       K_yComma        = DWORD(K_comma       ) or $80000000;   // Sys
  542.       K_yMinus        = DWORD(K_minus       ) or $80000000;   // Sys
  543.       K_yPeriod       = DWORD(K_period      ) or $80000000;   // Sys
  544.       K_ySlash        = DWORD(K_slash       ) or $80000000;   // Sys
  545.       K_ySemicolon    = DWORD(K_semicolon   ) or $80000000;   // Sys
  546.       K_yEqual        = DWORD(K_equal       ) or $80000000;   // Sys
  547.       K_yBracketleft  = DWORD(K_bracketleft ) or $80000000;   // Sys
  548.       K_yBracketright = DWORD(K_bracketright) or $80000000;   // Sys
  549.       K_yBackslash    = DWORD(K_backslash   ) or $80000000;   // Sys
  550.       K_yAsterisk     = DWORD(K_asterisk    ) or $80000000;   // Sys
  551.      
  552. implementation
  553.  
  554. end.
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!