/* * Win32 kernel functions * * Copyright 1995 Martin von Loewis and Cameron Heide * Copyright 1997 Karl Garrison * Copyright 1998 John Richardson */ #include #include #include #include #include #include #include #include #include #include #include "windows.h" #include "k32obj.h" #include "file.h" #include "process.h" #include "winerror.h" #include "wincon.h" #include "heap.h" #include "debug.h" static CONSOLE_SCREEN_BUFFER_INFO dummyinfo = { {80, 24}, {0, 0}, 0, {0, 0, 79, 23}, {80, 24} }; /* The console -- I chose to keep the master and slave * (UNIX) file descriptors around in case they are needed for * ioctls later. The pid is needed to destroy the xterm on close */ typedef struct _CONSOLE { K32OBJ header; int master; /* xterm side of pty */ int slave; /* wine side of pty */ int pid; /* xterm's pid, -1 if no xterm */ LPSTR title; /* title of console */ } CONSOLE; /* This probably belongs somewhere else */ typedef struct _CONSOLE_CURSOR_INFO { DWORD dwSize; /* Between 1 & 100 for percentage of cell filled */ BOOL32 bVisible; /* Visibility of cursor */ } CONSOLE_CURSOR_INFO, *LPCONSOLE_CURSOR_INFO; static void CONSOLE_Destroy( K32OBJ *obj ); static BOOL32 CONSOLE_Write(K32OBJ *ptr, LPCVOID lpBuffer, DWORD nNumberOfChars, LPDWORD lpNumberOfChars, LPOVERLAPPED lpOverlapped); static BOOL32 CONSOLE_Read(K32OBJ *ptr, LPVOID lpBuffer, DWORD nNumberOfChars, LPDWORD lpNumberOfChars, LPOVERLAPPED lpOverlapped); static int wine_openpty(int *master, int *slave, char *name, struct termios *term, struct winsize *winsize); static BOOL32 wine_createConsole(int *master, int *slave, int *pid); const K32OBJ_OPS CONSOLE_Ops = { NULL, /* signaled */ NULL, /* satisfied */ NULL, /* add_wait */ NULL, /* remove_wait */ CONSOLE_Read, /* read */ CONSOLE_Write, /* write */ CONSOLE_Destroy /* destroy */ }; /*********************************************************************** * CONSOLE_Destroy */ static void CONSOLE_Destroy(K32OBJ *obj) { CONSOLE *console = (CONSOLE *)obj; assert(obj->type == K32OBJ_CONSOLE); obj->type = K32OBJ_UNKNOWN; if (console->title) HeapFree( SystemHeap, 0, console->title ); console->title = NULL; /* make sure a xterm exists to kill */ if (console->pid != -1) { kill(console->pid, SIGTERM); } HeapFree(SystemHeap, 0, console); } /*********************************************************************** * CONSOLE_Read * * NOTES * lpOverlapped is ignored */ static BOOL32 CONSOLE_Read(K32OBJ *ptr, LPVOID lpBuffer, DWORD nNumberOfChars, LPDWORD lpNumberOfChars, LPOVERLAPPED lpOverlapped) { CONSOLE *console = (CONSOLE *)ptr; int result; TRACE(console, "%p %p %ld\n", ptr, lpBuffer, nNumberOfChars); *lpNumberOfChars = 0; if ((result = read(console->slave, lpBuffer, nNumberOfChars)) == -1) { FILE_SetDosError(); return FALSE; } *lpNumberOfChars = result; return TRUE; } /*********************************************************************** * CONSOLE_Write * * NOTES * lpOverlapped is ignored */ static BOOL32 CONSOLE_Write(K32OBJ *ptr, LPCVOID lpBuffer, DWORD nNumberOfChars, LPDWORD lpNumberOfChars, LPOVERLAPPED lpOverlapped) { CONSOLE *console = (CONSOLE *)ptr; int result; TRACE(console, "%p %p %ld\n", ptr, lpBuffer, nNumberOfChars); *lpNumberOfChars = 0; /* * I assume this loop around EAGAIN is here because * win32 doesn't have interrupted system calls */ for (;;) { result = write(console->slave, lpBuffer, nNumberOfChars); if (result != -1) { *lpNumberOfChars = result; return TRUE; } if (errno != EINTR) { FILE_SetDosError(); return FALSE; } } } /****************************************************************************** * SetConsoleCtrlHandler [KERNEL32.459] Adds function to calling process list * * PARAMS * func [I] Address of handler function * add [I] Handler to add or remove * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI SetConsoleCtrlHandler( HANDLER_ROUTINE *func, BOOL32 add ) { FIXME(console, "(%p,%i): stub\n",func,add); return TRUE; } /****************************************************************************** * CreateConsoleScreenBuffer [KERNEL32.151] Creates a console screen buffer * * PARAMS * dwDesiredAccess [I] Access flag * dwShareMode [I] Buffer share mode * sa [I] Security attributes * dwFlags [I] Type of buffer to create * lpScreenBufferData [I] Reserved * * NOTES * Should call SetLastError * * RETURNS * Success: Handle to new console screen buffer * Failure: INVALID_HANDLE_VALUE */ HANDLE32 WINAPI CreateConsoleScreenBuffer( DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES sa, DWORD dwFlags, LPVOID lpScreenBufferData ) { FIXME(console, "(%ld,%ld,%p,%ld,%p): stub\n",dwDesiredAccess, dwShareMode, sa, dwFlags, lpScreenBufferData); return 1; } /*********************************************************************** * GetConsoleScreenBufferInfo (KERNEL32.190) */ BOOL32 WINAPI GetConsoleScreenBufferInfo( HANDLE32 hConsoleOutput, LPCONSOLE_SCREEN_BUFFER_INFO csbi ) { csbi->dwSize.x = 80; csbi->dwSize.y = 24; csbi->dwCursorPosition.x = 0; csbi->dwCursorPosition.y = 0; csbi->wAttributes = 0; csbi->srWindow.Left = 0; csbi->srWindow.Right = 79; csbi->srWindow.Top = 0; csbi->srWindow.Bottom = 23; csbi->dwMaximumWindowSize.x = 80; csbi->dwMaximumWindowSize.y = 24; return TRUE; } /****************************************************************************** * SetConsoleActiveScreenBuffer [KERNEL32.623] Sets buffer to current console * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI SetConsoleActiveScreenBuffer( HANDLE32 hConsoleOutput) /* [in] Handle to console screen buffer */ { FIXME(console, "(%x): stub\n", hConsoleOutput); return FALSE; } /*********************************************************************** * GetLargestConsoleWindowSize (KERNEL32.226) */ DWORD WINAPI GetLargestConsoleWindowSize( HANDLE32 hConsoleOutput ) { return (DWORD)MAKELONG(dummyinfo.dwMaximumWindowSize.x,dummyinfo.dwMaximumWindowSize.y); } /*********************************************************************** * FreeConsole (KERNEL32.267) */ BOOL32 WINAPI FreeConsole(VOID) { PDB32 *pdb = PROCESS_Current(); CONSOLE *console; SYSTEM_LOCK(); console = (CONSOLE *)pdb->console; if (console == NULL) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } HANDLE_CloseAll( pdb, &console->header ); K32OBJ_DecCount( &console->header ); pdb->console = NULL; SYSTEM_UNLOCK(); return TRUE; } /** * It looks like the openpty that comes with glibc in RedHat 5.0 * is buggy (second call returns what looks like a dup of 0 and 1 * instead of a new pty), this is a generic replacement. */ static int wine_openpty(int *master, int *slave, char *name, struct termios *term, struct winsize *winsize) { int fdm, fds; char *ptr1, *ptr2; char pts_name[512]; strcpy (pts_name, "/dev/ptyXY"); for (ptr1 = "pqrstuvwxyzPQRST"; *ptr1 != 0; ptr1++) { pts_name[8] = *ptr1; for (ptr2 = "0123456789abcdef"; *ptr2 != 0; ptr2++) { pts_name[9] = *ptr2; if ((fdm = open(pts_name, O_RDWR)) < 0) { if (errno == ENOENT) return -1; else continue; } pts_name[5] = 't'; if ((fds = open(pts_name, O_RDWR)) < 0) { pts_name[5] = 'p'; continue; } *master = fdm; *slave = fds; if (term != NULL) tcsetattr(*slave, TCSANOW, term); if (winsize != NULL) ioctl(*slave, TIOCSWINSZ, winsize); if (name != NULL) strcpy(name, pts_name); return fds; } } return -1; } static BOOL32 wine_createConsole(int *master, int *slave, int *pid) { struct termios term; char buf[1024]; char c = '\0'; int status = 0; int i; if (tcgetattr(0, &term) < 0) return FALSE; term.c_lflag |= ICANON; term.c_lflag &= ~ECHO; if (wine_openpty(master, slave, NULL, &term, NULL) < 0) return FALSE; if ((*pid=fork()) == 0) { tcsetattr(*slave, TCSADRAIN, &term); sprintf(buf, "-Sxx%d", *master); execlp("xterm", "xterm", buf, NULL); ERR(console, "error creating AllocConsole xterm\n"); exit(1); } /* most xterms like to print their window ID when used with -S; * read it and continue before the user has a chance... * NOTE: this is the reason we started xterm with ECHO off, * we'll turn it back on below */ for (i=0; c!='\n'; (status=read(*slave, &c, 1)), i++) { if (status == -1 && c == '\0') { /* wait for xterm to be created */ usleep(100); } if (i > 10000) { WARN(console, "can't read xterm WID\n"); kill(*pid, SIGKILL); return FALSE; } } term.c_lflag |= ECHO; tcsetattr(*master, TCSADRAIN, &term); return TRUE; } /*********************************************************************** * CONSOLE_GetConsoleHandle * returns a 16-bit style console handle * note: only called from _lopen */ HFILE32 CONSOLE_GetConsoleHandle(VOID) { PDB32 *pdb = PROCESS_Current(); HFILE32 handle = HFILE_ERROR32; SYSTEM_LOCK(); if (pdb->console != NULL) { CONSOLE *console = (CONSOLE *)pdb->console; handle = (HFILE32)HANDLE_Alloc(pdb, &console->header, 0, TRUE); } SYSTEM_UNLOCK(); return handle; } /*********************************************************************** * AllocConsole (KERNEL32.103) * * creates an xterm with a pty to our program */ BOOL32 WINAPI AllocConsole(VOID) { int master; int slave; int pid; PDB32 *pdb = PROCESS_Current(); CONSOLE *console; HANDLE32 hIn, hOut, hErr; SYSTEM_LOCK(); /* FIXME: really only need to lock the process */ SetLastError(ERROR_CANNOT_MAKE); /* this might not be the right error, but it's a good guess :) */ console = (CONSOLE *)pdb->console; /* don't create a console if we already have one */ if (console != NULL) { SetLastError(ERROR_ACCESS_DENIED); SYSTEM_UNLOCK(); return FALSE; } if (!(console = (CONSOLE*)HeapAlloc( SystemHeap, 0, sizeof(*console)))) { SYSTEM_UNLOCK(); return FALSE; } console->header.type = K32OBJ_CONSOLE; console->header.refcount = 1; console->pid = -1; console->title = NULL; if (wine_createConsole(&master, &slave, &pid) == FALSE) { K32OBJ_DecCount(&console->header); SYSTEM_UNLOCK(); return FALSE; } /* save the pid and other info for future use */ console->master = master; console->slave = slave; console->pid = pid; if ((hIn = HANDLE_Alloc(pdb,&console->header, 0, TRUE)) == INVALID_HANDLE_VALUE32) { K32OBJ_DecCount(&console->header); SYSTEM_UNLOCK(); return FALSE; } if ((hOut = HANDLE_Alloc(pdb,&console->header, 0, TRUE)) == INVALID_HANDLE_VALUE32) { CloseHandle(hIn); K32OBJ_DecCount(&console->header); SYSTEM_UNLOCK(); return FALSE; } if ((hErr = HANDLE_Alloc(pdb,&console->header, 0, TRUE)) == INVALID_HANDLE_VALUE32) { CloseHandle(hIn); CloseHandle(hOut); K32OBJ_DecCount(&console->header); SYSTEM_UNLOCK(); return FALSE; } /* associate this console with the process */ if (pdb->console) K32OBJ_DecCount( pdb->console ); pdb->console = (K32OBJ *)console; /* NT resets the STD_*_HANDLEs on console alloc */ SetStdHandle(STD_INPUT_HANDLE, hIn); SetStdHandle(STD_OUTPUT_HANDLE, hOut); SetStdHandle(STD_ERROR_HANDLE, hErr); SetLastError(ERROR_SUCCESS); SYSTEM_UNLOCK(); SetConsoleTitle32A("Wine Console"); return TRUE; } /****************************************************************************** * GetConsoleCP [KERNEL32.295] Returns the OEM code page for the console * * RETURNS * Code page code */ UINT32 WINAPI GetConsoleCP(VOID) { return GetACP(); } /*********************************************************************** * GetConsoleOutputCP (KERNEL32.189) */ UINT32 WINAPI GetConsoleOutputCP(VOID) { return GetConsoleCP(); } /*********************************************************************** * GetConsoleMode (KERNEL32.188) */ BOOL32 WINAPI GetConsoleMode(HANDLE32 hcon,LPDWORD mode) { *mode = ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT; return TRUE; } /****************************************************************************** * SetConsoleMode [KERNEL32.628] Sets input mode of console's input buffer * * PARAMS * hcon [I] Handle to console input or screen buffer * mode [I] Input or output mode to set * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI SetConsoleMode( HANDLE32 hcon, DWORD mode ) { FIXME(console,"(%08x,%08lx): stub\n",hcon,mode); return TRUE; } /*********************************************************************** * GetConsoleTitleA (KERNEL32.191) */ DWORD WINAPI GetConsoleTitle32A(LPSTR title,DWORD size) { PDB32 *pdb = PROCESS_Current(); CONSOLE *console= (CONSOLE *)pdb->console; if(console && console->title) { lstrcpyn32A(title,console->title,size); return strlen(title); } return 0; } /****************************************************************************** * GetConsoleTitle32W [KERNEL32.192] Retrieves title string for console * * PARAMS * title [O] Address of buffer for title * size [I] Size of buffer * * RETURNS * Success: Length of string copied * Failure: 0 */ DWORD WINAPI GetConsoleTitle32W( LPWSTR title, DWORD size ) { PDB32 *pdb = PROCESS_Current(); CONSOLE *console= (CONSOLE *)pdb->console; if(console && console->title) { lstrcpynAtoW(title,console->title,size); return (lstrlen32W(title)); } return 0; } /*********************************************************************** * WriteConsoleA (KERNEL32.729) */ BOOL32 WINAPI WriteConsole32A( HANDLE32 hConsoleOutput, LPCVOID lpBuffer, DWORD nNumberOfCharsToWrite, LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved ) { /* FIXME: should I check if this is a console handle? */ return WriteFile(hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, lpNumberOfCharsWritten, NULL); } /*********************************************************************** * WriteConsoleOutputA (KERNEL32.732) */ BOOL32 WINAPI WriteConsoleOutput32A( HANDLE32 hConsoleOutput, LPCHAR_INFO lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, LPSMALL_RECT lpWriteRegion) { FIXME(console, "(...):stub\n"); return FALSE; } /*********************************************************************** * WriteConsoleW (KERNEL32.577) */ BOOL32 WINAPI WriteConsole32W( HANDLE32 hConsoleOutput, LPCVOID lpBuffer, DWORD nNumberOfCharsToWrite, LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved ) { BOOL32 ret; LPSTR xstring=HeapAlloc( GetProcessHeap(), 0, nNumberOfCharsToWrite ); lstrcpynWtoA( xstring, lpBuffer,nNumberOfCharsToWrite); /* FIXME: should I check if this is a console handle? */ ret= WriteFile(hConsoleOutput, xstring, nNumberOfCharsToWrite, lpNumberOfCharsWritten, NULL); HeapFree( GetProcessHeap(), 0, xstring ); return ret; } /*********************************************************************** * ReadConsoleA (KERNEL32.419) */ BOOL32 WINAPI ReadConsole32A( HANDLE32 hConsoleInput, LPVOID lpBuffer, DWORD nNumberOfCharsToRead, LPDWORD lpNumberOfCharsRead, LPVOID lpReserved ) { return ReadFile(hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, NULL); #ifdef OLD fgets(lpBuffer,nNumberOfCharsToRead, CONSOLE_console.conIO); if (ferror(CONSOLE_console.conIO) { clearerr(); return FALSE; } *lpNumberOfCharsRead = strlen(lpBuffer); return TRUE; #endif } /*********************************************************************** * ReadConsoleW (KERNEL32.427) */ BOOL32 WINAPI ReadConsole32W( HANDLE32 hConsoleInput, LPVOID lpBuffer, DWORD nNumberOfCharsToRead, LPDWORD lpNumberOfCharsRead, LPVOID lpReserved ) { BOOL32 ret; LPSTR buf = (LPSTR)HeapAlloc(GetProcessHeap(), 0, nNumberOfCharsToRead); ret = ReadFile(hConsoleInput, buf, nNumberOfCharsToRead, lpNumberOfCharsRead, NULL); lstrcpynAtoW(lpBuffer,buf,nNumberOfCharsToRead); *lpNumberOfCharsRead = strlen(buf); HeapFree( GetProcessHeap(), 0, buf ); return ret; #ifdef OLD LPSTR buf = (LPSTR)HEAP_xalloc(GetProcessHeap(), 0, nNumberOfCharsToRead); fgets(buf, nNumberOfCharsToRead, CONSOLE_console.conIO); if (ferror(CONSOLE_console.conIO) { HeapFree( GetProcessHeap(), 0, buf ); clearerr(); return FALSE; } lstrcpynAtoW(lpBuffer,buf,nNumberOfCharsToRead); *lpNumberOfCharsRead = strlen(buf); HeapFree( GetProcessHeap(), 0, buf ); return TRUE; #endif } /****************************************************************************** * ReadConsoleInputA [KERNEL32.569] Reads data from a console * * PARAMS * hConsoleInput [I] Handle to console input buffer * lpBuffer [O] Address of buffer for read data * nLength [I] Number of records to read * lpNumberOfEventsRead [O] Address of number of records read * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI ReadConsoleInputA( HANDLE32 hConsoleInput, LPINPUT_RECORD lpBuffer, DWORD nLength, LPDWORD lpNumberOfEventsRead) { FIXME(console, "(%d,%p,%ld,%p): stub\n",hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead); return ReadConsole32A(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead, 0); } /*********************************************************************** * SetConsoleTitle32A (KERNEL32.476) */ BOOL32 WINAPI SetConsoleTitle32A(LPCSTR title) { PDB32 *pdb = PROCESS_Current(); CONSOLE *console; DWORD written; char titleformat[]="\033]2;%s\a"; /*this should work for xterms*/ LPSTR titlestring; BOOL32 ret=FALSE; TRACE(console,"(%s)\n",title); console = (CONSOLE *)pdb->console; if (!console) return FALSE; if(console->title) /* Free old title, if there is one */ HeapFree( SystemHeap, 0, console->title ); console->title = (LPSTR)HeapAlloc(SystemHeap, 0,strlen(title)+1); if(console->title) strcpy(console->title,title); titlestring = HeapAlloc(GetProcessHeap(), 0,strlen(title)+strlen(titleformat)+1); if (!titlestring) return FALSE; sprintf(titlestring,titleformat,title); /* Ugly casting */ CONSOLE_Write((K32OBJ *)console,titlestring,strlen(titlestring),&written,NULL); if (written == strlen(titlestring)) ret =TRUE; HeapFree( GetProcessHeap(), 0, titlestring ); return ret; } /****************************************************************************** * SetConsoleTitle32W [KERNEL32.477] Sets title bar string for console * * PARAMS * title [I] Address of new title * * NOTES * This should not be calling the A version * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI SetConsoleTitle32W( LPCWSTR title ) { BOOL32 ret; LPSTR titleA = HEAP_strdupWtoA( GetProcessHeap(), 0, title ); ret = SetConsoleTitle32A(titleA); HeapFree( GetProcessHeap(), 0, titleA ); return ret; } /*********************************************************************** * FlushConsoleInputBuffer (KERNEL32.132) */ BOOL32 WINAPI FlushConsoleInputBuffer(HANDLE32 hConsoleInput) { FIXME(console,"(%d): stub\n",hConsoleInput); return TRUE; } /****************************************************************************** * SetConsoleCursorPosition [KERNEL32.627] * Sets the cursor position in console * * PARAMS * hConsoleOutput [I] Handle of console screen buffer * dwCursorPosition [I] New cursor position coordinates * * RETURNS STD */ BOOL32 WINAPI SetConsoleCursorPosition( HANDLE32 hConsoleOutput, COORD dwCursorPosition ) { TRACE(console, "%d (%d x %d)\n", hConsoleOutput, dwCursorPosition.x, dwCursorPosition.y); /* x are columns, y rows */ fprintf(stderr,"\r"); /* note: 0x1B == ESC */ fprintf(stdout,"%c[%d;%dH", 0x1B, dwCursorPosition.y, dwCursorPosition.x); return TRUE; } /*********************************************************************** * GetNumberOfConsoleInputEvents (KERNEL32.246) */ BOOL32 WINAPI GetNumberOfConsoleInputEvents(HANDLE32 hcon,LPDWORD nrofevents) { *nrofevents = 0; FIXME(console,"(%x): stub\n", hcon); return TRUE; } /*********************************************************************** * GetNumberOfConsoleMouseButtons (KERNEL32.358) */ BOOL32 WINAPI GetNumberOfConsoleMouseButtons(LPDWORD nrofbuttons) { FIXME(console,"(%p): stub\n", nrofbuttons); *nrofbuttons = 2; return TRUE; } /*********************************************************************** * PeekConsoleInputA (KERNEL32.550) */ BOOL32 WINAPI PeekConsoleInput32A(HANDLE32 hConsoleInput, LPINPUT_RECORD pirBuffer, DWORD cInRecords, LPDWORD lpcRead) { pirBuffer = NULL; cInRecords = 0; *lpcRead = 0; FIXME(console,"(%d,%p,%ld,%p): stub\n",hConsoleInput, pirBuffer, cInRecords, lpcRead); return TRUE; } /*********************************************************************** * PeekConsoleInputW (KERNEL32.551) */ BOOL32 WINAPI PeekConsoleInput32W(HANDLE32 hConsoleInput, LPINPUT_RECORD pirBuffer, DWORD cInRecords, LPDWORD lpcRead) { pirBuffer = NULL; cInRecords = 0; *lpcRead = 0; FIXME(console,"(%d,%p,%ld,%p): stub\n", hConsoleInput, pirBuffer, cInRecords, lpcRead); return TRUE; } /****************************************************************************** * GetConsoleCursorInfo32 [KERNEL32.296] Gets size and visibility of console * * PARAMS * hcon [I] Handle to console screen buffer * cinfo [O] Address of cursor information * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI GetConsoleCursorInfo32( HANDLE32 hcon, LPCONSOLE_CURSOR_INFO cinfo ) { FIXME(console, "(%x,%p): stub\n", hcon, cinfo); if (!cinfo) return FALSE; cinfo->dwSize = 10; /* 10% of character box is cursor. */ cinfo->bVisible = TRUE; /* Cursor is visible. */ return TRUE; } /****************************************************************************** * SetConsoleCursorInfo32 [KERNEL32.626] Sets size and visibility of cursor * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI SetConsoleCursorInfo32( HANDLE32 hcon, /* [in] Handle to console screen buffer */ LPCONSOLE_CURSOR_INFO cinfo) /* [in] Address of cursor information */ { FIXME(console, "(%x,%ld,%i): stub\n", hcon,cinfo->dwSize,cinfo->bVisible); return TRUE; } /****************************************************************************** * SetConsoleWindowInfo [KERNEL32.634] Sets size and position of console * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI SetConsoleWindowInfo( HANDLE32 hcon, /* [in] Handle to console screen buffer */ BOOL32 bAbsolute, /* [in] Coordinate type flag */ LPSMALL_RECT window) /* [in] Address of new window rectangle */ { FIXME(console, "(%x,%d,%p): stub\n", hcon, bAbsolute, window); return TRUE; } /****************************************************************************** * SetConsoleTextAttribute32 [KERNEL32.631] Sets colors for text * * Sets the foreground and background color attributes of characters * written to the screen buffer. * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI SetConsoleTextAttribute32(HANDLE32 hConsoleOutput,WORD wAttr) { int forecolor = 0; int backcolor = 0; int boldtext = 0; unsigned int attrib; attrib = wAttr; if( attrib >= BACKGROUND_INTENSITY ) attrib -= BACKGROUND_INTENSITY; /* Background intensity is ignored */ if( attrib >= BACKGROUND_RED ) { attrib -= BACKGROUND_RED; if( attrib >= BACKGROUND_GREEN ) { attrib -= BACKGROUND_GREEN; if( attrib >= BACKGROUND_BLUE ) { attrib -= BACKGROUND_BLUE; backcolor = 47; /* White background */ } else backcolor = 43; /* Yellow background */ } else if( attrib >= BACKGROUND_BLUE ) { attrib -= BACKGROUND_BLUE; backcolor = 45; /* Magenta background */ } else backcolor = 41; /* Red Background */ } else if( attrib >= BACKGROUND_GREEN ) { attrib -= BACKGROUND_GREEN; if( attrib >= BACKGROUND_BLUE ) { attrib -= BACKGROUND_BLUE; backcolor = 46; /* Cyan background */ } else backcolor = 42; /* Green background */ } else if( attrib >= BACKGROUND_BLUE ) { attrib -= BACKGROUND_BLUE; backcolor = 44; /* Blue background */ } else backcolor = 40; /* Black background */ if( attrib >= FOREGROUND_INTENSITY ) { attrib -= FOREGROUND_INTENSITY; boldtext = 1; /* Bold attribute is on */ } if( attrib >= FOREGROUND_RED ) { attrib -= FOREGROUND_RED; if( attrib >= FOREGROUND_GREEN ) { attrib -= FOREGROUND_GREEN; if( attrib >= FOREGROUND_BLUE ) { attrib -= FOREGROUND_BLUE; forecolor = 37; /* White foreground */ } else forecolor = 33; /* Yellow foreground */ } else if( attrib >= FOREGROUND_BLUE ) { attrib -= FOREGROUND_BLUE; forecolor = 35; /* Magenta foreground */ } else forecolor = 31; /* Red foreground */ } else if( attrib >= FOREGROUND_GREEN ) { attrib -= FOREGROUND_GREEN; if( attrib >= FOREGROUND_BLUE ) { attrib -= FOREGROUND_BLUE; forecolor = 36; /* Cyan foreground */ } else forecolor = 32; /* Green foreground */ } else if( attrib >= FOREGROUND_BLUE ) { attrib -= FOREGROUND_BLUE; forecolor = 34; /* Blue foreground */ } else forecolor = 30; /* Black foreground */ fprintf(stdout,"%c[%d;%d;%dm",0x1B,boldtext,forecolor,backcolor); return TRUE; } /****************************************************************************** * SetConsoleScreenBufferSize [KERNEL32.630] Changes size of console * * PARAMS * hConsoleOutput [I] Handle to console screen buffer * dwSize [I] New size in character rows and cols * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI SetConsoleScreenBufferSize( HANDLE32 hConsoleOutput, COORD dwSize ) { FIXME(console, "(%d,%dx%d): stub\n",hConsoleOutput,dwSize.x,dwSize.y); return TRUE; } /****************************************************************************** * FillConsoleOutputCharacterA [KERNEL32.242] * * PARAMS * hConsoleOutput [I] Handle to screen buffer * cCharacter [I] Character to write * nLength [I] Number of cells to write to * dwCoord [I] Coords of first cell * lpNumCharsWritten [O] Pointer to number of cells written * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI FillConsoleOutputCharacterA( HANDLE32 hConsoleOutput, BYTE cCharacter, DWORD nLength, COORD dwCoord, LPDWORD lpNumCharsWritten) { long count; SetConsoleCursorPosition(hConsoleOutput,dwCoord); for(count=0;count