console separation 4/4

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



the final move
the files win32/console.c and win32/editline.c have to removed too
Name:          con_move
ChangeLog:     moved all client-side console code to kernel DLL and directory
License:       X11
GenDate:       2002/07/30 19:19:22 UTC
ModifiedFiles: dlls/kernel/Makefile.in dlls/ntdll/Makefile.in dlls/kernel/console.c
AddedFiles:    dlls/kernel/editline.c
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/dlls/kernel/Makefile.in,v
retrieving revision 1.37
diff -u -u -r1.37 Makefile.in
--- dlls/kernel/Makefile.in	14 Jun 2002 02:09:08 -0000	1.37
+++ dlls/kernel/Makefile.in	30 Jul 2002 12:33:42 -0000
@@ -11,6 +11,7 @@
 	comm.c \
 	console.c \
 	debugger.c \
+	editline.c \
 	format_msg.c \
 	kernel_main.c \
 	stress.c \
Index: dlls/kernel/console.c
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/dlls/kernel/console.c,v
retrieving revision 1.5
diff -u -u -r1.5 console.c
--- dlls/kernel/console.c	31 May 2002 23:25:48 -0000	1.5
+++ dlls/kernel/console.c	30 Jul 2002 18:55:49 -0000
@@ -5,7 +5,7 @@
  * Copyright 1997 Karl Garrison
  * Copyright 1998 John Richardson
  * Copyright 1998 Marcus Meissner
- * Copyright 2001 Eric Pouech
+ * Copyright 2001,2002 Eric Pouech
  * Copyright 2001 Alexandre Julliard
  *
  * This library is free software; you can redistribute it and/or
@@ -29,6 +29,7 @@
  */
 
 #include "config.h"
+#include "wine/port.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -43,6 +44,7 @@
 #include "wine/exception.h"
 #include "wine/unicode.h"
 #include "wine/debug.h"
+#include "msvcrt/excpt.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(console);
 
@@ -818,3 +820,1410 @@
     return c;
 }
 #endif /* defined(__i386__) */
