开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
JwaWinCon.pas
资源名称：win32api.zip　[点击查看]
上传用户：davidchvip
上传日期：2009-07-28
资源大小：1749k
文件大小：62k
源码类别：

Windows编程

开发平台：

Delphi

JwaWinCon.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Console Applications API interface Unit for Object Pascal                    }
  4. {                                                                       }
  5. { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
  6. { Corporation. All Rights Reserved.                                            }
  7. {                 }
  8. { The original file is: wincon.h, released June 2000. The original Pascal      }
  9. { code is: WinCon.pas, released December 2000. The initial developer of the    }
  10. { Pascal code is Marcel van Brakel (brakelm@chello.nl).                        }
  11. {                                                                              }
  12. { Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
  13. { Marcel van Brakel. All Rights Reserved.                                      }
  14. {                 }
  15. { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
  16. {                }
  17. { You may retrieve the latest version of this file at the Project JEDI home    }
  18. { page, located at http://delphi-jedi.org or my personal homepage located at   }
  19. { http://members.chello.nl/m.vanbrakel2                                        }
  20. {                }
  21. { The contents of this file are used with permission, subject to the Mozilla   }
  22. { Public License Version 1.1 (the "License"); you may not use this file except }
  23. { in compliance with the License. You may obtain a copy of the License at      }
  24. { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  25. {                                                                              }
  26. { Software distributed under the License is distributed on an "AS IS" basis,   }
  27. { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
  28. { the specific language governing rights and limitations under the License.    }
  29. {                                                                              }
  30. { Alternatively, the contents of this file may be used under the terms of the  }
  31. { GNU Lesser General Public License (the  "LGPL License"), in which case the   }
  32. { provisions of the LGPL License are applicable instead of those above.        }
  33. { If you wish to allow use of your version of this file only under the terms   }
  34. { of the LGPL License and not to allow others to use your version of this file }
  35. { under the MPL, indicate your decision by deleting  the provisions above and  }
  36. { replace  them with the notice and other provisions required by the LGPL      }
  37. { License.  If you do not delete the provisions above, a recipient may use     }
  38. { your version of this file under either the MPL or the LGPL License.          }
  39. {                 }
  40. { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
  41. {                 }
  42. {******************************************************************************}
  44. unit JwaWinCon;
  46. {$WEAKPACKAGEUNIT}
  48. {$HPPEMIT ''}
  49. {$HPPEMIT '#include "WinCon.h"'}
  50. {$HPPEMIT ''}
  52. {$I WINDEFINES.INC}
  54. interface
  56. uses
  57.   JwaWinBase, JwaWinType;
  59. type
  60.   PCOORD = ^COORD;
  61.   {$EXTERNALSYM PCOORD}
  62.   _COORD = record
  63.     X: SHORT;
  64.     Y: SHORT;
  65.   end;
  66.   {$EXTERNALSYM _COORD}
  67.   COORD = _COORD;
  68.   {$EXTERNALSYM COORD}
  69.   TCoord = _COORD;
  71.   PSMALL_RECT = ^SMALL_RECT;
  72.   {$EXTERNALSYM PSMALL_RECT}
  73.   _SMALL_RECT = record
  74.     Left: SHORT;
  75.     Top: SHORT;
  76.     Right: SHORT;
  77.     Bottom: SHORT;
  78.   end;
  79.   {$EXTERNALSYM _SMALL_RECT}
  80.   SMALL_RECT = _SMALL_RECT;
  81.   {$EXTERNALSYM SMALL_RECT}
  82.   TSmallRect = SMALL_RECT;
  83.   PSmallRect = PSMALL_RECT;
  85.   TCharUnion = record
  86.     case Integer of
  87.       0: (UnicodeChar: WCHAR);
  88.       1: (AsciiChar: CHAR);
  89.   end;
  91.   PKEY_EVENT_RECORD = ^KEY_EVENT_RECORD;
  92.   {$EXTERNALSYM PKEY_EVENT_RECORD}
  93.   _KEY_EVENT_RECORD = record
  94.     bKeyDown: BOOL;
  95.     wRepeatCount: WORD;
  96.     wVirtualKeyCode: WORD;
  97.     wVirtualScanCode: WORD;
  98.     uChar: TCharUnion;
  99.     dwControlKeyState: DWORD;
  100.   end;
  101.   {$EXTERNALSYM _KEY_EVENT_RECORD}
  102.   KEY_EVENT_RECORD = _KEY_EVENT_RECORD;
  103.   {$EXTERNALSYM KEY_EVENT_RECORD}
  104.   TKeyEventRecord = KEY_EVENT_RECORD;
  105.   PKeyEventRecord = PKEY_EVENT_RECORD;
  107. //
  108. // ControlKeyState flags
  109. //
  111. const
  112.   RIGHT_ALT_PRESSED  = $0001; // the right alt key is pressed.
  113.   {$EXTERNALSYM RIGHT_ALT_PRESSED}
  114.   LEFT_ALT_PRESSED   = $0002; // the left alt key is pressed.
  115.   {$EXTERNALSYM LEFT_ALT_PRESSED}
  116.   RIGHT_CTRL_PRESSED = $0004; // the right ctrl key is pressed.
  117.   {$EXTERNALSYM RIGHT_CTRL_PRESSED}
  118.   LEFT_CTRL_PRESSED  = $0008; // the left ctrl key is pressed.
  119.   {$EXTERNALSYM LEFT_CTRL_PRESSED}
  120.   SHIFT_PRESSED      = $0010; // the shift key is pressed.
  121.   {$EXTERNALSYM SHIFT_PRESSED}
  122.   NUMLOCK_ON         = $0020; // the numlock light is on.
  123.   {$EXTERNALSYM NUMLOCK_ON}
  124.   SCROLLLOCK_ON      = $0040; // the scrolllock light is on.
  125.   {$EXTERNALSYM SCROLLLOCK_ON}
  126.   CAPSLOCK_ON        = $0080; // the capslock light is on.
  127.   {$EXTERNALSYM CAPSLOCK_ON}
  128.   ENHANCED_KEY       = $0100; // the key is enhanced.
  129.   {$EXTERNALSYM ENHANCED_KEY}
  130.   NLS_DBCSCHAR       = $00010000; // DBCS for JPN: SBCS/DBCS mode.
  131.   {$EXTERNALSYM NLS_DBCSCHAR}
  132.   NLS_ALPHANUMERIC   = $00000000; // DBCS for JPN: Alphanumeric mode.
  133.   {$EXTERNALSYM NLS_ALPHANUMERIC}
  134.   NLS_KATAKANA       = $00020000; // DBCS for JPN: Katakana mode.
  135.   {$EXTERNALSYM NLS_KATAKANA}
  136.   NLS_HIRAGANA       = $00040000; // DBCS for JPN: Hiragana mode.
  137.   {$EXTERNALSYM NLS_HIRAGANA}
  138.   NLS_ROMAN          = $00400000; // DBCS for JPN: Roman/Noroman mode.
  139.   {$EXTERNALSYM NLS_ROMAN}
  140.   NLS_IME_CONVERSION = $00800000; // DBCS for JPN: IME conversion.
  141.   {$EXTERNALSYM NLS_IME_CONVERSION}
  142.   NLS_IME_DISABLE    = $20000000; // DBCS for JPN: IME enable/disable.
  143.   {$EXTERNALSYM NLS_IME_DISABLE}
  145. type
  146.   PMOUSE_EVENT_RECORD = ^MOUSE_EVENT_RECORD;
  147.   {$EXTERNALSYM PMOUSE_EVENT_RECORD}
  148.   _MOUSE_EVENT_RECORD = record
  149.     dwMousePosition: COORD;
  150.     dwButtonState: DWORD;
  151.     dwControlKeyState: DWORD;
  152.     dwEventFlags: DWORD;
  153.   end;
  154.   {$EXTERNALSYM _MOUSE_EVENT_RECORD}
  155.   MOUSE_EVENT_RECORD = _MOUSE_EVENT_RECORD;
  156.   {$EXTERNALSYM MOUSE_EVENT_RECORD}
  157.   TMouseEventRecord = MOUSE_EVENT_RECORD;
  158.   PMouseEventRecord = PMOUSE_EVENT_RECORD;
  160. //
  161. // ButtonState flags
  162. //
  164. const
  165.   FROM_LEFT_1ST_BUTTON_PRESSED = $0001;
  166.   {$EXTERNALSYM FROM_LEFT_1ST_BUTTON_PRESSED}
  167.   RIGHTMOST_BUTTON_PRESSED     = $0002;
  168.   {$EXTERNALSYM RIGHTMOST_BUTTON_PRESSED}
  169.   FROM_LEFT_2ND_BUTTON_PRESSED = $0004;
  170.   {$EXTERNALSYM FROM_LEFT_2ND_BUTTON_PRESSED}
  171.   FROM_LEFT_3RD_BUTTON_PRESSED = $0008;
  172.   {$EXTERNALSYM FROM_LEFT_3RD_BUTTON_PRESSED}
  173.   FROM_LEFT_4TH_BUTTON_PRESSED = $0010;
  174.   {$EXTERNALSYM FROM_LEFT_4TH_BUTTON_PRESSED}
  176. //
  177. // EventFlags
  178. //
  180.   MOUSE_MOVED   = $0001;
  181.   {$EXTERNALSYM MOUSE_MOVED}
  182.   DOUBLE_CLICK  = $0002;
  183.   {$EXTERNALSYM DOUBLE_CLICK}
  184.   MOUSE_WHEELED = $0004;
  185.   {$EXTERNALSYM MOUSE_WHEELED}
  187. type
  188.   PWINDOW_BUFFER_SIZE_RECORD = ^WINDOW_BUFFER_SIZE_RECORD;
  189.   {$EXTERNALSYM PWINDOW_BUFFER_SIZE_RECORD}
  190.   _WINDOW_BUFFER_SIZE_RECORD = record
  191.     dwSize: COORD;
  192.   end;
  193.   {$EXTERNALSYM _WINDOW_BUFFER_SIZE_RECORD}
  194.   WINDOW_BUFFER_SIZE_RECORD = _WINDOW_BUFFER_SIZE_RECORD;
  195.   {$EXTERNALSYM WINDOW_BUFFER_SIZE_RECORD}
  196.   TWindowBufferSizeRecord = WINDOW_BUFFER_SIZE_RECORD;
  197.   PWindowBufferSizeRecord = PWINDOW_BUFFER_SIZE_RECORD;
  199.   PMENU_EVENT_RECORD = ^MENU_EVENT_RECORD;
  200.   {$EXTERNALSYM PMENU_EVENT_RECORD}
  201.   _MENU_EVENT_RECORD = record
  202.     dwCommandId: UINT;
  203.   end;
  204.   {$EXTERNALSYM _MENU_EVENT_RECORD}
  205.   MENU_EVENT_RECORD = _MENU_EVENT_RECORD;
  206.   {$EXTERNALSYM MENU_EVENT_RECORD}
  207.   TMenuEventRecord = MENU_EVENT_RECORD;
  208.   PMenuEventRecord = PMENU_EVENT_RECORD;
  210.   PFOCUS_EVENT_RECORD = ^FOCUS_EVENT_RECORD;
  211.   {$EXTERNALSYM PFOCUS_EVENT_RECORD}
  212.   _FOCUS_EVENT_RECORD = record
  213.     bSetFocus: BOOL;
  214.   end;
  215.   {$EXTERNALSYM _FOCUS_EVENT_RECORD}
  216.   FOCUS_EVENT_RECORD = _FOCUS_EVENT_RECORD;
  217.   {$EXTERNALSYM FOCUS_EVENT_RECORD}
  218.   TFocusEventRecord = FOCUS_EVENT_RECORD;
  219.   PFocusEventRecord = PFOCUS_EVENT_RECORD;
  221.   PINPUT_RECORD = ^INPUT_RECORD;
  222.   {$EXTERNALSYM PINPUT_RECORD}
  223.   _INPUT_RECORD = record
  224.     EventType: WORD;
  225.     case Integer of
  226.       0: (KeyEvent: KEY_EVENT_RECORD);
  227.       1: (MouseEvent: MOUSE_EVENT_RECORD);
  228.       2: (WindowBufferSizeEvent: WINDOW_BUFFER_SIZE_RECORD);
  229.       3: (MenuEvent: MENU_EVENT_RECORD);
  230.       4: (FocusEvent: FOCUS_EVENT_RECORD);
  231.   end;
  232.   {$EXTERNALSYM _INPUT_RECORD}
  233.   INPUT_RECORD = _INPUT_RECORD;
  234.   {$EXTERNALSYM INPUT_RECORD}
  235.   TInputRecord = INPUT_RECORD;
  236.   PInputRecord = PINPUT_RECORD;
  238. //
  239. //  EventType flags:
  240. //
  242. const
  243.   KEY_EVENT                = $0001; // Event contains key event record
  244.   {$EXTERNALSYM KEY_EVENT}
  245.   MOUSE_EVENT              = $0002; // Event contains mouse event record
  246.   {$EXTERNALSYM MOUSE_EVENT}
  247.   WINDOW_BUFFER_SIZE_EVENT = $0004; // Event contains window change event record
  248.   {$EXTERNALSYM WINDOW_BUFFER_SIZE_EVENT}
  249.   MENU_EVENT               = $0008; // Event contains menu event record
  250.   {$EXTERNALSYM MENU_EVENT}
  251.   FOCUS_EVENT              = $0010; // event contains focus change
  252.   {$EXTERNALSYM FOCUS_EVENT}
  254. type
  255.   PCHAR_INFO = ^CHAR_INFO;
  256.   {$EXTERNALSYM PCHAR_INFO}
  257.   _CHAR_INFO = record
  258.     uChar: TCharUnion;
  259.     Attributes: WORD;
  260.   end;
  261.   {$EXTERNALSYM _CHAR_INFO}
  262.   CHAR_INFO = _CHAR_INFO;
  263.   {$EXTERNALSYM CHAR_INFO}
  264.   TCharInfo = CHAR_INFO;
  265.   PCharInfo = PCHAR_INFO;
  267. //
  268. // Attributes flags:
  269. //
  271. const
  272.   FOREGROUND_BLUE            = $0001; // text color contains blue.
  273.   {$EXTERNALSYM FOREGROUND_BLUE}
  274.   FOREGROUND_GREEN           = $0002; // text color contains green.
  275.   {$EXTERNALSYM FOREGROUND_GREEN}
  276.   FOREGROUND_RED             = $0004; // text color contains red.
  277.   {$EXTERNALSYM FOREGROUND_RED}
  278.   FOREGROUND_INTENSITY       = $0008; // text color is intensified.
  279.   {$EXTERNALSYM FOREGROUND_INTENSITY}
  280.   BACKGROUND_BLUE            = $0010; // background color contains blue.
  281.   {$EXTERNALSYM BACKGROUND_BLUE}
  282.   BACKGROUND_GREEN           = $0020; // background color contains green.
  283.   {$EXTERNALSYM BACKGROUND_GREEN}
  284.   BACKGROUND_RED             = $0040; // background color contains red.
  285.   {$EXTERNALSYM BACKGROUND_RED}
  286.   BACKGROUND_INTENSITY       = $0080; // background color is intensified.
  287.   {$EXTERNALSYM BACKGROUND_INTENSITY}
  288.   COMMON_LVB_LEADING_BYTE    = $0100; // Leading Byte of DBCS
  289.   {$EXTERNALSYM COMMON_LVB_LEADING_BYTE}
  290.   COMMON_LVB_TRAILING_BYTE   = $0200; // Trailing Byte of DBCS
  291.   {$EXTERNALSYM COMMON_LVB_TRAILING_BYTE}
  292.   COMMON_LVB_GRID_HORIZONTAL = $0400; // DBCS: Grid attribute: top horizontal.
  293.   {$EXTERNALSYM COMMON_LVB_GRID_HORIZONTAL}
  294.   COMMON_LVB_GRID_LVERTICAL  = $0800; // DBCS: Grid attribute: left vertical.
  295.   {$EXTERNALSYM COMMON_LVB_GRID_LVERTICAL}
  296.   COMMON_LVB_GRID_RVERTICAL  = $1000; // DBCS: Grid attribute: right vertical.
  297.   {$EXTERNALSYM COMMON_LVB_GRID_RVERTICAL}
  298.   COMMON_LVB_REVERSE_VIDEO   = $4000; // DBCS: Reverse fore/back ground attribute.
  299.   {$EXTERNALSYM COMMON_LVB_REVERSE_VIDEO}
  300.   COMMON_LVB_UNDERSCORE      = $8000; // DBCS: Underscore.
  301.   {$EXTERNALSYM COMMON_LVB_UNDERSCORE}
  303.   COMMON_LVB_SBCSDBCS        = $0300; // SBCS or DBCS flag.
  304.   {$EXTERNALSYM COMMON_LVB_SBCSDBCS}
  306. type
  307.   PCONSOLE_SCREEN_BUFFER_INFO = ^CONSOLE_SCREEN_BUFFER_INFO;
  308.   {$EXTERNALSYM PCONSOLE_SCREEN_BUFFER_INFO}
  309.   _CONSOLE_SCREEN_BUFFER_INFO = record
  310.     dwSize: COORD;
  311.     dwCursorPosition: COORD;
  312.     wAttributes: WORD;
  313.     srWindow: SMALL_RECT;
  314.     dwMaximumWindowSize: COORD;
  315.   end;
  316.   {$EXTERNALSYM _CONSOLE_SCREEN_BUFFER_INFO}
  317.   CONSOLE_SCREEN_BUFFER_INFO = _CONSOLE_SCREEN_BUFFER_INFO;
  318.   {$EXTERNALSYM CONSOLE_SCREEN_BUFFER_INFO}
  319.   TConsoleScreenBufferInfo = CONSOLE_SCREEN_BUFFER_INFO;
  320.   PConsoleScreenBufferInfo = PCONSOLE_SCREEN_BUFFER_INFO;
  322.   PCONSOLE_CURSOR_INFO = ^CONSOLE_CURSOR_INFO;
  323.   {$EXTERNALSYM PCONSOLE_CURSOR_INFO}
  324.   _CONSOLE_CURSOR_INFO = record
  325.     dwSize: DWORD;
  326.     bVisible: BOOL;
  327.   end;
  328.   {$EXTERNALSYM _CONSOLE_CURSOR_INFO}
  329.   CONSOLE_CURSOR_INFO = _CONSOLE_CURSOR_INFO;
  330.   {$EXTERNALSYM CONSOLE_CURSOR_INFO}
  331.   TConsoleCursorInfo = CONSOLE_CURSOR_INFO;
  332.   PConsoleCursorInfo = PCONSOLE_CURSOR_INFO;
  334.   _CONSOLE_FONT_INFO = record
  335.     nFont: DWORD;
  336.     dwFontSize: COORD;
  337.   end;
  338.   {$EXTERNALSYM _CONSOLE_FONT_INFO}
  339.   CONSOLE_FONT_INFO = _CONSOLE_FONT_INFO;
  340.   {$EXTERNALSYM CONSOLE_FONT_INFO}
  341.   PCONSOLE_FONT_INFO = ^CONSOLE_FONT_INFO;
  342.   {$EXTERNALSYM PCONSOLE_FONT_INFO}
  343.   TConsoleFontInfo = CONSOLE_FONT_INFO;
  344.   PConsoleFontInfo = PCONSOLE_FONT_INFO;
  346.   _CONSOLE_SELECTION_INFO = record
  347.     dwFlags: DWORD;
  348.     dwSelectionAnchor: COORD;
  349.     srSelection: SMALL_RECT;
  350.   end;
  351.   {$EXTERNALSYM _CONSOLE_SELECTION_INFO}
  352.   CONSOLE_SELECTION_INFO = _CONSOLE_SELECTION_INFO;
  353.   {$EXTERNALSYM CONSOLE_SELECTION_INFO}
  354.   PCONSOLE_SELECTION_INFO = ^CONSOLE_SELECTION_INFO;
  355.   {$EXTERNALSYM PCONSOLE_SELECTION_INFO}
  356.   TConsoleSelectionInfo = CONSOLE_SELECTION_INFO;
  357.   PConsoleSelectionInfo = PCONSOLE_SELECTION_INFO;  
  359. //
  360. // Selection flags
  361. //
  363. const
  364.   CONSOLE_NO_SELECTION          = $0000;
  365.   {$EXTERNALSYM CONSOLE_NO_SELECTION}
  366.   CONSOLE_SELECTION_IN_PROGRESS = $0001;   // selection has begun
  367.   {$EXTERNALSYM CONSOLE_SELECTION_IN_PROGRESS}
  368.   CONSOLE_SELECTION_NOT_EMPTY   = $0002;   // non-null select rectangle
  369.   {$EXTERNALSYM CONSOLE_SELECTION_NOT_EMPTY}
  370.   CONSOLE_MOUSE_SELECTION       = $0004;   // selecting with mouse
  371.   {$EXTERNALSYM CONSOLE_MOUSE_SELECTION}
  372.   CONSOLE_MOUSE_DOWN            = $0008;   // mouse is down
  373.   {$EXTERNALSYM CONSOLE_MOUSE_DOWN}
  375. //
  376. // typedef for ctrl-c handler routines
  377. //
  379. type
  380.   PHANDLER_ROUTINE = function (CtrlType: DWORD): BOOL; stdcall;
  381.   {$EXTERNALSYM PHANDLER_ROUTINE}
  382.   THandlerRoutine = PHANDLER_ROUTINE;
  384. const
  385.   CTRL_C_EVENT        = 0;
  386.   {$EXTERNALSYM CTRL_C_EVENT}
  387.   CTRL_BREAK_EVENT    = 1;
  388.   {$EXTERNALSYM CTRL_BREAK_EVENT}
  389.   CTRL_CLOSE_EVENT    = 2;
  390.   {$EXTERNALSYM CTRL_CLOSE_EVENT}
  391.   // 3 is reserved!
  392.   // 4 is reserved!
  393.   CTRL_LOGOFF_EVENT   = 5;
  394.   {$EXTERNALSYM CTRL_LOGOFF_EVENT}
  395.   CTRL_SHUTDOWN_EVENT = 6;
  396.   {$EXTERNALSYM CTRL_SHUTDOWN_EVENT}
  398. //
  399. //  Input Mode flags:
  400. //
  402.   ENABLE_PROCESSED_INPUT = $0001;
  403.   {$EXTERNALSYM ENABLE_PROCESSED_INPUT}
  404.   ENABLE_LINE_INPUT      = $0002;
  405.   {$EXTERNALSYM ENABLE_LINE_INPUT}
  406.   ENABLE_ECHO_INPUT      = $0004;
  407.   {$EXTERNALSYM ENABLE_ECHO_INPUT}
  408.   ENABLE_WINDOW_INPUT    = $0008;
  409.   {$EXTERNALSYM ENABLE_WINDOW_INPUT}
  410.   ENABLE_MOUSE_INPUT     = $0010;
  411.   {$EXTERNALSYM ENABLE_MOUSE_INPUT}
  413. //
  414. // Output Mode flags:
  415. //
  417.   ENABLE_PROCESSED_OUTPUT   = $0001;
  418.   {$EXTERNALSYM ENABLE_PROCESSED_OUTPUT}
  419.   ENABLE_WRAP_AT_EOL_OUTPUT = $0002;
  420.   {$EXTERNALSYM ENABLE_WRAP_AT_EOL_OUTPUT}
  422. //
  423. // direct API definitions.
  424. //
  426. function PeekConsoleInputA(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  427.   nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
  428. {$EXTERNALSYM PeekConsoleInputA}
  429. function PeekConsoleInputW(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  430.   nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
  431. {$EXTERNALSYM PeekConsoleInputW}
  433. {$IFDEF UNICODE}
  434. function PeekConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  435.   nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
  436. {$EXTERNALSYM PeekConsoleInput}
  437. {$ELSE}
  438. function PeekConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  439.   nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
  440. {$EXTERNALSYM PeekConsoleInput}
  441. {$ENDIF}
  443. function ReadConsoleInputA(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  444.   nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
  445. {$EXTERNALSYM ReadConsoleInputA}
  446. function ReadConsoleInputW(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  447.   nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
  448. {$EXTERNALSYM ReadConsoleInputW}
  450. {$IFDEF UNICODE}
  451. function ReadConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  452.   nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
  453. {$EXTERNALSYM ReadConsoleInput}
  454. {$ELSE}
  455. function ReadConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  456.   nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
  457. {$EXTERNALSYM ReadConsoleInput}
  458. {$ENDIF}
  460. function WriteConsoleInputA(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  461.   nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; stdcall;
  462. {$EXTERNALSYM WriteConsoleInputA}
  463. function WriteConsoleInputW(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  464.   nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; stdcall;
  465. {$EXTERNALSYM WriteConsoleInputW}
  467. {$IFDEF UNICODE}
  468. function WriteConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  469.   nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; stdcall;
  470. {$EXTERNALSYM WriteConsoleInput}
  471. {$ELSE}
  472. function WriteConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
  473.   nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; stdcall;
  474. {$EXTERNALSYM WriteConsoleInput}
  475. {$ENDIF}
  477. function ReadConsoleOutputA(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
  478.   dwBufferSize: COORD; dwBufferCoord: COORD;
  479.   var lpReadRegion: SMALL_RECT): BOOL; stdcall;
  480. {$EXTERNALSYM ReadConsoleOutputA}
  481. function ReadConsoleOutputW(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
  482.   dwBufferSize: COORD; dwBufferCoord: COORD;
  483.   var lpReadRegion: SMALL_RECT): BOOL; stdcall;
  484. {$EXTERNALSYM ReadConsoleOutputW}
  486. {$IFDEF UNICODE}
  487. function ReadConsoleOutput(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
  488.   dwBufferSize: COORD; dwBufferCoord: COORD;
  489.   var lpReadRegion: SMALL_RECT): BOOL; stdcall;
  490. {$EXTERNALSYM ReadConsoleOutput}
  491. {$ELSE}
  492. function ReadConsoleOutput(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
  493.   dwBufferSize: COORD; dwBufferCoord: COORD;
  494.   var lpReadRegion: SMALL_RECT): BOOL; stdcall;
  495. {$EXTERNALSYM ReadConsoleOutput}
  496. {$ENDIF}
  498. function WriteConsoleOutputA(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
  499.   dwBufferSize: COORD; dwBufferCoord: COORD;
  500.   var lpWriteRegion: SMALL_RECT): BOOL; stdcall;
  501. {$EXTERNALSYM WriteConsoleOutputA}
  502. function WriteConsoleOutputW(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
  503.   dwBufferSize: COORD; dwBufferCoord: COORD;
  504.   var lpWriteRegion: SMALL_RECT): BOOL; stdcall;
  505. {$EXTERNALSYM WriteConsoleOutputW}
  507. {$IFDEF UNICODE}
  508. function WriteConsoleOutput(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
  509.   dwBufferSize: COORD; dwBufferCoord: COORD;
  510.   var lpWriteRegion: SMALL_RECT): BOOL; stdcall;
  511. {$EXTERNALSYM WriteConsoleOutput}
  512. {$ELSE}
  513. function WriteConsoleOutput(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
  514.   dwBufferSize: COORD; dwBufferCoord: COORD;
  515.   var lpWriteRegion: SMALL_RECT): BOOL; stdcall;
  516. {$EXTERNALSYM WriteConsoleOutput}
  517. {$ENDIF}
  519. function ReadConsoleOutputCharacterA(hConsoleOutput: HANDLE; lpCharacter: LPSTR;
  520.   nLength: DWORD; dwReadCoord: COORD; var lpNumberOfCharsRead: DWORD): BOOL; stdcall;
  521. {$EXTERNALSYM ReadConsoleOutputCharacterA}
  522. function ReadConsoleOutputCharacterW(hConsoleOutput: HANDLE; lpCharacter: LPWSTR;
  523.   nLength: DWORD; dwReadCoord: COORD; var lpNumberOfCharsRead: DWORD): BOOL; stdcall;
  524. {$EXTERNALSYM ReadConsoleOutputCharacterW}
  526. {$IFDEF UNICODE}
  527. function ReadConsoleOutputCharacter(hConsoleOutput: HANDLE; lpCharacter: LPWSTR;
  528.   nLength: DWORD; dwReadCoord: COORD; var lpNumberOfCharsRead: DWORD): BOOL; stdcall;
  529. {$EXTERNALSYM ReadConsoleOutputCharacter}
  530. {$ELSE}
  531. function ReadConsoleOutputCharacter(hConsoleOutput: HANDLE; lpCharacter: LPSTR;
  532.   nLength: DWORD; dwReadCoord: COORD; var lpNumberOfCharsRead: DWORD): BOOL; stdcall;
  533. {$EXTERNALSYM ReadConsoleOutputCharacter}
  534. {$ENDIF}
  536. function ReadConsoleOutputAttribute(hConsoleOutput: HANDLE;
  537.   var lpAttribute: DWORD; nLength: DWORD; dwReadCoord: COORD;
  538.   var lpNumberOfAttrsRead: DWORD): BOOL; stdcall;
  539. {$EXTERNALSYM ReadConsoleOutputAttribute}
  541. function WriteConsoleOutputCharacterA(hConsoleOutput: HANDLE;
  542.   lpCharacter: LPCSTR; nLength: DWORD; dwWriteCoord: COORD;
  543.   var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
  544. {$EXTERNALSYM WriteConsoleOutputCharacterA}
  545. function WriteConsoleOutputCharacterW(hConsoleOutput: HANDLE;
  546.   lpCharacter: LPCWSTR; nLength: DWORD; dwWriteCoord: COORD;
  547.   var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
  548. {$EXTERNALSYM WriteConsoleOutputCharacterW}
  550. {$IFDEF UNICODE}
  551. function WriteConsoleOutputCharacter(hConsoleOutput: HANDLE;
  552.   lpCharacter: LPCWSTR; nLength: DWORD; dwWriteCoord: COORD;
  553.   var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
  554. {$EXTERNALSYM WriteConsoleOutputCharacter}
  555. {$ELSE}
  556. function WriteConsoleOutputCharacter(hConsoleOutput: HANDLE;
  557.   lpCharacter: LPCSTR; nLength: DWORD; dwWriteCoord: COORD;
  558.   var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
  559. {$EXTERNALSYM WriteConsoleOutputCharacter}
  560. {$ENDIF}
  562. function WriteConsoleOutputAttribute(hConsoleOutput: HANDLE; lpAttribute: PWORD;
  563.   nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfAttrsWritten: DWORD): BOOL; stdcall;
  564. {$EXTERNALSYM WriteConsoleOutputAttribute}
  566. function FillConsoleOutputCharacterA(hConsoleOutput: HANDLE; cCharacter: CHAR;
  567.   nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
  568. {$EXTERNALSYM FillConsoleOutputCharacterA}
  569. function FillConsoleOutputCharacterW(hConsoleOutput: HANDLE; cCharacter: WCHAR;
  570.   nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
  571. {$EXTERNALSYM FillConsoleOutputCharacterW}
  573. {$IFDEF UNICODE}
  574. function FillConsoleOutputCharacter(hConsoleOutput: HANDLE; cCharacter: WCHAR;
  575.   nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
  576. {$EXTERNALSYM FillConsoleOutputCharacter}
  577. {$ELSE}
  578. function FillConsoleOutputCharacter(hConsoleOutput: HANDLE; cCharacter: CHAR;
  579.   nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
  580. {$EXTERNALSYM FillConsoleOutputCharacter}
  581. {$ENDIF}
  583. function FillConsoleOutputAttribute(hConsoleOutput: HANDLE; wAttribute: WORD;
  584.   nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfAttrsWritten: DWORD): BOOL; stdcall;
  585. {$EXTERNALSYM FillConsoleOutputAttribute}
  586. function GetConsoleMode(hConsoleHandle: HANDLE; var lpMode: DWORD): BOOL; stdcall;
  587. {$EXTERNALSYM GetConsoleMode}
  588. function GetNumberOfConsoleInputEvents(hConsoleInput: HANDLE;
  589.   var lpNumberOfEvents: DWORD): BOOL; stdcall;
  590. {$EXTERNALSYM GetNumberOfConsoleInputEvents}
  591. function GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE;
  592.   var lpConsoleScreenBufferInfo: CONSOLE_SCREEN_BUFFER_INFO): BOOL; stdcall;
  593. {$EXTERNALSYM GetConsoleScreenBufferInfo}
  594. function GetLargestConsoleWindowSize(hConsoleOutput: HANDLE): COORD; stdcall;
  595. {$EXTERNALSYM GetLargestConsoleWindowSize}
  596. function GetConsoleCursorInfo(hConsoleOutput: HANDLE;
  597.   var lpConsoleCursorInfo: CONSOLE_CURSOR_INFO): BOOL; stdcall;
  598. function GetCurrentConsoleFont(hConsoleOutput: HANDLE; bMaximumWindow: BOOL;
  599.   var lpConsoleCurrentFont: CONSOLE_FONT_INFO): BOOL; stdcall;
  600. {$EXTERNALSYM GetCurrentConsoleFont}
  601. function GetConsoleFontSize(hConsoleOutput: HANDLE; nFont: DWORD): COORD; stdcall;
  602. {$EXTERNALSYM GetConsoleFontSize}
  603. function GetConsoleSelectionInfo(var lpConsoleSelectionInfo: CONSOLE_SELECTION_INFO): BOOL; stdcall;
  604. {$EXTERNALSYM GetConsoleSelectionInfo}
  605. {$EXTERNALSYM GetConsoleCursorInfo}
  606. function GetNumberOfConsoleMouseButtons(var lpNumberOfMouseButtons: DWORD): BOOL; stdcall;
  607. {$EXTERNALSYM GetNumberOfConsoleMouseButtons}
  608. function SetConsoleMode(hConsoleHandle: HANDLE; dwMode: DWORD): BOOL; stdcall;
  609. {$EXTERNALSYM SetConsoleMode}
  610. function SetConsoleActiveScreenBuffer(hConsoleOutput: HANDLE): BOOL; stdcall;
  611. {$EXTERNALSYM SetConsoleActiveScreenBuffer}
  612. function FlushConsoleInputBuffer(hConsoleInput: HANDLE): BOOL; stdcall;
  613. {$EXTERNALSYM FlushConsoleInputBuffer}
  614. function SetConsoleScreenBufferSize(hConsoleOutput: HANDLE; dwSize: COORD): BOOL; stdcall;
  615. {$EXTERNALSYM SetConsoleScreenBufferSize}
  616. function SetConsoleCursorPosition(hConsoleOutput: HANDLE; dwCursorPosition: COORD): BOOL; stdcall;
  617. {$EXTERNALSYM SetConsoleCursorPosition}
  618. function SetConsoleCursorInfo(hConsoleOutput: HANDLE;
  619.   var lpConsoleCursorInfo: CONSOLE_CURSOR_INFO): BOOL; stdcall;
  620. {$EXTERNALSYM SetConsoleCursorInfo}
  622. function ScrollConsoleScreenBufferA(hConsoleOutput: HANDLE;
  623.   const lpScrollRectangle: SMALL_RECT; lpClipRectangle: PSMALL_RECT;
  624.   dwDestinationOrigin: COORD; const lpFill: CHAR_INFO): BOOL; stdcall;
  625. {$EXTERNALSYM ScrollConsoleScreenBufferA}
  626. function ScrollConsoleScreenBufferW(hConsoleOutput: HANDLE;
  627.   const lpScrollRectangle: PSMALL_RECT; lpClipRectangle: PSMALL_RECT;
  628.   dwDestinationOrigin: COORD; const lpFill: CHAR_INFO): BOOL; stdcall;
  629. {$EXTERNALSYM ScrollConsoleScreenBufferW}
  630. {$IFDEF UNICODE}
  631. function ScrollConsoleScreenBuffer(hConsoleOutput: HANDLE;
  632.   const lpScrollRectangle: PSMALL_RECT; lpClipRectangle: PSMALL_RECT;
  633.   dwDestinationOrigin: COORD; const lpFill: CHAR_INFO): BOOL; stdcall;
  634. {$EXTERNALSYM ScrollConsoleScreenBuffer}
  635. {$ELSE}
  636. function ScrollConsoleScreenBuffer(hConsoleOutput: HANDLE;
  637.   const lpScrollRectangle: SMALL_RECT; lpClipRectangle: PSMALL_RECT;
  638.   dwDestinationOrigin: COORD; const lpFill: CHAR_INFO): BOOL; stdcall;
  639. {$EXTERNALSYM ScrollConsoleScreenBuffer}
  640. {$ENDIF}
  642. function SetConsoleWindowInfo(hConsoleOutput: HANDLE; bAbsolute: BOOL;
  643.   const lpConsoleWindow: SMALL_RECT): BOOL; stdcall;
  644. {$EXTERNALSYM SetConsoleWindowInfo}
  645. function SetConsoleTextAttribute(hConsoleOutput: HANDLE; wAttributes: WORD): BOOL; stdcall;
  646. {$EXTERNALSYM SetConsoleTextAttribute}
  647. function SetConsoleCtrlHandler(HandlerRoutine: PHANDLER_ROUTINE; Add: BOOL): BOOL; stdcall;
  648. {$EXTERNALSYM SetConsoleCtrlHandler}
  649. function GenerateConsoleCtrlEvent(dwCtrlEvent: DWORD; dwProcessGroupId: DWORD): BOOL; stdcall;
  650. {$EXTERNALSYM GenerateConsoleCtrlEvent}
  651. function AllocConsole: BOOL; stdcall;
  652. {$EXTERNALSYM AllocConsole}
  653. function FreeConsole: BOOL; stdcall;
  654. {$EXTERNALSYM FreeConsole}
  655. function AttachConsole(dwProcessId: DWORD): BOOL; stdcall;
  656. {$EXTERNALSYM AttachConsole}
  658. function GetConsoleTitleA(lpConsoleTitle: LPSTR; nSize: DWORD): DWORD; stdcall;
  659. {$EXTERNALSYM GetConsoleTitleA}
  660. function GetConsoleTitleW(lpConsoleTitle: LPWSTR; nSize: DWORD): DWORD; stdcall;
  661. {$EXTERNALSYM GetConsoleTitleW}
  662. {$IFDEF UNICODE}
  663. function GetConsoleTitle(lpConsoleTitle: LPWSTR; nSize: DWORD): DWORD; stdcall;
  664. {$EXTERNALSYM GetConsoleTitle}
  665. {$ELSE}
  666. function GetConsoleTitle(lpConsoleTitle: LPSTR; nSize: DWORD): DWORD; stdcall;
  667. {$EXTERNALSYM GetConsoleTitle}
  668. {$ENDIF}
  670. function SetConsoleTitleA(lpConsoleTitle: LPCSTR): BOOL; stdcall;
  671. {$EXTERNALSYM SetConsoleTitleA}
  672. function SetConsoleTitleW(lpConsoleTitle: LPCWSTR): BOOL; stdcall;
  673. {$EXTERNALSYM SetConsoleTitleW}
  674. {$IFDEF UNICODE}
  675. function SetConsoleTitle(lpConsoleTitle: LPCWSTR): BOOL; stdcall;
  676. {$EXTERNALSYM SetConsoleTitle}
  677. {$ELSE}
  678. function SetConsoleTitle(lpConsoleTitle: LPCSTR): BOOL; stdcall;
  679. {$EXTERNALSYM SetConsoleTitle}
  680. {$ENDIF}
  682. function ReadConsoleA(hConsoleInput: HANDLE; lpBuffer: LPVOID;
  683.   nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD;
  684.   lpReserved: LPVOID): BOOL; stdcall;
  685. {$EXTERNALSYM ReadConsoleA}
  686. function ReadConsoleW(hConsoleInput: HANDLE; lpBuffer: LPVOID;
  687.   nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD;
  688.   lpReserved: LPVOID): BOOL; stdcall;
  689. {$EXTERNALSYM ReadConsoleW}
  690. {$IFDEF UNICODE}
  691. function ReadConsole(hConsoleInput: HANDLE; lpBuffer: LPVOID;
  692.   nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD;
  693.   lpReserved: LPVOID): BOOL; stdcall;
  694. {$EXTERNALSYM ReadConsole}
  695. {$ELSE}
  696. function ReadConsole(hConsoleInput: HANDLE; lpBuffer: LPVOID;
  697.   nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD;
  698.   lpReserved: LPVOID): BOOL; stdcall;
  699. {$EXTERNALSYM ReadConsole}
  700. {$ENDIF}
  702. function WriteConsoleA(hConsoleOutput: HANDLE; lpBuffer: LPVOID;
  703.   nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD;
  704.   lpReserved: LPVOID): BOOL; stdcall;
  705. {$EXTERNALSYM WriteConsoleA}
  706. function WriteConsoleW(hConsoleOutput: HANDLE; lpBuffer: LPVOID;
  707.   nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD;
  708.   lpReserved: LPVOID): BOOL; stdcall;
  709. {$EXTERNALSYM WriteConsoleW}
  710. {$IFDEF UNICODE}
  711. function WriteConsole(hConsoleOutput: HANDLE; lpBuffer: LPVOID;
  712.   nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD;
  713.   lpReserved: LPVOID): BOOL; stdcall;
  714. {$EXTERNALSYM WriteConsole}
  715. {$ELSE}
  716. function WriteConsole(hConsoleOutput: HANDLE; lpBuffer: LPVOID;
  717.   nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD;
  718.   lpReserved: LPVOID): BOOL; stdcall;
  719. {$EXTERNALSYM WriteConsole}
  720. {$ENDIF}
  722. const
  723.   CONSOLE_TEXTMODE_BUFFER = 1;
  724.   {$EXTERNALSYM CONSOLE_TEXTMODE_BUFFER}
  726. function CreateConsoleScreenBuffer(dwDesiredAccess: DWORD; dwShareMode: DWORD;
  727.   lpSecurityAttributes: PSECURITY_ATTRIBUTES; dwFlags: DWORD;
  728.   lpScreenBufferData: LPVOID): HANDLE; stdcall;
  729. {$EXTERNALSYM CreateConsoleScreenBuffer}
  730. function GetConsoleCP: UINT; stdcall;
  731. {$EXTERNALSYM GetConsoleCP}
  732. function SetConsoleCP(wCodePageID: UINT): BOOL; stdcall;
  733. {$EXTERNALSYM SetConsoleCP}
  734. function GetConsoleOutputCP: UINT; stdcall;
  735. {$EXTERNALSYM GetConsoleOutputCP}
  736. function SetConsoleOutputCP(wCodePageID: UINT): BOOL; stdcall;
  737. {$EXTERNALSYM SetConsoleOutputCP}
  739. const
  740.   CONSOLE_FULLSCREEN = 1;            // fullscreen console
  741.   {$EXTERNALSYM CONSOLE_FULLSCREEN}
  742.   CONSOLE_FULLSCREEN_HARDWARE = 2;   // console owns the hardware
  743.   {$EXTERNALSYM CONSOLE_FULLSCREEN_HARDWARE}
  745. function GetConsoleDisplayMode(var lpModeFlags: DWORD): BOOL; stdcall;
  746. {$EXTERNALSYM GetConsoleDisplayMode}
  748. function GetConsoleWindow: HWND; stdcall;
  749. {$EXTERNALSYM GetConsoleWindow}
  751. function GetConsoleProcessList(var lpdwProcessList: LPDWORD; dwProcessCount: DWORD): DWORD; stdcall;
  752. {$EXTERNALSYM GetConsoleProcessList}
  754. implementation
  756. const
  757.   kernel32 = 'kernel32.dll';
  760. {$IFDEF DYNAMIC_LINK}
  761. var
  762.   _PeekConsoleInputA: Pointer;
  764. function PeekConsoleInputA;
  765. begin
  766.   GetProcedureAddress(_PeekConsoleInputA, kernel32, 'PeekConsoleInputA');
  767.   asm
  768.     mov esp, ebp
  769.     pop ebp
  770.     jmp [_PeekConsoleInputA]
  771.   end;
  772. end;
  773. {$ELSE}
  774. function PeekConsoleInputA; external kernel32 name 'PeekConsoleInputA';
  775. {$ENDIF DYNAMIC_LINK}
  777. {$IFDEF DYNAMIC_LINK}
  778. var
  779.   _PeekConsoleInputW: Pointer;
  781. function PeekConsoleInputW;
  782. begin
  783.   GetProcedureAddress(_PeekConsoleInputW, kernel32, 'PeekConsoleInputW');
  784.   asm
  785.     mov esp, ebp
  786.     pop ebp
  787.     jmp [_PeekConsoleInputW]
  788.   end;
  789. end;
  790. {$ELSE}
  791. function PeekConsoleInputW; external kernel32 name 'PeekConsoleInputW';
  792. {$ENDIF DYNAMIC_LINK}
  793. {$IFDEF UNICODE}
  795. {$IFDEF DYNAMIC_LINK}
  796. var
  797.   _PeekConsoleInput: Pointer;
  799. function PeekConsoleInput;
  800. begin
  801.   GetProcedureAddress(_PeekConsoleInput, kernel32, 'PeekConsoleInputW');
  802.   asm
  803.     mov esp, ebp
  804.     pop ebp
  805.     jmp [_PeekConsoleInput]
  806.   end;
  807. end;
  808. {$ELSE}
  809. function PeekConsoleInput; external kernel32 name 'PeekConsoleInputW';
  810. {$ENDIF DYNAMIC_LINK}
  811. {$ELSE}
  813. {$IFDEF DYNAMIC_LINK}
  814. var
  815.   _PeekConsoleInput: Pointer;
  817. function PeekConsoleInput;
  818. begin
  819.   GetProcedureAddress(_PeekConsoleInput, kernel32, 'PeekConsoleInputA');
  820.   asm
  821.     mov esp, ebp
  822.     pop ebp
  823.     jmp [_PeekConsoleInput]
  824.   end;
  825. end;
  826. {$ELSE}
  827. function PeekConsoleInput; external kernel32 name 'PeekConsoleInputA';
  828. {$ENDIF DYNAMIC_LINK}
  829. {$ENDIF}
  832. {$IFDEF DYNAMIC_LINK}
  833. var
  834.   _ReadConsoleInputA: Pointer;
  836. function ReadConsoleInputA;
  837. begin
  838.   GetProcedureAddress(_ReadConsoleInputA, kernel32, 'ReadConsoleInputA');
  839.   asm
  840.     mov esp, ebp
  841.     pop ebp
  842.     jmp [_ReadConsoleInputA]
  843.   end;
  844. end;
  845. {$ELSE}
  846. function ReadConsoleInputA; external kernel32 name 'ReadConsoleInputA';
  847. {$ENDIF DYNAMIC_LINK}
  849. {$IFDEF DYNAMIC_LINK}
  850. var
  851.   _ReadConsoleInputW: Pointer;
  853. function ReadConsoleInputW;
  854. begin
  855.   GetProcedureAddress(_ReadConsoleInputW, kernel32, 'ReadConsoleInputW');
  856.   asm
  857.     mov esp, ebp
  858.     pop ebp
  859.     jmp [_ReadConsoleInputW]
  860.   end;
  861. end;
  862. {$ELSE}
  863. function ReadConsoleInputW; external kernel32 name 'ReadConsoleInputW';
  864. {$ENDIF DYNAMIC_LINK}
  865. {$IFDEF UNICODE}
  867. {$IFDEF DYNAMIC_LINK}
  868. var
  869.   _ReadConsoleInput: Pointer;
  871. function ReadConsoleInput;
  872. begin
  873.   GetProcedureAddress(_ReadConsoleInput, kernel32, 'ReadConsoleInputW');
  874.   asm
  875.     mov esp, ebp
  876.     pop ebp
  877.     jmp [_ReadConsoleInput]
  878.   end;
  879. end;
  880. {$ELSE}
  881. function ReadConsoleInput; external kernel32 name 'ReadConsoleInputW';
  882. {$ENDIF DYNAMIC_LINK}
  883. {$ELSE}
  885. {$IFDEF DYNAMIC_LINK}
  886. var
  887.   _ReadConsoleInput: Pointer;
  889. function ReadConsoleInput;
  890. begin
  891.   GetProcedureAddress(_ReadConsoleInput, kernel32, 'ReadConsoleInputA');
  892.   asm
  893.     mov esp, ebp
  894.     pop ebp
  895.     jmp [_ReadConsoleInput]
  896.   end;
  897. end;
  898. {$ELSE}
  899. function ReadConsoleInput; external kernel32 name 'ReadConsoleInputA';
  900. {$ENDIF DYNAMIC_LINK}
  901. {$ENDIF}
  904. {$IFDEF DYNAMIC_LINK}
  905. var
  906.   _WriteConsoleInputA: Pointer;
  908. function WriteConsoleInputA;
  909. begin
  910.   GetProcedureAddress(_WriteConsoleInputA, kernel32, 'WriteConsoleInputA');
  911.   asm
  912.     mov esp, ebp
  913.     pop ebp
  914.     jmp [_WriteConsoleInputA]
  915.   end;
  916. end;
  917. {$ELSE}
  918. function WriteConsoleInputA; external kernel32 name 'WriteConsoleInputA';
  919. {$ENDIF DYNAMIC_LINK}
  921. {$IFDEF DYNAMIC_LINK}
  922. var
  923.   _WriteConsoleInputW: Pointer;
  925. function WriteConsoleInputW;
  926. begin
  927.   GetProcedureAddress(_WriteConsoleInputW, kernel32, 'WriteConsoleInputW');
  928.   asm
  929.     mov esp, ebp
  930.     pop ebp
  931.     jmp [_WriteConsoleInputW]
  932.   end;
  933. end;
  934. {$ELSE}
  935. function WriteConsoleInputW; external kernel32 name 'WriteConsoleInputW';
  936. {$ENDIF DYNAMIC_LINK}
  937. {$IFDEF UNICODE}
  939. {$IFDEF DYNAMIC_LINK}
  940. var
  941.   _WriteConsoleInput: Pointer;
  943. function WriteConsoleInput;
  944. begin
  945.   GetProcedureAddress(_WriteConsoleInput, kernel32, 'WriteConsoleInputW');
  946.   asm
  947.     mov esp, ebp
  948.     pop ebp
  949.     jmp [_WriteConsoleInput]
  950.   end;
  951. end;
  952. {$ELSE}
  953. function WriteConsoleInput; external kernel32 name 'WriteConsoleInputW';
  954. {$ENDIF DYNAMIC_LINK}
  955. {$ELSE}
  957. {$IFDEF DYNAMIC_LINK}
  958. var
  959.   _WriteConsoleInput: Pointer;
  961. function WriteConsoleInput;
  962. begin
  963.   GetProcedureAddress(_WriteConsoleInput, kernel32, 'WriteConsoleInputA');
  964.   asm
  965.     mov esp, ebp
  966.     pop ebp
  967.     jmp [_WriteConsoleInput]
  968.   end;
  969. end;
  970. {$ELSE}
  971. function WriteConsoleInput; external kernel32 name 'WriteConsoleInputA';
  972. {$ENDIF DYNAMIC_LINK}
  973. {$ENDIF}
  976. {$IFDEF DYNAMIC_LINK}
  977. var
  978.   _ReadConsoleOutputA: Pointer;
  980. function ReadConsoleOutputA;
  981. begin
  982.   GetProcedureAddress(_ReadConsoleOutputA, kernel32, 'ReadConsoleOutputA');
  983.   asm
  984.     mov esp, ebp
  985.     pop ebp
  986.     jmp [_ReadConsoleOutputA]
  987.   end;
  988. end;
  989. {$ELSE}
  990. function ReadConsoleOutputA; external kernel32 name 'ReadConsoleOutputA';
  991. {$ENDIF DYNAMIC_LINK}
  993. {$IFDEF DYNAMIC_LINK}
  994. var
  995.   _ReadConsoleOutputW: Pointer;
  997. function ReadConsoleOutputW;
  998. begin
  999.   GetProcedureAddress(_ReadConsoleOutputW, kernel32, 'ReadConsoleOutputW');
  1000.   asm
  1001.     mov esp, ebp
  1002.     pop ebp
  1003.     jmp [_ReadConsoleOutputW]
  1004.   end;
  1005. end;
  1006. {$ELSE}
  1007. function ReadConsoleOutputW; external kernel32 name 'ReadConsoleOutputW';
  1008. {$ENDIF DYNAMIC_LINK}
  1009. {$IFDEF UNICODE}
  1011. {$IFDEF DYNAMIC_LINK}
  1012. var
  1013.   _ReadConsoleOutput: Pointer;
  1015. function ReadConsoleOutput;
  1016. begin
  1017.   GetProcedureAddress(_ReadConsoleOutput, kernel32, 'ReadConsoleOutputW');
  1018.   asm
  1019.     mov esp, ebp
  1020.     pop ebp
  1021.     jmp [_ReadConsoleOutput]
  1022.   end;
  1023. end;
  1024. {$ELSE}
  1025. function ReadConsoleOutput; external kernel32 name 'ReadConsoleOutputW';
  1026. {$ENDIF DYNAMIC_LINK}
  1027. {$ELSE}
  1029. {$IFDEF DYNAMIC_LINK}
  1030. var
  1031.   _ReadConsoleOutput: Pointer;
  1033. function ReadConsoleOutput;
  1034. begin
  1035.   GetProcedureAddress(_ReadConsoleOutput, kernel32, 'ReadConsoleOutputA');
  1036.   asm
  1037.     mov esp, ebp
  1038.     pop ebp
  1039.     jmp [_ReadConsoleOutput]
  1040.   end;
  1041. end;
  1042. {$ELSE}
  1043. function ReadConsoleOutput; external kernel32 name 'ReadConsoleOutputA';
  1044. {$ENDIF DYNAMIC_LINK}
  1045. {$ENDIF}
  1048. {$IFDEF DYNAMIC_LINK}
  1049. var
  1050.   _WriteConsoleOutputA: Pointer;
  1052. function WriteConsoleOutputA;
  1053. begin
  1054.   GetProcedureAddress(_WriteConsoleOutputA, kernel32, 'WriteConsoleOutputA');
  1055.   asm
  1056.     mov esp, ebp
  1057.     pop ebp
  1058.     jmp [_WriteConsoleOutputA]
  1059.   end;
  1060. end;
  1061. {$ELSE}
  1062. function WriteConsoleOutputA; external kernel32 name 'WriteConsoleOutputA';
  1063. {$ENDIF DYNAMIC_LINK}
  1065. {$IFDEF DYNAMIC_LINK}
  1066. var
  1067.   _WriteConsoleOutputW: Pointer;
  1069. function WriteConsoleOutputW;
  1070. begin
  1071.   GetProcedureAddress(_WriteConsoleOutputW, kernel32, 'WriteConsoleOutputW');
  1072.   asm
  1073.     mov esp, ebp
  1074.     pop ebp
  1075.     jmp [_WriteConsoleOutputW]
  1076.   end;
  1077. end;
  1078. {$ELSE}
  1079. function WriteConsoleOutputW; external kernel32 name 'WriteConsoleOutputW';
  1080. {$ENDIF DYNAMIC_LINK}
  1081. {$IFDEF UNICODE}
  1083. {$IFDEF DYNAMIC_LINK}
  1084. var
  1085.   _WriteConsoleOutput: Pointer;
  1087. function WriteConsoleOutput;
  1088. begin
  1089.   GetProcedureAddress(_WriteConsoleOutput, kernel32, 'WriteConsoleOutputW');
  1090.   asm
  1091.     mov esp, ebp
  1092.     pop ebp
  1093.     jmp [_WriteConsoleOutput]
  1094.   end;
  1095. end;
  1096. {$ELSE}
  1097. function WriteConsoleOutput; external kernel32 name 'WriteConsoleOutputW';
  1098. {$ENDIF DYNAMIC_LINK}
  1099. {$ELSE}
  1101. {$IFDEF DYNAMIC_LINK}
  1102. var
  1103.   _WriteConsoleOutput: Pointer;
  1105. function WriteConsoleOutput;
  1106. begin
  1107.   GetProcedureAddress(_WriteConsoleOutput, kernel32, 'WriteConsoleOutputA');
  1108.   asm
  1109.     mov esp, ebp
  1110.     pop ebp
  1111.     jmp [_WriteConsoleOutput]
  1112.   end;
  1113. end;
  1114. {$ELSE}
  1115. function WriteConsoleOutput; external kernel32 name 'WriteConsoleOutputA';
  1116. {$ENDIF DYNAMIC_LINK}
  1117. {$ENDIF}
  1120. {$IFDEF DYNAMIC_LINK}
  1121. var
  1122.   _ReadConsoleOutputCharacterA: Pointer;
  1124. function ReadConsoleOutputCharacterA;
  1125. begin
  1126.   GetProcedureAddress(_ReadConsoleOutputCharacterA, kernel32, 'ReadConsoleOutputCharacterA');
  1127.   asm
  1128.     mov esp, ebp
  1129.     pop ebp
  1130.     jmp [_ReadConsoleOutputCharacterA]
  1131.   end;
  1132. end;
  1133. {$ELSE}
  1134. function ReadConsoleOutputCharacterA; external kernel32 name 'ReadConsoleOutputCharacterA';
  1135. {$ENDIF DYNAMIC_LINK}
  1137. {$IFDEF DYNAMIC_LINK}
  1138. var
  1139.   _ReadConsoleOutputCharacterW: Pointer;
  1141. function ReadConsoleOutputCharacterW;
  1142. begin
  1143.   GetProcedureAddress(_ReadConsoleOutputCharacterW, kernel32, 'ReadConsoleOutputCharacterW');
  1144.   asm
  1145.     mov esp, ebp
  1146.     pop ebp
  1147.     jmp [_ReadConsoleOutputCharacterW]
  1148.   end;
  1149. end;
  1150. {$ELSE}
  1151. function ReadConsoleOutputCharacterW; external kernel32 name 'ReadConsoleOutputCharacterW';
  1152. {$ENDIF DYNAMIC_LINK}
  1153. {$IFDEF UNICODE}
  1155. {$IFDEF DYNAMIC_LINK}
  1156. var
  1157.   _ReadConsoleOutputCharacter: Pointer;
  1159. function ReadConsoleOutputCharacter;
  1160. begin
  1161.   GetProcedureAddress(_ReadConsoleOutputCharacter, kernel32, 'ReadConsoleOutputCharacterW');
  1162.   asm
  1163.     mov esp, ebp
  1164.     pop ebp
  1165.     jmp [_ReadConsoleOutputCharacter]
  1166.   end;
  1167. end;
  1168. {$ELSE}
  1169. function ReadConsoleOutputCharacter; external kernel32 name 'ReadConsoleOutputCharacterW';
  1170. {$ENDIF DYNAMIC_LINK}
  1171. {$ELSE}
  1173. {$IFDEF DYNAMIC_LINK}
  1174. var
  1175.   _ReadConsoleOutputCharacter: Pointer;
  1177. function ReadConsoleOutputCharacter;
  1178. begin
  1179.   GetProcedureAddress(_ReadConsoleOutputCharacter, kernel32, 'ReadConsoleOutputCharacterA');
  1180.   asm
  1181.     mov esp, ebp
  1182.     pop ebp
  1183.     jmp [_ReadConsoleOutputCharacter]
  1184.   end;
  1185. end;
  1186. {$ELSE}
  1187. function ReadConsoleOutputCharacter; external kernel32 name 'ReadConsoleOutputCharacterA';
  1188. {$ENDIF DYNAMIC_LINK}
  1189. {$ENDIF}
  1192. {$IFDEF DYNAMIC_LINK}
  1193. var
  1194.   _ReadConsoleOutputAttribute: Pointer;
  1196. function ReadConsoleOutputAttribute;
  1197. begin
  1198.   GetProcedureAddress(_ReadConsoleOutputAttribute, kernel32, 'ReadConsoleOutputAttribute');
  1199.   asm
  1200.     mov esp, ebp
  1201.     pop ebp
  1202.     jmp [_ReadConsoleOutputAttribute]
  1203.   end;
  1204. end;
  1205. {$ELSE}
  1206. function ReadConsoleOutputAttribute; external kernel32 name 'ReadConsoleOutputAttribute';
  1207. {$ENDIF DYNAMIC_LINK}
  1210. {$IFDEF DYNAMIC_LINK}
  1211. var
  1212.   _WriteConsoleOutputCharacterA: Pointer;
  1214. function WriteConsoleOutputCharacterA;
  1215. begin
  1216.   GetProcedureAddress(_WriteConsoleOutputCharacterA, kernel32, 'WriteConsoleOutputCharacterA');
  1217.   asm
  1218.     mov esp, ebp
  1219.     pop ebp
  1220.     jmp [_WriteConsoleOutputCharacterA]
  1221.   end;
  1222. end;
  1223. {$ELSE}
  1224. function WriteConsoleOutputCharacterA; external kernel32 name 'WriteConsoleOutputCharacterA';
  1225. {$ENDIF DYNAMIC_LINK}
  1227. {$IFDEF DYNAMIC_LINK}
  1228. var
  1229.   _WriteConsoleOutputCharacterW: Pointer;
  1231. function WriteConsoleOutputCharacterW;
  1232. begin
  1233.   GetProcedureAddress(_WriteConsoleOutputCharacterW, kernel32, 'WriteConsoleOutputCharacterW');
  1234.   asm
  1235.     mov esp, ebp
  1236.     pop ebp
  1237.     jmp [_WriteConsoleOutputCharacterW]
  1238.   end;
  1239. end;
  1240. {$ELSE}
  1241. function WriteConsoleOutputCharacterW; external kernel32 name 'WriteConsoleOutputCharacterW';
  1242. {$ENDIF DYNAMIC_LINK}
  1243. {$IFDEF UNICODE}
  1245. {$IFDEF DYNAMIC_LINK}
  1246. var
  1247.   _WriteConsoleOutputCharacter: Pointer;
  1249. function WriteConsoleOutputCharacter;
  1250. begin
  1251.   GetProcedureAddress(_WriteConsoleOutputCharacter, kernel32, 'WriteConsoleOutputCharacterW');
  1252.   asm
  1253.     mov esp, ebp
  1254.     pop ebp
  1255.     jmp [_WriteConsoleOutputCharacter]
  1256.   end;
  1257. end;
  1258. {$ELSE}
  1259. function WriteConsoleOutputCharacter; external kernel32 name 'WriteConsoleOutputCharacterW';
  1260. {$ENDIF DYNAMIC_LINK}
  1261. {$ELSE}
  1263. {$IFDEF DYNAMIC_LINK}
  1264. var
  1265.   _WriteConsoleOutputCharacter: Pointer;
  1267. function WriteConsoleOutputCharacter;
  1268. begin
  1269.   GetProcedureAddress(_WriteConsoleOutputCharacter, kernel32, 'WriteConsoleOutputCharacterA');
  1270.   asm
  1271.     mov esp, ebp
  1272.     pop ebp
  1273.     jmp [_WriteConsoleOutputCharacter]
  1274.   end;
  1275. end;
  1276. {$ELSE}
  1277. function WriteConsoleOutputCharacter; external kernel32 name 'WriteConsoleOutputCharacterA';
  1278. {$ENDIF DYNAMIC_LINK}
  1279. {$ENDIF}
  1282. {$IFDEF DYNAMIC_LINK}
  1283. var
  1284.   _WriteConsoleOutputAttribute: Pointer;
  1286. function WriteConsoleOutputAttribute;
  1287. begin
  1288.   GetProcedureAddress(_WriteConsoleOutputAttribute, kernel32, 'WriteConsoleOutputAttribute');
  1289.   asm
  1290.     mov esp, ebp
  1291.     pop ebp
  1292.     jmp [_WriteConsoleOutputAttribute]
  1293.   end;
  1294. end;
  1295. {$ELSE}
  1296. function WriteConsoleOutputAttribute; external kernel32 name 'WriteConsoleOutputAttribute';
  1297. {$ENDIF DYNAMIC_LINK}
  1300. {$IFDEF DYNAMIC_LINK}
  1301. var
  1302.   _FillConsoleOutputCharacterA: Pointer;
  1304. function FillConsoleOutputCharacterA;
  1305. begin
  1306.   GetProcedureAddress(_FillConsoleOutputCharacterA, kernel32, 'FillConsoleOutputCharacterA');
  1307.   asm
  1308.     mov esp, ebp
  1309.     pop ebp
  1310.     jmp [_FillConsoleOutputCharacterA]
  1311.   end;
  1312. end;
  1313. {$ELSE}
  1314. function FillConsoleOutputCharacterA; external kernel32 name 'FillConsoleOutputCharacterA';
  1315. {$ENDIF DYNAMIC_LINK}
  1317. {$IFDEF DYNAMIC_LINK}
  1318. var
  1319.   _FillConsoleOutputCharacterW: Pointer;
  1321. function FillConsoleOutputCharacterW;
  1322. begin
  1323.   GetProcedureAddress(_FillConsoleOutputCharacterW, kernel32, 'FillConsoleOutputCharacterW');
  1324.   asm
  1325.     mov esp, ebp
  1326.     pop ebp
  1327.     jmp [_FillConsoleOutputCharacterW]
  1328.   end;
  1329. end;
  1330. {$ELSE}
  1331. function FillConsoleOutputCharacterW; external kernel32 name 'FillConsoleOutputCharacterW';
  1332. {$ENDIF DYNAMIC_LINK}
  1333. {$IFDEF UNICODE}
  1335. {$IFDEF DYNAMIC_LINK}
  1336. var
  1337.   _FillConsoleOutputCharacter: Pointer;
  1339. function FillConsoleOutputCharacter;
  1340. begin
  1341.   GetProcedureAddress(_FillConsoleOutputCharacter, kernel32, 'FillConsoleOutputCharacterW');
  1342.   asm
  1343.     mov esp, ebp
  1344.     pop ebp
  1345.     jmp [_FillConsoleOutputCharacter]
  1346.   end;
  1347. end;
  1348. {$ELSE}
  1349. function FillConsoleOutputCharacter; external kernel32 name 'FillConsoleOutputCharacterW';
  1350. {$ENDIF DYNAMIC_LINK}
  1351. {$ELSE}
  1353. {$IFDEF DYNAMIC_LINK}
  1354. var
  1355.   _FillConsoleOutputCharacter: Pointer;
  1357. function FillConsoleOutputCharacter;
  1358. begin
  1359.   GetProcedureAddress(_FillConsoleOutputCharacter, kernel32, 'FillConsoleOutputCharacterA');
  1360.   asm
  1361.     mov esp, ebp
  1362.     pop ebp
  1363.     jmp [_FillConsoleOutputCharacter]
  1364.   end;
  1365. end;
  1366. {$ELSE}
  1367. function FillConsoleOutputCharacter; external kernel32 name 'FillConsoleOutputCharacterA';
  1368. {$ENDIF DYNAMIC_LINK}
  1369. {$ENDIF}
  1372. {$IFDEF DYNAMIC_LINK}
  1373. var
  1374.   _FillConsoleOutputAttribute: Pointer;
  1376. function FillConsoleOutputAttribute;
  1377. begin
  1378.   GetProcedureAddress(_FillConsoleOutputAttribute, kernel32, 'FillConsoleOutputAttribute');
  1379.   asm
  1380.     mov esp, ebp
  1381.     pop ebp
  1382.     jmp [_FillConsoleOutputAttribute]
  1383.   end;
  1384. end;
  1385. {$ELSE}
  1386. function FillConsoleOutputAttribute; external kernel32 name 'FillConsoleOutputAttribute';
  1387. {$ENDIF DYNAMIC_LINK}
  1389. {$IFDEF DYNAMIC_LINK}
  1390. var
  1391.   _GetConsoleMode: Pointer;
  1393. function GetConsoleMode;
  1394. begin
  1395.   GetProcedureAddress(_GetConsoleMode, kernel32, 'GetConsoleMode');
  1396.   asm
  1397.     mov esp, ebp
  1398.     pop ebp
  1399.     jmp [_GetConsoleMode]
  1400.   end;
  1401. end;
  1402. {$ELSE}
  1403. function GetConsoleMode; external kernel32 name 'GetConsoleMode';
  1404. {$ENDIF DYNAMIC_LINK}
  1406. {$IFDEF DYNAMIC_LINK}
  1407. var
  1408.   _GetNumberOfConsoleInputEvents: Pointer;
  1410. function GetNumberOfConsoleInputEvents;
  1411. begin
  1412.   GetProcedureAddress(_GetNumberOfConsoleInputEvents, kernel32, 'GetNumberOfConsoleInputEvents');
  1413.   asm
  1414.     mov esp, ebp
  1415.     pop ebp
  1416.     jmp [_GetNumberOfConsoleInputEvents]
  1417.   end;
  1418. end;
  1419. {$ELSE}
  1420. function GetNumberOfConsoleInputEvents; external kernel32 name 'GetNumberOfConsoleInputEvents';
  1421. {$ENDIF DYNAMIC_LINK}
  1423. {$IFDEF DYNAMIC_LINK}
  1424. var
  1425.   _GetConsoleScreenBufferInfo: Pointer;
  1427. function GetConsoleScreenBufferInfo;
  1428. begin
  1429.   GetProcedureAddress(_GetConsoleScreenBufferInfo, kernel32, 'GetConsoleScreenBufferInfo');
  1430.   asm
  1431.     mov esp, ebp
  1432.     pop ebp
  1433.     jmp [_GetConsoleScreenBufferInfo]
  1434.   end;
  1435. end;
  1436. {$ELSE}
  1437. function GetConsoleScreenBufferInfo; external kernel32 name 'GetConsoleScreenBufferInfo';
  1438. {$ENDIF DYNAMIC_LINK}
  1440. {$IFDEF DYNAMIC_LINK}
  1441. var
  1442.   _GetLargestConsoleWindowSize: Pointer;
  1444. function GetLargestConsoleWindowSize;
  1445. begin
  1446.   GetProcedureAddress(_GetLargestConsoleWindowSize, kernel32, 'GetLargestConsoleWindowSize');
  1447.   asm
  1448.     mov esp, ebp
  1449.     pop ebp
  1450.     jmp [_GetLargestConsoleWindowSize]
  1451.   end;
  1452. end;
  1453. {$ELSE}
  1454. function GetLargestConsoleWindowSize; external kernel32 name 'GetLargestConsoleWindowSize';
  1455. {$ENDIF DYNAMIC_LINK}
  1457. {$IFDEF DYNAMIC_LINK}
  1458. var
  1459.   _GetConsoleCursorInfo: Pointer;
  1461. function GetConsoleCursorInfo;
  1462. begin
  1463.   GetProcedureAddress(_GetConsoleCursorInfo, kernel32, 'GetConsoleCursorInfo');
  1464.   asm
  1465.     mov esp, ebp
  1466.     pop ebp
  1467.     jmp [_GetConsoleCursorInfo]
  1468.   end;
  1469. end;
  1470. {$ELSE}
  1471. function GetConsoleCursorInfo; external kernel32 name 'GetConsoleCursorInfo';
  1472. {$ENDIF DYNAMIC_LINK}
  1474. {$IFDEF DYNAMIC_LINK}
  1475. var
  1476.   _GetCurrentConsoleFont: Pointer;
  1478. function GetCurrentConsoleFont;
  1479. begin
  1480.   GetProcedureAddress(_GetCurrentConsoleFont, kernel32, 'GetCurrentConsoleFont');
  1481.   asm
  1482.     mov esp, ebp
  1483.     pop ebp
  1484.     jmp [_GetCurrentConsoleFont]
  1485.   end;
  1486. end;
  1487. {$ELSE}
  1488. function GetCurrentConsoleFont; external kernel32 name 'GetCurrentConsoleFont';
  1489. {$ENDIF DYNAMIC_LINK}
  1491. {$IFDEF DYNAMIC_LINK}
  1492. var
  1493.   _GetConsoleFontSize: Pointer;
  1495. function GetConsoleFontSize;
  1496. begin
  1497.   GetProcedureAddress(_GetConsoleFontSize, kernel32, 'GetConsoleFontSize');
  1498.   asm
  1499.     mov esp, ebp
  1500.     pop ebp
  1501.     jmp [_GetConsoleFontSize]
  1502.   end;
  1503. end;
  1504. {$ELSE}
  1505. function GetConsoleFontSize; external kernel32 name 'GetConsoleFontSize';
  1506. {$ENDIF DYNAMIC_LINK}
  1508. {$IFDEF DYNAMIC_LINK}
  1509. var
  1510.   _GetConsoleSelectionInfo: Pointer;
  1512. function GetConsoleSelectionInfo;
  1513. begin
  1514.   GetProcedureAddress(_GetConsoleSelectionInfo, kernel32, 'GetConsoleSelectionInfo');
  1515.   asm
  1516.     mov esp, ebp
  1517.     pop ebp
  1518.     jmp [_GetConsoleSelectionInfo]
  1519.   end;
  1520. end;
  1521. {$ELSE}
  1522. function GetConsoleSelectionInfo; external kernel32 name 'GetConsoleSelectionInfo';
  1523. {$ENDIF DYNAMIC_LINK}
  1525. {$IFDEF DYNAMIC_LINK}
  1526. var
  1527.   _GetNumberOfConsoleMouseButtons: Pointer;
  1529. function GetNumberOfConsoleMouseButtons;
  1530. begin
  1531.   GetProcedureAddress(_GetNumberOfConsoleMouseButtons, kernel32, 'GetNumberOfConsoleMouseButtons');
  1532.   asm
  1533.     mov esp, ebp
  1534.     pop ebp
  1535.     jmp [_GetNumberOfConsoleMouseButtons]
  1536.   end;
  1537. end;
  1538. {$ELSE}
  1539. function GetNumberOfConsoleMouseButtons; external kernel32 name 'GetNumberOfConsoleMouseButtons';
  1540. {$ENDIF DYNAMIC_LINK}
  1542. {$IFDEF DYNAMIC_LINK}
  1543. var
  1544.   _SetConsoleMode: Pointer;
  1546. function SetConsoleMode;
  1547. begin
  1548.   GetProcedureAddress(_SetConsoleMode, kernel32, 'SetConsoleMode');
  1549.   asm
  1550.     mov esp, ebp
  1551.     pop ebp
  1552.     jmp [_SetConsoleMode]
  1553.   end;
  1554. end;
  1555. {$ELSE}
  1556. function SetConsoleMode; external kernel32 name 'SetConsoleMode';
  1557. {$ENDIF DYNAMIC_LINK}
  1559. {$IFDEF DYNAMIC_LINK}
  1560. var
  1561.   _SetConsoleActiveScreenBuffer: Pointer;
  1563. function SetConsoleActiveScreenBuffer;
  1564. begin
  1565.   GetProcedureAddress(_SetConsoleActiveScreenBuffer, kernel32, 'SetConsoleActiveScreenBuffer');
  1566.   asm
  1567.     mov esp, ebp
  1568.     pop ebp
  1569.     jmp [_SetConsoleActiveScreenBuffer]
  1570.   end;
  1571. end;
  1572. {$ELSE}
  1573. function SetConsoleActiveScreenBuffer; external kernel32 name 'SetConsoleActiveScreenBuffer';
  1574. {$ENDIF DYNAMIC_LINK}
  1576. {$IFDEF DYNAMIC_LINK}
  1577. var
  1578.   _FlushConsoleInputBuffer: Pointer;
  1580. function FlushConsoleInputBuffer;
  1581. begin
  1582.   GetProcedureAddress(_FlushConsoleInputBuffer, kernel32, 'FlushConsoleInputBuffer');
  1583.   asm
  1584.     mov esp, ebp
  1585.     pop ebp
  1586.     jmp [_FlushConsoleInputBuffer]
  1587.   end;
  1588. end;
  1589. {$ELSE}
  1590. function FlushConsoleInputBuffer; external kernel32 name 'FlushConsoleInputBuffer';
  1591. {$ENDIF DYNAMIC_LINK}
  1593. {$IFDEF DYNAMIC_LINK}
  1594. var
  1595.   _SetConsoleScreenBufferSize: Pointer;
  1597. function SetConsoleScreenBufferSize;
  1598. begin
  1599.   GetProcedureAddress(_SetConsoleScreenBufferSize, kernel32, 'SetConsoleScreenBufferSize');
  1600.   asm
  1601.     mov esp, ebp
  1602.     pop ebp
  1603.     jmp [_SetConsoleScreenBufferSize]
  1604.   end;
  1605. end;
  1606. {$ELSE}
  1607. function SetConsoleScreenBufferSize; external kernel32 name 'SetConsoleScreenBufferSize';
  1608. {$ENDIF DYNAMIC_LINK}
  1610. {$IFDEF DYNAMIC_LINK}
  1611. var
  1612.   _SetConsoleCursorPosition: Pointer;
  1614. function SetConsoleCursorPosition;
  1615. begin
  1616.   GetProcedureAddress(_SetConsoleCursorPosition, kernel32, 'SetConsoleCursorPosition');
  1617.   asm
  1618.     mov esp, ebp
  1619.     pop ebp
  1620.     jmp [_SetConsoleCursorPosition]
  1621.   end;
  1622. end;
  1623. {$ELSE}
  1624. function SetConsoleCursorPosition; external kernel32 name 'SetConsoleCursorPosition';
  1625. {$ENDIF DYNAMIC_LINK}
  1627. {$IFDEF DYNAMIC_LINK}
  1628. var
  1629.   _SetConsoleCursorInfo: Pointer;
  1631. function SetConsoleCursorInfo;
  1632. begin
  1633.   GetProcedureAddress(_SetConsoleCursorInfo, kernel32, 'SetConsoleCursorInfo');
  1634.   asm
  1635.     mov esp, ebp
  1636.     pop ebp
  1637.     jmp [_SetConsoleCursorInfo]
  1638.   end;
  1639. end;
  1640. {$ELSE}
  1641. function SetConsoleCursorInfo; external kernel32 name 'SetConsoleCursorInfo';
  1642. {$ENDIF DYNAMIC_LINK}
  1645. {$IFDEF DYNAMIC_LINK}
  1646. var
  1647.   _ScrollConsoleScreenBufferA: Pointer;
  1649. function ScrollConsoleScreenBufferA;
  1650. begin
  1651.   GetProcedureAddress(_ScrollConsoleScreenBufferA, kernel32, 'ScrollConsoleScreenBufferA');
  1652.   asm
  1653.     mov esp, ebp
  1654.     pop ebp
  1655.     jmp [_ScrollConsoleScreenBufferA]
  1656.   end;
  1657. end;
  1658. {$ELSE}
  1659. function ScrollConsoleScreenBufferA; external kernel32 name 'ScrollConsoleScreenBufferA';
  1660. {$ENDIF DYNAMIC_LINK}
  1662. {$IFDEF DYNAMIC_LINK}
  1663. var
  1664.   _ScrollConsoleScreenBufferW: Pointer;
  1666. function ScrollConsoleScreenBufferW;
  1667. begin
  1668.   GetProcedureAddress(_ScrollConsoleScreenBufferW, kernel32, 'ScrollConsoleScreenBufferW');
  1669.   asm
  1670.     mov esp, ebp
  1671.     pop ebp
  1672.     jmp [_ScrollConsoleScreenBufferW]
  1673.   end;
  1674. end;
  1675. {$ELSE}
  1676. function ScrollConsoleScreenBufferW; external kernel32 name 'ScrollConsoleScreenBufferW';
  1677. {$ENDIF DYNAMIC_LINK}
  1678. {$IFDEF UNICODE}
  1680. {$IFDEF DYNAMIC_LINK}
  1681. var
  1682.   _ScrollConsoleScreenBuffer: Pointer;
  1684. function ScrollConsoleScreenBuffer;
  1685. begin
  1686.   GetProcedureAddress(_ScrollConsoleScreenBuffer, kernel32, 'ScrollConsoleScreenBufferW');
  1687.   asm
  1688.     mov esp, ebp
  1689.     pop ebp
  1690.     jmp [_ScrollConsoleScreenBuffer]
  1691.   end;
  1692. end;
  1693. {$ELSE}
  1694. function ScrollConsoleScreenBuffer; external kernel32 name 'ScrollConsoleScreenBufferW';
  1695. {$ENDIF DYNAMIC_LINK}
  1696. {$ELSE}
  1698. {$IFDEF DYNAMIC_LINK}
  1699. var
  1700.   _ScrollConsoleScreenBuffer: Pointer;
  1702. function ScrollConsoleScreenBuffer;
  1703. begin
  1704.   GetProcedureAddress(_ScrollConsoleScreenBuffer, kernel32, 'ScrollConsoleScreenBufferA');
  1705.   asm
  1706.     mov esp, ebp
  1707.     pop ebp
  1708.     jmp [_ScrollConsoleScreenBuffer]
  1709.   end;
  1710. end;
  1711. {$ELSE}
  1712. function ScrollConsoleScreenBuffer; external kernel32 name 'ScrollConsoleScreenBufferA';
  1713. {$ENDIF DYNAMIC_LINK}
  1714. {$ENDIF}
  1717. {$IFDEF DYNAMIC_LINK}
  1718. var
  1719.   _SetConsoleWindowInfo: Pointer;
  1721. function SetConsoleWindowInfo;
  1722. begin
  1723.   GetProcedureAddress(_SetConsoleWindowInfo, kernel32, 'SetConsoleWindowInfo');
  1724.   asm
  1725.     mov esp, ebp
  1726.     pop ebp
  1727.     jmp [_SetConsoleWindowInfo]
  1728.   end;
  1729. end;
  1730. {$ELSE}
  1731. function SetConsoleWindowInfo; external kernel32 name 'SetConsoleWindowInfo';
  1732. {$ENDIF DYNAMIC_LINK}
  1734. {$IFDEF DYNAMIC_LINK}
  1735. var
  1736.   _SetConsoleTextAttribute: Pointer;
  1738. function SetConsoleTextAttribute;
  1739. begin
  1740.   GetProcedureAddress(_SetConsoleTextAttribute, kernel32, 'SetConsoleTextAttribute');
  1741.   asm
  1742.     mov esp, ebp
  1743.     pop ebp
  1744.     jmp [_SetConsoleTextAttribute]
  1745.   end;
  1746. end;
  1747. {$ELSE}
  1748. function SetConsoleTextAttribute; external kernel32 name 'SetConsoleTextAttribute';
  1749. {$ENDIF DYNAMIC_LINK}
  1751. {$IFDEF DYNAMIC_LINK}
  1752. var
  1753.   _SetConsoleCtrlHandler: Pointer;
  1755. function SetConsoleCtrlHandler;
  1756. begin
  1757.   GetProcedureAddress(_SetConsoleCtrlHandler, kernel32, 'SetConsoleCtrlHandler');
  1758.   asm
  1759.     mov esp, ebp
  1760.     pop ebp
  1761.     jmp [_SetConsoleCtrlHandler]
  1762.   end;
  1763. end;
  1764. {$ELSE}
  1765. function SetConsoleCtrlHandler; external kernel32 name 'SetConsoleCtrlHandler';
  1766. {$ENDIF DYNAMIC_LINK}
  1768. {$IFDEF DYNAMIC_LINK}
  1769. var
  1770.   _GenerateConsoleCtrlEvent: Pointer;
  1772. function GenerateConsoleCtrlEvent;
  1773. begin
  1774.   GetProcedureAddress(_GenerateConsoleCtrlEvent, kernel32, 'GenerateConsoleCtrlEvent');
  1775.   asm
  1776.     mov esp, ebp
  1777.     pop ebp
  1778.     jmp [_GenerateConsoleCtrlEvent]
  1779.   end;
  1780. end;
  1781. {$ELSE}
  1782. function GenerateConsoleCtrlEvent; external kernel32 name 'GenerateConsoleCtrlEvent';
  1783. {$ENDIF DYNAMIC_LINK}
  1785. {$IFDEF DYNAMIC_LINK}
  1786. var
  1787.   _AllocConsole: Pointer;
  1789. function AllocConsole;
  1790. begin
  1791.   GetProcedureAddress(_AllocConsole, kernel32, 'AllocConsole');
  1792.   asm
  1793.     mov esp, ebp
  1794.     pop ebp
  1795.     jmp [_AllocConsole]
  1796.   end;
  1797. end;
  1798. {$ELSE}
  1799. function AllocConsole; external kernel32 name 'AllocConsole';
  1800. {$ENDIF DYNAMIC_LINK}
  1802. {$IFDEF DYNAMIC_LINK}
  1803. var
  1804.   _FreeConsole: Pointer;
  1806. function FreeConsole;
  1807. begin
  1808.   GetProcedureAddress(_FreeConsole, kernel32, 'FreeConsole');
  1809.   asm
  1810.     mov esp, ebp
  1811.     pop ebp
  1812.     jmp [_FreeConsole]
  1813.   end;
  1814. end;
  1815. {$ELSE}
  1816. function FreeConsole; external kernel32 name 'FreeConsole';
  1817. {$ENDIF DYNAMIC_LINK}
  1819. {$IFDEF DYNAMIC_LINK}
  1820. var
  1821.   _AttachConsole: Pointer;
  1823. function AttachConsole;
  1824. begin
  1825.   GetProcedureAddress(_AttachConsole, kernel32, 'AttachConsole');
  1826.   asm
  1827.     mov esp, ebp
  1828.     pop ebp
  1829.     jmp [_AttachConsole]
  1830.   end;
  1831. end;
  1832. {$ELSE}
  1833. function AttachConsole; external kernel32 name 'AttachConsole';
  1834. {$ENDIF DYNAMIC_LINK}
  1837. {$IFDEF DYNAMIC_LINK}
  1838. var
  1839.   _GetConsoleTitleA: Pointer;
  1841. function GetConsoleTitleA;
  1842. begin
  1843.   GetProcedureAddress(_GetConsoleTitleA, kernel32, 'GetConsoleTitleA');
  1844.   asm
  1845.     mov esp, ebp
  1846.     pop ebp
  1847.     jmp [_GetConsoleTitleA]
  1848.   end;
  1849. end;
  1850. {$ELSE}
  1851. function GetConsoleTitleA; external kernel32 name 'GetConsoleTitleA';
  1852. {$ENDIF DYNAMIC_LINK}
  1854. {$IFDEF DYNAMIC_LINK}
  1855. var
  1856.   _GetConsoleTitleW: Pointer;
  1858. function GetConsoleTitleW;
  1859. begin
  1860.   GetProcedureAddress(_GetConsoleTitleW, kernel32, 'GetConsoleTitleW');
  1861.   asm
  1862.     mov esp, ebp
  1863.     pop ebp
  1864.     jmp [_GetConsoleTitleW]
  1865.   end;
  1866. end;
  1867. {$ELSE}
  1868. function GetConsoleTitleW; external kernel32 name 'GetConsoleTitleW';
  1869. {$ENDIF DYNAMIC_LINK}
  1870. {$IFDEF UNICODE}
  1872. {$IFDEF DYNAMIC_LINK}
  1873. var
  1874.   _GetConsoleTitle: Pointer;
  1876. function GetConsoleTitle;
  1877. begin
  1878.   GetProcedureAddress(_GetConsoleTitle, kernel32, 'GetConsoleTitleW');
  1879.   asm
  1880.     mov esp, ebp
  1881.     pop ebp
  1882.     jmp [_GetConsoleTitle]
  1883.   end;
  1884. end;
  1885. {$ELSE}
  1886. function GetConsoleTitle; external kernel32 name 'GetConsoleTitleW';
  1887. {$ENDIF DYNAMIC_LINK}
  1888. {$ELSE}
  1890. {$IFDEF DYNAMIC_LINK}
  1891. var
  1892.   _GetConsoleTitle: Pointer;
  1894. function GetConsoleTitle;
  1895. begin
  1896.   GetProcedureAddress(_GetConsoleTitle, kernel32, 'GetConsoleTitleA');
  1897.   asm
  1898.     mov esp, ebp
  1899.     pop ebp
  1900.     jmp [_GetConsoleTitle]
  1901.   end;
  1902. end;
  1903. {$ELSE}
  1904. function GetConsoleTitle; external kernel32 name 'GetConsoleTitleA';
  1905. {$ENDIF DYNAMIC_LINK}
  1906. {$ENDIF}
  1909. {$IFDEF DYNAMIC_LINK}
  1910. var
  1911.   _SetConsoleTitleA: Pointer;
  1913. function SetConsoleTitleA;
  1914. begin
  1915.   GetProcedureAddress(_SetConsoleTitleA, kernel32, 'SetConsoleTitleA');
  1916.   asm
  1917.     mov esp, ebp
  1918.     pop ebp
  1919.     jmp [_SetConsoleTitleA]
  1920.   end;
  1921. end;
  1922. {$ELSE}
  1923. function SetConsoleTitleA; external kernel32 name 'SetConsoleTitleA';
  1924. {$ENDIF DYNAMIC_LINK}
  1926. {$IFDEF DYNAMIC_LINK}
  1927. var
  1928.   _SetConsoleTitleW: Pointer;
  1930. function SetConsoleTitleW;
  1931. begin
  1932.   GetProcedureAddress(_SetConsoleTitleW, kernel32, 'SetConsoleTitleW');
  1933.   asm
  1934.     mov esp, ebp
  1935.     pop ebp
  1936.     jmp [_SetConsoleTitleW]
  1937.   end;
  1938. end;
  1939. {$ELSE}
  1940. function SetConsoleTitleW; external kernel32 name 'SetConsoleTitleW';
  1941. {$ENDIF DYNAMIC_LINK}
  1943. {$IFDEF UNICODE}
  1945. {$IFDEF DYNAMIC_LINK}
  1946. var
  1947.   _SetConsoleTitle: Pointer;
  1949. function SetConsoleTitle;
  1950. begin
  1951.   GetProcedureAddress(_SetConsoleTitle, kernel32, 'SetConsoleTitleW');
  1952.   asm
  1953.     mov esp, ebp
  1954.     pop ebp
  1955.     jmp [_SetConsoleTitle]
  1956.   end;
  1957. end;
  1958. {$ELSE}
  1959. function SetConsoleTitle; external kernel32 name 'SetConsoleTitleW';
  1960. {$ENDIF DYNAMIC_LINK}
  1961. {$ELSE}
  1963. {$IFDEF DYNAMIC_LINK}
  1964. var
  1965.   _SetConsoleTitle: Pointer;
  1967. function SetConsoleTitle;
  1968. begin
  1969.   GetProcedureAddress(_SetConsoleTitle, kernel32, 'SetConsoleTitleA');
  1970.   asm
  1971.     mov esp, ebp
  1972.     pop ebp
  1973.     jmp [_SetConsoleTitle]
  1974.   end;
  1975. end;
  1976. {$ELSE}
  1977. function SetConsoleTitle; external kernel32 name 'SetConsoleTitleA';
  1978. {$ENDIF DYNAMIC_LINK}
  1979. {$ENDIF}
  1982. {$IFDEF DYNAMIC_LINK}
  1983. var
  1984.   _ReadConsoleA: Pointer;
  1986. function ReadConsoleA;
  1987. begin
  1988.   GetProcedureAddress(_ReadConsoleA, kernel32, 'ReadConsoleA');
  1989.   asm
  1990.     mov esp, ebp
  1991.     pop ebp
  1992.     jmp [_ReadConsoleA]
  1993.   end;
  1994. end;
  1995. {$ELSE}
  1996. function ReadConsoleA; external kernel32 name 'ReadConsoleA';
  1997. {$ENDIF DYNAMIC_LINK}
  1999. {$IFDEF DYNAMIC_LINK}
  2000. var
  2001.   _ReadConsoleW: Pointer;
  2003. function ReadConsoleW;
  2004. begin
  2005.   GetProcedureAddress(_ReadConsoleW, kernel32, 'ReadConsoleW');
  2006.   asm
  2007.     mov esp, ebp
  2008.     pop ebp
  2009.     jmp [_ReadConsoleW]
  2010.   end;
  2011. end;
  2012. {$ELSE}
  2013. function ReadConsoleW; external kernel32 name 'ReadConsoleW';
  2014. {$ENDIF DYNAMIC_LINK}
  2016. {$IFDEF UNICODE}
  2018. {$IFDEF DYNAMIC_LINK}
  2019. var
  2020.   _ReadConsole: Pointer;
  2022. function ReadConsole;
  2023. begin
  2024.   GetProcedureAddress(_ReadConsole, kernel32, 'ReadConsoleW');
  2025.   asm
  2026.     mov esp, ebp
  2027.     pop ebp
  2028.     jmp [_ReadConsole]
  2029.   end;
  2030. end;
  2031. {$ELSE}
  2032. function ReadConsole; external kernel32 name 'ReadConsoleW';
  2033. {$ENDIF DYNAMIC_LINK}
  2034. {$ELSE}
  2036. {$IFDEF DYNAMIC_LINK}
  2037. var
  2038.   _ReadConsole: Pointer;
  2040. function ReadConsole;
  2041. begin
  2042.   GetProcedureAddress(_ReadConsole, kernel32, 'ReadConsoleA');
  2043.   asm
  2044.     mov esp, ebp
  2045.     pop ebp
  2046.     jmp [_ReadConsole]
  2047.   end;
  2048. end;
  2049. {$ELSE}
  2050. function ReadConsole; external kernel32 name 'ReadConsoleA';
  2051. {$ENDIF DYNAMIC_LINK}
  2052. {$ENDIF}
  2055. {$IFDEF DYNAMIC_LINK}
  2056. var
  2057.   _WriteConsoleA: Pointer;
  2059. function WriteConsoleA;
  2060. begin
  2061.   GetProcedureAddress(_WriteConsoleA, kernel32, 'WriteConsoleA');
  2062.   asm
  2063.     mov esp, ebp
  2064.     pop ebp
  2065.     jmp [_WriteConsoleA]
  2066.   end;
  2067. end;
  2068. {$ELSE}
  2069. function WriteConsoleA; external kernel32 name 'WriteConsoleA';
  2070. {$ENDIF DYNAMIC_LINK}
  2072. {$IFDEF DYNAMIC_LINK}
  2073. var
  2074.   _WriteConsoleW: Pointer;
  2076. function WriteConsoleW;
  2077. begin
  2078.   GetProcedureAddress(_WriteConsoleW, kernel32, 'WriteConsoleW');
  2079.   asm
  2080.     mov esp, ebp
  2081.     pop ebp
  2082.     jmp [_WriteConsoleW]
  2083.   end;
  2084. end;
  2085. {$ELSE}
  2086. function WriteConsoleW; external kernel32 name 'WriteConsoleW';
  2087. {$ENDIF DYNAMIC_LINK}
  2089. {$IFDEF UNICODE}
  2091. {$IFDEF DYNAMIC_LINK}
  2092. var
  2093.   _WriteConsole: Pointer;
  2095. function WriteConsole;
  2096. begin
  2097.   GetProcedureAddress(_WriteConsole, kernel32, 'WriteConsoleW');
  2098.   asm
  2099.     mov esp, ebp
  2100.     pop ebp
  2101.     jmp [_WriteConsole]
  2102.   end;
  2103. end;
  2104. {$ELSE}
  2105. function WriteConsole; external kernel32 name 'WriteConsoleW';
  2106. {$ENDIF DYNAMIC_LINK}
  2107. {$ELSE}
  2109. {$IFDEF DYNAMIC_LINK}
  2110. var
  2111.   _WriteConsole: Pointer;
  2113. function WriteConsole;
  2114. begin
  2115.   GetProcedureAddress(_WriteConsole, kernel32, 'WriteConsoleA');
  2116.   asm
  2117.     mov esp, ebp
  2118.     pop ebp
  2119.     jmp [_WriteConsole]
  2120.   end;
  2121. end;
  2122. {$ELSE}
  2123. function WriteConsole; external kernel32 name 'WriteConsoleA';
  2124. {$ENDIF DYNAMIC_LINK}
  2125. {$ENDIF}
  2128. {$IFDEF DYNAMIC_LINK}
  2129. var
  2130.   _CreateConsoleScreenBuffer: Pointer;
  2132. function CreateConsoleScreenBuffer;
  2133. begin
  2134.   GetProcedureAddress(_CreateConsoleScreenBuffer, kernel32, 'CreateConsoleScreenBuffer');
  2135.   asm
  2136.     mov esp, ebp
  2137.     pop ebp
  2138.     jmp [_CreateConsoleScreenBuffer]
  2139.   end;
  2140. end;
  2141. {$ELSE}
  2142. function CreateConsoleScreenBuffer; external kernel32 name 'CreateConsoleScreenBuffer';
  2143. {$ENDIF DYNAMIC_LINK}
  2145. {$IFDEF DYNAMIC_LINK}
  2146. var
  2147.   _GetConsoleCP: Pointer;
  2149. function GetConsoleCP;
  2150. begin
  2151.   GetProcedureAddress(_GetConsoleCP, kernel32, 'GetConsoleCP');
  2152.   asm
  2153.     mov esp, ebp
  2154.     pop ebp
  2155.     jmp [_GetConsoleCP]
  2156.   end;
  2157. end;
  2158. {$ELSE}
  2159. function GetConsoleCP; external kernel32 name 'GetConsoleCP';
  2160. {$ENDIF DYNAMIC_LINK}
  2162. {$IFDEF DYNAMIC_LINK}
  2163. var
  2164.   _SetConsoleCP: Pointer;
  2166. function SetConsoleCP;
  2167. begin
  2168.   GetProcedureAddress(_SetConsoleCP, kernel32, 'SetConsoleCP');
  2169.   asm
  2170.     mov esp, ebp
  2171.     pop ebp
  2172.     jmp [_SetConsoleCP]
  2173.   end;
  2174. end;
  2175. {$ELSE}
  2176. function SetConsoleCP; external kernel32 name 'SetConsoleCP';
  2177. {$ENDIF DYNAMIC_LINK}
  2179. {$IFDEF DYNAMIC_LINK}
  2180. var
  2181.   _GetConsoleOutputCP: Pointer;
  2183. function GetConsoleOutputCP;
  2184. begin
  2185.   GetProcedureAddress(_GetConsoleOutputCP, kernel32, 'GetConsoleOutputCP');
  2186.   asm
  2187.     mov esp, ebp
  2188.     pop ebp
  2189.     jmp [_GetConsoleOutputCP]
  2190.   end;
  2191. end;
  2192. {$ELSE}
  2193. function GetConsoleOutputCP; external kernel32 name 'GetConsoleOutputCP';
  2194. {$ENDIF DYNAMIC_LINK}
  2196. {$IFDEF DYNAMIC_LINK}
  2197. var
  2198.   _SetConsoleOutputCP: Pointer;
  2200. function SetConsoleOutputCP;
  2201. begin
  2202.   GetProcedureAddress(_SetConsoleOutputCP, kernel32, 'SetConsoleOutputCP');
  2203.   asm
  2204.     mov esp, ebp
  2205.     pop ebp
  2206.     jmp [_SetConsoleOutputCP]
  2207.   end;
  2208. end;
  2209. {$ELSE}
  2210. function SetConsoleOutputCP; external kernel32 name 'SetConsoleOutputCP';
  2211. {$ENDIF DYNAMIC_LINK}
  2214. {$IFDEF DYNAMIC_LINK}
  2215. var
  2216.   _GetConsoleDisplayMode: Pointer;
  2218. function GetConsoleDisplayMode;
  2219. begin
  2220.   GetProcedureAddress(_GetConsoleDisplayMode, kernel32, 'GetConsoleDisplayMode');
  2221.   asm
  2222.     mov esp, ebp
  2223.     pop ebp
  2224.     jmp [_GetConsoleDisplayMode]
  2225.   end;
  2226. end;
  2227. {$ELSE}
  2228. function GetConsoleDisplayMode; external kernel32 name 'GetConsoleDisplayMode';
  2229. {$ENDIF DYNAMIC_LINK}
  2231. {$IFDEF DYNAMIC_LINK}
  2232. var
  2233.   _GetConsoleWindow: Pointer;
  2235. function GetConsoleWindow;
  2236. begin
  2237.   GetProcedureAddress(_GetConsoleWindow, kernel32, 'GetConsoleWindow');
  2238.   asm
  2239.     mov esp, ebp
  2240.     pop ebp
  2241.     jmp [_GetConsoleWindow]
  2242.   end;
  2243. end;
  2244. {$ELSE}
  2245. function GetConsoleWindow; external kernel32 name 'GetConsoleWindow';
  2246. {$ENDIF DYNAMIC_LINK}
  2248. {$IFDEF DYNAMIC_LINK}
  2249. var
  2250.   _GetConsoleProcessList: Pointer;
  2252. function GetConsoleProcessList;
  2253. begin
  2254.   GetProcedureAddress(_GetConsoleProcessList, kernel32, 'GetConsoleProcessList');
  2255.   asm
  2256.     mov esp, ebp
  2257.     pop ebp
  2258.     jmp [_GetConsoleProcessList]
  2259.   end;
  2260. end;
  2261. {$ELSE}
  2262. function GetConsoleProcessList; external kernel32 name 'GetConsoleProcessList';
  2263. {$ENDIF DYNAMIC_LINK}
  2265. end.