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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 外挂编程 > 查看源码
Win32.pm.svn-base
资源名称：openkore-2.0.7.zip　[点击查看]
上传用户：market2
上传日期：2018-11-18
资源大小：18786k
文件大小：15k
源码类别：

外挂编程

开发平台：

Windows_Unix

Win32.pm.svn-base：源码内容
  1. #########################################################################
  2. #  OpenKore - Interface::Console::Win32
  3. #
  4. #  Copyright (c) 2004 OpenKore development team 
  5. #
  6. #  This program is free software; you can redistribute it and/or modify
  7. #  it under the terms of the GNU General Public License as published by
  8. #  the Free Software Foundation; either version 2 of the License, or
  9. #  (at your option) any later version.
  10. #
  11. #  This program is distributed in the hope that it will be useful,
  12. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. #  GNU General Public License for more details.
  15. #
  16. #
  17. #  $Revision$
  18. #  $Id$
  19. #
  20. #########################################################################
  21. ##
  22. # MODULE DESCRIPTION: 
  23. #
  24. # Support for asyncronous input on MS Windows computers
  26. package Interface::Console::Win32;
  28. use strict;
  29. use warnings;
  31. die "W32 only, this module should never be called on any other OSn"
  32. unless ($^O eq 'MSWin32' || $^O eq 'cygwin');
  34. use Carp;
  35. use Time::HiRes qw/time sleep/;
  36. use Text::Wrap;
  37. use Win32::Console;
  38. use Utils::Win32;
  39. use encoding 'utf8';
  40. use Encode;
  41. use I18N qw(stringToBytes);
  42. use Translation qw(T);
  45. use Globals;
  46. use Settings qw(%sys);
  47. use base qw(Interface::Console);
  49. our %fgcolors;
  50. our %bgcolors;
  52. sub new {
  53. my $class = shift;
  54. my $self = {
  55. input_list => [],
  56. last_line_end => 1,
  57. input_lines => [],
  58. input_offset => 0,
  59. input_part => '',
  60. };
  61. bless $self, $class;
  62. $self->{out_con} = new Win32::Console(STD_OUTPUT_HANDLE()) 
  63. or die "Could not init output Console: $!n";
  64. $self->{in_con} = new Win32::Console(STD_INPUT_HANDLE()) 
  65. or die "Could not init input Console: $!n";
  66. $self->setWinDim();
  68. $self->{out_con}->Cursor(0, $self->{in_line});
  69. $self->{codepage} = $self->{out_con}->OutputCP;
  70. return $self;
  71. }
  73. sub DESTROY {
  74. my $self = shift;
  76. $self->color('reset');
  77. }
  79. sub setWinDim {
  80. my $self = shift;
  81. my($wLeft, $wTop, $wRight, $wBottom) = $self->{out_con}->Window() or die "Can't find initial dimentions for the output windown";
  82. my($bCol, $bRow) = $self->{out_con}->Size() or die "Can't find dimentions for the output buffern";
  83. $self->{out_con}->Window(1, $wLeft, $bRow - $wBottom - 1, $wRight, $bRow - 1);# or die "Can't set dimentions for the output windown";
  84. @{$self}{qw(left out_top right in_line)} = $self->{out_con}->Window() or die "Can't find new dimentions for the output windown";
  85. $self->{out_bot} = $self->{in_line} - 1; #one line above the input line
  86. $self->{out_line} = $self->{in_line};
  87. $self->{out_col} = $self->{in_pos} = $self->{left};
  88. }
  90. sub getInput {
  91. # return undef unless ($enabled);
  92. my $self = shift;
  93. my $timeout = shift;
  94. $self->readEvents();
  95. my $msg;
  96. if ($timeout < 0) {
  97. until (defined $msg) {
  98. $self->readEvents();
  99. sleep 0.01;
  100. if (@{$self->{input_lines}}) {
  101. $msg = shift @{$self->{input_lines}};
  102. }
  103. }
  104. } elsif ($timeout > 0) {
  105. my $end = time + $timeout;
  106. until ($end < time || defined $msg) {
  107. $self->readEvents();
  108. sleep 0.01;
  109. if (@{$self->{input_lines}}) {
  110. $msg = shift @{$self->{input_lines}};
  111. }
  112. }
  113. } else {
  114. if (@{$self->{input_lines}}) {
  115. $msg = shift @{$self->{input_lines}};
  116. }
  117. }
  118. undef $msg if (defined $msg && $msg eq '');
  120. return $msg;
  121. }
  124. ##
  125. # readEvents()
  126. #
  127. # reads low level events from the input console, for key presses it
  128. # updates the console input variables
  129. #
  130. # note: most of this is commented out, it need a cordinated output
  131. # system to use the separate input line (meaning output does not
  132. # over write your input line)
  133. sub readEvents {
  134. my $self = shift;
  135. # local($|) = 1;
  136. while ($self->{in_con}->GetEvents()) {
  137. my @event = $self->{in_con}->Input();
  139. if (@event && $event[5] < 0) {
  140. # Special characters are returned as unsigned integer
  141. # (dunno why). Fix this.
  142. $event[5] = 256 + $event[5];
  143. }
  144. if (@event && $event[0] == 1 && $event[1] == 0 && $event[3] == 18) {
  145. # Alt was released and there's an ASCII code. This is
  146. # a special character. Change @events as if a normal key
  147. # was pressed.
  148. $event[1] = 1;
  149. }
  151. if (@event && $event[0] == 1 && $event[1] == 1) {
  152. ##Ctrl+U (erases entire line)
  153. if ($event[6] == 40 && $event[5] == 21) {
  154. $self->{in_pos} = 0;
  155. $self->{out_con}->Scroll(
  156. 0, $self->{in_line}, $self->{right}, $self->{in_line},
  157. -$self->{right}, $self->{in_line}, ord(' '), $main::ATTR_NORMAL, 
  158. 0, $self->{in_line}, $self->{right}, $self->{in_line},
  159. );
  160. $self->{out_con}->Cursor(0, $self->{in_line});
  161. $self->{input_part} = '';
  162. ##Backspace
  163. } elsif ($event[5] == 8) {
  164. $self->{in_pos}-- if $self->{in_pos} > 0;
  165. substr($self->{input_part}, $self->{in_pos}, 1, '');
  166. $self->{out_con}->Scroll(
  167. $self->{in_pos}, $self->{in_line}, $self->{right}, $self->{in_line},
  168. $self->{in_pos}-1, $self->{in_line}, ord(' '), $main::ATTR_NORMAL, 
  169. $self->{in_pos}, $self->{in_line}, $self->{right}, $self->{in_line},
  170. );
  171. $self->{out_con}->Cursor($self->{in_pos}, $self->{in_line});
  172. # print "10 10";
  173. ##Enter
  174. } elsif ($event[5] == 13) {
  175. my $ret = $self->{out_con}->Scroll(
  176. $self->{left}, 0, $self->{right}, $self->{in_line},
  177. 0, -1, ord(' '), $main::ATTR_NORMAL, 
  178. $self->{left}, 0, $self->{right}, $self->{in_line}
  179. );
  180. $self->{out_con}->Cursor(0, $self->{in_line});
  181. $self->{in_pos} = 0;
  182. $self->{input_list}[0] = $self->{input_part};
  183. if ($self->{input_part} ne ""
  184.  && ( @{$self->{input_list}} < 2 || $self->{input_list}[1] ne $self->{input_part} )) {
  185. unshift(@{ $self->{input_list} }, "");
  186. }
  187. push @{ $self->{input_lines} }, $self->{input_part};
  188. $self->{out_col} = 0;
  189. $self->{input_offset} = 0;
  190. $self->{input_part} = '';
  191. # print "n";
  192. #Other ASCII (+ ISO Latin-*)
  193. } elsif ($event[5] >= 32 && $event[5] != 127 && $event[5] <= 255) {
  194. my $char;
  195. eval {
  196. $char = Encode::decode("cp" . $self->{codepage}, chr($event[5]));
  197. };
  198. if ($@ =~ /^Unknown encoding/s) {
  199. $self->errorDialog(T("Your Windows's default language is not supported by OpenKore.n" .
  200. "Please go to 'Start->Control Panel->Regional and language options' and set " .
  201. "the Windows default language to English."));
  202. exit 1;
  203. } elsif ($@) {
  204. die $@;
  205. }
  207. if ($self->{in_pos} < length($self->{input_part})) {
  208. $self->{out_con}->Scroll(
  209. $self->{in_pos}, $self->{in_line}, $self->{right}, $self->{in_line},
  210. $self->{in_pos}+1, $self->{in_line}, ord(' '), $main::ATTR_NORMAL, 
  211. $self->{in_pos}, $self->{in_line}, $self->{right}, $self->{in_line},
  212. );
  213. } elsif ($self->{in_pos} > length($self->{input_part})) {
  214. $self->{in_pos} = length($self->{input_part});
  215. }
  216. $self->{out_con}->Cursor($self->{in_pos}, $self->{in_line});
  217. Utils::Win32::printConsole($char);
  218. substr($self->{input_part}, $self->{in_pos}, 0, $char) if ($self->{in_pos} <= length($self->{input_part}));
  219. $self->{in_pos}++;
  220. # } elsif ($event[3] == 33) {
  221. # __PACKAGE__->writeOutput("pgupn");
  222. # } elsif ($event[3] == 34) {
  223. # __PACKAGE__->writeOutput("pgdnn");
  224. ##End
  225. } elsif ($event[3] == 35) {
  226. $self->{out_con}->Cursor($self->{in_pos} = length($self->{input_part}), $self->{in_line});
  227. ##Home
  228. } elsif ($event[3] == 36) {
  229. $self->{out_con}->Cursor($self->{in_pos} = 0, $self->{in_line});
  230. ##Left Arrow
  231. } elsif ($event[3] == 37) {
  232. $self->{in_pos}--;
  233. $self->{out_con}->Cursor($self->{in_pos}, $self->{in_line});
  234. ##Up Arrow
  235. } elsif ($event[3] == 38) {
  236. unless ($self->{input_offset}) {
  237. $self->{input_list}[$self->{input_offset}] = $self->{input_part};
  238. }
  239. $self->{input_offset}++;
  240. $self->{input_offset} = $#{$self->{input_list}} if ($self->{input_offset} > $#{$self->{input_list}});
  241. #$self->{input_offset} -= $#{ $self->{input_list} } + 1 while $self->{input_offset} > $#{ $self->{input_list} };
  243. $self->{out_con}->Cursor(0, $self->{in_line});
  244. $self->{out_con}->Write(' ' x length($self->{input_part}));
  245. $self->{out_con}->Cursor(0, $self->{in_line});
  246. $self->{input_part} = $self->{input_list}[$self->{input_offset}];
  247. Utils::Win32::printConsole($self->{input_part});
  248. $self->{in_pos} = length($self->{input_part});
  249. ##Right Arrow
  250. } elsif ($event[3] == 39) {
  251. if ($self->{in_pos} + 1 <= length($self->{input_part})) {
  252. $self->{in_pos}++;
  253. $self->{out_con}->Cursor($self->{in_pos}, $self->{in_line});
  254. }
  255. ##Down Arrow
  256. } elsif ($event[3] == 40) {
  257. unless ($self->{input_offset}) {
  258. $self->{input_list}[$self->{input_offset}] = $self->{input_part};
  259. }
  260. $self->{input_offset}--;
  261. $self->{input_offset} = 0 if ($self->{input_offset} < 0);
  262. #$self->{input_offset} += $#{ $self->{input_list} } + 1 while $self->{input_offset} < 0;
  264. $self->{out_con}->Cursor(0, $self->{in_line});
  265. $self->{out_con}->Write(' ' x length($self->{input_part}));
  266. $self->{out_con}->Cursor(0, $self->{in_line});
  267. $self->{input_part} = $self->{input_list}[$self->{input_offset}];
  268. Utils::Win32::printConsole($self->{input_part});
  269. $self->{in_pos} = length($self->{input_part});
  270. ##Insert
  271. # } elsif ($event[3] == 45) {
  272. # __PACKAGE__->writeOutput("insertn");
  273. ##Delete
  274. } elsif ($event[3] == 46) {
  275. substr($self->{input_part}, $self->{in_pos}, 1, '');
  276. $self->{out_con}->Scroll(
  277. $self->{in_pos}, $self->{in_line}, $self->{right}, $self->{in_line},
  278. $self->{in_pos} - 1, $self->{in_line}, ord(' '), $main::ATTR_NORMAL, 
  279. $self->{in_pos}, $self->{in_line}, $self->{right}, $self->{in_line},
  280. );
  281. ##F1-F12
  282. # } elsif ($event[3] >= 112 && $event[3] <= 123) {
  283. # __PACKAGE__->writeOutput("F" . ($event[3] - 111) . "n");
  284. # } else {
  285. # __PACKAGE__->writeOutput(join '-', @event, "n");
  286. }
  287. # } else {
  288. # __PACKAGE__->writeOutput(join '-', @event, "n");
  289. }
  290. }
  291. }
  294. sub writeOutput {
  295. my ($self, $type, $message, $domain) = @_;
  297. #wrap the text
  298. local($Text::Wrap::columns) = $self->{right} - $self->{left} + 1;
  299. my ($endspace) = $message =~ /(s*)$/; #Save trailing whitespace: wrap kills spaces near wraps, especialy at the end of stings, so "n" becomes "", not what we want
  300. $message = wrap('', '', $message);
  301. $message =~ s/s*$/$endspace/; #restore the whitespace
  303. my $lines = $message =~ s/r?n/n/g; #fastest? way to count newlines
  305. #this paragraph is all about handleing lines that don't end in a newline. I have no clue how it works, even though I wrote it, but it does. =)
  306. $lines++ if (!$lines && $self->{last_line_end});
  307. if ($lines && !$self->{last_line_end}) {
  308. $lines--;
  309. $self->{out_line}--;
  310. } elsif (!$self->{last_line_end}) {
  311. $self->{out_line}--;
  312. }
  313. $self->{last_line_end} = ($message =~ /n$/) ? 1 : 0;
  315. my $ret = $self->{out_con}->Scroll(
  316. $self->{left}, 0, $self->{right}, $self->{out_bot},
  317. 0, 0-$lines, ord(' '), $main::ATTR_NORMAL, 
  318. $self->{left}, 0, $self->{right}, $self->{out_bot}
  319. );
  321. my ($ocx, $ocy) = $self->{out_con}->Cursor();
  322. $self->{out_con}->Cursor($self->{out_col}, $self->{out_line} - $lines);
  323. $self->setColor($type, $domain);
  324. #$self->{out_con}->Write($message);
  325. Utils::Win32::printConsole($message);
  326. $self->color('reset');
  327. ($self->{out_col}, $self->{out_line}) = $self->{out_con}->Cursor();
  328. $self->{out_line} -= $self->{last_line_end} - 1;
  329. $self->{out_con}->Cursor($ocx, $ocy);
  330. }
  332. sub setColor {
  333. return if (!$consoleColors{''}{'useColors'});
  334. my $self = shift;
  335. my ($type, $domain) = @_;
  336. my $color;
  337. $color = $consoleColors{$type}{$domain} if (defined $type && defined $domain && defined $consoleColors{$type});
  338. $color = $consoleColors{$type}{'default'} if (!defined $color && defined $type);
  339. $self->color($color) if (defined $color);
  340. }
  342. sub color {
  343. my $self = shift;
  344. my $color = shift;
  345. my ($bgcolor, $fgcode, $bgcode);
  346. $color =~ s//(.*)//;
  347. $bgcolor = $1 || "default";
  349. $fgcode = $fgcolors{$color} || $fgcolors{'default'};
  350. $bgcode = $bgcolors{$bgcolor} || $bgcolors{'default'};
  351. $self->{out_con}->Attr($fgcode | $bgcode);
  352. }
  354. sub title {
  355. my ($self, $title) = @_;
  357. if (defined $title) {
  358. if (!defined $self->{currentTitle} || $self->{currentTitle} ne $title) {
  359. Utils::Win32::setConsoleTitle($title);
  360. $self->{currentTitle} = $title;
  361. }
  362. } else {
  363. return $self->{out_con}->Title();
  364. }
  365. }
  367. # IRGB
  368. # 8421
  370. # Deal with ActivePerl version incompatibilities
  371. if (defined($main::ATTR_NORMAL)) {
  372. %fgcolors = (
  373. 'reset' => $main::ATTR_NORMAL,
  374. 'default' => $main::ATTR_NORMAL,
  375. 'black' => $main::FG_BLACK,
  376. 'darkgray' => FOREGROUND_INTENSITY(),
  377. 'darkgrey' => FOREGROUND_INTENSITY(),
  378. 'darkred' => $main::FG_RED,
  379. 'red' => $main::FG_LIGHTRED,
  380. 'darkgreen' => $main::FG_GREEN,
  381. 'green' => $main::FG_LIGHTGREEN,
  382. 'brown' => $main::FG_BROWN,
  383. 'yellow' => $main::FG_YELLOW,
  384. 'darkblue' => $main::FG_BLUE,
  385. 'blue' => $main::FG_LIGHTBLUE,
  386. 'darkmagenta' => $main::FG_MAGENTA,
  387. 'magenta' => $main::FG_LIGHTMAGENTA,
  388. 'darkcyan' => $main::FG_CYAN,
  389. 'cyan' => $main::FG_LIGHTCYAN,
  390. 'gray' => $main::FG_GRAY,
  391. 'grey' => $main::FG_GRAY,
  392. 'white' => $main::FG_WHITE,
  393. );
  394. } else {
  395. %fgcolors = (
  396. 'reset' => $Win32::Console::ATTR_NORMAL,
  397. 'default' => $Win32::Console::ATTR_NORMAL,
  398. 'black' => $Win32::Console::FG_BLACK,
  399. 'darkgray' => FOREGROUND_INTENSITY(),
  400. 'darkgrey' => FOREGROUND_INTENSITY(),
  401. 'darkred' => $Win32::Console::FG_RED,
  402. 'red' => $Win32::Console::FG_LIGHTRED,
  403. 'darkgreen' => $Win32::Console::FG_GREEN,
  404. 'green' => $Win32::Console::FG_LIGHTGREEN,
  405. 'brown' => $Win32::Console::FG_BROWN,
  406. 'yellow' => $Win32::Console::FG_YELLOW,
  407. 'darkblue' => $Win32::Console::FG_BLUE,
  408. 'blue' => $Win32::Console::FG_LIGHTBLUE,
  409. 'darkmagenta' => $Win32::Console::FG_MAGENTA,
  410. 'magenta' => $Win32::Console::FG_LIGHTMAGENTA,
  411. 'darkcyan' => $Win32::Console::FG_CYAN,
  412. 'cyan' => $Win32::Console::FG_LIGHTCYAN,
  413. 'gray' => $Win32::Console::FG_GRAY,
  414. 'grey' => $Win32::Console::FG_GRAY,
  415. 'white' => $Win32::Console::FG_WHITE,
  416. );
  417. }
  419. #   I  R  G  B
  420. # 128 64 32 16
  421. if (defined($main::BG_BLACK)) {
  422. %bgcolors = (
  423. '' => $main::BG_BLACK,
  424. 'default' => $main::BG_BLACK,
  425. 'black' => $main::BG_BLACK,
  426. 'darkgray' => BACKGROUND_INTENSITY(),
  427. 'darkgrey' => BACKGROUND_INTENSITY(),
  428. 'darkred' => $main::BG_RED,
  429. 'red' => $main::BG_LIGHTRED,
  430. 'darkgreen' => $main::BG_GREEN,
  431. 'green' => $main::BG_LIGHTGREEN,
  432. 'brown' => $main::BG_BROWN,
  433. 'yellow' => $main::BG_YELLOW,
  434. 'darkblue' => $main::BG_BLUE,
  435. 'blue' => $main::BG_LIGHTBLUE,
  436. 'darkmagenta' => $main::BG_MAGENTA,
  437. 'magenta' => $main::BG_LIGHTMAGENTA,
  438. 'darkcyan' => $main::BG_CYAN,
  439. 'cyan' => $main::BG_LIGHTCYAN,
  440. 'gray' => $main::BG_GRAY,
  441. 'grey' => $main::BG_GRAY,
  442. 'white' => $main::BG_WHITE,
  443. );
  444. } else {
  445. %bgcolors = (
  446. '' => $Win32::Console::BG_BLACK,
  447. 'default' => $Win32::Console::BG_BLACK,
  448. 'black' => $Win32::Console::BG_BLACK,
  449. 'darkgray' => BACKGROUND_INTENSITY(),
  450. 'darkgrey' => BACKGROUND_INTENSITY(),
  451. 'darkred' => $Win32::Console::BG_RED,
  452. 'red' => $Win32::Console::BG_LIGHTRED,
  453. 'darkgreen' => $Win32::Console::BG_GREEN,
  454. 'green' => $Win32::Console::BG_LIGHTGREEN,
  455. 'brown' => $Win32::Console::BG_BROWN,
  456. 'yellow' => $Win32::Console::BG_YELLOW,
  457. 'darkblue' => $Win32::Console::BG_BLUE,
  458. 'blue' => $Win32::Console::BG_LIGHTBLUE,
  459. 'darkmagenta' => $Win32::Console::BG_MAGENTA,
  460. 'magenta' => $Win32::Console::BG_LIGHTMAGENTA,
  461. 'darkcyan' => $Win32::Console::BG_CYAN,
  462. 'cyan' => $Win32::Console::BG_LIGHTCYAN,
  463. 'gray' => $Win32::Console::BG_GRAY,
  464. 'grey' => $Win32::Console::BG_GRAY,
  465. 'white' => $Win32::Console::BG_WHITE,
  466. );
  467. }
  470. 1 #end of module