PageRenderTime 27ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/Ruby/lib/ruby/gems/2.0.0/gems/win32console-1.3.2-x86-mingw32/ext/Console_ext/Console.c

https://gitlab.com/orvi2014/rcs-db-ext
C | 1216 lines | 1050 code | 156 blank | 10 comment | 89 complexity | 4a62a0c0fbd6e82d8b14ba410fdf457b MD5 | raw file
    

  1. #include <windows.h>

    2. 

  2. #include "ruby.h"

    3. 

  3. 

    4. 

  4. /* Workaround deprecated RString accessors */

    5. 

  5. #ifndef RSTRING_PTR

    6. 

  6. #define RSTRING_PTR(s) (RSTRING(s)->ptr)

    7. 

  7. #endif

    8. 

  8. #ifndef RSTRING_LEN

    9. 

  9. #define RSTRING_LEN(s) (RSTRING(s)->len)

    10. 

  10. #endif

    11. 

  11. 

    12. 

  12. VALUE rb_mWin32;

    13. 

  13. VALUE rb_mConsole;

    14. 

  14. VALUE rb_mAPI;

    15. 

  15. VALUE rb_mConstants;

    16. 

  16. 

    17. 

  17. /* old RUBY_METHOD_FUNC() definition doesn't match to prototypes in those days. */

    18. 

  18. #ifndef ANYARGS

    19. 

  19. #undef  RUBY_METHOD_FUNC

    20. 

  20. #define RUBY_METHOD_FUNC(func) ((VALUE (*)())func)

    21. 

  21. #endif

    22. 

  22. 

    23. 

  23. 

    24. 

  24. #define RB_DEF_S_METHOD(klass,method,func,argtype) \

    25. 

  25.      rb_define_singleton_method(klass,method,RUBY_METHOD_FUNC(func), argtype)

    26. 

  26. 

    27. 

  27. #define RB_DEF_API_METHOD(name,argtype) \

    28. 

  28.      RB_DEF_S_METHOD(rb_mAPI,#name,RUBY_METHOD_FUNC(rb_##name), argtype)

    29. 

  29. 

    30. 

  30. #define RB_DEF_METHOD(klass,method,func,argtype) \

    31. 

  31.         rb_define_method(klass,method,RUBY_METHOD_FUNC(func), argtype)

    32. 

  32. 

    33. 

  33. VALUE

    34. 

  34. rb_getWin32Error()

    35. 

  35. {

    36. 

  36.    LPVOID lpMsgBuf;

    37. 

  37.    if (!FormatMessage( 

    38. 

  38. 		      FORMAT_MESSAGE_ALLOCATE_BUFFER | 

    39. 

  39. 		      FORMAT_MESSAGE_FROM_SYSTEM | 

    40. 

  40. 		      FORMAT_MESSAGE_IGNORE_INSERTS,

    41. 

  41. 		      NULL,

    42. 

  42. 		      GetLastError(),

    43. 

  43. 		      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language

    44. 

  44. 		      (LPTSTR) &lpMsgBuf,

    45. 

  45. 		      0,

    46. 

  46. 		      NULL ))

    47. 

  47.    {

    48. 

  48.       // Handle the error.

    49. 

  49.       return Qnil;

    50. 

  50.    }

    51. 

  51. 

    52. 

  52.    VALUE t = rb_str_new2( (LPCTSTR) lpMsgBuf );

    53. 

  53.    

    54. 

  54.    // Free the buffer.

    55. 

  55.    LocalFree( lpMsgBuf );

    56. 

  56. 

    57. 

  57.    // Raise exception

    58. 

  58.    rb_raise(rb_eRuntimeError, RSTRING_PTR(t));

    59. 

  59.    return Qnil;

    60. 

  60. 

    61. 

  61. }

    62. 

  62. 

    63. 

  63. 

    64. 

  64. static VALUE rb_GetStdHandle(VALUE self, VALUE handle)

    65. 

  65. {

    66. 

  66.    unsigned long x;

    67. 

  67.    if ( FIXNUM_P( handle ) )

    68. 

  68.    {

    69. 

  69.       x = NUM2ULONG( handle );

    70. 

  70.    }

    71. 

  71.    else

    72. 

  72.    {

    73. 

  73.       Check_Type( handle, T_BIGNUM );

    74. 

  74.       x = rb_big2ulong(handle);

    75. 

  75.    }

    76. 

  76.    unsigned long h = PtrToUlong( GetStdHandle( x ) );

    77. 

  77.    return ULONG2NUM(h);

    78. 

  78. }

    79. 

  79. 

    80. 

  80. 

    81. 

  81. static VALUE rb_AllocConsole(VALUE self)

    82. 

  82. {

    83. 

  83.    if (AllocConsole()) return INT2FIX(1);

    84. 

  84.    return rb_getWin32Error();

    85. 

  85. }

    86. 

  86. 

    87. 

  87. 

    88. 

  88. static VALUE rb_FreeConsole(VALUE self)

    89. 

  89. {

    90. 

  90.    if (FreeConsole()) return INT2FIX(1);

    91. 

  91.    return rb_getWin32Error();

    92. 

  92. }

    93. 

  93. 

    94. 

  94. static VALUE rb_GenerateConsoleCtrlEvent(VALUE self, VALUE event, VALUE pgid)

    95. 

  95. {

    96. 

  96.    unsigned int e = NUM2UINT(event);

    97. 

  97.    if ( e != CTRL_C_EVENT && e != CTRL_BREAK_EVENT )

    98. 

  98.       rb_raise(rb_eArgError, "Wrong event: only CTRL_C_EVENT or "

    99. 

  99. 	       "CTRL_BREAK_EVENT accepted.");

    100. 

  100.    if ( GenerateConsoleCtrlEvent(e, NUM2UINT(pgid)) )

    101. 

  101.       return INT2FIX(1);

    102. 

  102.    return rb_getWin32Error();

    103. 

  103. }

    104. 

  104. 

    105. 

  105. static VALUE rb_GetConsoleMode(VALUE self, VALUE hConsoleOutput)

    106. 

  106. {

    107. 

  107.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    108. 

  108.    DWORD mode;

    109. 

  109.    if (GetConsoleMode(handle,&mode))

    110. 

  110.       return UINT2NUM(mode);

    111. 

  111.    return rb_getWin32Error();

    112. 

  112. }

    113. 

  113. 

    114. 

  114. static VALUE rb_GetConsoleTitle(VALUE self)

    115. 

  115. {

    116. 

  116.    char title[1024];

    117. 

  117.    if (GetConsoleTitle((char*)&title,1024))

    118. 

  118.       return  rb_str_new2( title );

    119. 

  119.    return rb_getWin32Error();

    120. 

  120. }

    121. 

  121. 

    122. 

  122. 

    123. 

  123. 

    124. 

  124. 

    125. 

  125. static VALUE rb_GetNumberOfConsoleMouseButtons( VALUE self )

    126. 

  126. {

    127. 

  127.    DWORD mb;

    128. 

  128.    if (GetNumberOfConsoleMouseButtons( &mb ))

    129. 

  129.       return INT2FIX(mb);

    130. 

  130.    return rb_getWin32Error();

    131. 

  131. }

    132. 

  132. 

    133. 

  133. 

    134. 

  134. 

    135. 

  135. static VALUE rb_GetNumberOfConsoleInputEvents( VALUE self, VALUE hConsoleOutput )

    136. 

  136. {

    137. 

  137.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    138. 

  138.    DWORD events;

    139. 

  139.    if (GetNumberOfConsoleInputEvents(handle, &events))

    140. 

  140.       return INT2FIX(events);

    141. 

  141.    return rb_getWin32Error();

    142. 

  142. }

    143. 

  143. 

    144. 

  144. 

    145. 

  145. static VALUE

    146. 

  146. rb_CreateConsoleScreenBuffer( VALUE self, VALUE dwDesiredAccess,

    147. 

  147. 				  VALUE dwShareMode, VALUE dwFlags )

    148. 

  148. {

    149. 

  149.    if (CreateConsoleScreenBuffer( NUM2UINT(dwDesiredAccess),

    150. 

  150. 				      NUM2UINT( dwShareMode),

    151. 

  151. 				      NULL,

    152. 

  152. 				      NUM2UINT( dwFlags),

    153. 

  153. 				      NULL

    154. 

  154. 				      ))

    155. 

  155.       return INT2FIX(1);

    156. 

  156.    return rb_getWin32Error();

    157. 

  157. }

    158. 

  158. 

    159. 

  159. 

    160. 

  160. static VALUE rb_GetConsoleCP( VALUE self )

    161. 

  161. {

    162. 

  162.    unsigned int h = GetConsoleCP();

    163. 

  163.    return UINT2NUM(h);

    164. 

  164. }

    165. 

  165. 

    166. 

  166. static VALUE rb_GetConsoleOutputCP( VALUE self )

    167. 

  167. {

    168. 

  168.    unsigned int h = GetConsoleOutputCP();

    169. 

  169.    return UINT2NUM(h);

    170. 

  170. }

    171. 

  171. 

    172. 

  172. static VALUE rb_SetConsoleMode( VALUE self, VALUE hConsoleOutput,

    173. 

  173. 				VALUE Mode )

    174. 

  174. {

    175. 

  175.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    176. 

  176.    if ( SetConsoleMode( handle, NUM2UINT( Mode ) ) )

    177. 

  177.       return INT2FIX(1);

    178. 

  178.    return rb_getWin32Error();

    179. 

  179. }

    180. 

  180. 

    181. 

  181. static VALUE rb_SetConsoleCP( VALUE self, VALUE wCodePageID )

    182. 

  182. {

    183. 

  183.    if ( SetConsoleCP( NUM2UINT( wCodePageID ) ) )

    184. 

  184.       return INT2FIX(1);

    185. 

  185.    return rb_getWin32Error();

    186. 

  186. }

    187. 

  187. 

    188. 

  188. static VALUE rb_SetConsoleOutputCP( VALUE self, VALUE wCodePageID )

    189. 

  189. {

    190. 

  190.    if ( SetConsoleOutputCP( NUM2UINT( wCodePageID ) ) )

    191. 

  191.       return INT2FIX(1);

    192. 

  192.    return rb_getWin32Error();

    193. 

  193. }

    194. 

  194. 

    195. 

  195. static VALUE rb_GetConsoleWindow( VALUE self )

    196. 

  196. {

    197. 

  197.    unsigned long h = PtrToUlong( GetConsoleOutputCP() );

    198. 

  198.    return ULONG2NUM(h);

    199. 

  199. }

    200. 

  200. 

    201. 

  201. static VALUE rb_WriteConsole( VALUE self, VALUE hConsoleOutput,

    202. 

  202. 			      VALUE lpBuffer )

    203. 

  203. {

    204. 

  204.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    205. 

  205.    DWORD nNumberOfCharsToWrite = RSTRING_LEN(lpBuffer);

    206. 

  206.    

    207. 

  207.    DWORD lpNumberOfCharsWritten;

    208. 

  208. 

    209. 

  209.    WriteConsole( handle, RSTRING_PTR(lpBuffer),

    210. 

  210. 		 nNumberOfCharsToWrite,

    211. 

  211. 		 &lpNumberOfCharsWritten, NULL );

    212. 

  212.    return UINT2NUM( lpNumberOfCharsWritten );

    213. 

  213. }

    214. 

  214. 

    215. 

  215. static VALUE rb_WriteFile( VALUE self, VALUE hConsoleOutput,

    216. 

  216.                VALUE lpBuffer )

    217. 

  217. {

    218. 

  218.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    219. 

  219.    DWORD nNumberOfBytesToWrite = RSTRING_LEN(lpBuffer);

    220. 

  220. 

    221. 

  221.    DWORD lpNumberOfBytesWritten;

    222. 

  222. 

    223. 

  223.    WriteFile( handle, RSTRING_PTR(lpBuffer),

    224. 

  224.        nNumberOfBytesToWrite,

    225. 

  225.        &lpNumberOfBytesWritten, NULL );

    226. 

  226.    return UINT2NUM( lpNumberOfBytesWritten );

    227. 

  227. }

    228. 

  228. 

    229. 

  229. 

    230. 

  230. static VALUE rb_GetLargestConsoleWindowSize( VALUE self, VALUE hConsoleOutput )

    231. 

  231. {

    232. 

  232.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    233. 

  233.    COORD size = GetLargestConsoleWindowSize( handle);

    234. 

  234.    

    235. 

  235.    VALUE ret = rb_ary_new();

    236. 

  236.    rb_ary_push( ret, UINT2NUM( size.X ) );

    237. 

  237.    rb_ary_push( ret, UINT2NUM( size.Y ) );

    238. 

  238.    return ret;

    239. 

  239. }

    240. 

  240. 

    241. 

  241. static VALUE rb_GetConsoleCursorInfo( VALUE self, VALUE hConsoleOutput )

    242. 

  242. {

    243. 

  243.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    244. 

  244.    

    245. 

  245.    CONSOLE_CURSOR_INFO out;

    246. 

  246.    if ( !GetConsoleCursorInfo( handle, &out ) )

    247. 

  247.       return rb_getWin32Error();

    248. 

  248.    

    249. 

  249.    VALUE ret = rb_ary_new();

    250. 

  250.    rb_ary_push( ret, UINT2NUM( out.dwSize ) );

    251. 

  251.    rb_ary_push( ret, UINT2NUM( out.bVisible ) );

    252. 

  252.    return ret;

    253. 

  253. }

    254. 

  254. 

    255. 

  255. void rb_ParseEvent(VALUE ret, INPUT_RECORD *event )

    256. 

  256. {

    257. 

  257.    switch(event->EventType) {

    258. 

  258.       case KEY_EVENT:

    259. 

  259. 	 {

    260. 

  260. 	    KEY_EVENT_RECORD* kevent=(KEY_EVENT_RECORD *)&(event->Event);

    261. 

  261. 	    rb_ary_push(ret, UINT2NUM(KEY_EVENT));

    262. 

  262. 	    rb_ary_push(ret, UINT2NUM(kevent->bKeyDown));

    263. 

  263. 	    rb_ary_push(ret, UINT2NUM(kevent->wRepeatCount));

    264. 

  264. 	    rb_ary_push(ret, UINT2NUM(kevent->wVirtualKeyCode));

    265. 

  265. 	    rb_ary_push(ret, UINT2NUM(kevent->wVirtualScanCode));

    266. 

  266. #ifdef UNICODE

    267. 

  267. 	    rb_ary_push(ret, UINT2NUM(kevent->uChar.UnicodeChar));

    268. 

  268. #else

    269. 

  269. 	    rb_ary_push(ret, UINT2NUM(kevent->uChar.AsciiChar));

    270. 

  270. #endif

    271. 

  271. 	    rb_ary_push(ret, UINT2NUM(kevent->dwControlKeyState));

    272. 

  272. 	    break;

    273. 

  273. 	 }

    274. 

  274.       case MOUSE_EVENT:

    275. 

  275. 	 {

    276. 

  276. 	    MOUSE_EVENT_RECORD * mevent=(MOUSE_EVENT_RECORD *)&(event->Event);

    277. 

  277. 	    rb_ary_push(ret, UINT2NUM(MOUSE_EVENT) );

    278. 

  278. 	    rb_ary_push(ret, UINT2NUM(mevent->dwMousePosition.X) );

    279. 

  279. 	    rb_ary_push(ret, UINT2NUM(mevent->dwMousePosition.Y) );

    280. 

  280. 	    rb_ary_push(ret, UINT2NUM(mevent->dwButtonState) );

    281. 

  281. 	    rb_ary_push(ret, UINT2NUM(mevent->dwControlKeyState) );

    282. 

  282. 	    rb_ary_push(ret, UINT2NUM(mevent->dwEventFlags) );

    283. 

  283. 	    break;

    284. 

  284. 	 }

    285. 

  285.       case WINDOW_BUFFER_SIZE_EVENT:

    286. 

  286. 	 {

    287. 

  287. 	    WINDOW_BUFFER_SIZE_RECORD* wevent=

    288. 

  288. 	    (WINDOW_BUFFER_SIZE_RECORD *)&(event->Event);

    289. 

  289. 	    rb_ary_push(ret, UINT2NUM(WINDOW_BUFFER_SIZE_EVENT) );

    290. 

  290. 	    rb_ary_push(ret, UINT2NUM(wevent->dwSize.X) );

    291. 

  291. 	    rb_ary_push(ret, UINT2NUM(wevent->dwSize.Y) );

    292. 

  292. 	 }

    293. 

  293. 	 break;

    294. 

  294.       case MENU_EVENT:

    295. 

  295. 	 {

    296. 

  296. 	    MENU_EVENT_RECORD* mevent= (MENU_EVENT_RECORD *)&(event->Event);

    297. 

  297. 	    rb_ary_push(ret, UINT2NUM(MENU_EVENT) );

    298. 

  298. 	    rb_ary_push(ret, UINT2NUM(mevent->dwCommandId) );

    299. 

  299. 	 }

    300. 

  300. 	 break;

    301. 

  301.       case FOCUS_EVENT:

    302. 

  302. 	 {

    303. 

  303. 	    FOCUS_EVENT_RECORD* mevent= (FOCUS_EVENT_RECORD *)&(event->Event);

    304. 

  304. 	    rb_ary_push(ret, UINT2NUM(FOCUS_EVENT) );

    305. 

  305. 	    rb_ary_push(ret, UINT2NUM(mevent->bSetFocus) );

    306. 

  306. 	 }

    307. 

  307. 	 break;

    308. 

  308.    }

    309. 

  309. }

    310. 

  310. 

    311. 

  311. static VALUE rb_PeekConsoleInput( VALUE self, VALUE hConsoleOutput )

    312. 

  312. {

    313. 

  313.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    314. 

  314.    

    315. 

  315.    DWORD nofread;

    316. 

  316.    INPUT_RECORD event;

    317. 

  317.    if (!PeekConsoleInput(handle,&event,1,&nofread))

    318. 

  318.       return rb_getWin32Error();

    319. 

  319.    

    320. 

  320.    VALUE ret = rb_ary_new();

    321. 

  321.    rb_ParseEvent( ret, &event );

    322. 

  322.    return ret;

    323. 

  323. }

    324. 

  324. 

    325. 

  325. static VALUE rb_ReadConsole( VALUE self, VALUE hConsoleOutput,

    326. 

  326. 				  VALUE buffer, VALUE numread )

    327. 

  327. {

    328. 

  328.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    329. 

  329.    DWORD nofread;

    330. 

  330.    Check_Type( buffer, T_STRING );

    331. 

  331.    int to_read = NUM2INT(numread);

    332. 

  332.    if ( RSTRING_LEN(buffer) > to_read )

    333. 

  333.       rb_raise(rb_eArgError, "String is too small to read that many characters.");

    334. 

  334.    if (ReadConsole(handle,(void *)RSTRING_PTR(buffer), to_read,

    335. 

  335. 		   &nofread,NULL))

    336. 

  336.       return UINT2NUM(nofread);

    337. 

  337.    return rb_getWin32Error();

    338. 

  338. }

    339. 

  339. 

    340. 

  340. static VALUE rb_ReadConsoleInput( VALUE self, VALUE hConsoleOutput )

    341. 

  341. {

    342. 

  342.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    343. 

  343.    DWORD nofread;

    344. 

  344.    INPUT_RECORD event;

    345. 

  345.    if (!ReadConsoleInput(handle,&event,1,&nofread))

    346. 

  346.       return rb_getWin32Error();

    347. 

  347.    

    348. 

  348.    VALUE ret = rb_ary_new();

    349. 

  349.    rb_ParseEvent( ret, &event );

    350. 

  350.    return ret;

    351. 

  351. }

    352. 

  352. 

    353. 

  353. 

    354. 

  354. 

    355. 

  355. static VALUE rb_ReadConsoleOutputCharacter( VALUE self, VALUE hConsoleOutput,

    356. 

  356. 					    VALUE charbuf, VALUE len,

    357. 

  357. 					    VALUE x, VALUE y )

    358. 

  358. {

    359. 

  359.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    360. 

  360.    COORD coords;

    361. 

  361.    DWORD nofread;

    362. 

  362.    coords.X= NUM2UINT( x );

    363. 

  363.    coords.Y= NUM2UINT( y );

    364. 

  364.    int l = NUM2INT(len);

    365. 

  365.    if ( (unsigned long)RSTRING_LEN(charbuf) < l*sizeof(TCHAR) )

    366. 

  366.       rb_raise(rb_eArgError, "String is too small to read that many characters.");

    367. 

  367.    if (ReadConsoleOutputCharacter(handle,RSTRING_PTR(charbuf),l,

    368. 

  368. 				  coords,&nofread))

    369. 

  369.       return UINT2NUM( nofread );

    370. 

  370.    return rb_getWin32Error();

    371. 

  371. }

    372. 

  372. 

    373. 

  373. 

    374. 

  374. static VALUE rb_ReadConsoleOutputAttribute( VALUE self, VALUE hConsoleOutput,

    375. 

  375. 					    VALUE len, VALUE x, VALUE y )

    376. 

  376. {

    377. 

  377.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    378. 

  378.    COORD coords;

    379. 

  379.    DWORD nofread;

    380. 

  380.    unsigned short abuffer[80*999*sizeof(unsigned short)];

    381. 

  381.    char cbuffer[80*999];

    382. 

  382.    unsigned i = 0;

    383. 

  383. 

    384. 

  384.    coords.X= NUM2UINT( x );

    385. 

  385.    coords.Y= NUM2UINT( y );

    386. 

  386.    if (ReadConsoleOutputAttribute(handle, abuffer, NUM2UINT(len),

    387. 

  387. 				  coords,&nofread))

    388. 

  388.    {

    389. 

  389.       for(i=0;i<nofread;++i) {

    390. 

  390. 	 cbuffer[i]=(char)abuffer[i];

    391. 

  391.       }

    392. 

  392.       return rb_str_new( cbuffer, nofread );

    393. 

  393.    }

    394. 

  394.    return rb_getWin32Error();

    395. 

  395. }

    396. 

  396. 

    397. 

  397. 

    398. 

  398. static VALUE rb_ReadConsoleOutput( VALUE self, VALUE hConsoleOutput,

    399. 

  399. 				   VALUE buffer, VALUE srcwid, VALUE srcht,

    400. 

  400. 				   VALUE startx, VALUE starty,

    401. 

  401. 				   VALUE l, VALUE t, VALUE r, VALUE b )

    402. 

  402. {

    403. 

  403.    COORD coords;

    404. 

  404.    COORD size;

    405. 

  405.    SMALL_RECT from;

    406. 

  406.    size.X= NUM2UINT( srcwid );

    407. 

  407.    size.Y= NUM2UINT( srcht );

    408. 

  408.    coords.X= NUM2INT( startx );

    409. 

  409.    coords.Y= NUM2INT( starty );

    410. 

  410.    from.Left   = NUM2INT( l );

    411. 

  411.    from.Top    = NUM2INT( t );

    412. 

  412.    from.Right  = NUM2INT( r );

    413. 

  413.    from.Bottom = NUM2INT( b );

    414. 

  414.    Check_Type( buffer, T_STRING );

    415. 

  415.    if ( (unsigned long)RSTRING_LEN(buffer) < (sizeof(CHAR_INFO)*size.X*size.Y) )

    416. 

  416.       rb_raise(rb_eArgError, "string buffer is too small for reading that many characters.");

    417. 

  417.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    418. 

  418.    if (!ReadConsoleOutput(handle,(CHAR_INFO *)RSTRING_PTR(buffer),size,coords,&from))

    419. 

  419.       return rb_getWin32Error();

    420. 

  420. 

    421. 

  421.    VALUE ret = rb_ary_new();

    422. 

  422.    rb_ary_push( ret, INT2FIX(from.Left) );

    423. 

  423.    rb_ary_push( ret, INT2FIX(from.Top) );

    424. 

  424.    rb_ary_push( ret, INT2FIX(from.Right) );

    425. 

  425.    rb_ary_push( ret, INT2FIX(from.Bottom) );

    426. 

  426.    return ret;

    427. 

  427. }

    428. 

  428. 

    429. 

  429. 

    430. 

  430. 

    431. 

  431. static VALUE rb_GetConsoleScreenBufferInfo( VALUE self, VALUE hConsoleOutput )

    432. 

  432. {

    433. 

  433.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    434. 

  434. 

    435. 

  435.    CONSOLE_SCREEN_BUFFER_INFO out;

    436. 

  436. 

    437. 

  437.    if ( !GetConsoleScreenBufferInfo( handle, &out ) )

    438. 

  438.       return rb_getWin32Error();

    439. 

  439. 

    440. 

  440.    VALUE ret = rb_ary_new();

    441. 

  441.    rb_ary_push( ret, UINT2NUM( out.dwSize.X ) );

    442. 

  442.    rb_ary_push( ret, UINT2NUM( out.dwSize.Y ) );

    443. 

  443.    rb_ary_push( ret, UINT2NUM( out.dwCursorPosition.X ) );

    444. 

  444.    rb_ary_push( ret, UINT2NUM( out.dwCursorPosition.Y ) );

    445. 

  445.    

    446. 

  446.    rb_ary_push( ret, UINT2NUM( out.wAttributes ) );

    447. 

  447.    

    448. 

  448.    rb_ary_push( ret, INT2FIX( out.srWindow.Left ) );

    449. 

  449.    rb_ary_push( ret, INT2FIX( out.srWindow.Top ) );

    450. 

  450.    rb_ary_push( ret, INT2FIX( out.srWindow.Right ) );

    451. 

  451.    rb_ary_push( ret, INT2FIX( out.srWindow.Bottom ) );

    452. 

  452.    

    453. 

  453.    rb_ary_push( ret, UINT2NUM( out.dwMaximumWindowSize.X ) );

    454. 

  454.    rb_ary_push( ret, UINT2NUM( out.dwMaximumWindowSize.Y ) );

    455. 

  455. 

    456. 

  456.    

    457. 

  457.    return ret;

    458. 

  458. }

    459. 

  459. 

    460. 

  460. 

    461. 

  461. #define strEQ(x,y) strcmp(x,y) == 0

    462. 

  462. 

    463. 

  463. DWORD c_constant(char *name)

    464. 

  464. {

    465. 

  465.    switch (*name) {

    466. 

  466.     case 'A':

    467. 

  467.         break;

    468. 

  468.     case 'B':

    469. 

  469.         if (strEQ(name, "BACKGROUND_BLUE"))

    470. 

  470.             #ifdef BACKGROUND_BLUE

    471. 

  471.                 return BACKGROUND_BLUE;

    472. 

  472.             #else

    473. 

  473.                 goto not_there;

    474. 

  474.             #endif

    475. 

  475.         if (strEQ(name, "BACKGROUND_GREEN"))

    476. 

  476.             #ifdef BACKGROUND_GREEN

    477. 

  477.                 return BACKGROUND_GREEN;

    478. 

  478.             #else

    479. 

  479.                 goto not_there;

    480. 

  480.             #endif

    481. 

  481.         if (strEQ(name, "BACKGROUND_INTENSITY"))

    482. 

  482.             #ifdef BACKGROUND_INTENSITY

    483. 

  483.                 return BACKGROUND_INTENSITY;

    484. 

  484.             #else

    485. 

  485.                 goto not_there;

    486. 

  486.             #endif

    487. 

  487.         if (strEQ(name, "BACKGROUND_RED"))

    488. 

  488.             #ifdef BACKGROUND_RED

    489. 

  489.                 return BACKGROUND_RED;

    490. 

  490.             #else

    491. 

  491.                 goto not_there;

    492. 

  492.             #endif

    493. 

  493.         break;

    494. 

  494.     case 'C':

    495. 

  495.        if (strEQ(name, "CAPSLOCK_ON"))

    496. 

  496.             #ifdef CAPSLOCK_ON

    497. 

  497.                 return CAPSLOCK_ON;

    498. 

  498.             #else

    499. 

  499.                 goto not_there;

    500. 

  500.             #endif

    501. 

  501.         if (strEQ(name, "CONSOLE_TEXTMODE_BUFFER"))

    502. 

  502.             #ifdef CONSOLE_TEXTMODE_BUFFER

    503. 

  503.                 return CONSOLE_TEXTMODE_BUFFER;

    504. 

  504.             #else

    505. 

  505.                 goto not_there;

    506. 

  506.             #endif

    507. 

  507.         if (strEQ(name, "CTRL_BREAK_EVENT"))

    508. 

  508.             #ifdef CTRL_BREAK_EVENT

    509. 

  509.                 return CTRL_BREAK_EVENT;

    510. 

  510.             #else

    511. 

  511.                 goto not_there;

    512. 

  512.             #endif

    513. 

  513.         if (strEQ(name, "CTRL_C_EVENT"))

    514. 

  514.             #ifdef CTRL_C_EVENT

    515. 

  515.                 return CTRL_C_EVENT;

    516. 

  516.             #else

    517. 

  517.                 goto not_there;

    518. 

  518.             #endif

    519. 

  519. 		break;

    520. 

  520. 

    521. 

  521.     case 'D':

    522. 

  522.         break;

    523. 

  523.     case 'E':

    524. 

  524.         if (strEQ(name, "ENABLE_ECHO_INPUT"))

    525. 

  525.             #ifdef ENABLE_ECHO_INPUT

    526. 

  526.                 return ENABLE_ECHO_INPUT;

    527. 

  527.             #else

    528. 

  528.                 goto not_there;

    529. 

  529.             #endif

    530. 

  530.         if (strEQ(name, "ENABLE_LINE_INPUT"))

    531. 

  531.             #ifdef ENABLE_LINE_INPUT

    532. 

  532.                 return ENABLE_LINE_INPUT;

    533. 

  533.             #else

    534. 

  534.                 goto not_there;

    535. 

  535.             #endif

    536. 

  536.         if (strEQ(name, "ENABLE_MOUSE_INPUT"))

    537. 

  537.             #ifdef ENABLE_MOUSE_INPUT

    538. 

  538.                 return ENABLE_MOUSE_INPUT;

    539. 

  539.             #else

    540. 

  540.                 goto not_there;

    541. 

  541.             #endif

    542. 

  542.         if (strEQ(name, "ENABLE_PROCESSED_INPUT"))

    543. 

  543.             #ifdef ENABLE_PROCESSED_INPUT

    544. 

  544.                 return ENABLE_PROCESSED_INPUT;

    545. 

  545.             #else

    546. 

  546.                 goto not_there;

    547. 

  547.             #endif

    548. 

  548.         if (strEQ(name, "ENABLE_PROCESSED_OUTPUT"))

    549. 

  549.             #ifdef ENABLE_PROCESSED_OUTPUT

    550. 

  550.                 return ENABLE_PROCESSED_OUTPUT;

    551. 

  551.             #else

    552. 

  552.                 goto not_there;

    553. 

  553.             #endif

    554. 

  554.         if (strEQ(name, "ENABLE_WINDOW_INPUT"))

    555. 

  555.             #ifdef ENABLE_WINDOW_INPUT

    556. 

  556.                 return ENABLE_WINDOW_INPUT;

    557. 

  557.             #else

    558. 

  558.                 goto not_there;

    559. 

  559.             #endif

    560. 

  560.         if (strEQ(name, "ENABLE_WRAP_AT_EOL_OUTPUT"))

    561. 

  561.             #ifdef ENABLE_WRAP_AT_EOL_OUTPUT

    562. 

  562.                 return ENABLE_WRAP_AT_EOL_OUTPUT;

    563. 

  563.             #else

    564. 

  564.                 goto not_there;

    565. 

  565.             #endif

    566. 

  566.         if (strEQ(name, "ENHANCED_KEY"))

    567. 

  567.             #ifdef ENHANCED_KEY

    568. 

  568.                 return ENHANCED_KEY;

    569. 

  569.             #else

    570. 

  570.                 goto not_there;

    571. 

  571.             #endif

    572. 

  572.         break;

    573. 

  573.     case 'F':

    574. 

  574.         if (strEQ(name, "FILE_SHARE_READ"))

    575. 

  575.             #ifdef FILE_SHARE_READ

    576. 

  576.                 return FILE_SHARE_READ;

    577. 

  577.             #else

    578. 

  578.                 goto not_there;

    579. 

  579.             #endif

    580. 

  580.         if (strEQ(name, "FILE_SHARE_WRITE"))

    581. 

  581.             #ifdef FILE_SHARE_WRITE

    582. 

  582.                 return FILE_SHARE_WRITE;

    583. 

  583.             #else

    584. 

  584.                 goto not_there;

    585. 

  585.             #endif

    586. 

  586.         if (strEQ(name, "FOREGROUND_BLUE"))

    587. 

  587.             #ifdef FOREGROUND_BLUE

    588. 

  588.                 return FOREGROUND_BLUE;

    589. 

  589.             #else

    590. 

  590.                 goto not_there;

    591. 

  591.             #endif

    592. 

  592.         if (strEQ(name, "FOREGROUND_GREEN"))

    593. 

  593.             #ifdef FOREGROUND_GREEN

    594. 

  594.                 return FOREGROUND_GREEN;

    595. 

  595.             #else

    596. 

  596.                 goto not_there;

    597. 

  597.             #endif

    598. 

  598.         if (strEQ(name, "FOREGROUND_INTENSITY"))

    599. 

  599.             #ifdef FOREGROUND_INTENSITY

    600. 

  600.                 return FOREGROUND_INTENSITY;

    601. 

  601.             #else

    602. 

  602.                 goto not_there;

    603. 

  603.             #endif

    604. 

  604.         if (strEQ(name, "FOREGROUND_RED"))

    605. 

  605.             #ifdef FOREGROUND_RED

    606. 

  606.                 return FOREGROUND_RED;

    607. 

  607.             #else

    608. 

  608.                 goto not_there;

    609. 

  609.             #endif

    610. 

  610.         break;

    611. 

  611.     case 'G':

    612. 

  612.         if (strEQ(name, "GENERIC_READ"))

    613. 

  613.             #ifdef GENERIC_READ

    614. 

  614.                 return GENERIC_READ;

    615. 

  615.             #else

    616. 

  616.                 goto not_there;

    617. 

  617.             #endif

    618. 

  618.         if (strEQ(name, "GENERIC_WRITE"))

    619. 

  619.             #ifdef GENERIC_WRITE

    620. 

  620.                 return GENERIC_WRITE;

    621. 

  621.             #else

    622. 

  622.                 goto not_there;

    623. 

  623.             #endif

    624. 

  624.         break;

    625. 

  625.     case 'H':

    626. 

  626.         break;

    627. 

  627.     case 'I':

    628. 

  628.         break;

    629. 

  629.     case 'J':

    630. 

  630.         break;

    631. 

  631.     case 'K':

    632. 

  632.         if (strEQ(name, "KEY_EVENT"))

    633. 

  633.             #ifdef KEY_EVENT

    634. 

  634.                 return KEY_EVENT;

    635. 

  635.             #else

    636. 

  636.                 goto not_there;

    637. 

  637.             #endif

    638. 

  638.         break;

    639. 

  639.     case 'L':

    640. 

  640.         if (strEQ(name, "LEFT_ALT_PRESSED"))

    641. 

  641.             #ifdef LEFT_ALT_PRESSED

    642. 

  642.                 return LEFT_ALT_PRESSED;

    643. 

  643.             #else

    644. 

  644.                 goto not_there;

    645. 

  645.             #endif

    646. 

  646.         if (strEQ(name, "LEFT_CTRL_PRESSED"))

    647. 

  647.             #ifdef LEFT_CTRL_PRESSED

    648. 

  648.                 return LEFT_CTRL_PRESSED;

    649. 

  649.             #else

    650. 

  650.                 goto not_there;

    651. 

  651.             #endif

    652. 

  652. 		break;

    653. 

  653.     case 'M':

    654. 

  654.         break;

    655. 

  655.     case 'N':

    656. 

  656.         if (strEQ(name, "NUMLOCK_ON"))

    657. 

  657.             #ifdef NUMLOCK_ON

    658. 

  658.                 return NUMLOCK_ON;

    659. 

  659.             #else

    660. 

  660.                 goto not_there;

    661. 

  661.             #endif

    662. 

  662.         break;

    663. 

  663.     case 'O':

    664. 

  664.         break;

    665. 

  665.     case 'P':

    666. 

  666.         break;

    667. 

  667.     case 'Q':

    668. 

  668.         break;

    669. 

  669.     case 'R':

    670. 

  670.         if (strEQ(name, "RIGHT_ALT_PRESSED"))

    671. 

  671.             #ifdef RIGHT_ALT_PRESSED

    672. 

  672.                 return RIGHT_ALT_PRESSED;

    673. 

  673.             #else

    674. 

  674.                 goto not_there;

    675. 

  675.             #endif

    676. 

  676.         if (strEQ(name, "RIGHT_CTRL_PRESSED"))

    677. 

  677.             #ifdef RIGHT_CTRL_PRESSED

    678. 

  678.                 return RIGHT_CTRL_PRESSED;

    679. 

  679.             #else

    680. 

  680.                 goto not_there;

    681. 

  681.             #endif

    682. 

  682. 		break;

    683. 

  683.     case 'S':

    684. 

  684. 		if (strEQ(name, "SCROLLLOCK_ON"))

    685. 

  685. 			#ifdef SCROLLLOCK_ON

    686. 

  686. 				return SCROLLLOCK_ON;

    687. 

  687. 			#else

    688. 

  688. 				goto not_there;

    689. 

  689. 			#endif

    690. 

  690. 		if (strEQ(name, "SHIFT_PRESSED"))

    691. 

  691. 			#ifdef SHIFT_PRESSED

    692. 

  692. 				return SHIFT_PRESSED;

    693. 

  693. 			#else

    694. 

  694. 				goto not_there;

    695. 

  695. 			#endif

    696. 

  696. 		if (strEQ(name, "STD_ERROR_HANDLE"))

    697. 

  697. 			#ifdef STD_ERROR_HANDLE

    698. 

  698. 				return STD_ERROR_HANDLE;

    699. 

  699. 			#else

    700. 

  700. 				goto not_there;

    701. 

  701. 			#endif

    702. 

  702. 		if (strEQ(name, "STD_INPUT_HANDLE"))

    703. 

  703. 			#ifdef STD_INPUT_HANDLE

    704. 

  704. 				return STD_INPUT_HANDLE;

    705. 

  705. 			#else

    706. 

  706. 				goto not_there;

    707. 

  707. 			#endif

    708. 

  708. 		if (strEQ(name, "STD_OUTPUT_HANDLE"))

    709. 

  709. 			#ifdef STD_OUTPUT_HANDLE

    710. 

  710. 				return STD_OUTPUT_HANDLE;

    711. 

  711. 			#else

    712. 

  712. 				goto not_there;

    713. 

  713. 			#endif

    714. 

  714.         break;

    715. 

  715.     case 'T':

    716. 

  716.         break;

    717. 

  717.     case 'U':

    718. 

  718.         break;

    719. 

  719.     case 'V':

    720. 

  720.         break;

    721. 

  721.     case 'W':

    722. 

  722.         break;

    723. 

  723.     case 'X':

    724. 

  724.         break;

    725. 

  725.     case 'Y':

    726. 

  726.         break;

    727. 

  727.     case 'Z':

    728. 

  728.         break;

    729. 

  729.     }

    730. 

  730.     rb_raise(rb_eArgError, "Not such constant.");

    731. 

  731.     return 0;

    732. 

  732. 

    733. 

  733. not_there:

    734. 

  734.     rb_raise(rb_eArgError, "Not defined.");

    735. 

  735.     return 0;

    736. 

  736. }

    737. 

  737. 

    738. 

  738. VALUE rb_constant( VALUE self, VALUE name )

    739. 

  739. {

    740. 

  740.    Check_Type( name, T_STRING );

    741. 

  741.    return ULONG2NUM( c_constant( RSTRING_PTR(name) ) );

    742. 

  742. }

    743. 

  743. 

    744. 

  744. 

    745. 

  745. void define_constants()

    746. 

  746. {

    747. 

  747. #define DEF_SELF_CONST(NAME) \

    748. 

  748.    rb_define_const(rb_mConstants, #NAME, ULONG2NUM( (ULONG)NAME ) );

    749. 

  749. 

    750. 

  750.    DEF_SELF_CONST(  STD_INPUT_HANDLE          );

    751. 

  751.    DEF_SELF_CONST(  STD_OUTPUT_HANDLE         );

    752. 

  752.    DEF_SELF_CONST(  STD_ERROR_HANDLE          );

    753. 

  753.    DEF_SELF_CONST(  INVALID_HANDLE_VALUE      );

    754. 

  754.    DEF_SELF_CONST(  GENERIC_READ              );

    755. 

  755.    DEF_SELF_CONST(  GENERIC_WRITE             );

    756. 

  756.    DEF_SELF_CONST(  FILE_SHARE_READ           );

    757. 

  757.    DEF_SELF_CONST(  FILE_SHARE_WRITE          );

    758. 

  758.    DEF_SELF_CONST(  CONSOLE_TEXTMODE_BUFFER   );

    759. 

  759. 

    760. 

  760.    DEF_SELF_CONST(  FOREGROUND_BLUE           );

    761. 

  761.    DEF_SELF_CONST(  FOREGROUND_GREEN          );

    762. 

  762.    DEF_SELF_CONST(  FOREGROUND_RED            );

    763. 

  763.    DEF_SELF_CONST(  FOREGROUND_INTENSITY      );

    764. 

  764.    DEF_SELF_CONST(  BACKGROUND_BLUE           );

    765. 

  765.    DEF_SELF_CONST(  BACKGROUND_GREEN          );

    766. 

  766.    DEF_SELF_CONST(  BACKGROUND_RED            );

    767. 

  767.    DEF_SELF_CONST(  BACKGROUND_INTENSITY      );

    768. 

  768. 

    769. 

  769.    DEF_SELF_CONST(  ENABLE_PROCESSED_INPUT    );

    770. 

  770.    DEF_SELF_CONST(  ENABLE_LINE_INPUT         );

    771. 

  771.    DEF_SELF_CONST(  ENABLE_ECHO_INPUT         );

    772. 

  772.    DEF_SELF_CONST(  ENABLE_WINDOW_INPUT       );

    773. 

  773.    DEF_SELF_CONST(  ENABLE_MOUSE_INPUT        );

    774. 

  774.    DEF_SELF_CONST(  ENABLE_PROCESSED_OUTPUT   );

    775. 

  775.    DEF_SELF_CONST(  ENABLE_WRAP_AT_EOL_OUTPUT );

    776. 

  776. 

    777. 

  777.    DEF_SELF_CONST(  KEY_EVENT                 );

    778. 

  778.    DEF_SELF_CONST(  MOUSE_EVENT               );

    779. 

  779.    DEF_SELF_CONST(  WINDOW_BUFFER_SIZE_EVENT  );

    780. 

  780.    DEF_SELF_CONST(  MENU_EVENT                );

    781. 

  781.    DEF_SELF_CONST(  FOCUS_EVENT               );

    782. 

  782. 

    783. 

  783.    DEF_SELF_CONST(  CAPSLOCK_ON               );

    784. 

  784.    DEF_SELF_CONST(  ENHANCED_KEY              );

    785. 

  785.    DEF_SELF_CONST(  NUMLOCK_ON                );

    786. 

  786.    DEF_SELF_CONST(  SHIFT_PRESSED             );

    787. 

  787.    DEF_SELF_CONST(  LEFT_CTRL_PRESSED         );

    788. 

  788.    DEF_SELF_CONST(  RIGHT_CTRL_PRESSED        );

    789. 

  789.    DEF_SELF_CONST(  LEFT_ALT_PRESSED          );

    790. 

  790.    DEF_SELF_CONST(  RIGHT_ALT_PRESSED         );

    791. 

  791.    DEF_SELF_CONST(  SCROLLLOCK_ON             );

    792. 

  792. 

    793. 

  793.    DEF_SELF_CONST(  MOUSE_WHEELED             );

    794. 

  794.    DEF_SELF_CONST(  DOUBLE_CLICK              );

    795. 

  795.    DEF_SELF_CONST(  MOUSE_MOVED               );

    796. 

  796. 

    797. 

  797.    DEF_SELF_CONST(  FROM_LEFT_1ST_BUTTON_PRESSED    );

    798. 

  798.    DEF_SELF_CONST(  FROM_LEFT_2ND_BUTTON_PRESSED    );

    799. 

  799.    DEF_SELF_CONST(  FROM_LEFT_3RD_BUTTON_PRESSED    );

    800. 

  800.    DEF_SELF_CONST(  FROM_LEFT_4TH_BUTTON_PRESSED    );

    801. 

  801.    DEF_SELF_CONST(  RIGHTMOST_BUTTON_PRESSED        );

    802. 

  802. 

    803. 

  803.    DEF_SELF_CONST(  CTRL_C_EVENT              );

    804. 

  804.    DEF_SELF_CONST(  CTRL_BREAK_EVENT          );

    805. 

  805.    DEF_SELF_CONST(  CTRL_CLOSE_EVENT          );

    806. 

  806.    DEF_SELF_CONST(  CTRL_LOGOFF_EVENT         );

    807. 

  807.    DEF_SELF_CONST(  CTRL_SHUTDOWN_EVENT       );

    808. 

  808. }

    809. 

  809. 

    810. 

  810. 

    811. 

  811. VALUE

    812. 

  812. rb_FillConsoleOutputAttribute( VALUE self, VALUE hConsoleOutput,

    813. 

  813. 			       VALUE wAttribute, VALUE nLength,

    814. 

  814. 			       VALUE col, VALUE row )

    815. 

  815. {

    816. 

  816.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    817. 

  817. 

    818. 

  818.    COORD dwWriteCoord;

    819. 

  819.    dwWriteCoord.X = NUM2UINT(col);

    820. 

  820.    dwWriteCoord.Y = NUM2UINT(row);

    821. 

  821.    DWORD numChars;

    822. 

  822.    if (FillConsoleOutputAttribute( handle, NUM2UINT(wAttribute),

    823. 

  823. 				   NUM2ULONG(nLength), dwWriteCoord,

    824. 

  824. 				   &numChars ))

    825. 

  825.       return ULONG2NUM(numChars);

    826. 

  826.    return rb_getWin32Error();

    827. 

  827. }

    828. 

  828. 

    829. 

  829. VALUE

    830. 

  830. rb_SetConsoleScreenBufferSize( VALUE self, VALUE hConsoleOutput,

    831. 

  831. 			       VALUE x, VALUE y )

    832. 

  832. {

    833. 

  833.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    834. 

  834.    COORD size;

    835. 

  835.    size.X=NUM2UINT(x);

    836. 

  836.    size.Y=NUM2UINT(y);

    837. 

  837.    if (SetConsoleScreenBufferSize(handle, size))

    838. 

  838.       return NUM2UINT(1);

    839. 

  839.    return rb_getWin32Error();

    840. 

  840. }

    841. 

  841. 

    842. 

  842. VALUE

    843. 

  843. rb_SetConsoleTitle( VALUE self, VALUE title )

    844. 

  844. {

    845. 

  845.    Check_Type( title, T_STRING );

    846. 

  846.    if (SetConsoleTitle(RSTRING_PTR( title )))

    847. 

  847.       return NUM2UINT(1);

    848. 

  848.    return rb_getWin32Error();

    849. 

  849. }

    850. 

  850. 

    851. 

  851. VALUE

    852. 

  852. rb_SetStdHandle( VALUE self, VALUE fd, VALUE hConsoleOutput )

    853. 

  853. {

    854. 

  854.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    855. 

  855.    if (SetStdHandle(NUM2UINT(fd), handle))

    856. 

  856.       return NUM2UINT(1);

    857. 

  857.    return rb_getWin32Error();

    858. 

  858. }

    859. 

  859. 

    860. 

  860. VALUE

    861. 

  861. rb_SetConsoleWindowInfo( VALUE self, VALUE hConsoleOutput, VALUE bAbsolute, 

    862. 

  862. 			 VALUE left, VALUE top, VALUE right, VALUE bottom )

    863. 

  863. {

    864. 

  864.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    865. 

  865.    

    866. 

  866.    SMALL_RECT rect;

    867. 

  867.    rect.Left   = NUM2INT( left );

    868. 

  868.    rect.Top    = NUM2INT( top );

    869. 

  869.    rect.Right  = NUM2INT( right );

    870. 

  870.    rect.Bottom = NUM2INT( bottom );

    871. 

  871.    if (SetConsoleWindowInfo( handle, NUM2INT( bAbsolute ), &rect ))

    872. 

  872.       return UINT2NUM(1);

    873. 

  873.    return rb_getWin32Error();

    874. 

  874. }

    875. 

  875. 

    876. 

  876. 

    877. 

  877. 

    878. 

  878. VALUE

    879. 

  879. rb_SetConsoleCursorPosition( VALUE self, VALUE hConsoleOutput,

    880. 

  880. 			     VALUE col, VALUE row )

    881. 

  881. {  

    882. 

  882.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    883. 

  883. 

    884. 

  884.    COORD dwWriteCoord;

    885. 

  885.    dwWriteCoord.X = NUM2UINT(col);

    886. 

  886.    dwWriteCoord.Y = NUM2UINT(row);

    887. 

  887.    // Cannot call rb_getWin32Error as this function fails when

    888. 

  888.    // setting cursor to last column/row.

    889. 

  889.    if ( !SetConsoleCursorPosition( handle, dwWriteCoord ) )

    890. 

  890.       return Qnil;

    891. 

  891.    return INT2FIX(1);

    892. 

  892. }

    893. 

  893. 

    894. 

  894. VALUE

    895. 

  895. rb_SetConsoleCursorInfo( VALUE self, VALUE hConsoleOutput,

    896. 

  896. 			 VALUE size, VALUE visib )

    897. 

  897. {  

    898. 

  898.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    899. 

  899.    CONSOLE_CURSOR_INFO c;

    900. 

  900.    c.dwSize = NUM2UINT(size);

    901. 

  901.    c.bVisible = NUM2UINT(visib);

    902. 

  902.    if ( !SetConsoleCursorInfo( handle, &c ) )

    903. 

  903.       return rb_getWin32Error();

    904. 

  904.    return INT2FIX(1);

    905. 

  905. }

    906. 

  906. 

    907. 

  907. 

    908. 

  908. 

    909. 

  909. VALUE

    910. 

  910. rb_SetConsoleActiveScreenBuffer( VALUE self, VALUE hConsoleOutput )

    911. 

  911. {

    912. 

  912.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    913. 

  913. 

    914. 

  914.    if ( !SetConsoleActiveScreenBuffer( handle ) )

    915. 

  915.       return rb_getWin32Error();

    916. 

  916.    return INT2FIX(1);

    917. 

  917. }

    918. 

  918. 

    919. 

  919. VALUE

    920. 

  920. rb_SetConsoleTextAttribute( VALUE self, VALUE hConsoleOutput, 

    921. 

  921. 						   VALUE wAttributes )

    922. 

  922. {

    923. 

  923.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    924. 

  924. 

    925. 

  925.    if ( !SetConsoleTextAttribute( handle, NUM2UINT(wAttributes) ) )

    926. 

  926.       return Qnil; // no getWin32Error to allow piping/redirecting

    927. 

  927.    return INT2FIX(1);

    928. 

  928. }

    929. 

  929. 

    930. 

  930. 

    931. 

  931. 

    932. 

  932. VALUE

    933. 

  933. rb_ScrollConsoleScreenBuffer( VALUE self, VALUE hConsoleOutput, VALUE left1,

    934. 

  934. 			      VALUE top1, VALUE right1, VALUE bottom1,

    935. 

  935. 			      VALUE col, VALUE row, VALUE cChar, VALUE attr,

    936. 

  936. 			      VALUE left2, VALUE top2, VALUE right2,

    937. 

  937. 			      VALUE bottom2)

    938. 

  938. {

    939. 

  939.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    940. 

  940.    

    941. 

  941.    SMALL_RECT scroll, clip;

    942. 

  942.    scroll.Left   = NUM2INT( left1 );

    943. 

  943.    scroll.Right  = NUM2INT( right1 );

    944. 

  944.    scroll.Top    = NUM2INT( top1 );

    945. 

  945.    scroll.Bottom = NUM2INT( bottom1 );

    946. 

  946.    clip.Left   = NUM2INT( left2 );

    947. 

  947.    clip.Right  = NUM2INT( right2 );

    948. 

  948.    clip.Top    = NUM2INT( top2 );

    949. 

  949.    clip.Bottom = NUM2INT( bottom2 );

    950. 

  950.    CHAR_INFO fill;

    951. 

  951. #ifdef UNICODE

    952. 

  952.    fill.Char.UnicodeChar = NUM2CHR( cChar );

    953. 

  953. #else

    954. 

  954.    fill.Char.AsciiChar = NUM2CHR( cChar );

    955. 

  955. #endif

    956. 

  956.    fill.Attributes = NUM2INT(attr);

    957. 

  957.    COORD origin;

    958. 

  958.    origin.X = NUM2UINT( col );

    959. 

  959.    origin.Y = NUM2UINT( row );

    960. 

  960.    

    961. 

  961.    if ( ScrollConsoleScreenBuffer( handle, &scroll, &clip, origin,

    962. 

  962. 				   &fill ) )

    963. 

  963.       return INT2FIX(1);

    964. 

  964.    return rb_getWin32Error();

    965. 

  965. }

    966. 

  966. 

    967. 

  967. 

    968. 

  968. VALUE

    969. 

  969. rb_FillConsoleOutputCharacter( VALUE self, VALUE hConsoleOutput,

    970. 

  970. 			       VALUE cCharacter, VALUE nLength,

    971. 

  971. 			       VALUE col, VALUE row )

    972. 

  972. {

    973. 

  973.    HANDLE handle = ULongToPtr( NUM2ULONG( hConsoleOutput ) );

    974. 

  974. 

    975. 

  975.    COORD dwWriteCoord;

    976. 

  976.    dwWriteCoord.X = NUM2UINT(col);

    977. 

  977.    dwWriteCoord.Y = NUM2UINT(row);

    978. 

  978.    DWORD numChars;

    979. 

  979.    if (FillConsoleOutputCharacter( handle, NUM2CHR(cCharacter),

    980. 

  980. 				   NUM2ULONG(nLength), dwWriteCoord,

    981. 

  981. 				   &numChars ))

    982. 

  982.       return ULONG2NUM(numChars);

    983. 

  983.    return rb_getWin32Error();

    984. 

  984. }

    985. 

  985. 

    986. 

  986. 

    987. 

  987. VALUE

    988. 

  988. rb_WriteConsoleInput(int argc, VALUE *argv, VALUE self)

    989. 

  989. {

    990. 

  990.    if (argc < 3)

    991. 

  991.       rb_raise(rb_eArgError, "Wrong number of arguments.");

    992. 

  992.    

    993. 

  993.    HANDLE handle = ULongToPtr( NUM2ULONG( argv[0] ) );

    994. 

  994.    WORD type = NUM2INT( argv[1] );

    995. 

  995.    DWORD written;

    996. 

  996.    INPUT_RECORD event;

    997. 

  997.    event.EventType = type;

    998. 

  998.    switch(event.EventType) {

    999. 

  999.       case KEY_EVENT:

    1000. 

  1000. 	 {

    1001. 

  1001. 	 KEY_EVENT_RECORD* kevent=(KEY_EVENT_RECORD *)&(event.Event);

    1002. 

  1002. 	 kevent->bKeyDown=(BOOL)NUM2UINT( argv[2] );

    1003. 

  1003. 	 kevent->wRepeatCount=NUM2UINT( argv[3] );

    1004. 

  1004. 	 kevent->wVirtualKeyCode=NUM2UINT( argv[4] );

    1005. 

  1005. 	 kevent->wVirtualScanCode=NUM2UINT( argv[5] );

    1006. 

  1006. #ifdef UNICODE

    1007. 

  1007. 	 if (argc < 7)

    1008. 

  1008. 	    rb_raise(rb_eArgError, "Wrong number of arguments.");

    1009. 

  1009. 	kevent->uChar.UnicodeChar=NUM2UINT( argv[6] );

    1010. 

  1010. #else

    1011. 

  1011. 	if (argc < 8)

    1012. 

  1012. 	   rb_raise(rb_eArgError, "Wrong number of arguments.");

    1013. 

  1013. 	kevent->uChar.AsciiChar=NUM2UINT( argv[7] );

    1014. 

  1014. #endif

    1015. 

  1015. 	break;

    1016. 

  1016. 	 }

    1017. 

  1017.     case MOUSE_EVENT:

    1018. 

  1018.        {

    1019. 

  1019. 	  if (argc < 7)

    1020. 

  1020. 	     rb_raise(rb_eArgError, "Wrong number of arguments.");

    1021. 

  1021. 	

    1022. 

  1022. 	  MOUSE_EVENT_RECORD* mevent=(MOUSE_EVENT_RECORD *)&(event.Event);

    1023. 

  1023. 	  mevent->dwMousePosition.X=NUM2UINT( argv[2] );

    1024. 

  1024. 	  mevent->dwMousePosition.Y=NUM2UINT( argv[3] );

    1025. 

  1025. 	  mevent->dwButtonState=NUM2UINT( argv[4] );

    1026. 

  1026. 	  mevent->dwControlKeyState=NUM2UINT( argv[5] );

    1027. 

  1027. 	  mevent->dwEventFlags=NUM2UINT( argv[6] );

    1028. 

  1028.        break;

    1029. 

  1029.        }

    1030. 

  1030.       case WINDOW_BUFFER_SIZE_EVENT:

    1031. 

  1031. 	 {

    1032. 

  1032. 	    if (argc < 4)

    1033. 

  1033. 	       rb_raise(rb_eArgError, "Wrong number of arguments.");

    1034. 

  1034. 	    WINDOW_BUFFER_SIZE_RECORD* mevent=

    1035. 

  1035. 	    (WINDOW_BUFFER_SIZE_RECORD *)&(event.Event);

    1036. 

  1036. 	    mevent->dwSize.X = NUM2UINT( argv[2] );

    1037. 

  1037. 	    mevent->dwSize.Y = NUM2UINT( argv[3] );

    1038. 

  1038. 	 }

    1039. 

  1039. 	 break;

    1040. 

  1040.       case MENU_EVENT:

    1041. 

  1041. 	 {

    1042. 

  1042. 	    if (argc < 3)

    1043. 

  1043. 	       rb_raise(rb_eArgError, "Wrong number of arguments.");

    1044. 

  1044. 	    MENU_EVENT_RECORD* mevent= (MENU_EVENT_RECORD *)&(event.Event);

    1045. 

  1045. 	    mevent->dwCommandId = argv[2];

    1046. 

  1046. 	 }

    1047. 

  1047. 	 break;

    1048. 

  1048.       case FOCUS_EVENT:

    1049. 

  1049. 	 {

    1050. 

  1050. 	    if (argc < 3)

    1051. 

  1051. 	       rb_raise(rb_eArgError, "Wrong number of arguments.");

    1052. 

  1052. 	    FOCUS_EVENT_RECORD* mevent= (FOCUS_EVENT_RECORD *)&(event.Event);

    1053. 

  1053. 	    mevent->bSetFocus = NUM2UINT( argv[2] );

    1054. 

  1054. 	 }

    1055. 

  1055.     default:

    1056. 

  1056.        rb_raise( rb_eArgError, "Unknown type of event.");

    1057. 

  1057.        break;

    1058. 

  1058.    }

    1059. 

  1059.    if (WriteConsoleInput(handle,&event,1,&written))

    1060. 

  1060.       return INT2FIX(1);

    1061. 

  1061.    return rb_getWin32Error();

    1062. 

  1062. }

    1063. 

  1063. 

    1064. 

  1064. VALUE

    1065. 

  1065. rb_WriteConsoleOutput(VALUE self, VALUE h, VALUE buffer,

    1066. 

  1066. 		      VALUE srcwid, VALUE srcht, VALUE startx,

    1067. 

  1067. 		      VALUE starty, VALUE l, VALUE t, VALUE r, VALUE b)

    1068. 

  1068. {

    1069. 

  1069.     COORD coords;

    1070. 

  1070.     COORD size;

    1071. 

  1071.     SMALL_RECT to;

    1072. 

  1072. 

    1073. 

  1073.     HANDLE handle = ULongToPtr( NUM2ULONG( h ) );

    1074. 

  1074.     Check_Type( buffer, T_STRING );

    1075. 

  1075.     size.X=NUM2UINT( srcwid );

    1076. 

  1076.     size.Y=NUM2UINT( srcht );

    1077. 

  1077.     coords.X=NUM2INT( startx );

    1078. 

  1078.     coords.Y=NUM2INT( starty );

    1079. 

  1079.     to.Left   = NUM2INT( l );

    1080. 

  1080.     to.Top    = NUM2INT( t );

    1081. 

  1081.     to.Right  = NUM2INT( r );

    1082. 

  1082.     to.Bottom = NUM2INT( b );

    1083. 

  1083.     if (WriteConsoleOutput(handle,(CHAR_INFO *)RSTRING_PTR(buffer),

    1084. 

  1084. 			   size,coords,&to)) {

    1085. 

  1085.        VALUE ret = rb_ary_new();

    1086. 

  1086.        rb_ary_push( ret, INT2FIX( to.Left   ) );

    1087. 

  1087.        rb_ary_push( ret, INT2FIX( to.Top    ) );

    1088. 

  1088.        rb_ary_push( ret, INT2FIX( to.Right  ) );

    1089. 

  1089.        rb_ary_push( ret, INT2FIX( to.Bottom ) );

    1090. 

  1090.        return ret;

    1091. 

  1091.     }

    1092. 

  1092.     return rb_getWin32Error();

    1093. 

  1093. }

    1094. 

  1094. 

    1095. 

  1095. 

    1096. 

  1096. VALUE

    1097. 

  1097. rb_WriteConsoleOutputAttribute(VALUE self, VALUE h, VALUE s,

    1098. 

  1098. 			       VALUE x, VALUE y)

    1099. 

  1099. {

    1100. 

  1100. 

    1101. 

  1101.     HANDLE handle = ULongToPtr( NUM2ULONG( h ) );

    1102. 

  1102.     Check_Type( s, T_STRING );

    1103. 

  1103.     

    1104. 

  1104.     unsigned short buffer[80*999*sizeof(unsigned short)];

    1105. 

  1105.     DWORD written;

    1106. 

  1106.     DWORD towrite = RSTRING_LEN(s);

    1107. 

  1107.     unsigned i = 0;

    1108. 

  1108. 

    1109. 

  1109.     for(i=0; i<towrite; i++) {

    1110. 

  1110.         buffer[i] = (unsigned short)(RSTRING_PTR(s)[i]);

    1111. 

  1111.     }

    1112. 

  1112.     COORD coords;

    1113. 

  1113.     coords.X=NUM2INT( x );

    1114. 

  1114.     coords.Y=NUM2INT( y );

    1115. 

  1115.     if (WriteConsoleOutputAttribute(handle,(const unsigned short *)&buffer,

    1116. 

  1116. 				    towrite,coords,&written)) {

    1117. 

  1117.        return UINT2NUM( written );

    1118. 

  1118.     }

    1119. 

  1119.     return rb_getWin32Error();

    1120. 

  1120. }

    1121. 

  1121. 

    1122. 

  1122. 

    1123. 

  1123. VALUE

    1124. 

  1124. rb_WriteConsoleOutputCharacter(VALUE self, VALUE h, VALUE s,

    1125. 

  1125. 			       VALUE x, VALUE y)

    1126. 

  1126. {

    1127. 

  1127. 

    1128. 

  1128.     HANDLE handle = ULongToPtr( NUM2ULONG( h ) );

    1129. 

  1129.     Check_Type( s, T_STRING );

    1130. 

  1130.     

    1131. 

  1131.     DWORD written;

    1132. 

  1132.     COORD coords;

    1133. 

  1133.     coords.X=NUM2INT( x );

    1134. 

  1134.     coords.Y=NUM2INT( y );

    1135. 

  1135.     if (WriteConsoleOutputCharacter(handle,(LPCTSTR)RSTRING_PTR(s),

    1136. 

  1136. 				    RSTRING_LEN(s),coords,&written)) {

    1137. 

  1137.        return UINT2NUM( written );

    1138. 

  1138.     }

    1139. 

  1139.     return rb_getWin32Error();

    1140. 

  1140. }

    1141. 

  1141. 

    1142. 

  1142. 

    1143. 

  1143. void Init_Console_ext(void)

    1144. 

  1144. {

    1145. 

  1145.    rb_mWin32 = rb_define_module("Win32");

    1146. 

  1146.    rb_define_const(rb_mKernel, "Win32", rb_mWin32);

    1147. 

  1147. 

    1148. 

  1148.    rb_mConsole = rb_define_class_under(rb_mWin32, "Console", rb_cObject);

    1149. 

  1149. 

    1150. 

  1150.    // Handle Constants

    1151. 

  1151.    rb_mConstants = rb_define_module_under(rb_mConsole,"Constants");

    1152. 

  1152.    define_constants();

    1153. 

  1153. 

    1154. 

  1154.    // Handle API

    1155. 

  1155.    rb_mAPI = rb_define_class_under(rb_mConsole, "API", rb_cObject);

    1156. 

  1156.    

    1157. 

  1157.    RB_DEF_API_METHOD(constant, 1); //OK

    1158. 

  1158. 

    1159. 

  1159.    RB_DEF_API_METHOD(AllocConsole, 0);

    1160. 

  1160.    

    1161. 

  1161.    RB_DEF_API_METHOD(CreateConsoleScreenBuffer, 3); //OK

    1162. 

  1162.    

    1163. 

  1163.    RB_DEF_API_METHOD(FillConsoleOutputAttribute, 5); //OK

    1164. 

  1164.    RB_DEF_API_METHOD(FillConsoleOutputCharacter, 5); //OK

    1165. 

  1165. //     RB_DEF_API_METHOD(FillConsoleInputBuffer, 1); // Does not exist anymore

    1166. 

  1166.    

    1167. 

  1167.    RB_DEF_API_METHOD(FreeConsole, 0);

    1168. 

  1168.    

    1169. 

  1169.    RB_DEF_API_METHOD(GenerateConsoleCtrlEvent, 2);

    1170. 

  1170.    

    1171. 

  1171.    RB_DEF_API_METHOD(GetConsoleCP, 0); //OK

    1172. 

  1172.    RB_DEF_API_METHOD(GetConsoleCursorInfo, 1); //OK

    1173. 

  1173.    RB_DEF_API_METHOD(GetConsoleMode, 1);

    1174. 

  1174.    RB_DEF_API_METHOD(GetConsoleOutputCP, 0);

    1175. 

  1175.    RB_DEF_API_METHOD(GetConsoleScreenBufferInfo, 1); //OK

    1176. 

  1176.    RB_DEF_API_METHOD(GetConsoleTitle, 0);

    1177. 

  1177.    RB_DEF_API_METHOD(GetConsoleWindow, 0);

    1178. 

  1178.    RB_DEF_API_METHOD(GetLargestConsoleWindowSize, 1);

    1179. 

  1179.    RB_DEF_API_METHOD(GetNumberOfConsoleInputEvents, 1);

    1180. 

  1180.    RB_DEF_API_METHOD(GetNumberOfConsoleMouseButtons, 0);

    1181. 

  1181.    

    1182. 

  1182.    RB_DEF_API_METHOD(GetStdHandle, 1); //OK

    1183. 

  1183.    

    1184. 

  1184.    RB_DEF_API_METHOD(PeekConsoleInput, 1); //OK

    1185. 

  1185.    RB_DEF_API_METHOD(ReadConsole, 3); //OK

    1186. 

  1186.    RB_DEF_API_METHOD(ReadConsoleInput, 1); //OK

    1187. 

  1187.    

    1188. 

  1188.    RB_DEF_API_METHOD(ReadConsoleOutput, 10);  // OK

    1189. 

  1189.    RB_DEF_API_METHOD(ReadConsoleOutputAttribute, 4);  // OK

    1190. 

  1190.    RB_DEF_API_METHOD(ReadConsoleOutputCharacter, 5);  // OK

    1191. 

  1191. 

    1192. 

  1192.    

    1193. 

  1193.    RB_DEF_API_METHOD(ScrollConsoleScreenBuffer, 13); //OK

    1194. 

  1194.    

    1195. 

  1195.    RB_DEF_API_METHOD(SetConsoleActiveScreenBuffer, 1);

    1196. 

  1196.    RB_DEF_API_METHOD(SetConsoleCP, 1);

    1197. 

  1197.    RB_DEF_API_METHOD(SetConsoleCursorPosition, 3);

    1198. 

  1198.    RB_DEF_API_METHOD(SetConsoleCursorInfo, 3);

    1199. 

  1199.    RB_DEF_API_METHOD(SetConsoleMode, 2); //OK

    1200. 

  1200.    RB_DEF_API_METHOD(SetConsoleOutputCP, 1);

    1201. 

  1201.    RB_DEF_API_METHOD(SetConsoleScreenBufferSize, 3);

    1202. 

  1202.    RB_DEF_API_METHOD(SetConsoleTextAttribute, 2);

    1203. 

  1203.    RB_DEF_API_METHOD(SetConsoleTitle, 1); //OK

    1204. 

  1204.    RB_DEF_API_METHOD(SetConsoleWindowInfo, 6);

    1205. 

  1205.    

    1206. 

  1206.    RB_DEF_API_METHOD(SetStdHandle, 2);

    1207. 

  1207.    

    1208. 

  1208.    RB_DEF_API_METHOD(WriteConsole, 2);

    1209. 

  1209.    RB_DEF_API_METHOD(WriteFile, 2);

    1210. 

  1210.    

    1211. 

  1211.    RB_DEF_API_METHOD(WriteConsoleInput, -1);

    1212. 

  1212.    RB_DEF_API_METHOD(WriteConsoleOutput, 10);

    1213. 

  1213.    RB_DEF_API_METHOD(WriteConsoleOutputAttribute, 4);

    1214. 

  1214.    RB_DEF_API_METHOD(WriteConsoleOutputCharacter, 4);

    1215. 

  1215.  

    1216. 

  1216. }

    1217. 

  1217.