+
+/* editline.c */
+extern WCHAR* CONSOLE_Readline(HANDLE, int);
+
+static WCHAR*	S_EditString /* = NULL */;
+static unsigned S_EditStrPos /* = 0 */;
+
+/***********************************************************************
+ *            FreeConsole (KERNEL32.@)
+ */
+BOOL WINAPI FreeConsole(VOID)
+{
+    BOOL ret;
+
+    SERVER_START_REQ(free_console)
+    {
+        ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
+/******************************************************************
+ *		start_console_renderer
+ *
+ * helper for AllocConsole
+ * starts the renderer process
+ */
+static	BOOL	start_console_renderer(void)
+{
+    char		buffer[256];
+    int			ret;
+    STARTUPINFOA	si;
+    PROCESS_INFORMATION	pi;
+    HANDLE		hEvent = 0;
+    LPSTR		p;
+    OBJECT_ATTRIBUTES	attr;
+
+    attr.Length                   = sizeof(attr);
+    attr.RootDirectory            = 0;
+    attr.Attributes               = OBJ_INHERIT;
+    attr.ObjectName               = NULL;
+    attr.SecurityDescriptor       = NULL;
+    attr.SecurityQualityOfService = NULL;
+
+    NtCreateEvent(&hEvent, EVENT_ALL_ACCESS, &attr, TRUE, FALSE);
+    if (!hEvent) return FALSE;
+
+    memset(&si, 0, sizeof(si));
+    si.cb = sizeof(si);
+
+    /* FIXME: use dynamic allocation for most of the buffers below */
+    /* first try environment variable */
+    if ((p = getenv("WINECONSOLE")) != NULL)
+    {
+	ret = snprintf(buffer, sizeof(buffer), "%s --use-event=%d", p, hEvent);
+	if ((ret > -1) && (ret < sizeof(buffer)) &&
+	    CreateProcessA(NULL, buffer, NULL, NULL, TRUE, DETACHED_PROCESS, NULL, NULL, &si, &pi))
+	    goto succeed;
+	ERR("Couldn't launch Wine console from WINECONSOLE env var... trying default access\n");
+    }
+
+    /* then try the regular PATH */
+    sprintf(buffer, "wineconsole --use-event=%d", hEvent);
+    if (CreateProcessA(NULL, buffer, NULL, NULL, TRUE, DETACHED_PROCESS, NULL, NULL, &si, &pi))
+	goto succeed;
+
+    goto the_end;
+
+ succeed:
+    if (WaitForSingleObject(hEvent, INFINITE) != WAIT_OBJECT_0) goto the_end;
+    CloseHandle(hEvent);
+
+    TRACE("Started wineconsole pid=%08lx tid=%08lx\n", pi.dwProcessId, pi.dwThreadId);
+
+    return TRUE;
+
+ the_end:
+    ERR("Can't allocate console\n");
+    CloseHandle(hEvent);
+    return FALSE;
+}
+
+/***********************************************************************
+ *            AllocConsole (KERNEL32.@)
+ *
+ * creates an xterm with a pty to our program
+ */
+BOOL WINAPI AllocConsole(void)
+{
+    HANDLE 		handle_in = INVALID_HANDLE_VALUE;
+    HANDLE		handle_out = INVALID_HANDLE_VALUE;
+    HANDLE 		handle_err = INVALID_HANDLE_VALUE;
+    STARTUPINFOW si;
+
+    TRACE("()\n");
+
+    handle_in = CreateFileA( "CONIN$", GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,
+			     0, NULL, OPEN_EXISTING, 0, 0 );
+
+    if (handle_in != INVALID_HANDLE_VALUE)
+    {
+	/* we already have a console opened on this process, don't create a new one */
+	CloseHandle(handle_in);
+	return FALSE;
+    }
+
+    if (!start_console_renderer())
+	goto the_end;
+
+    handle_in = CreateFileA( "CONIN$", GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,
+			     0, NULL, OPEN_EXISTING, 0, 0 );
+    if (handle_in == INVALID_HANDLE_VALUE) goto the_end;
+
+    handle_out = CreateFileA( "CONOUT$", GENERIC_READ|GENERIC_WRITE,
+			     0, NULL, OPEN_EXISTING, 0, 0 );
+    if (handle_out == INVALID_HANDLE_VALUE) goto the_end;
+
+    if (!DuplicateHandle(GetCurrentProcess(), handle_out, GetCurrentProcess(), &handle_err,
+			 0, TRUE, DUPLICATE_SAME_ACCESS))
+	goto the_end;
+
+    /* NT resets the STD_*_HANDLEs on console alloc */
+    SetStdHandle(STD_INPUT_HANDLE,  handle_in);
+    SetStdHandle(STD_OUTPUT_HANDLE, handle_out);
+    SetStdHandle(STD_ERROR_HANDLE,  handle_err);
+
+    GetStartupInfoW(&si);
+    if (si.dwFlags & STARTF_USECOUNTCHARS)
+    {
+	COORD	c;
+	c.X = si.dwXCountChars;
+	c.Y = si.dwYCountChars;
+	SetConsoleScreenBufferSize(handle_out, c);
+    }
+    if (si.dwFlags & STARTF_USEFILLATTRIBUTE)
+	SetConsoleTextAttribute(handle_out, si.dwFillAttribute);
+    if (si.lpTitle)
+	SetConsoleTitleW(si.lpTitle);
+
+    SetLastError(ERROR_SUCCESS);
+
+    return TRUE;
+
+ the_end:
+    ERR("Can't allocate console\n");
+    if (handle_in != INVALID_HANDLE_VALUE)	CloseHandle(handle_in);
+    if (handle_out != INVALID_HANDLE_VALUE)	CloseHandle(handle_out);
+    if (handle_err != INVALID_HANDLE_VALUE)	CloseHandle(handle_err);
+    FreeConsole();
+    return FALSE;
+}
+
+
+/******************************************************************************
+ * read_console_input
+ *
+ * Helper function for ReadConsole, ReadConsoleInput and PeekConsoleInput
+ */
+static BOOL read_console_input(HANDLE handle, LPINPUT_RECORD buffer, DWORD count,
+			       LPDWORD pRead, BOOL flush)
+{
+    BOOL	ret;
+    unsigned	read = 0;
+
+    SERVER_START_REQ( read_console_input )
+    {
+        req->handle = handle;
+        req->flush = flush;
+        wine_server_set_reply( req, buffer, count * sizeof(INPUT_RECORD) );
+        if ((ret = !wine_server_call_err( req ))) read = reply->read;
+    }
+    SERVER_END_REQ;
+    if (pRead) *pRead = read;
+    return ret;
+}
+
+
+/***********************************************************************
+ *            ReadConsoleA   (KERNEL32.@)
+ */
+BOOL WINAPI ReadConsoleA(HANDLE hConsoleInput, LPVOID lpBuffer, DWORD nNumberOfCharsToRead,
+			 LPDWORD lpNumberOfCharsRead, LPVOID lpReserved)
+{
+    LPWSTR	ptr = HeapAlloc(GetProcessHeap(), 0, nNumberOfCharsToRead * sizeof(WCHAR));
+    DWORD	ncr = 0;
+    BOOL	ret;
+
+    if ((ret = ReadConsoleW(hConsoleInput, ptr, nNumberOfCharsToRead, &ncr, NULL)))
+	ncr = WideCharToMultiByte(CP_ACP, 0, ptr, ncr, lpBuffer, nNumberOfCharsToRead, NULL, NULL);
+
+    if (lpNumberOfCharsRead) *lpNumberOfCharsRead = ncr;
+    HeapFree(GetProcessHeap(), 0, ptr);
+
+    return ret;
+}
+
+/***********************************************************************
+ *            ReadConsoleW   (KERNEL32.@)
+ */
+BOOL WINAPI ReadConsoleW(HANDLE hConsoleInput, LPVOID lpBuffer,
+			 DWORD nNumberOfCharsToRead, LPDWORD lpNumberOfCharsRead, LPVOID lpReserved)
+{
+    DWORD	charsread;
+    LPWSTR	xbuf = (LPWSTR)lpBuffer;
+    DWORD	mode;
+
+    TRACE("(%d,%p,%ld,%p,%p)\n",
+	  hConsoleInput, lpBuffer, nNumberOfCharsToRead, lpNumberOfCharsRead, lpReserved);
+
+    if (!GetConsoleMode(hConsoleInput, &mode))
+        return FALSE;
+
+    if (mode & ENABLE_LINE_INPUT)
+    {
+	if (!S_EditString || S_EditString[S_EditStrPos] == 0)
+	{
+	    if (S_EditString) HeapFree(GetProcessHeap(), 0, S_EditString);
+	    if (!(S_EditString = CONSOLE_Readline(hConsoleInput, mode & WINE_ENABLE_LINE_INPUT_EMACS)))
+		return FALSE;
+	    S_EditStrPos = 0;
+	}
+	charsread = lstrlenW(&S_EditString[S_EditStrPos]);
+	if (charsread > nNumberOfCharsToRead) charsread = nNumberOfCharsToRead;
+	memcpy(xbuf, &S_EditString[S_EditStrPos], charsread * sizeof(WCHAR));
+	S_EditStrPos += charsread;
+    }
+    else
+    {
+	INPUT_RECORD 	ir;
+	DWORD 		count;
+
+	/* FIXME: should we read at least 1 char? The SDK does not say */
+	/* wait for at least one available input record (it doesn't mean we'll have
+	 * chars stored in xbuf...
+	 */
+	WaitForSingleObject(hConsoleInput, INFINITE);
+	for (charsread = 0; charsread < nNumberOfCharsToRead;)
+	{
+	    if (!read_console_input(hConsoleInput, &ir, 1, &count, TRUE)) return FALSE;
+	    if (count && ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown &&
+		ir.Event.KeyEvent.uChar.UnicodeChar &&
+		!(ir.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY))
+	    {
+		xbuf[charsread++] = ir.Event.KeyEvent.uChar.UnicodeChar;
+	    }
+	}
+    }
+
+    if (lpNumberOfCharsRead) *lpNumberOfCharsRead = charsread;
+
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *            ReadConsoleInputW   (KERNEL32.@)
+ */
+BOOL WINAPI ReadConsoleInputW(HANDLE hConsoleInput, LPINPUT_RECORD lpBuffer,
+                              DWORD nLength, LPDWORD lpNumberOfEventsRead)
+{
+    DWORD count;
+
+    if (!nLength)
+    {
+        if (lpNumberOfEventsRead) *lpNumberOfEventsRead = 0;
+        return TRUE;
+    }
+
+    /* loop until we get at least one event */
+    for (;;)
+    {
+        WaitForSingleObject(hConsoleInput, INFINITE);
+	if (!read_console_input(hConsoleInput, lpBuffer, nLength, &count, TRUE))
+	    return FALSE;
+        if (count)
+        {
+            if (lpNumberOfEventsRead) *lpNumberOfEventsRead = count;
+            return TRUE;
+        }
+    }
+}
+
+
+/******************************************************************************
+ * WriteConsoleOutputCharacterW [KERNEL32.@]  Copies character to consecutive
+ * 					      cells in the console screen buffer
+ *
+ * PARAMS
+ *    hConsoleOutput    [I] Handle to screen buffer
+ *    str               [I] Pointer to buffer with chars to write
+ *    length            [I] Number of cells to write to
+ *    coord             [I] Coords of first cell
+ *    lpNumCharsWritten [O] Pointer to number of cells written
+ *
+ * RETURNS
+ *    Success: TRUE
+ *    Failure: FALSE
+ *
+ */
+BOOL WINAPI WriteConsoleOutputCharacterW( HANDLE hConsoleOutput, LPCWSTR str, DWORD length,
+                                          COORD coord, LPDWORD lpNumCharsWritten )
+{
+    BOOL ret;
+
+    TRACE("(%d,%s,%ld,%dx%d,%p)\n", hConsoleOutput,
+          debugstr_wn(str, length), length, coord.X, coord.Y, lpNumCharsWritten);
+
+    SERVER_START_REQ( write_console_output )
+    {
+        req->handle = hConsoleOutput;
+        req->x      = coord.X;
+        req->y      = coord.Y;
+        req->mode   = CHAR_INFO_MODE_TEXT;
+        req->wrap   = TRUE;
+        wine_server_add_data( req, str, length * sizeof(WCHAR) );
+        if ((ret = !wine_server_call_err( req )))
+        {
+            if (lpNumCharsWritten) *lpNumCharsWritten = reply->written;
+        }
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
+
+/******************************************************************************
+ * SetConsoleTitleW [KERNEL32.@]  Sets title bar string for console
+ *
+ * PARAMS
+ *    title [I] Address of new title
+ *
+ * RETURNS
+ *    Success: TRUE
+ *    Failure: FALSE
+ */
+BOOL WINAPI SetConsoleTitleW(LPCWSTR title)
+{
+    BOOL ret;
+
+    SERVER_START_REQ( set_console_input_info )
+    {
+        req->handle = 0;
+        req->mask = SET_CONSOLE_INPUT_INFO_TITLE;
+        wine_server_add_data( req, title, strlenW(title) * sizeof(WCHAR) );
+        ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
+
+/***********************************************************************
+ *            GetNumberOfConsoleMouseButtons   (KERNEL32.@)
+ */
+BOOL WINAPI GetNumberOfConsoleMouseButtons(LPDWORD nrofbuttons)
+{
+    FIXME("(%p): stub\n", nrofbuttons);
+    *nrofbuttons = 2;
+    return TRUE;
+}
+
+/******************************************************************************
+ *  SetConsoleInputExeNameW	 [KERNEL32.@]
+ *
+ * BUGS
+ *   Unimplemented
+ */
+BOOL WINAPI SetConsoleInputExeNameW(LPCWSTR name)
+{
+    FIXME("(%s): stub!\n", debugstr_w(name));
+
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return TRUE;
+}
+
+/******************************************************************************
+ *  SetConsoleInputExeNameA	 [KERNEL32.@]
+ *
+ * BUGS
+ *   Unimplemented
+ */
+BOOL WINAPI SetConsoleInputExeNameA(LPCSTR name)
+{
+    int		len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
+    LPWSTR	xptr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+    BOOL	ret;
+
+    if (!xptr) return FALSE;
+
+    MultiByteToWideChar(CP_ACP, 0, name, -1, xptr, len);
+    ret = SetConsoleInputExeNameW(xptr);
+    HeapFree(GetProcessHeap(), 0, xptr);
+
+    return ret;
+}
+
+/******************************************************************
+ *		CONSOLE_DefaultHandler
+ *
+ * Final control event handler
+ */
+static BOOL WINAPI CONSOLE_DefaultHandler(DWORD dwCtrlType)
+{
+    FIXME("Terminating process %lx on event %lx\n", GetCurrentProcessId(), dwCtrlType);
+    ExitProcess(0);
+    /* should never go here */
+    return TRUE;
+}
+
+/******************************************************************************
+ * SetConsoleCtrlHandler [KERNEL32.@]  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
+ *
+ * CHANGED
+ * James Sutherland (JamesSutherland@gmx.de)
+ * Added global variables console_ignore_ctrl_c and handlers[]
+ * Does not yet do any error checking, or set LastError if failed.
+ * This doesn't yet matter, since these handlers are not yet called...!
+ */
+
+struct ConsoleHandler {
+    PHANDLER_ROUTINE            handler;
+    struct ConsoleHandler*      next;
+};
+
+static unsigned int             CONSOLE_IgnoreCtrlC = 0; /* FIXME: this should be inherited somehow */
+static struct ConsoleHandler    CONSOLE_DefaultConsoleHandler = {CONSOLE_DefaultHandler, NULL};
+static struct ConsoleHandler*   CONSOLE_Handlers = &CONSOLE_DefaultConsoleHandler;
+static CRITICAL_SECTION         CONSOLE_CritSect = CRITICAL_SECTION_INIT("console_ctrl_section");
+
+/*****************************************************************************/
+
+BOOL WINAPI SetConsoleCtrlHandler(PHANDLER_ROUTINE func, BOOL add)
+{
+    BOOL        ret = TRUE;
+
+    FIXME("(%p,%i) - no error checking or testing yet\n", func, add);
+
+    if (!func)
+    {
+	CONSOLE_IgnoreCtrlC = add;
+    }
+    else if (add)
+    {
+        struct ConsoleHandler*  ch = HeapAlloc(GetProcessHeap(), 0, sizeof(struct ConsoleHandler));
+
+        if (!ch) return FALSE;
+        ch->handler = func;
+        EnterCriticalSection(&CONSOLE_CritSect);
+        ch->next = CONSOLE_Handlers;
+        CONSOLE_Handlers = ch;
+        LeaveCriticalSection(&CONSOLE_CritSect);
+    }
+    else
+    {
+        struct ConsoleHandler**  ch;
+        EnterCriticalSection(&CONSOLE_CritSect);
+        for (ch = &CONSOLE_Handlers; *ch; *ch = (*ch)->next)
+        {
+            if ((*ch)->handler == func) break;
+        }
+        if (*ch)
+        {
+            struct ConsoleHandler*   rch = *ch;
+
+            /* sanity check */
+            if (rch == &CONSOLE_DefaultConsoleHandler)
+            {
+                ERR("Who's trying to remove default handler???\n");
+                ret = FALSE;
+            }
+            else
+            {
+                rch = *ch;
+                *ch = (*ch)->next;
+                HeapFree(GetProcessHeap(), 0, rch);
+            }
+        }
+        else
+        {
+            WARN("Attempt to remove non-installed CtrlHandler %p\n", func);
+            ret = FALSE;
+        }
+        LeaveCriticalSection(&CONSOLE_CritSect);
+    }
+    return ret;
+}
+
+static WINE_EXCEPTION_FILTER(CONSOLE_CtrlEventHandler)
+{
+    TRACE("(%lx)\n", GetExceptionCode());
+    return EXCEPTION_EXECUTE_HANDLER;
+}
+
+static DWORD WINAPI CONSOLE_HandleCtrlCEntry(void* pmt)
+{
+    struct ConsoleHandler*  ch;
+
+    EnterCriticalSection(&CONSOLE_CritSect);
+    /* the debugger didn't continue... so, pass to ctrl handlers */
+    for (ch = CONSOLE_Handlers; ch; ch = ch->next)
+    {
+        if (ch->handler((DWORD)pmt)) break;
+    }
+    LeaveCriticalSection(&CONSOLE_CritSect);
+    return 0;
+}
+
+/******************************************************************
+ *		CONSOLE_HandleCtrlC
+ *
+ * Check whether the shall manipulate CtrlC events
+ */
+int     CONSOLE_HandleCtrlC(unsigned sig)
+{
+    /* FIXME: better test whether a console is attached to this process ??? */
+    extern    unsigned CONSOLE_GetNumHistoryEntries(void);
+    if (CONSOLE_GetNumHistoryEntries() == (unsigned)-1) return 0;
+    if (CONSOLE_IgnoreCtrlC) return 1;
+
+    /* try to pass the exception to the debugger
+     * if it continues, there's nothing more to do
+     * otherwise, we need to send the ctrl-event to the handlers
+     */
+    __TRY
+    {
+        RaiseException( DBG_CONTROL_C, 0, 0, NULL );
+    }
+    __EXCEPT(CONSOLE_CtrlEventHandler)
+    {
+        /* Create a separate thread to signal all the events. This would allow to
+         * synchronize between setting the handlers and actually calling them
+         */
+        CreateThread(NULL, 0, CONSOLE_HandleCtrlCEntry, (void*)CTRL_C_EVENT, 0, NULL);
+    }
+    __ENDTRY;
+    return 1;
+}
+
+/******************************************************************************
+ * GenerateConsoleCtrlEvent [KERNEL32.@] Simulate a CTRL-C or CTRL-BREAK
+ *
+ * PARAMS
+ *    dwCtrlEvent        [I] Type of event
+ *    dwProcessGroupID   [I] Process group ID to send event to
+ *
+ * RETURNS
+ *    Success: True
+ *    Failure: False (and *should* [but doesn't] set LastError)
+ */
+BOOL WINAPI GenerateConsoleCtrlEvent(DWORD dwCtrlEvent,
+				     DWORD dwProcessGroupID)
+{
+    BOOL ret;
+
+    TRACE("(%ld, %ld)\n", dwCtrlEvent, dwProcessGroupID);
+
+    if (dwCtrlEvent != CTRL_C_EVENT && dwCtrlEvent != CTRL_BREAK_EVENT)
+    {
+	ERR("Invalid event %ld for PGID %ld\n", dwCtrlEvent, dwProcessGroupID);
+	return FALSE;
+    }
+
+    SERVER_START_REQ( send_console_signal )
+    {
+        req->signal = dwCtrlEvent;
+        req->group_id = (void*)dwProcessGroupID;
+        ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+
+    return ret;
+}
+
+
+/******************************************************************************
+ * CreateConsoleScreenBuffer [KERNEL32.@]  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
+ */
+HANDLE WINAPI CreateConsoleScreenBuffer(DWORD dwDesiredAccess, DWORD dwShareMode,
+					LPSECURITY_ATTRIBUTES sa, DWORD dwFlags,
+					LPVOID lpScreenBufferData)
+{
+    HANDLE	ret = INVALID_HANDLE_VALUE;
+
+    TRACE("(%ld,%ld,%p,%ld,%p)\n",
+	  dwDesiredAccess, dwShareMode, sa, dwFlags, lpScreenBufferData);
+
+    if (dwFlags != CONSOLE_TEXTMODE_BUFFER || lpScreenBufferData != NULL)
+    {
+	SetLastError(ERROR_INVALID_PARAMETER);
+	return INVALID_HANDLE_VALUE;
+    }
+
+    SERVER_START_REQ(create_console_output)
+    {
+	req->handle_in = 0;
+	req->access    = dwDesiredAccess;
+	req->share     = dwShareMode;
+	req->inherit   = (sa && sa->bInheritHandle);
+	if (!wine_server_call_err( req )) ret = reply->handle_out;
+    }
+    SERVER_END_REQ;
+
+    return ret;
+}
+
+
+/***********************************************************************
+ *           GetConsoleScreenBufferInfo   (KERNEL32.@)
+ */
+BOOL WINAPI GetConsoleScreenBufferInfo(HANDLE hConsoleOutput, LPCONSOLE_SCREEN_BUFFER_INFO csbi)
+{
+    BOOL	ret;
+
+    SERVER_START_REQ(get_console_output_info)
+    {
+        req->handle = hConsoleOutput;
+        if ((ret = !wine_server_call_err( req )))
+        {
+            csbi->dwSize.X              = reply->width;
+            csbi->dwSize.Y              = reply->height;
+            csbi->dwCursorPosition.X    = reply->cursor_x;
+            csbi->dwCursorPosition.Y    = reply->cursor_y;
+            csbi->wAttributes           = reply->attr;
+            csbi->srWindow.Left         = reply->win_left;
+            csbi->srWindow.Right        = reply->win_right;
+            csbi->srWindow.Top          = reply->win_top;
+            csbi->srWindow.Bottom       = reply->win_bottom;
+            csbi->dwMaximumWindowSize.X = reply->max_width;
+            csbi->dwMaximumWindowSize.Y = reply->max_height;
+        }
+    }
+    SERVER_END_REQ;
+
+    return ret;
+}
+
+
+/******************************************************************************
+ * SetConsoleActiveScreenBuffer [KERNEL32.@]  Sets buffer to current console
+ *
+ * RETURNS
+ *    Success: TRUE
+ *    Failure: FALSE
+ */
+BOOL WINAPI SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput)
+{
+    BOOL ret;
+
+    TRACE("(%x)\n", hConsoleOutput);
+
+    SERVER_START_REQ( set_console_input_info )
+    {
+        req->handle    = 0;
+        req->mask      = SET_CONSOLE_INPUT_INFO_ACTIVE_SB;
+        req->active_sb = hConsoleOutput;
+        ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
+
+/***********************************************************************
+ *            GetConsoleMode   (KERNEL32.@)
+ */
+BOOL WINAPI GetConsoleMode(HANDLE hcon, LPDWORD mode)
+{
+    BOOL ret;
+
+    SERVER_START_REQ(get_console_mode)
+    {
+	req->handle = hcon;
+	ret = !wine_server_call_err( req );
+	if (ret && mode) *mode = reply->mode;
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
+
+/******************************************************************************
+ * SetConsoleMode [KERNEL32.@]  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
+ *
+ *    mode:
+ *      ENABLE_PROCESSED_INPUT	0x01
+ *      ENABLE_LINE_INPUT	0x02
+ *      ENABLE_ECHO_INPUT	0x04
+ *      ENABLE_WINDOW_INPUT	0x08
+ *      ENABLE_MOUSE_INPUT	0x10
+ */
+BOOL WINAPI SetConsoleMode(HANDLE hcon, DWORD mode)
+{
+    BOOL ret;
+
+    SERVER_START_REQ(set_console_mode)
+    {
+	req->handle = hcon;
+	req->mode = mode;
+	ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+    /* FIXME: when resetting a console input to editline mode, I think we should
+     * empty the S_EditString buffer
+     */
+
+    TRACE("(%x,%lx) retval == %d\n", hcon, mode, ret);
+
+    return ret;
+}
+
+
+/******************************************************************
+ *		write_char
+ *
+ * WriteConsoleOutput helper: hides server call semantics
+ */
+static int write_char(HANDLE hCon, LPCWSTR lpBuffer, int nc, COORD* pos)
+{
+    int written = -1;
+
+    if (!nc) return 0;
+
+    SERVER_START_REQ( write_console_output )
+    {
+        req->handle = hCon;
+        req->x      = pos->X;
+        req->y      = pos->Y;
+        req->mode   = CHAR_INFO_MODE_TEXTSTDATTR;
+        req->wrap   = FALSE;
+        wine_server_add_data( req, lpBuffer, nc * sizeof(WCHAR) );
+        if (!wine_server_call_err( req )) written = reply->written;
+    }
+    SERVER_END_REQ;
+
+    if (written > 0) pos->X += written;
+    return written;
+}
+
+/******************************************************************
+ *		next_line
+ *
+ * WriteConsoleOutput helper: handles passing to next line (+scrolling if necessary)
+ *
+ */
+static int	next_line(HANDLE hCon, CONSOLE_SCREEN_BUFFER_INFO* csbi)
+{
+    SMALL_RECT	src;
+    CHAR_INFO	ci;
+    COORD	dst;
+
+    csbi->dwCursorPosition.X = 0;
+    csbi->dwCursorPosition.Y++;
+
+    if (csbi->dwCursorPosition.Y < csbi->dwSize.Y) return 1;
+
+    src.Top    = 1;
+    src.Bottom = csbi->dwSize.Y - 1;
+    src.Left   = 0;
+    src.Right  = csbi->dwSize.X - 1;
+
+    dst.X      = 0;
+    dst.Y      = 0;
+
+    ci.Attributes = csbi->wAttributes;
+    ci.Char.UnicodeChar = ' ';
+
+    csbi->dwCursorPosition.Y--;
+    if (!ScrollConsoleScreenBufferW(hCon, &src, NULL, dst, &ci))
+	return 0;
+    return 1;
+}
+
+/******************************************************************
+ *		write_block
+ *
+ * WriteConsoleOutput helper: writes a block of non special characters
+ * Block can spread on several lines, and wrapping, if needed, is
+ * handled
+ *
+ */
+static int     	write_block(HANDLE hCon, CONSOLE_SCREEN_BUFFER_INFO* csbi,
+			    DWORD mode, LPWSTR ptr, int len)
+{
+    int	blk;	/* number of chars to write on current line */
+
+    if (len <= 0) return 1;
+
+    if (mode & ENABLE_WRAP_AT_EOL_OUTPUT) /* writes remaining on next line */
+    {
+        int     done;
+
+        for (done = 0; done < len; done += blk)
+        {
+            blk = min(len - done, csbi->dwSize.X - csbi->dwCursorPosition.X);
+
+            if (write_char(hCon, ptr + done, blk, &csbi->dwCursorPosition) != blk)
+                return 0;
+            if (csbi->dwCursorPosition.X == csbi->dwSize.X && !next_line(hCon, csbi))
+                return 0;
+        }
+    }
+    else
+    {
+        blk = min(len, csbi->dwSize.X - csbi->dwCursorPosition.X);
+
+        if (write_char(hCon, ptr, blk, &csbi->dwCursorPosition) != blk)
+            return 0;
+        if (blk < len)
+        {
+            csbi->dwCursorPosition.X = csbi->dwSize.X - 1;
+            /* all remaining chars should be written on last column,
+             * so only overwrite the last column with last char in block
+             */
+            if (write_char(hCon, ptr + len - 1, 1, &csbi->dwCursorPosition) != 1)
+                return 0;
+            csbi->dwCursorPosition.X = csbi->dwSize.X - 1;
+        }
+    }
+
+    return 1;
+}
+
+/***********************************************************************
+ *            WriteConsoleW   (KERNEL32.@)
+ */
+BOOL WINAPI WriteConsoleW(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumberOfCharsToWrite,
+			  LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved)
+{
+    DWORD			mode;
+    DWORD			nw = 0;
+    WCHAR*			psz = (WCHAR*)lpBuffer;
+    CONSOLE_SCREEN_BUFFER_INFO	csbi;
+    int				k, first = 0;
+
+    TRACE("%d %s %ld %p %p\n",
+	  hConsoleOutput, debugstr_wn(lpBuffer, nNumberOfCharsToWrite),
+	  nNumberOfCharsToWrite, lpNumberOfCharsWritten, lpReserved);
+
+    if (lpNumberOfCharsWritten) *lpNumberOfCharsWritten = 0;
+
+    if (!GetConsoleMode(hConsoleOutput, &mode) ||
+	!GetConsoleScreenBufferInfo(hConsoleOutput, &csbi))
+	return FALSE;
+
+    if (mode & ENABLE_PROCESSED_OUTPUT)
+    {
+	int	i;
+
+	for (i = 0; i < nNumberOfCharsToWrite; i++)
+	{
+	    switch (psz[i])
+	    {
+	    case '\b': case '\t': case '\n': case '\a': case '\r':
+		/* don't handle here the i-th char... done below */
+		if ((k = i - first) > 0)
+		{
+		    if (!write_block(hConsoleOutput, &csbi, mode, &psz[first], k))
+			goto the_end;
+		    nw += k;
+		}
+		first = i + 1;
+		nw++;
+	    }
+	    switch (psz[i])
+	    {
+	    case '\b':
+		if (csbi.dwCursorPosition.X > 0) csbi.dwCursorPosition.X--;
+		break;
+	    case '\t':
+	        {
+		    WCHAR tmp[8] = {' ',' ',' ',' ',' ',' ',' ',' '};
+
+		    if (!write_block(hConsoleOutput, &csbi, mode, tmp,
+				     ((csbi.dwCursorPosition.X + 8) & ~7) - csbi.dwCursorPosition.X))
+			goto the_end;
+		}
+		break;
+	    case '\n':
+		next_line(hConsoleOutput, &csbi);
+		break;
+ 	    case '\a':
+		Beep(400, 300);
+ 		break;
+	    case '\r':
+		csbi.dwCursorPosition.X = 0;
+		break;
+	    default:
+		break;
+	    }
+	}
+    }
+
+    /* write the remaining block (if any) if processed output is enabled, or the
+     * entire buffer otherwise
+     */
+    if ((k = nNumberOfCharsToWrite - first) > 0)
+    {
+	if (!write_block(hConsoleOutput, &csbi, mode, &psz[first], k))
+	    goto the_end;
+	nw += k;
+    }
+
+ the_end:
+    SetConsoleCursorPosition(hConsoleOutput, csbi.dwCursorPosition);
+    if (lpNumberOfCharsWritten) *lpNumberOfCharsWritten = nw;
+    return nw != 0;
+}
+
+
+/***********************************************************************
+ *            WriteConsoleA   (KERNEL32.@)
+ */
+BOOL WINAPI WriteConsoleA(HANDLE hConsoleOutput, LPCVOID lpBuffer, DWORD nNumberOfCharsToWrite,
+			  LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved)
+{
+    BOOL	ret;
+    LPWSTR	xstring;
+    DWORD 	n;
+
+    n = MultiByteToWideChar(CP_ACP, 0, lpBuffer, nNumberOfCharsToWrite, NULL, 0);
+
+    if (lpNumberOfCharsWritten) *lpNumberOfCharsWritten = 0;
+    xstring = HeapAlloc(GetProcessHeap(), 0, n * sizeof(WCHAR));
+    if (!xstring) return 0;
+
+    MultiByteToWideChar(CP_ACP, 0, lpBuffer, nNumberOfCharsToWrite, xstring, n);
+
+    ret = WriteConsoleW(hConsoleOutput, xstring, n, lpNumberOfCharsWritten, 0);
+
+    HeapFree(GetProcessHeap(), 0, xstring);
+
+    return ret;
+}
+
+/******************************************************************************
+ * SetConsoleCursorPosition [KERNEL32.@]
+ * Sets the cursor position in console
+ *
+ * PARAMS
+ *    hConsoleOutput   [I] Handle of console screen buffer
+ *    dwCursorPosition [I] New cursor position coordinates
+ *
+ * RETURNS STD
+ */
+BOOL WINAPI SetConsoleCursorPosition(HANDLE hcon, COORD pos)
+{
+    BOOL 			ret;
+    CONSOLE_SCREEN_BUFFER_INFO	csbi;
+    int				do_move = 0;
+    int				w, h;
+
+    TRACE("%x %d %d\n", hcon, pos.X, pos.Y);
+
+    SERVER_START_REQ(set_console_output_info)
+    {
+        req->handle         = hcon;
+        req->cursor_x       = pos.X;
+        req->cursor_y       = pos.Y;
+        req->mask           = SET_CONSOLE_OUTPUT_INFO_CURSOR_POS;
+        ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+
+    if (!ret || !GetConsoleScreenBufferInfo(hcon, &csbi))
+	return FALSE;
+
+    /* if cursor is no longer visible, scroll the visible window... */
+    w = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+    h = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+    if (pos.X < csbi.srWindow.Left)
+    {
+	csbi.srWindow.Left   = min(pos.X, csbi.dwSize.X - w);
+	do_move++;
+    }
+    else if (pos.X > csbi.srWindow.Right)
+    {
+	csbi.srWindow.Left   = max(pos.X, w) - w + 1;
+	do_move++;
+    }
+    csbi.srWindow.Right  = csbi.srWindow.Left + w - 1;
+
+    if (pos.Y < csbi.srWindow.Top)
+    {
+	csbi.srWindow.Top    = min(pos.Y, csbi.dwSize.Y - h);
+	do_move++;
+    }
+    else if (pos.Y > csbi.srWindow.Bottom)
+    {
+	csbi.srWindow.Top   = max(pos.Y, h) - h + 1;
+	do_move++;
+    }
+    csbi.srWindow.Bottom = csbi.srWindow.Top + h - 1;
+
+    ret = (do_move) ? SetConsoleWindowInfo(hcon, TRUE, &csbi.srWindow) : TRUE;
+
+    return ret;
+}
+
+/******************************************************************************
+ * GetConsoleCursorInfo [KERNEL32.@]  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
+ */
+BOOL WINAPI GetConsoleCursorInfo(HANDLE hcon, LPCONSOLE_CURSOR_INFO cinfo)
+{
+    BOOL ret;
+
+    SERVER_START_REQ(get_console_output_info)
+    {
+        req->handle = hcon;
+        ret = !wine_server_call_err( req );
+        if (ret && cinfo)
+        {
+            cinfo->dwSize = reply->cursor_size;
+            cinfo->bVisible = reply->cursor_visible;
+        }
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
+
+/******************************************************************************
+ * SetConsoleCursorInfo [KERNEL32.@]  Sets size and visibility of cursor
+ *
+ * PARAMS
+ * 	hcon	[I] Handle to console screen buffer
+ * 	cinfo	[I] Address of cursor information
+ * RETURNS
+ *    Success: TRUE
+ *    Failure: FALSE
+ */
+BOOL WINAPI SetConsoleCursorInfo(HANDLE hCon, LPCONSOLE_CURSOR_INFO cinfo)
+{
+    BOOL ret;
+
+    SERVER_START_REQ(set_console_output_info)
+    {
+        req->handle         = hCon;
+        req->cursor_size    = cinfo->dwSize;
+        req->cursor_visible = cinfo->bVisible;
+        req->mask           = SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM;
+        ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
+
+/******************************************************************************
+ * SetConsoleWindowInfo [KERNEL32.@]  Sets size and position of console
+ *
+ * PARAMS
+ *	hcon	        [I] Handle to console screen buffer
+ *	bAbsolute	[I] Coordinate type flag
+ *	window		[I] Address of new window rectangle
+ * RETURNS
+ *    Success: TRUE
+ *    Failure: FALSE
+ */
+BOOL WINAPI SetConsoleWindowInfo(HANDLE hCon, BOOL bAbsolute, LPSMALL_RECT window)
+{
+    SMALL_RECT	p = *window;
+    BOOL	ret;
+
+    if (!bAbsolute)
+    {
+	CONSOLE_SCREEN_BUFFER_INFO	csbi;
+	if (!GetConsoleScreenBufferInfo(hCon, &csbi))
+	    return FALSE;
+	p.Left   += csbi.srWindow.Left;
+	p.Top    += csbi.srWindow.Top;
+	p.Right  += csbi.srWindow.Left;
+	p.Bottom += csbi.srWindow.Top;
+    }
+    SERVER_START_REQ(set_console_output_info)
+    {
+        req->handle         = hCon;
+	req->win_left       = p.Left;
+	req->win_top        = p.Top;
+	req->win_right      = p.Right;
+	req->win_bottom     = p.Bottom;
+        req->mask           = SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW;
+        ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+
+    return ret;
+}
+
+
+/******************************************************************************
+ * SetConsoleTextAttribute [KERNEL32.@]  Sets colors for text
+ *
+ * Sets the foreground and background color attributes of characters
+ * written to the screen buffer.
+ *
+ * RETURNS
+ *    Success: TRUE
+ *    Failure: FALSE
+ */
+BOOL WINAPI SetConsoleTextAttribute(HANDLE hConsoleOutput, WORD wAttr)
+{
+    BOOL ret;
+
+    SERVER_START_REQ(set_console_output_info)
+    {
+        req->handle = hConsoleOutput;
+        req->attr   = wAttr;
+        req->mask   = SET_CONSOLE_OUTPUT_INFO_ATTR;
+        ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
+
+/******************************************************************************
+ * SetConsoleScreenBufferSize [KERNEL32.@]  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
+ */
+BOOL WINAPI SetConsoleScreenBufferSize(HANDLE hConsoleOutput, COORD dwSize)
+{
+    BOOL ret;
+
+    SERVER_START_REQ(set_console_output_info)
+    {
+        req->handle = hConsoleOutput;
+        req->width  = dwSize.X;
+        req->height = dwSize.Y;
+        req->mask   = SET_CONSOLE_OUTPUT_INFO_SIZE;
+        ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
+
+/******************************************************************************
+ * ScrollConsoleScreenBufferA [KERNEL32.@]
+ *
+ */
+BOOL WINAPI ScrollConsoleScreenBufferA(HANDLE hConsoleOutput, LPSMALL_RECT lpScrollRect,
+				       LPSMALL_RECT lpClipRect, COORD dwDestOrigin,
+				       LPCHAR_INFO lpFill)
+{
+    CHAR_INFO	ciw;
+
+    ciw.Attributes = lpFill->Attributes;
+    MultiByteToWideChar(CP_ACP, 0, &lpFill->Char.AsciiChar, 1, &ciw.Char.UnicodeChar, 1);
+
+    return ScrollConsoleScreenBufferW(hConsoleOutput, lpScrollRect, lpClipRect,
+				      dwDestOrigin, &ciw);
+}
+
+/******************************************************************
+ *		CONSOLE_FillLineUniform
+ *
+ * Helper function for ScrollConsoleScreenBufferW
+ * Fills a part of a line with a constant character info
+ */
+void CONSOLE_FillLineUniform(HANDLE hConsoleOutput, int i, int j, int len, LPCHAR_INFO lpFill)
+{
+    SERVER_START_REQ( fill_console_output )
+    {
+        req->handle    = hConsoleOutput;
+        req->mode      = CHAR_INFO_MODE_TEXTATTR;
+        req->x         = i;
+        req->y         = j;
+        req->count     = len;
+        req->wrap      = FALSE;
+        req->data.ch   = lpFill->Char.UnicodeChar;
+        req->data.attr = lpFill->Attributes;
+        wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+}
+
+/******************************************************************************
+ * ScrollConsoleScreenBufferW [KERNEL32.@]
+ *
+ */
+
+BOOL WINAPI ScrollConsoleScreenBufferW(HANDLE hConsoleOutput, LPSMALL_RECT lpScrollRect,
+				       LPSMALL_RECT lpClipRect, COORD dwDestOrigin,
+				       LPCHAR_INFO lpFill)
+{
+    SMALL_RECT			dst;
+    DWORD			ret;
+    int				i, j;
+    int				start = -1;
+    SMALL_RECT			clip;
+    CONSOLE_SCREEN_BUFFER_INFO	csbi;
+    BOOL			inside;
+
+    if (lpClipRect)
+	TRACE("(%d,(%d,%d-%d,%d),(%d,%d-%d,%d),%d-%d,%p)\n", hConsoleOutput,
+	      lpScrollRect->Left, lpScrollRect->Top,
+	      lpScrollRect->Right, lpScrollRect->Bottom,
+	      lpClipRect->Left, lpClipRect->Top,
+	      lpClipRect->Right, lpClipRect->Bottom,
+	      dwDestOrigin.X, dwDestOrigin.Y, lpFill);
+    else
+	TRACE("(%d,(%d,%d-%d,%d),(nil),%d-%d,%p)\n", hConsoleOutput,
+	      lpScrollRect->Left, lpScrollRect->Top,
+	      lpScrollRect->Right, lpScrollRect->Bottom,
+	      dwDestOrigin.X, dwDestOrigin.Y, lpFill);
+
+    if (!GetConsoleScreenBufferInfo(hConsoleOutput, &csbi))
+	return FALSE;
+
+    /* step 1: get dst rect */
+    dst.Left = dwDestOrigin.X;
+    dst.Top = dwDestOrigin.Y;
+    dst.Right = dst.Left + (lpScrollRect->Right - lpScrollRect->Left);
+    dst.Bottom = dst.Top + (lpScrollRect->Bottom - lpScrollRect->Top);
+
+    /* step 2a: compute the final clip rect (optional passed clip and screen buffer limits */
+    if (lpClipRect)
+    {
+	clip.Left   = max(0, lpClipRect->Left);
+	clip.Right  = min(csbi.dwSize.X - 1, lpClipRect->Right);
+	clip.Top    = max(0, lpClipRect->Top);
+	clip.Bottom = min(csbi.dwSize.Y - 1, lpClipRect->Bottom);
+    }
+    else
+    {
+	clip.Left   = 0;
+	clip.Right  = csbi.dwSize.X - 1;
+	clip.Top    = 0;
+	clip.Bottom = csbi.dwSize.Y - 1;
+    }
+    if (clip.Left > clip.Right || clip.Top > clip.Bottom) return FALSE;
+
+    /* step 2b: clip dst rect */
+    if (dst.Left   < clip.Left  ) dst.Left   = clip.Left;
+    if (dst.Top    < clip.Top   ) dst.Top    = clip.Top;
+    if (dst.Right  > clip.Right ) dst.Right  = clip.Right;
+    if (dst.Bottom > clip.Bottom) dst.Bottom = clip.Bottom;
+
+    /* step 3: transfer the bits */
+    SERVER_START_REQ(move_console_output)
+    {
+        req->handle = hConsoleOutput;
+	req->x_src = lpScrollRect->Left;
+	req->y_src = lpScrollRect->Top;
+	req->x_dst = dst.Left;
+	req->y_dst = dst.Top;
+	req->w = dst.Right - dst.Left + 1;
+	req->h = dst.Bottom - dst.Top + 1;
+	ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+
+    if (!ret) return FALSE;
+
+    /* step 4: clean out the exposed part */
+
+    /* have to write cell [i,j] if it is not in dst rect (because it has already
+     * been written to by the scroll) and is in clip (we shall not write
+     * outside of clip)
+     */
+    for (j = max(lpScrollRect->Top, clip.Top); j <= min(lpScrollRect->Bottom, clip.Bottom); j++)
+    {
+	inside = dst.Top <= j && j <= dst.Bottom;
+	start = -1;
+	for (i = max(lpScrollRect->Left, clip.Left); i <= min(lpScrollRect->Right, clip.Right); i++)
+	{
+	    if (inside && dst.Left <= i && i <= dst.Right)
+	    {
+		if (start != -1)
+		{
+		    CONSOLE_FillLineUniform(hConsoleOutput, start, j, i - start, lpFill);
+		    start = -1;
+		}
+	    }
+	    else
+	    {
+		if (start == -1) start = i;
+	    }
+	}
+	if (start != -1)
+	    CONSOLE_FillLineUniform(hConsoleOutput, start, j, i - start, lpFill);
+    }
+
+    return TRUE;
+}
+
+
+/* ====================================================================
+ *
+ * Console manipulation functions
+ *
+ * ====================================================================*/
+
+/* some missing functions...
+ * FIXME: those are likely to be defined as undocumented function in kernel32 (or part of them)
+ * should get the right API and implement them
+ *	GetConsoleCommandHistory[AW] (dword dword dword)
+ *	GetConsoleCommandHistoryLength[AW]
+ *	SetConsoleCommandHistoryMode
+ *	SetConsoleNumberOfCommands[AW]
+ */
+int CONSOLE_GetHistory(int idx, WCHAR* buf, int buf_len)
+{
+    int len = 0;
+
+    SERVER_START_REQ( get_console_input_history )
+    {
+        req->handle = 0;
+        req->index = idx;
+        if (buf && buf_len > 1)
+        {
+            wine_server_set_reply( req, buf, (buf_len - 1) * sizeof(WCHAR) );
+        }
+        if (!wine_server_call_err( req ))
+        {
+            if (buf) buf[wine_server_reply_size(reply) / sizeof(WCHAR)] = 0;
+            len = reply->total / sizeof(WCHAR) + 1;
+        }
+    }
+    SERVER_END_REQ;
+    return len;
+}
+
+/******************************************************************
+ *		CONSOLE_AppendHistory
+ *
+ *
+ */
+BOOL	CONSOLE_AppendHistory(const WCHAR* ptr)
+{
+    size_t	len = strlenW(ptr);
+    BOOL	ret;
+
+    while (len && (ptr[len - 1] == '\n' || ptr[len - 1] == '\r')) len--;
+
+    SERVER_START_REQ( append_console_input_history )
+    {
+        req->handle = 0;
+        wine_server_add_data( req, ptr, len * sizeof(WCHAR) );
+        ret = !wine_server_call_err( req );
+    }
+    SERVER_END_REQ;
+    return ret;
+}
+
+/******************************************************************
+ *		CONSOLE_GetNumHistoryEntries
+ *
+ *
+ */
+unsigned CONSOLE_GetNumHistoryEntries(void)
+{
+    unsigned ret = -1;
+    SERVER_START_REQ(get_console_input_info)
+    {
+        req->handle = 0;
+        if (!wine_server_call_err( req )) ret = reply->history_index;
+    }
+    SERVER_END_REQ;
+    return ret;
+}
Index: dlls/ntdll/Makefile.in
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/dlls/ntdll/Makefile.in,v
retrieving revision 1.29
diff -u -u -r1.29 Makefile.in
--- dlls/ntdll/Makefile.in	10 Jul 2002 23:22:29 -0000	1.29
+++ dlls/ntdll/Makefile.in	30 Jul 2002 12:17:13 -0000
@@ -85,9 +85,7 @@
 	$(TOPOBJDIR)/scheduler/syslevel.c \
 	$(TOPOBJDIR)/scheduler/thread.c \
 	$(TOPOBJDIR)/scheduler/timer.c \
-	$(TOPOBJDIR)/win32/console.c \
 	$(TOPOBJDIR)/win32/device.c \
-	$(TOPOBJDIR)/win32/editline.c \
 	$(TOPOBJDIR)/win32/except.c \
 	$(TOPOBJDIR)/win32/init.c \
 	$(TOPOBJDIR)/win32/kernel32.c \
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/kernel/editline.c	Tue Jul 30 14:30:27 2002
@@ -0,0 +1,879 @@
+/*
+ * line edition function for Win32 console
+ *
+ * Copyright 2001 Eric Pouech
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+#include "wine/port.h"
+
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wincon.h"
+#include "wine/unicode.h"
+#include "winnls.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(console);
+
+/* console.c */
+extern int CONSOLE_GetHistory(int idx, WCHAR* buf, int buf_len);
+extern BOOL CONSOLE_AppendHistory(const WCHAR *p);
+extern unsigned int CONSOLE_GetNumHistoryEntries(void);
+extern void CONSOLE_FillLineUniform(HANDLE hConsoleOutput, int i, int j, int len, LPCHAR_INFO lpFill);
+
+struct WCEL_Context;
+
+typedef struct
+{
+    WCHAR			val;		/* vk or unicode char */
+    void			(*func)(struct WCEL_Context* ctx);
+} KeyEntry;
+
+typedef struct
+{
+    DWORD			keyState;	/* keyState (from INPUT_RECORD) to match */
+    BOOL			chkChar;	/* check vk or char */
+    KeyEntry*			entries;	/* array of entries */
+} KeyMap;
+
+typedef struct WCEL_Context {
+    WCHAR*			line;		/* the line being edited */
+    size_t			alloc;		/* number of WCHAR in line */
+    unsigned    		len;		/* number of chars in line */
+    unsigned			ofs;		/* offset for cursor in current line */
+    WCHAR*			yanked;		/* yanked line */
+    unsigned			mark;		/* marked point (emacs mode only) */
+    CONSOLE_SCREEN_BUFFER_INFO	csbi;		/* current state (initial cursor, window size, attribute) */
+    HANDLE			hConIn;
+    HANDLE			hConOut;
+    unsigned			done : 1,	/* to 1 when we're done with editing */
+	                        error : 1,	/* to 1 when an error occurred in the editing */
+                                can_wrap : 1;   /* to 1 when multi-line edition can take place */
+    unsigned			histSize;
+    unsigned			histPos;
+    WCHAR*			histCurr;
+} WCEL_Context;
+
+#if 0
+static void WCEL_Dump(WCEL_Context* ctx, const char* pfx)
+{
+    MESSAGE("%s: [line=%s[alloc=%u] ofs=%u len=%u start=(%d,%d) mask=%c%c%c]\n"
+	    "\t\thist=(size=%u pos=%u curr=%s)\n"
+            "\t\tyanked=%s\n",
+	    pfx, debugstr_w(ctx->line), ctx->alloc, ctx->ofs, ctx->len,
+	    ctx->csbi.dwCursorPosition.X, ctx->csbi.dwCursorPosition.Y,
+	    ctx->done ? 'D' : 'd', ctx->error ? 'E' : 'e', ctx->can_wrap ? 'W' : 'w',
+	    ctx->histSize, ctx->histPos, debugstr_w(ctx->histCurr),
+            debugstr_w(ctx->yanked));
+}
+#endif
+
+/* ====================================================================
+ *
+ * Console helper functions
+ *
+ * ====================================================================*/
+
+static BOOL WCEL_Get(WCEL_Context* ctx, INPUT_RECORD* ir)
+{
+    DWORD		retv;
+
+    for (;;)
+    {
+	/* data available ? */
+	if (ReadConsoleInputW(ctx->hConIn, ir, 1, &retv) && retv == 1)
+	    return TRUE;
+	/* then wait... */
+	switch (WaitForSingleObject(ctx->hConIn, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+	    break;
+	default:
+	    /* we have checked that hConIn was a console handle (could be sb) */
+	    ERR("Shouldn't happen\n");
+	    /* fall thru */
+	case WAIT_ABANDONED:
+	case WAIT_TIMEOUT:
+	    ctx->error = 1;
+	    ERR("hmm bad situation\n");
+	    return FALSE;
+	}
+    }
+}
+
+static inline void WCEL_Beep(WCEL_Context* ctx)
+{
+    Beep(400, 300);
+}
+
+static inline BOOL WCEL_IsSingleLine(WCEL_Context* ctx, size_t len)
+{
+    return ctx->csbi.dwCursorPosition.X + ctx->len + len <= ctx->csbi.dwSize.X;
+}
+
+static inline COORD WCEL_GetCoord(WCEL_Context* ctx, int ofs)
+{
+    COORD       c;
+    unsigned    len = ctx->csbi.dwSize.X - ctx->csbi.dwCursorPosition.X;
+
+    c.Y = ctx->csbi.dwCursorPosition.Y;
+    if (ofs >= len)
+    {
+        ofs -= len;
+        c.X = ofs % ctx->csbi.dwSize.X;
+        c.Y += 1 + ofs / ctx->csbi.dwSize.X;
+    }
+    else c.X = ctx->csbi.dwCursorPosition.X + ofs;
+    return c;
+}
+
+static inline void WCEL_Update(WCEL_Context* ctx, int beg, int len)
+{
+    WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[beg], len,
+                                 WCEL_GetCoord(ctx, beg), NULL);
+}
+
+/* ====================================================================
+ *
+ * context manipulation functions
+ *
+ * ====================================================================*/
+
+static BOOL WCEL_Grow(WCEL_Context* ctx, size_t len)
+{
+    if (!WCEL_IsSingleLine(ctx, len) && !ctx->can_wrap)
+    {
+        FIXME("Mode doesn't allow to wrap. However, we should allow to overwrite current string\n");
+        return FALSE;
+    }
+
+    if (ctx->len + len >= ctx->alloc)
+    {
+	WCHAR*	newline;
+        size_t  newsize;
+
+        /* round up size to 32 byte-WCHAR boundary */
+        newsize = (ctx->len + len + 1 + 31) & ~31;
+	newline = HeapReAlloc(GetProcessHeap(), 0, ctx->line, sizeof(WCHAR) * newsize);
+	if (!newline) return FALSE;
+	ctx->line = newline;
+	ctx->alloc = newsize;
+    }
+    return TRUE;
+}
+
+static void WCEL_DeleteString(WCEL_Context* ctx, int beg, int end)
+{
+    unsigned    str_len = end - beg;
+    COORD       cbeg = WCEL_GetCoord(ctx, ctx->len - str_len);
+    COORD       cend = WCEL_GetCoord(ctx, ctx->len);
+    CHAR_INFO   ci;
+
+    if (end < ctx->len)
+	memmove(&ctx->line[beg], &ctx->line[end], (ctx->len - end) * sizeof(WCHAR));
+    /* we need to clean from ctx->len - str_len to ctx->len */
+
+    ci.Char.UnicodeChar = ' ';
+    ci.Attributes = ctx->csbi.wAttributes;
+
+    if (cbeg.Y == cend.Y)
+    {
+        /* partial erase of sole line */
+        CONSOLE_FillLineUniform(ctx->hConOut, cbeg.X, cbeg.Y,
+                                cend.X - cbeg.X, &ci);
+    }
+    else
+    {
+        int         i;
+        /* erase til eol on first line */
+        CONSOLE_FillLineUniform(ctx->hConOut, cbeg.X, cbeg.Y,
+                                ctx->csbi.dwSize.X - cbeg.X, &ci);
+        /* completly erase all the others (full lines) */
+        for (i = cbeg.Y + 1; i < cend.Y; i++)
+            CONSOLE_FillLineUniform(ctx->hConOut, 0, i, ctx->csbi.dwSize.X, &ci);
+        /* erase from beg of line until last pos on last line */
+        CONSOLE_FillLineUniform(ctx->hConOut, 0, cend.Y, cend.X, &ci);
+    }
+    ctx->len -= str_len;
+    WCEL_Update(ctx, 0, ctx->len);
+    ctx->line[ctx->len] = 0;
+}
+
+static void WCEL_InsertString(WCEL_Context* ctx, const WCHAR* str)
+{
+    size_t	len = lstrlenW(str);
+
+    if (!len || !WCEL_Grow(ctx, len)) return;
+    if (ctx->len > ctx->ofs)
+	memmove(&ctx->line[ctx->ofs + len], &ctx->line[ctx->ofs], (ctx->len - ctx->ofs) * sizeof(WCHAR));
+    memcpy(&ctx->line[ctx->ofs], str, len * sizeof(WCHAR));
+    ctx->len += len;
+    ctx->line[ctx->len] = 0;
+    WCEL_Update(ctx, ctx->ofs, ctx->len - ctx->ofs);
+
+    ctx->ofs += len;
+}
+
+static void WCEL_InsertChar(WCEL_Context* ctx, WCHAR c)
+{
+    WCHAR	buffer[2];
+
+    /* do not insert 0..31 control characters */
+    if (c < ' ' && c != '\t') return;
+
+    buffer[0] = c;
+    buffer[1] = 0;
+    WCEL_InsertString(ctx, buffer);
+}
+
+static void WCEL_FreeYank(WCEL_Context* ctx)
+{
+    if (ctx->yanked)
+    {
+        HeapFree(GetProcessHeap(), 0, ctx->yanked);
+        ctx->yanked = NULL;
+    }
+}
+
+static void WCEL_SaveYank(WCEL_Context* ctx, int beg, int end)
+{
+    int len = end - beg;
+    if (len <= 0) return;
+
+    WCEL_FreeYank(ctx);
+    ctx->yanked = HeapReAlloc(GetProcessHeap(), 0, ctx->yanked, (len + 1) * sizeof(WCHAR));
+    if (!ctx->yanked) return;
+    memcpy(ctx->yanked, &ctx->line[beg], len * sizeof(WCHAR));
+    ctx->yanked[len] = 0;
+}
+
+/* FIXME NTDLL doesn't export iswalnum, and I don't want to link in msvcrt when most
+ * of the data lay in unicode lib
+ */
+static inline BOOL WCEL_iswalnum(WCHAR wc)
+{
+    return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
+}
+
+static int WCEL_GetLeftWordTransition(WCEL_Context* ctx, int ofs)
+{
+    ofs--;
+    while (ofs >= 0 && !WCEL_iswalnum(ctx->line[ofs])) ofs--;
+    while (ofs >= 0 && WCEL_iswalnum(ctx->line[ofs])) ofs--;
+    if (ofs >= 0) ofs++;
+    return max(ofs, 0);
+}
+
+static int WCEL_GetRightWordTransition(WCEL_Context* ctx, int ofs)
+{
+    ofs++;
+    while (ofs <= ctx->len && WCEL_iswalnum(ctx->line[ofs])) ofs++;
+    while (ofs <= ctx->len && !WCEL_iswalnum(ctx->line[ofs])) ofs++;
+    return min(ofs, ctx->len);
+}
+
+static WCHAR* WCEL_GetHistory(WCEL_Context* ctx, int idx)
+{
+    WCHAR*	ptr;
+
+    if (idx == ctx->histSize - 1)
+    {
+	ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(ctx->histCurr) + 1) * sizeof(WCHAR));
+	lstrcpyW(ptr, ctx->histCurr);
+    }
+    else
+    {
+	int	len = CONSOLE_GetHistory(idx, NULL, 0);
+
+	if ((ptr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
+	{
+	    CONSOLE_GetHistory(idx, ptr, len);
+	}
+    }
+    return ptr;
+}
+
+static void	WCEL_HistoryInit(WCEL_Context* ctx)
+{
+    ctx->histPos  = CONSOLE_GetNumHistoryEntries();
+    ctx->histSize = ctx->histPos + 1;
+    ctx->histCurr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR));
+}
+
+static void    WCEL_MoveToHist(WCEL_Context* ctx, int idx)
+{
+    WCHAR*	data = WCEL_GetHistory(ctx, idx);
+    int		len = lstrlenW(data) + 1;
+
+    /* save current line edition for recall when needed (FIXME seems broken to me) */
+    if (ctx->histPos == ctx->histSize - 1)
+    {
+	if (ctx->histCurr) HeapFree(GetProcessHeap(), 0, ctx->histCurr);
+	ctx->histCurr = HeapAlloc(GetProcessHeap(), 0, (ctx->len + 1) * sizeof(WCHAR));
+	memcpy(ctx->histCurr, ctx->line, (ctx->len + 1) * sizeof(WCHAR));
+    }
+    /* need to clean also the screen if new string is shorter than old one */
+    WCEL_DeleteString(ctx, 0, ctx->len);
+    ctx->ofs = 0;
+    /* insert new string */
+    if (WCEL_Grow(ctx, len))
+    {
+	WCEL_InsertString(ctx, data);
+	HeapFree(GetProcessHeap(), 0, data);
+	ctx->histPos = idx;
+    }
+}
+
+static void    WCEL_FindPrevInHist(WCEL_Context* ctx)
+{
+    int startPos = ctx->histPos;
+    WCHAR*	data;
+    int		len, oldofs;
+
+    if (ctx->histPos && ctx->histPos == ctx->histSize) {
+        startPos--;
+        ctx->histPos--;
+    }
+
+    do {
+       data = WCEL_GetHistory(ctx, ctx->histPos);
+
+       if (ctx->histPos) ctx->histPos--;
+       else ctx->histPos = (ctx->histSize-1);
+
+       len = lstrlenW(data) + 1;
+       if ((len >= ctx->ofs) &&
+           (memcmp(ctx->line, data, ctx->ofs * sizeof(WCHAR)) == 0)) {
+
+           /* need to clean also the screen if new string is shorter than old one */
+           WCEL_DeleteString(ctx, 0, ctx->len);
+
+           if (WCEL_Grow(ctx, len))
+           {
+              oldofs = ctx->ofs;
+              ctx->ofs = 0;
+              WCEL_InsertString(ctx, data);
+              ctx->ofs = oldofs;
+              SetConsoleCursorPosition(ctx->hConOut, WCEL_GetCoord(ctx, ctx->ofs));
+              HeapFree(GetProcessHeap(), 0, data);
+              return;
+           }
+       }
+    } while (ctx->histPos != startPos);
+
+    return;
+}
+
+/* ====================================================================
+ *
+ * basic edition functions
+ *
+ * ====================================================================*/
+
+static void WCEL_Done(WCEL_Context* ctx)
+{
+    WCHAR       nl = '\n';
+    if (!WCEL_Grow(ctx, 1)) return;
+    ctx->line[ctx->len++] = '\n';
+    ctx->line[ctx->len] = 0;
+    WriteConsoleW(ctx->hConOut, &nl, 1, NULL, NULL);
+    ctx->done = 1;
+}
+
+static void WCEL_MoveLeft(WCEL_Context* ctx)
+{
+    if (ctx->ofs > 0) ctx->ofs--;
+}
+
+static void WCEL_MoveRight(WCEL_Context* ctx)
+{
+    if (ctx->ofs < ctx->len) ctx->ofs++;
+}
+
+static void WCEL_MoveToLeftWord(WCEL_Context* ctx)
+{
+    int	new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
+    if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
+}
+
+static void WCEL_MoveToRightWord(WCEL_Context* ctx)
+{
+    int	new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
+    if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
+}
+
+static void WCEL_MoveToBeg(WCEL_Context* ctx)
+{
+    ctx->ofs = 0;
+}
+
+static void WCEL_MoveToEnd(WCEL_Context* ctx)
+{
+    ctx->ofs = ctx->len;
+}
+
+static void WCEL_SetMark(WCEL_Context* ctx)
+{
+    ctx->mark = ctx->ofs;
+}
+
+static void WCEL_ExchangeMark(WCEL_Context* ctx)
+{
+    unsigned tmp;
+
+    if (ctx->mark > ctx->len) return;
+    tmp = ctx->ofs;
+    ctx->ofs = ctx->mark;
+    ctx->mark = tmp;
+}
+
+static void WCEL_CopyMarkedZone(WCEL_Context* ctx)
+{
+    unsigned beg, end;
+
+    if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
+    if (ctx->mark > ctx->ofs)
+    {
+	beg = ctx->ofs;		end = ctx->mark;
+    }
+    else
+    {
+	beg = ctx->mark;	end = ctx->ofs;
+    }
+    WCEL_SaveYank(ctx, beg, end);
+}
+
+static void WCEL_TransposeChar(WCEL_Context* ctx)
+{
+    WCHAR	c;
+
+    if (!ctx->ofs || ctx->ofs == ctx->len) return;
+
+    c = ctx->line[ctx->ofs];
+    ctx->line[ctx->ofs] = ctx->line[ctx->ofs - 1];
+    ctx->line[ctx->ofs - 1] = c;
+
+    WCEL_Update(ctx, ctx->ofs - 1, 2);
+    ctx->ofs++;
+}
+
+static void WCEL_TransposeWords(WCEL_Context* ctx)
+{
+    int	left_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs),
+        right_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
+    if (left_ofs < ctx->ofs && right_ofs > ctx->ofs)
+    {
+        unsigned len_r = right_ofs - ctx->ofs;
+        unsigned len_l = ctx->ofs - left_ofs;
+
+        char*   tmp = HeapAlloc(GetProcessHeap(), 0, len_r * sizeof(WCHAR));
+        if (!tmp) return;
+
+        memcpy(tmp, &ctx->line[ctx->ofs], len_r * sizeof(WCHAR));
+        memmove(&ctx->line[left_ofs + len_r], &ctx->line[left_ofs], len_l * sizeof(WCHAR));
+        memcpy(&ctx->line[left_ofs], tmp, len_r * sizeof(WCHAR));
+
+        HeapFree(GetProcessHeap(), 0, tmp);
+        WCEL_Update(ctx, left_ofs, len_l + len_r);
+        ctx->ofs = right_ofs;
+    }
+}
+
+static void WCEL_LowerCaseWord(WCEL_Context* ctx)
+{
+    int	new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
+    if (new_ofs != ctx->ofs)
+    {
+	int	i;
+	for (i = ctx->ofs; i <= new_ofs; i++)
+	    ctx->line[i] = tolowerW(ctx->line[i]);
+        WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
+	ctx->ofs = new_ofs;
+    }
+}
+
+static void WCEL_UpperCaseWord(WCEL_Context* ctx)
+{
+    int	new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
+    if (new_ofs != ctx->ofs)
+    {
+	int	i;
+	for (i = ctx->ofs; i <= new_ofs; i++)
+	    ctx->line[i] = toupperW(ctx->line[i]);
+	WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
+	ctx->ofs = new_ofs;
+    }
+}
+
+static void WCEL_CapitalizeWord(WCEL_Context* ctx)
+{
+    int	new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
+    if (new_ofs != ctx->ofs)
+    {
+	int	i;
+
+	ctx->line[ctx->ofs] = toupperW(ctx->line[ctx->ofs]);
+	for (i = ctx->ofs + 1; i <= new_ofs; i++)
+	    ctx->line[i] = tolowerW(ctx->line[i]);
+	WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
+	ctx->ofs = new_ofs;
+    }
+}
+
+static void WCEL_Yank(WCEL_Context* ctx)
+{
+    WCEL_InsertString(ctx, ctx->yanked);
+}
+
+static void WCEL_KillToEndOfLine(WCEL_Context* ctx)
+{
+    WCEL_SaveYank(ctx, ctx->ofs, ctx->len);
+    WCEL_DeleteString(ctx, ctx->ofs, ctx->len);
+}
+
+static void WCEL_KillMarkedZone(WCEL_Context* ctx)
+{
+    unsigned beg, end;
+
+    if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
+    if (ctx->mark > ctx->ofs)
+    {
+	beg = ctx->ofs;		end = ctx->mark;
+    }
+    else
+    {
+	beg = ctx->mark;	end = ctx->ofs;
+    }
+    WCEL_SaveYank(ctx, beg, end);
+    WCEL_DeleteString(ctx, beg, end);
+    ctx->ofs = beg;
+}
+
+static void WCEL_DeletePrevChar(WCEL_Context* ctx)
+{
+    if (ctx->ofs)
+    {
+	WCEL_DeleteString(ctx, ctx->ofs - 1, ctx->ofs);
+	ctx->ofs--;
+    }
+}
+
+static void WCEL_DeleteCurrChar(WCEL_Context* ctx)
+{
+    if (ctx->ofs < ctx->len)
+	WCEL_DeleteString(ctx, ctx->ofs, ctx->ofs + 1);
+}
+
+static void WCEL_DeleteLeftWord(WCEL_Context* ctx)
+{
+    int	new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
+    if (new_ofs != ctx->ofs)
+    {
+	WCEL_DeleteString(ctx, new_ofs, ctx->ofs);
+	ctx->ofs = new_ofs;
+    }
+}
+
+static void WCEL_DeleteRightWord(WCEL_Context* ctx)
+{
+    int	new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
+    if (new_ofs != ctx->ofs)
+    {
+	WCEL_DeleteString(ctx, ctx->ofs, new_ofs);
+    }
+}
+
+static void WCEL_MoveToPrevHist(WCEL_Context* ctx)
+{
+    if (ctx->histPos) WCEL_MoveToHist(ctx, ctx->histPos - 1);
+}
+
+static void WCEL_MoveToNextHist(WCEL_Context* ctx)
+{
+    if (ctx->histPos < ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histPos + 1);
+}
+
+static void WCEL_MoveToFirstHist(WCEL_Context* ctx)
+{
+    if (ctx->histPos != 0) WCEL_MoveToHist(ctx, 0);
+}
+
+static void WCEL_MoveToLastHist(WCEL_Context* ctx)
+{
+    if (ctx->histPos != ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histSize - 1);
+}
+
+static void WCEL_Redraw(WCEL_Context* ctx)
+{
+    COORD       c = WCEL_GetCoord(ctx, ctx->len);
+    CHAR_INFO   ci;
+
+    WCEL_Update(ctx, 0, ctx->len);
+
+    ci.Char.UnicodeChar = ' ';
+    ci.Attributes = ctx->csbi.wAttributes;
+
+    CONSOLE_FillLineUniform(ctx->hConOut, c.X, c.Y, ctx->csbi.dwSize.X - c.X, &ci);
+}
+
+static void WCEL_RepeatCount(WCEL_Context* ctx)
+{
+#if 0
+/* FIXME: wait untill all console code is in kernel32 */
+    INPUT_RECORD        ir;
+    unsigned            repeat = 0;
+
+    while (WCEL_Get(ctx, &ir, FALSE))
+    {
+        if (ir.EventType != KEY_EVENT) break;
+        if (ir.Event.KeyEvent.bKeyDown)
+        {
+            if ((ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON)) != 0)
+                break;
+            if (ir.Event.KeyEvent.uChar.UnicodeChar < '0' ||
+                ir.Event.KeyEvent.uChar.UnicodeChar > '9')
+                break;
+            repeat = repeat * 10 + ir.Event.KeyEvent.uChar.UnicodeChar - '0';
+        }
+        WCEL_Get(ctx, &ir, TRUE);
+    }
+    FIXME("=> %u\n", repeat);
+#endif
+}
+
+/* ====================================================================
+ *
+ * 		Key Maps
+ *
+ * ====================================================================*/
+
+#define CTRL(x)	((x) - '@')
+static KeyEntry StdKeyMap[] =
+{
+    {/*BACK*/0x08,	WCEL_DeletePrevChar 	},
+    {/*RETURN*/0x0d,	WCEL_Done		},
+    {/*DEL*/127,	WCEL_DeleteCurrChar 	},
+    {	0,		NULL			}
+};
+
+static KeyEntry Win32ExtraStdKeyMap[] =
+{
+    {/*VK_F8*/   0x77,	WCEL_FindPrevInHist	},
+    {	0,		NULL			}
+};
+
+
+static	KeyEntry EmacsKeyMapCtrl[] =
+{
+    {	CTRL('@'),	WCEL_SetMark		},
+    {	CTRL('A'),	WCEL_MoveToBeg		},
+    {	CTRL('B'),	WCEL_MoveLeft		},
+    /* C: done in server */
+    {	CTRL('D'),	WCEL_DeleteCurrChar	},
+    {	CTRL('E'),	WCEL_MoveToEnd		},
+    {	CTRL('F'),	WCEL_MoveRight		},
+    {	CTRL('G'),	WCEL_Beep		},
+    {	CTRL('H'),	WCEL_DeletePrevChar	},
+    /* I: meaningless (or tab ???) */
+    {	CTRL('J'),	WCEL_Done		},
+    {	CTRL('K'),	WCEL_KillToEndOfLine	},
+    {   CTRL('L'),      WCEL_Redraw             },
+    {	CTRL('M'),	WCEL_Done		},
+    {	CTRL('N'),	WCEL_MoveToNextHist	},
+    /* O; insert line... meaningless */
+    {	CTRL('P'),	WCEL_MoveToPrevHist	},
+    /* Q: [NIY] quoting... */
+    /* R: [NIY] search backwards... */
+    /* S: [NIY] search forwards... */
+    {	CTRL('T'),	WCEL_TransposeChar	},
+    {   CTRL('U'),      WCEL_RepeatCount        },
+    /* V: paragraph down... meaningless */
+    {	CTRL('W'),	WCEL_KillMarkedZone	},
+    {	CTRL('X'),	WCEL_ExchangeMark	},
+    {	CTRL('Y'),	WCEL_Yank		},
+    /* Z: meaningless */
+    {	0,		NULL			}
+};
+
+static KeyEntry EmacsKeyMapAlt[] =
+{
+    {/*DEL*/127,	WCEL_DeleteLeftWord	},
+    {	'<',		WCEL_MoveToFirstHist	},
+    {	'>',		WCEL_MoveToLastHist	},
+    {	'?',		WCEL_Beep		},
+    {	'b',		WCEL_MoveToLeftWord	},
+    {   'c',		WCEL_CapitalizeWord	},
+    {	'd',		WCEL_DeleteRightWord	},
+    {	'f',		WCEL_MoveToRightWord	},
+    {	'l',		WCEL_LowerCaseWord	},
+    {   't',		WCEL_TransposeWords	},
+    {	'u',		WCEL_UpperCaseWord	},
+    {	'w', 		WCEL_CopyMarkedZone	},
+    {	0,		NULL			}
+};
+
+static KeyEntry EmacsKeyMapExtended[] =
+{
+    {/*RETURN*/  0x0d,	WCEL_Done },
+    {/*VK_PRIOR*/0x21, 	WCEL_MoveToPrevHist	},
+    {/*VK_NEXT*/ 0x22,	WCEL_MoveToNextHist 	},
+    {/*VK_END*/  0x23,	WCEL_MoveToEnd		},
+    {/*VK_HOME*/ 0x24,	WCEL_MoveToBeg		},
+    {/*VK_RIGHT*/0x27,	WCEL_MoveRight 		},
+    {/*VK_LEFT*/ 0x25,	WCEL_MoveLeft 		},
+    {/*VK_DEL*/  0x2e,  WCEL_DeleteCurrChar     },
+    {	0,		NULL 			}
+};
+
+static KeyMap	EmacsKeyMap[] =
+{
+    {0x00000000, 1, StdKeyMap},
+    {0x00000001, 1, EmacsKeyMapAlt},	/* left  alt  */
+    {0x00000002, 1, EmacsKeyMapAlt},	/* right alt  */
+    {0x00000004, 1, EmacsKeyMapCtrl},	/* left  ctrl */
+    {0x00000008, 1, EmacsKeyMapCtrl},	/* right ctrl */
+    {0x00000100, 0, EmacsKeyMapExtended},
+    {0,		 0, 0}
+};
+
+static	KeyEntry Win32KeyMapExtended[] =
+{
+    {/*VK_LEFT*/ 0x25, 	WCEL_MoveLeft 		},
+    {/*VK_RIGHT*/0x27,	WCEL_MoveRight		},
+    {/*VK_HOME*/ 0x24,	WCEL_MoveToBeg 		},
+    {/*VK_END*/  0x23,	WCEL_MoveToEnd 		},
+    {/*VK_UP*/   0x26, 	WCEL_MoveToPrevHist 	},
+    {/*VK_DOWN*/ 0x28,	WCEL_MoveToNextHist	},
+    {/*VK_DEL*/  0x2e,	WCEL_DeleteCurrChar	},
+    {	0,		NULL 			}
+};
+
+static	KeyEntry Win32KeyMapCtrlExtended[] =
+{
+    {/*VK_LEFT*/ 0x25, 	WCEL_MoveToLeftWord 	},
+    {/*VK_RIGHT*/0x27,	WCEL_MoveToRightWord	},
+    {/*VK_END*/  0x23,	WCEL_KillToEndOfLine	},
+    {	0,		NULL 			}
+};
+
+KeyMap	Win32KeyMap[] =
+{
+    {0x00000000, 1, StdKeyMap},
+    {0x00000000, 0, Win32ExtraStdKeyMap},
+    {0x00000100, 0, Win32KeyMapExtended},
+    {0x00000104, 0, Win32KeyMapCtrlExtended},
+    {0x00000108, 0, Win32KeyMapCtrlExtended},
+    {0,		 0, 0}
+};
+#undef CTRL
+
+/* ====================================================================
+ *
+ * 		Read line master function
+ *
+ * ====================================================================*/
+
+WCHAR* CONSOLE_Readline(HANDLE hConsoleIn, int use_emacs)
+{
+    WCEL_Context	ctx;
+    INPUT_RECORD	ir;
+    KeyMap*		km;
+    KeyEntry*		ke;
+    unsigned		ofs;
+    void		(*func)(struct WCEL_Context* ctx);
+    DWORD               ks;
+
+    memset(&ctx, 0, sizeof(ctx));
+    ctx.hConIn = hConsoleIn;
+    WCEL_HistoryInit(&ctx);
+    if ((ctx.hConOut = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL,
+				    OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE ||
+	!GetConsoleScreenBufferInfo(ctx.hConOut, &ctx.csbi))
+	return NULL;
+    ctx.can_wrap = (GetConsoleMode(ctx.hConOut, &ks) && (ks & ENABLE_WRAP_AT_EOL_OUTPUT)) ? 1 : 0;
+
+    if (!WCEL_Grow(&ctx, 1))
+    {
+	CloseHandle(ctx.hConOut);
+	return NULL;
+    }
+    ctx.line[0] = 0;
+
+/* EPP     WCEL_Dump(&ctx, "init"); */
+
+    while (!ctx.done && !ctx.error && WCEL_Get(&ctx, &ir))
+    {
+	if (ir.EventType != KEY_EVENT || !ir.Event.KeyEvent.bKeyDown) continue;
+	TRACE("key%s repeatCount=%u, keyCode=%02x scanCode=%02x char=%02x keyState=%08lx\n",
+	      ir.Event.KeyEvent.bKeyDown ? "Down" : "Up  ", ir.Event.KeyEvent.wRepeatCount,
+	      ir.Event.KeyEvent.wVirtualKeyCode, ir.Event.KeyEvent.wVirtualScanCode,
+	      ir.Event.KeyEvent.uChar.UnicodeChar, ir.Event.KeyEvent.dwControlKeyState);
+
+/* EPP  	WCEL_Dump(&ctx, "before func"); */
+	ofs = ctx.ofs;
+        /* mask out some bits which don't interest us */
+        ks = ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON);
+
+	func = NULL;
+	for (km = (use_emacs) ? EmacsKeyMap : Win32KeyMap; km->entries != NULL; km++)
+	{
+	    if (km->keyState != ks)
+		continue;
+	    if (km->chkChar)
+	    {
+		for (ke = &km->entries[0]; ke->func != 0; ke++)
+		    if (ke->val == ir.Event.KeyEvent.uChar.UnicodeChar) break;
+	    }
+	    else
+	    {
+		for (ke = &km->entries[0]; ke->func != 0; ke++)
+		    if (ke->val == ir.Event.KeyEvent.wVirtualKeyCode) break;
+
+	    }
+	    if (ke->func)
+	    {
+		func = ke->func;
+		break;
+	    }
+	}
+
+	if (func)
+	    (func)(&ctx);
+	else if (!(ir.Event.KeyEvent.dwControlKeyState & (ENHANCED_KEY|LEFT_ALT_PRESSED)))
+	    WCEL_InsertChar(&ctx, ir.Event.KeyEvent.uChar.UnicodeChar);
+	else TRACE("Dropped event\n");
+
+/* EPP         WCEL_Dump(&ctx, "after func"); */
+	if (ctx.ofs != ofs)
+	    SetConsoleCursorPosition(ctx.hConOut, WCEL_GetCoord(&ctx, ctx.ofs));
+    }
+    if (ctx.error)
+    {
+	HeapFree(GetProcessHeap(), 0, ctx.line);
+	ctx.line = NULL;
+    }
+    WCEL_FreeYank(&ctx);
+    if (ctx.line)
+	CONSOLE_AppendHistory(ctx.line);
+
+    CloseHandle(ctx.hConOut);
+    if (ctx.histCurr) HeapFree(GetProcessHeap(), 0, ctx.histCurr);
+    return ctx.line;
+}

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux