// Code from http://dslweb.nwnexus.com/~ast/dload/guicon.htm
// Andrew Tucker, no license, assumed to be public domain.
void wxlua_RedirectIOToDosConsole(bool alloc_new_if_needed, short max_console_lines)
{
int hConHandle = 0;
long lStdHandle = 0;
CONSOLE_SCREEN_BUFFER_INFO coninfo;
memset(&coninfo, 0, sizeof(CONSOLE_SCREEN_BUFFER_INFO));
FILE *fp = 0; // we don't close this, let the OS close it when the app exits
wxDynamicLibrary kernel;
// Dynamically load kernel32 because AttachConsole() is not supported pre-XP
BOOL attached_ok = kernel.Load(wxT("kernel32.dll"));
if (attached_ok)
{
// Try to attach to the parent process if it's a console, i.e. we're run from a DOS prompt.
// The code below is equivalent to calling this code:
// BOOL attached_ok = AttachConsole( ATTACH_PARENT_PROCESS );
typedef BOOL (WINAPI *AttachConsole_t)(DWORD dwProcessId);
AttachConsole_t wxDL_INIT_FUNC(pfn, AttachConsole, kernel);
if (pfnAttachConsole)
attached_ok = pfnAttachConsole( ATTACH_PARENT_PROCESS );
else
attached_ok = 0;
}
if (attached_ok == 0) // failed attaching
{
// we tried to attach, but failed don't alloc a new one
if (!alloc_new_if_needed)
return;
// Unable to attach, allocate a console for this app
AllocConsole();
}
// set the screen buffer to be big enough to let us scroll text
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &coninfo);
coninfo.dwSize.Y = (WORD)max_console_lines;
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), coninfo.dwSize);
// redirect unbuffered STDOUT to the console
lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "w" );
*stdout = *fp;
setvbuf( stdout, NULL, _IONBF, 0 );
// redirect unbuffered STDIN to the console
lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "r" );
*stdin = *fp;
setvbuf( stdin, NULL, _IONBF, 0 );
// redirect unbuffered STDERR to the console
lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "w" );
*stderr = *fp;
setvbuf( stderr, NULL, _IONBF, 0 );
// make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
// point to console as well
std::ios::sync_with_stdio();
}
void RedirectIOToConsole()
{
// allocate a console for this app
bool br = AllocConsole() == TRUE;
if (!br) return;
//assert( br );
CONSOLE_SCREEN_BUFFER_INFO coninfo = { 0 };
// set the screen buffer to be big enough to let us scroll text
br = GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &coninfo) == TRUE;
assert( br );
coninfo.dwSize.Y = MAX_CONSOLE_LINES;
br = SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), coninfo.dwSize) == TRUE;
assert( br );
// redirect unbuffered STDOUT to the console
HANDLE lStdHandle = GetStdHandle(STD_OUTPUT_HANDLE);
assert( lStdHandle != INVALID_HANDLE_VALUE );
assert( lStdHandle != NULL );
int hConHandle = _open_osfhandle((intptr_t)lStdHandle, _O_TEXT);
assert( hConHandle != -1 );
FILE *fp = _fdopen( hConHandle, "w" );
assert(fp);
*stdout = *fp;
int ir = setvbuf( stdout, NULL, _IONBF, 0 );
assert( ir ==0 );
// redirect unbuffered STDIN to the console
lStdHandle = GetStdHandle(STD_INPUT_HANDLE);
hConHandle = _open_osfhandle((intptr_t)lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "r" );
*stdin = *fp;
ir = setvbuf( stdin, NULL, _IONBF, 0 );
assert( ir ==0 );
// redirect unbuffered STDERR to the console
lStdHandle = GetStdHandle(STD_ERROR_HANDLE);
hConHandle = _open_osfhandle((intptr_t)lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "w" );
*stderr = *fp;
ir = setvbuf( stderr, NULL, _IONBF, 0 );
assert( ir ==0 );
// make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
// point to console as well
std::ios::sync_with_stdio( true );
}
/*
==============
SetConsoleCXCY
==============
*/
BOOL SetConsoleCXCY(HANDLE hStdout, int cx, int cy)
{
CONSOLE_SCREEN_BUFFER_INFO info;
COORD coordMax;
coordMax = GetLargestConsoleWindowSize(hStdout);
if (cy > coordMax.Y)
cy = coordMax.Y;
if (cx > coordMax.X)
cx = coordMax.X;
if (!GetConsoleScreenBufferInfo(hStdout, &info))
return FALSE;
// height
info.srWindow.Left = 0;
info.srWindow.Right = info.dwSize.X - 1;
info.srWindow.Top = 0;
info.srWindow.Bottom = cy - 1;
if (cy < info.dwSize.Y)
{
if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
return FALSE;
info.dwSize.Y = cy;
if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
return FALSE;
}
else if (cy > info.dwSize.Y)
{
info.dwSize.Y = cy;
if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
return FALSE;
if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
return FALSE;
}
if (!GetConsoleScreenBufferInfo(hStdout, &info))
return FALSE;
// width
info.srWindow.Left = 0;
info.srWindow.Right = cx - 1;
info.srWindow.Top = 0;
info.srWindow.Bottom = info.dwSize.Y - 1;
if (cx < info.dwSize.X)
{
if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
return FALSE;
info.dwSize.X = cx;
if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
return FALSE;
}
else if (cx > info.dwSize.X)
{
info.dwSize.X = cx;
if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
return FALSE;
if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
return FALSE;
}
return TRUE;
}
//! constructor
CIrrDeviceConsole::CIrrDeviceConsole(const SIrrlichtCreationParameters& params)
: CIrrDeviceStub(params), IsDeviceRunning(true), IsWindowFocused(true), ConsoleFont(0), OutFile(stdout)
{
DeviceToClose = this;
#ifdef _IRR_WINDOWS_NT_CONSOLE_
MouseButtonStates = 0;
WindowsSTDIn = GetStdHandle(STD_INPUT_HANDLE);
WindowsSTDOut = GetStdHandle(STD_OUTPUT_HANDLE);
PCOORD Dimensions = 0;
if (CreationParams.Fullscreen)
{
if (SetConsoleDisplayMode(WindowsSTDOut, CONSOLE_FULLSCREEN_MODE, Dimensions))
{
CreationParams.WindowSize.Width = Dimensions->X;
CreationParams.WindowSize.Width = Dimensions->Y;
}
}
else
{
COORD ConsoleSize;
ConsoleSize.X = CreationParams.WindowSize.Width;
ConsoleSize.X = CreationParams.WindowSize.Height;
SetConsoleScreenBufferSize(WindowsSTDOut, ConsoleSize);
}
// catch windows close/break signals
SetConsoleCtrlHandler((PHANDLER_ROUTINE)ConsoleHandler, TRUE);
#elif defined(_IRR_POSIX_API_)
// catch other signals
signal(SIGABRT, &sighandler);
signal(SIGTERM, &sighandler);
signal(SIGINT, &sighandler);
// set output stream
if (params.WindowId)
OutFile = (FILE*)(params.WindowId);
#endif
#ifdef _IRR_VT100_CONSOLE_
// reset terminal
fprintf(OutFile, "%cc", 27);
// disable line wrapping
fprintf(OutFile, "%c[7l", 27);
#endif
switch (params.DriverType)
{
case video::EDT_SOFTWARE:
#ifdef _IRR_COMPILE_WITH_SOFTWARE_
VideoDriver = video::createSoftwareDriver(CreationParams.WindowSize, CreationParams.Fullscreen, FileSystem, this);
#else
os::Printer::log("Software driver was not compiled in.", ELL_ERROR);
#endif
break;
case video::EDT_BURNINGSVIDEO:
#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
VideoDriver = video::createSoftwareDriver2(CreationParams.WindowSize, CreationParams.Fullscreen, FileSystem, this);
#else
os::Printer::log("Burning's Video driver was not compiled in.", ELL_ERROR);
#endif
break;
case video::EDT_DIRECT3D8:
case video::EDT_DIRECT3D9:
case video::EDT_OPENGL:
os::Printer::log("The console device cannot use hardware drivers yet.", ELL_ERROR);
break;
case video::EDT_NULL:
VideoDriver = video::createNullDriver(FileSystem, CreationParams.WindowSize);
break;
default:
break;
}
// set up output buffer
for (u32 y=0; y<CreationParams.WindowSize.Height; ++y)
{
core::stringc str;
str.reserve(CreationParams.WindowSize.Width);
for (u32 x=0; x<CreationParams.WindowSize.Width; ++x)
str += " ";
OutputBuffer.push_back(str);
}
#ifdef _IRR_WINDOWS_NT_CONSOLE_
CursorControl = new CCursorControl(CreationParams.WindowSize);
#endif
if (VideoDriver)
{
createGUIAndScene();
#ifdef _IRR_USE_CONSOLE_FONT_
if (GUIEnvironment)
{
ConsoleFont = new gui::CGUIConsoleFont(this);
gui::IGUISkin *skin = GUIEnvironment->getSkin();
if (skin)
{
for (u32 i=0; i < gui::EGDF_COUNT; ++i)
skin->setFont(ConsoleFont, gui::EGUI_DEFAULT_FONT(i));
}
}
#endif
}
}
int main() {
//set window
BOOL bRtn;
HANDLE hand;
CONSOLE_SCREEN_BUFFER_INFO info;
COORD dwCoord = { 100, 40 };
SMALL_RECT rctWindowRect = { 0, 0, 30, 35 };
hand = GetStdHandle(STD_OUTPUT_HANDLE);
bRtn = SetConsoleScreenBufferSize(hand, dwCoord);
bRtn = SetConsoleWindowInfo(hand, TRUE, &rctWindowRect);
//initialization
t = time(NULL);
buff = false;
memset(field, 0, sizeof(field)); // initialize field
//use ASCII art to count down
system("cls");
int i = 3;
while (i > 0) {
if (t != time(NULL)) {
system("cls");
for (int j = 0; j < ASCII_HEIGHT; j++) {
for (int k = 0; k < ASCII_WIDTH; k++)
printf(ASCII[i - 1][j][k] ? "■" : " ");
printf("\n");
}
i--;
t = time(NULL);
}
}
//prepare frame
for (int i = 0; i < FIELD_HEIGHT; i++)
field[i][0] = field[i][FIELD_WIDTH - 1] = 1;
for (int i = 0; i < FIELD_HEIGHT; i++)
field[FIELD_HEIGHT - 1][i] = 1;
resetMino();
while (1) {
if (_kbhit()) {
switch (_getch()) {
case 0x1b: //hit esc to exit
return 0;
case 0x20: //hit space to restart
main();
return 0; //end old game
case 'j':
if (!isHit(
minoX,
minoY + 1,
minoType,
minoAngle))
minoY++;
break;
case 'h':
if (!isHit(
minoX - 1,
minoY,
minoType,
minoAngle))
minoX--;
break;
case 'l':
if (!isHit(
minoX + 1,
minoY,
minoType,
minoAngle))
minoX++;
break;
case 'k':
if (!isHit(
minoX,
minoY,
minoType,
(minoAngle + 1) % MINO_ANGLE_MAX))
minoAngle = (minoAngle + 1) % MINO_ANGLE_MAX;
break;
case 'r':
if (!isHit(
minoX,
minoY,
minoType,
minoAngle))
store();
break;
}
display();
}
if (t != time(NULL)) {
t = time(NULL);
if (isHit(minoX, minoY + 1, minoType, minoAngle))
{
for (int i = 0; i < MINO_HEIGHT; i++)
for (int j = 0; j < MINO_WIDTH; j++)
//if mino hit the block beneath it, fix it as a field
field[minoY + i][minoX + j] |= minoShapes[minoType][minoAngle][i][j];
for (int i = 0; i < FIELD_HEIGHT - 1; i++) {
bool lineFill = true;
for (int j = 0; j < FIELD_WIDTH - 1; j++) {
if (!field[i][j])
lineFill = false;
}
if (lineFill) {
for (int j = i; 0 < j; j--)
memcpy(field[j], field[j - 1], FIELD_WIDTH);
}
}
resetMino();
}
else
minoY++;
display();
}
}
return 0;
}
co_rc_t
console_widget_NT_t::set_window(console_window_t * W)
{
CONSOLE_CURSOR_INFO cci;
CONSOLE_FONT_INFO cfi;
COORD fs;
HWND hwnd;
RECT r;
window = W;
input = GetStdHandle(STD_INPUT_HANDLE);
SetConsoleMode(input, 0);
output = GetStdHandle(STD_OUTPUT_HANDLE);
GetCurrentConsoleFont(output, 0, &cfi);
fs = GetConsoleFontSize(output, cfi.nFont);
r.top = 0;
r.left = 0;
r.bottom = fs.Y * 25;
r.right = fs.X * 80;
AdjustWindowRect(&r, WS_CAPTION|WS_SYSMENU|WS_THICKFRAME
|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, 0);
hwnd = GetConsoleWindow();
SetWindowPos(hwnd, HWND_TOP, 0, 0,
r.right - r.left, r.bottom - r.top,
SWP_NOMOVE|SWP_SHOWWINDOW);
GetConsoleCursorInfo(output, &cursor);
cci = cursor;
cci.bVisible = 0;
SetConsoleCursorInfo(output, &cci);
size.X = 80 ;
size.Y = 25 ;
region.Top = 0;
region.Left = 0;
region.Right = 79;
region.Bottom = 24;
if( ! SetConsoleWindowInfo( output , TRUE , ®ion ) )
co_debug("SetConsoleWindowInfo() error 0x%lx", GetLastError());
screen =
(CHAR_INFO *) co_os_malloc(sizeof (CHAR_INFO) * size.X * size.Y);
buffer =
CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0, 0,
CONSOLE_TEXTMODE_BUFFER, 0);
if( ! SetConsoleScreenBufferSize( buffer , size ) )
co_debug("SetConsoleScreenBufferSize() error 0x%lx", GetLastError());
SetConsoleMode(buffer, 0);
cci.bVisible = true;
cci.dwSize = 10;
SetConsoleCursorInfo(buffer, &cci);
SetConsoleActiveScreenBuffer(buffer);
return CO_RC(OK);
}
/*
* call-seq:
* io.winsize = [rows, columns]
*
* Tries to set console size. The effect depends on the platform and
* the running environment.
*
* You must require 'io/console' to use this method.
*/
static VALUE
console_set_winsize(VALUE io, VALUE size)
{
rb_io_t *fptr;
rb_console_size_t ws;
#if defined _WIN32
HANDLE wh;
int newrow, newcol;
#endif
VALUE row, col, xpixel, ypixel;
const VALUE *sz;
int fd;
long sizelen;
GetOpenFile(io, fptr);
size = rb_Array(size);
if ((sizelen = RARRAY_LEN(size)) != 2 && sizelen != 4) {
rb_raise(rb_eArgError,
"wrong number of arguments (given %ld, expected 2 or 4)",
sizelen);
}
sz = RARRAY_CONST_PTR(size);
row = sz[0], col = sz[1], xpixel = ypixel = Qnil;
if (sizelen == 4) xpixel = sz[2], ypixel = sz[3];
fd = GetWriteFD(fptr);
#if defined TIOCSWINSZ
ws.ws_row = ws.ws_col = ws.ws_xpixel = ws.ws_ypixel = 0;
#define SET(m) ws.ws_##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m)
SET(row);
SET(col);
SET(xpixel);
SET(ypixel);
#undef SET
if (!setwinsize(fd, &ws)) rb_sys_fail(0);
#elif defined _WIN32
wh = (HANDLE)rb_w32_get_osfhandle(fd);
#define SET(m) new##m = NIL_P(m) ? 0 : (unsigned short)NUM2UINT(m)
SET(row);
SET(col);
#undef SET
if (!NIL_P(xpixel)) (void)NUM2UINT(xpixel);
if (!NIL_P(ypixel)) (void)NUM2UINT(ypixel);
if (!GetConsoleScreenBufferInfo(wh, &ws)) {
rb_syserr_fail(LAST_ERROR, "GetConsoleScreenBufferInfo");
}
if ((ws.dwSize.X < newcol && (ws.dwSize.X = newcol, 1)) ||
(ws.dwSize.Y < newrow && (ws.dwSize.Y = newrow, 1))) {
if (!SetConsoleScreenBufferSize(wh, ws.dwSize)) {
rb_syserr_fail(LAST_ERROR, "SetConsoleScreenBufferInfo");
}
}
ws.srWindow.Left = 0;
ws.srWindow.Top = 0;
ws.srWindow.Right = newcol;
ws.srWindow.Bottom = newrow;
if (!SetConsoleWindowInfo(wh, FALSE, &ws.srWindow)) {
rb_syserr_fail(LAST_ERROR, "SetConsoleWindowInfo");
}
#endif
return io;
}
int RunDebugger()
{
if (!gpSrv->DbgInfo.pDebugTreeProcesses)
{
gpSrv->DbgInfo.pDebugTreeProcesses = (MMap<DWORD,CEDebugProcessInfo>*)calloc(1,sizeof(*gpSrv->DbgInfo.pDebugTreeProcesses));
gpSrv->DbgInfo.pDebugTreeProcesses->Init(1024);
}
UpdateDebuggerTitle();
// Если это новая консоль - увеличить ее размер, для удобства
if (IsWindowVisible(ghConWnd))
{
HANDLE hCon = ghConOut;
CONSOLE_SCREEN_BUFFER_INFO csbi = {};
GetConsoleScreenBufferInfo(hCon, &csbi);
if (csbi.dwSize.X < 260)
{
COORD crNewSize = {260, 9999};
SetConsoleScreenBufferSize(ghConOut, crNewSize);
}
//if ((csbi.srWindow.Right - csbi.srWindow.Left + 1) < 120)
//{
// COORD crMax = GetLargestConsoleWindowSize(hCon);
// if ((crMax.X - 10) > (csbi.srWindow.Right - csbi.srWindow.Left + 1))
// {
// COORD crSize = {((int)((crMax.X - 15)/10))*10, min(crMax.Y, (csbi.srWindow.Bottom - csbi.srWindow.Top + 1))};
// SMALL_RECT srWnd = {0, csbi.srWindow.Top, crSize.X - 1, csbi.srWindow.Bottom};
// MONITORINFO mi = {sizeof(mi)};
// GetMonitorInfo(MonitorFromWindow(ghConWnd, MONITOR_DEFAULTTONEAREST), &mi);
// RECT rcWnd = {}; GetWindowRect(ghConWnd, &rcWnd);
// SetWindowPos(ghConWnd, NULL, min(rcWnd.left,(mi.rcWork.left+50)), rcWnd.top, 0,0, SWP_NOSIZE|SWP_NOZORDER);
// SetConsoleSize(9999, crSize, srWnd, "StartDebugger");
// }
//}
}
// Вывести в консоль информацию о версии.
PrintVersion();
#ifdef SHOW_DEBUG_STARTED_MSGBOX
wchar_t szInfo[128];
StringCchPrintf(szInfo, countof(szInfo), L"Attaching debugger...\n" CE_CONEMUC_NAME_W " PID = %u\nDebug PID = %u",
GetCurrentProcessId(), gpSrv->dwRootProcess);
MessageBox(GetConEmuHWND(2), szInfo, CE_CONEMUC_NAME_W L".Debugger", 0);
#endif
if (gpSrv->DbgInfo.pszDebuggingCmdLine == NULL)
{
int iAttachRc = AttachRootProcessHandle();
if (iAttachRc != 0)
return iAttachRc;
}
else
{
_ASSERTE(!gpSrv->DbgInfo.bDebuggerActive);
}
gpszRunCmd = (wchar_t*)calloc(1,sizeof(*gpszRunCmd));
if (!gpszRunCmd)
{
_printf("Can't allocate 1 wchar!\n");
return CERR_NOTENOUGHMEM1;
}
_ASSERTE(((gpSrv->hRootProcess!=NULL) || (gpSrv->DbgInfo.pszDebuggingCmdLine!=NULL)) && "Process handle must be opened");
// Если просили сделать дамп нескольких процессов - нужно сразу уточнить его тип
if (gpSrv->DbgInfo.bDebugMultiProcess && (gpSrv->DbgInfo.nDebugDumpProcess == 1))
{
// 2 - minidump, 3 - fulldump
int nConfirmDumpType = ConfirmDumpType(gpSrv->dwRootProcess, NULL);
if (nConfirmDumpType < 2)
{
// Отмена
return CERR_CANTSTARTDEBUGGER;
}
gpSrv->DbgInfo.nDebugDumpProcess = nConfirmDumpType;
}
// gpSrv->DbgInfo.bDebuggerActive must be set in DebugThread
// Run DebugThread
gpSrv->DbgInfo.hDebugReady = CreateEvent(NULL, FALSE, FALSE, NULL);
// Перенес обработку отладочных событий в отдельную нить, чтобы случайно не заблокироваться с главной
gpSrv->DbgInfo.hDebugThread = CreateThread(NULL, 0, DebugThread, NULL, 0, &gpSrv->DbgInfo.dwDebugThreadId);
HANDLE hEvents[2] = {gpSrv->DbgInfo.hDebugReady, gpSrv->DbgInfo.hDebugThread};
DWORD nReady = WaitForMultipleObjects(countof(hEvents), hEvents, FALSE, INFINITE);
if (nReady != WAIT_OBJECT_0)
{
DWORD nExit = 0;
GetExitCodeThread(gpSrv->DbgInfo.hDebugThread, &nExit);
return nExit;
}
// gpSrv->DbgInfo.bDebuggerActive was set in DebugThread
// And wait for debugger thread completion
_ASSERTE(gnRunMode == RM_UNDEFINED);
DWORD nDebugThread = WaitForSingleObject(gpSrv->DbgInfo.hDebugThread, INFINITE);
_ASSERTE(nDebugThread == WAIT_OBJECT_0); UNREFERENCED_PARAMETER(nDebugThread);
gbInShutdown = TRUE;
return 0;
}
/**
* This function initializes libcaca vout method.
*/
static int Open(vlc_object_t *object)
{
vout_display_t *vd = (vout_display_t *)object;
vout_display_sys_t *sys;
#if !defined(__APPLE__) && !defined(WIN32)
# ifndef X_DISPLAY_MISSING
if (!vlc_xlib_init(object))
return VLC_EGENERIC;
# endif
#endif
#if defined(WIN32)
CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
SMALL_RECT rect;
COORD coord;
HANDLE hstdout;
if (!AllocConsole()) {
msg_Err(vd, "cannot create console");
return VLC_EGENERIC;
}
hstdout =
CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
if (!hstdout || hstdout == INVALID_HANDLE_VALUE) {
msg_Err(vd, "cannot create screen buffer");
FreeConsole();
return VLC_EGENERIC;
}
if (!SetConsoleActiveScreenBuffer(hstdout)) {
msg_Err(vd, "cannot set active screen buffer");
FreeConsole();
return VLC_EGENERIC;
}
coord = GetLargestConsoleWindowSize(hstdout);
msg_Dbg(vd, "SetConsoleWindowInfo: %ix%i", coord.X, coord.Y);
/* Force size for now */
coord.X = 100;
coord.Y = 40;
if (!SetConsoleScreenBufferSize(hstdout, coord))
msg_Warn(vd, "SetConsoleScreenBufferSize %i %i",
coord.X, coord.Y);
/* Get the current screen buffer size and window position. */
if (GetConsoleScreenBufferInfo(hstdout, &csbiInfo)) {
rect.Top = 0; rect.Left = 0;
rect.Right = csbiInfo.dwMaximumWindowSize.X - 1;
rect.Bottom = csbiInfo.dwMaximumWindowSize.Y - 1;
if (!SetConsoleWindowInfo(hstdout, TRUE, &rect))
msg_Dbg(vd, "SetConsoleWindowInfo failed: %ix%i",
rect.Right, rect.Bottom);
}
#endif
/* Allocate structure */
vd->sys = sys = calloc(1, sizeof(*sys));
if (!sys)
goto error;
sys->cv = cucul_create_canvas(0, 0);
if (!sys->cv) {
msg_Err(vd, "cannot initialize libcucul");
goto error;
}
const char *driver = NULL;
#ifdef __APPLE__
// Make sure we don't try to open a window.
driver = "ncurses";
#endif
sys->dp = caca_create_display_with_driver(sys->cv, driver);
if (!sys->dp) {
msg_Err(vd, "cannot initialize libcaca");
goto error;
}
vout_display_DeleteWindow(vd, NULL);
if (vd->cfg->display.title)
caca_set_display_title(sys->dp,
vd->cfg->display.title);
else
caca_set_display_title(sys->dp,
VOUT_TITLE "(Colour AsCii Art)");
/* Fix format */
video_format_t fmt = vd->fmt;
if (fmt.i_chroma != VLC_CODEC_RGB32) {
fmt.i_chroma = VLC_CODEC_RGB32;
fmt.i_rmask = 0x00ff0000;
fmt.i_gmask = 0x0000ff00;
fmt.i_bmask = 0x000000ff;
}
/* TODO */
vout_display_info_t info = vd->info;
/* Setup vout_display now that everything is fine */
vd->fmt = fmt;
vd->info = info;
vd->pool = Pool;
vd->prepare = Prepare;
vd->display = PictureDisplay;
vd->control = Control;
vd->manage = Manage;
/* Fix initial state */
vout_display_SendEventFullscreen(vd, false);
Refresh(vd);
return VLC_SUCCESS;
error:
if (sys) {
if (sys->pool)
picture_pool_Delete(sys->pool);
if (sys->dither)
cucul_free_dither(sys->dither);
if (sys->dp)
caca_free_display(sys->dp);
if (sys->cv)
cucul_free_canvas(sys->cv);
free(sys);
}
#if defined(WIN32)
FreeConsole();
#endif
return VLC_EGENERIC;
}
