430 lines
13 KiB
C++
430 lines
13 KiB
C++
/*
|
|
https://github.com/peterix/dfhack
|
|
Copyright (c) 2009-2011 Petr Mrázek (peterix@gmail.com)
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any
|
|
damages arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any
|
|
purpose, including commercial applications, and to alter it and
|
|
redistribute it freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must
|
|
not claim that you wrote the original software. If you use this
|
|
software in a product, an acknowledgment in the product documentation
|
|
would be appreciated but is not required.
|
|
|
|
2. Altered source versions must be plainly marked as such, and
|
|
must not be misrepresented as being the original software.
|
|
|
|
3. This notice may not be removed or altered from any source
|
|
distribution.
|
|
*/
|
|
|
|
/*
|
|
Some functions are based on the linenoise win32 port:
|
|
|
|
linenoise_win32.c -- Linenoise win32 port.
|
|
|
|
Modifications copyright 2010, Jon Griffiths <jon_p_griffiths at yahoo dot com>.
|
|
All rights reserved.
|
|
Based on linenoise, copyright 2010, Salvatore Sanfilippo <antirez at gmail dot com>.
|
|
The original linenoise can be found at: http://github.com/antirez/linenoise
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
* Neither the name of Redis nor the names of its contributors may be used
|
|
to endorse or promote products derived from this software without
|
|
specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
|
|
#include <windows.h>
|
|
#include <conio.h>
|
|
#include <stdarg.h>
|
|
|
|
#include "dfhack/extra/stdiostream.h"
|
|
#include < process.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <io.h>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <istream>
|
|
#include <string>
|
|
|
|
#include "dfhack/Console.h"
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <sstream>
|
|
#include <deque>
|
|
using namespace DFHack;
|
|
|
|
// FIXME: maybe make configurable with an ini option?
|
|
#define MAX_CONSOLE_LINES 999;
|
|
|
|
namespace DFHack
|
|
{
|
|
class Private
|
|
{
|
|
public:
|
|
Private()
|
|
{
|
|
dfout_C = 0;
|
|
stream_o = 0;
|
|
rawmode = 0;
|
|
console_in = 0;
|
|
console_out = 0;
|
|
ConsoleWindow = 0;
|
|
default_attributes = 0;
|
|
};
|
|
void output(const char* str, size_t len, int x, int y)
|
|
{
|
|
COORD pos = { (SHORT)x, (SHORT)y };
|
|
DWORD count = 0;
|
|
WriteConsoleOutputCharacterA(console_out, str, len, pos, &count);
|
|
}
|
|
|
|
FILE * dfout_C;
|
|
duthomhas::stdiobuf * stream_o;
|
|
int rawmode; /* for atexit() function to check if restore is needed*/
|
|
std::deque <std::string> history;
|
|
|
|
HANDLE console_in;
|
|
HANDLE console_out;
|
|
HWND ConsoleWindow;
|
|
WORD default_attributes;
|
|
};
|
|
}
|
|
|
|
|
|
Console::Console():std::ostream(0), std::ios(0)
|
|
{
|
|
d = 0;
|
|
}
|
|
|
|
Console::~Console()
|
|
{
|
|
}
|
|
|
|
bool Console::init(void)
|
|
{
|
|
d = new Private();
|
|
int hConHandle;
|
|
long lStdHandle;
|
|
CONSOLE_SCREEN_BUFFER_INFO coninfo;
|
|
FILE *fp;
|
|
DWORD oldMode, newMode;
|
|
|
|
// Allocate a console!
|
|
AllocConsole();
|
|
d->ConsoleWindow = GetConsoleWindow();
|
|
HMENU hm = GetSystemMenu(d->ConsoleWindow,false);
|
|
DeleteMenu(hm, SC_CLOSE, MF_BYCOMMAND);
|
|
|
|
// set the screen buffer to be big enough to let us scroll text
|
|
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &coninfo);
|
|
d->default_attributes = coninfo.wAttributes;
|
|
coninfo.dwSize.Y = MAX_CONSOLE_LINES; // How many lines do you want to have in the console buffer
|
|
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), coninfo.dwSize);
|
|
|
|
// redirect unbuffered STDOUT to the console
|
|
d->console_out = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
lStdHandle = (long)d->console_out;
|
|
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
|
|
d->dfout_C = _fdopen( hConHandle, "w" );
|
|
setvbuf( d->dfout_C, NULL, _IONBF, 0 );
|
|
|
|
// redirect unbuffered STDIN to the console
|
|
d->console_in = GetStdHandle(STD_INPUT_HANDLE);
|
|
lStdHandle = (long)d->console_in;
|
|
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
|
|
fp = _fdopen( hConHandle, "r" );
|
|
*stdin = *fp;
|
|
setvbuf( stdin, NULL, _IONBF, 0 );
|
|
GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE),&oldMode);
|
|
newMode = oldMode | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT;
|
|
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE),newMode);
|
|
std::ios::sync_with_stdio();
|
|
|
|
// make our own weird streams so our IO isn't redirected
|
|
d->stream_o = new duthomhas::stdiobuf(d->dfout_C);
|
|
rdbuf(d->stream_o);
|
|
std::cin.tie(this);
|
|
clear();
|
|
return true;
|
|
}
|
|
|
|
bool Console::shutdown(void)
|
|
{
|
|
FreeConsole();
|
|
return true;
|
|
}
|
|
|
|
int Console::print( const char* format, ... )
|
|
{
|
|
va_list args;
|
|
va_start( args, format );
|
|
int ret = vfprintf( d->dfout_C, format, args );
|
|
va_end( args );
|
|
return ret;
|
|
}
|
|
|
|
int Console::get_columns(void)
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO inf = { 0 };
|
|
GetConsoleScreenBufferInfo(d->console_out, &inf);
|
|
return (size_t)inf.dwSize.X;
|
|
}
|
|
|
|
int Console::get_rows(void)
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO inf = { 0 };
|
|
GetConsoleScreenBufferInfo(d->console_out, &inf);
|
|
return (size_t)inf.dwSize.Y;
|
|
}
|
|
|
|
void Console::clear()
|
|
{
|
|
system("cls");
|
|
}
|
|
|
|
void Console::gotoxy(int x, int y)
|
|
{
|
|
COORD coord = {x-1, y-1}; // Windows uses 0-based coordinates
|
|
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
|
|
}
|
|
|
|
void Console::color(int index)
|
|
{
|
|
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
SetConsoleTextAttribute(hConsole, index);
|
|
}
|
|
|
|
void Console::reset_color( void )
|
|
{
|
|
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
SetConsoleTextAttribute(hConsole, d->default_attributes);
|
|
}
|
|
|
|
|
|
void Console::cursor(bool enable)
|
|
{
|
|
if(enable)
|
|
{
|
|
HANDLE hConsoleOutput;
|
|
CONSOLE_CURSOR_INFO structCursorInfo;
|
|
hConsoleOutput = GetStdHandle( STD_OUTPUT_HANDLE );
|
|
GetConsoleCursorInfo( hConsoleOutput, &structCursorInfo ); // Get current cursor size
|
|
structCursorInfo.bVisible = TRUE;
|
|
SetConsoleCursorInfo( hConsoleOutput, &structCursorInfo );
|
|
}
|
|
else
|
|
{
|
|
HANDLE hConsoleOutput;
|
|
CONSOLE_CURSOR_INFO structCursorInfo;
|
|
hConsoleOutput = GetStdHandle( STD_OUTPUT_HANDLE );
|
|
GetConsoleCursorInfo( hConsoleOutput, &structCursorInfo ); // Get current cursor size
|
|
structCursorInfo.bVisible = FALSE;
|
|
SetConsoleCursorInfo( hConsoleOutput, &structCursorInfo );
|
|
}
|
|
}
|
|
|
|
void Console::msleep (unsigned int msec)
|
|
{
|
|
Sleep(msec);
|
|
}
|
|
|
|
int Console::enable_raw()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void Console::disable_raw()
|
|
{
|
|
/* Nothing to do yet */
|
|
}
|
|
|
|
void Console::prompt_refresh( const std::string& prompt, const std::string& buffer, size_t pos)
|
|
{
|
|
size_t cols = get_columns();
|
|
size_t plen = prompt.size();
|
|
const char * buf = buffer.c_str();
|
|
size_t len = buffer.size();
|
|
|
|
while ((plen + pos) >= cols)
|
|
{
|
|
buf++;
|
|
len--;
|
|
pos--;
|
|
}
|
|
while (plen + len > cols)
|
|
{
|
|
len--;
|
|
}
|
|
|
|
CONSOLE_SCREEN_BUFFER_INFO inf = { 0 };
|
|
GetConsoleScreenBufferInfo(d->console_out, &inf);
|
|
d->output(prompt.c_str(), plen, 0, inf.dwCursorPosition.Y);
|
|
d->output(buf, len, plen, inf.dwCursorPosition.Y);
|
|
if (plen + len < (size_t)inf.dwSize.X)
|
|
{
|
|
/* Blank to EOL */
|
|
char* tmp = (char*)malloc(inf.dwSize.X - (plen + len));
|
|
memset(tmp, ' ', inf.dwSize.X - (plen + len));
|
|
d->output(tmp, inf.dwSize.X - (plen + len), len + plen, inf.dwCursorPosition.Y);
|
|
free(tmp);
|
|
}
|
|
inf.dwCursorPosition.X = (SHORT)(pos + plen);
|
|
SetConsoleCursorPosition(d->console_out, inf.dwCursorPosition);
|
|
}
|
|
|
|
int Console::prompt_loop(const std::string & prompt, std::string & buffer)
|
|
{
|
|
buffer.clear(); // make sure the buffer is empty!
|
|
size_t plen = prompt.size();
|
|
size_t pos = 0;
|
|
int history_index = 0;
|
|
/* The latest history entry is always our current buffer, that
|
|
* initially is just an empty string. */
|
|
const std::string empty;
|
|
history_add(empty);
|
|
|
|
CONSOLE_SCREEN_BUFFER_INFO inf = { 0 };
|
|
GetConsoleScreenBufferInfo(d->console_out, &inf);
|
|
size_t cols = inf.dwSize.X;
|
|
d->output(prompt.c_str(), plen, 0, inf.dwCursorPosition.Y);
|
|
inf.dwCursorPosition.X = (SHORT)plen;
|
|
SetConsoleCursorPosition(d->console_out, inf.dwCursorPosition);
|
|
|
|
while (1)
|
|
{
|
|
INPUT_RECORD rec;
|
|
DWORD count;
|
|
ReadConsoleInputA(d->console_in, &rec, 1, &count);
|
|
if (rec.EventType != KEY_EVENT || !rec.Event.KeyEvent.bKeyDown)
|
|
continue;
|
|
switch (rec.Event.KeyEvent.wVirtualKeyCode)
|
|
{
|
|
case VK_RETURN: // enter
|
|
d->history.pop_front();
|
|
return buffer.size();
|
|
case VK_BACK: // backspace
|
|
if (pos > 0 && buffer.size() > 0)
|
|
{
|
|
buffer.erase(pos-1,1);
|
|
pos--;
|
|
prompt_refresh(prompt,buffer,pos);
|
|
}
|
|
break;
|
|
case VK_LEFT: // left arrow
|
|
if (pos > 0)
|
|
{
|
|
pos--;
|
|
prompt_refresh(prompt,buffer,pos);
|
|
}
|
|
break;
|
|
case VK_RIGHT: // right arrow
|
|
if (pos != buffer.size())
|
|
{
|
|
pos++;
|
|
prompt_refresh(prompt,buffer,pos);
|
|
}
|
|
break;
|
|
case VK_UP:
|
|
case VK_DOWN:
|
|
/* up and down arrow: history */
|
|
if (d->history.size() > 1)
|
|
{
|
|
/* Update the current history entry before to
|
|
* overwrite it with tne next one. */
|
|
d->history[history_index] = buffer;
|
|
/* Show the new entry */
|
|
history_index += (rec.Event.KeyEvent.wVirtualKeyCode == VK_UP) ? 1 : -1;
|
|
if (history_index < 0)
|
|
{
|
|
history_index = 0;
|
|
break;
|
|
}
|
|
else if (history_index >= d->history.size())
|
|
{
|
|
history_index = d->history.size()-1;
|
|
break;
|
|
}
|
|
buffer = d->history[history_index];
|
|
pos = buffer.size();
|
|
prompt_refresh(prompt,buffer,pos);
|
|
}
|
|
break;
|
|
case VK_DELETE:
|
|
// delete
|
|
if (buffer.size() > 0 && pos < buffer.size())
|
|
{
|
|
buffer.erase(pos,1);
|
|
prompt_refresh(prompt,buffer,pos);
|
|
}
|
|
break;
|
|
case VK_HOME:
|
|
pos = 0;
|
|
prompt_refresh(prompt,buffer,pos);
|
|
break;
|
|
case VK_END:
|
|
pos = buffer.size();
|
|
prompt_refresh(prompt,buffer,pos);
|
|
break;
|
|
default:
|
|
if (rec.Event.KeyEvent.uChar.AsciiChar < ' ' ||
|
|
rec.Event.KeyEvent.uChar.AsciiChar > '~')
|
|
continue;
|
|
if (buffer.size() == pos)
|
|
buffer.append(1,rec.Event.KeyEvent.uChar.AsciiChar);
|
|
else
|
|
buffer.insert(pos,1,rec.Event.KeyEvent.uChar.AsciiChar);
|
|
pos++;
|
|
prompt_refresh(prompt,buffer,pos);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// push to front, remove from back if we are above maximum. ignore immediate duplicates
|
|
void Console::history_add(const std::string & command)
|
|
{
|
|
if(d->history.front() == command)
|
|
return;
|
|
d->history.push_front(command);
|
|
if(d->history.size() > 100)
|
|
d->history.pop_back();
|
|
}
|
|
|
|
int Console::lineedit(const std::string & prompt, std::string & output)
|
|
{
|
|
output.clear();
|
|
int count;
|
|
if (enable_raw() == -1)
|
|
return -1;
|
|
count = prompt_loop(prompt,output);
|
|
disable_raw();
|
|
*this << std::endl;
|
|
return count;
|
|
} |