conoutput.c File Reference

#include "consrv.h"
#include <debug.h>

Include dependency graph for conoutput.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS NTAPI	ConDrvWriteConsoleOutputVDM (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN PCHAR_CELL CharInfo, IN COORD CharInfoSize, IN PSMALL_RECT WriteRegion)
NTSTATUS NTAPI	ConDrvInvalidateBitMapRect (IN PCONSOLE Console, IN PCONSOLE_SCREEN_BUFFER Buffer, IN PSMALL_RECT Region)
	CON_API (SrvInvalidateBitMapRect, CONSOLE_INVALIDATEDIBITS, InvalidateDIBitsRequest)
NTSTATUS NTAPI	ConDrvSetConsolePalette (IN PCONSOLE Console, IN PCONSOLE_SCREEN_BUFFER Buffer, IN HPALETTE PaletteHandle, IN UINT PaletteUsage)
	CON_API (SrvSetConsolePalette, CONSOLE_SETPALETTE, SetPaletteRequest)
NTSTATUS NTAPI	ConDrvGetConsoleCursorInfo (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, OUT PCONSOLE_CURSOR_INFO CursorInfo)
	CON_API (SrvGetConsoleCursorInfo, CONSOLE_GETSETCURSORINFO, CursorInfoRequest)
NTSTATUS NTAPI	ConDrvSetConsoleCursorInfo (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN PCONSOLE_CURSOR_INFO CursorInfo)
	CON_API (SrvSetConsoleCursorInfo, CONSOLE_GETSETCURSORINFO, CursorInfoRequest)
NTSTATUS NTAPI	ConDrvSetConsoleCursorPosition (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN PCOORD Position)
	CON_API (SrvSetConsoleCursorPosition, CONSOLE_SETCURSORPOSITION, SetCursorPositionRequest)
	CON_API (SrvCreateConsoleScreenBuffer, CONSOLE_CREATESCREENBUFFER, CreateScreenBufferRequest)
NTSTATUS NTAPI	ConDrvSetConsoleActiveScreenBuffer (IN PCONSOLE Console, IN PCONSOLE_SCREEN_BUFFER Buffer)
	CON_API (SrvSetConsoleActiveScreenBuffer, CONSOLE_SETACTIVESCREENBUFFER, SetScreenBufferRequest)
static NTSTATUS	DoWriteConsole (IN PCSR_API_MESSAGE ApiMessage, IN PCSR_THREAD ClientThread, IN BOOLEAN CreateWaitBlock OPTIONAL)
static BOOLEAN NTAPI	WriteConsoleThread (IN PLIST_ENTRY WaitList, IN PCSR_THREAD WaitThread, IN PCSR_API_MESSAGE WaitApiMessage, IN PVOID WaitContext, IN PVOID WaitArgument1, IN PVOID WaitArgument2, IN ULONG WaitFlags)
NTSTATUS NTAPI	ConDrvWriteConsole (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER ScreenBuffer, IN BOOLEAN Unicode, IN PVOID StringBuffer, IN ULONG NumCharsToWrite, OUT PULONG NumCharsWritten OPTIONAL)
NTSTATUS NTAPI	ConDrvReadConsoleOutput (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN BOOLEAN Unicode, OUT PCHAR_INFO CharInfo, IN OUT PSMALL_RECT ReadRegion)
	CON_API (SrvReadConsoleOutput, CONSOLE_READOUTPUT, ReadOutputRequest)
NTSTATUS NTAPI	ConDrvWriteConsoleOutput (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN BOOLEAN Unicode, IN PCHAR_INFO CharInfo, IN OUT PSMALL_RECT WriteRegion)
	CON_API (SrvWriteConsoleOutput, CONSOLE_WRITEOUTPUT, WriteOutputRequest)
	CON_API (SrvWriteConsole, CONSOLE_WRITECONSOLE, WriteConsoleRequest)
NTSTATUS NTAPI	ConDrvReadConsoleOutputString (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN CODE_TYPE CodeType, OUT PVOID StringBuffer, IN ULONG NumCodesToRead, IN PCOORD ReadCoord, OUT PULONG NumCodesRead OPTIONAL)
	CON_API (SrvReadConsoleOutputString, CONSOLE_READOUTPUTCODE, ReadOutputCodeRequest)
NTSTATUS NTAPI	ConDrvWriteConsoleOutputString (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN CODE_TYPE CodeType, IN PVOID StringBuffer, IN ULONG NumCodesToWrite, IN PCOORD WriteCoord, OUT PULONG NumCodesWritten OPTIONAL)
	CON_API (SrvWriteConsoleOutputString, CONSOLE_WRITEOUTPUTCODE, WriteOutputCodeRequest)
NTSTATUS NTAPI	ConDrvFillConsoleOutput (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN CODE_TYPE CodeType, IN CODE_ELEMENT Code, IN ULONG NumCodesToWrite, IN PCOORD WriteCoord, OUT PULONG NumCodesWritten OPTIONAL)
	CON_API (SrvFillConsoleOutput, CONSOLE_FILLOUTPUTCODE, FillOutputRequest)
NTSTATUS NTAPI	ConDrvGetConsoleScreenBufferInfo (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, OUT PCOORD ScreenBufferSize, OUT PCOORD CursorPosition, OUT PCOORD ViewOrigin, OUT PCOORD ViewSize, OUT PCOORD MaximumViewSize, OUT PWORD Attributes)
	CON_API (SrvGetConsoleScreenBufferInfo, CONSOLE_GETSCREENBUFFERINFO, ScreenBufferInfoRequest)
NTSTATUS NTAPI	ConDrvSetConsoleTextAttribute (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN WORD Attributes)
	CON_API (SrvSetConsoleTextAttribute, CONSOLE_SETTEXTATTRIB, SetTextAttribRequest)
NTSTATUS NTAPI	ConDrvSetConsoleScreenBufferSize (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN PCOORD Size)
	CON_API (SrvSetConsoleScreenBufferSize, CONSOLE_SETSCREENBUFFERSIZE, SetScreenBufferSizeRequest)
NTSTATUS NTAPI	ConDrvScrollConsoleScreenBuffer (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN BOOLEAN Unicode, IN PSMALL_RECT ScrollRectangle, IN BOOLEAN UseClipRectangle, IN PSMALL_RECT ClipRectangle OPTIONAL, IN PCOORD DestinationOrigin, IN CHAR_INFO FillChar)
	CON_API (SrvScrollConsoleScreenBuffer, CONSOLE_SCROLLSCREENBUFFER, ScrollScreenBufferRequest)
NTSTATUS NTAPI	ConDrvSetConsoleWindowInfo (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN BOOLEAN Absolute, IN PSMALL_RECT WindowRect)
	CON_API (SrvSetConsoleWindowInfo, CONSOLE_SETWINDOWINFO, SetWindowInfoRequest)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file conoutput.c.

Function Documentation

CON_API() [1/18]

CON_API	(	SrvCreateConsoleScreenBuffer	,
		CONSOLE_CREATESCREENBUFFER	,
		CreateScreenBufferRequest
	)

Definition at line 201 of file conoutput.c.

{
    NTSTATUS Status;
    PCSR_PROCESS Process = CsrGetClientThread()->Process;
    // PCONSOLE_PROCESS_DATA ProcessData = ConsoleGetPerProcessData(Process);
    PCONSOLE_SCREEN_BUFFER Buff;
 
    PVOID ScreenBufferInfo = NULL;
    TEXTMODE_BUFFER_INFO TextModeInfo = {{80, 25},
                                         {80, 25},
                                         DEFAULT_SCREEN_ATTRIB,
                                         DEFAULT_POPUP_ATTRIB,
                                         TRUE,
                                         CSR_DEFAULT_CURSOR_SIZE};
    GRAPHICS_BUFFER_INFO GraphicsInfo;
    GraphicsInfo.Info = CreateScreenBufferRequest->GraphicsBufferInfo; // HACK for MSVC
 
    if (CreateScreenBufferRequest->ScreenBufferType == CONSOLE_TEXTMODE_BUFFER)
    {
        ScreenBufferInfo = &TextModeInfo;
 
        /*
         * This is Windows behaviour, as described by MSDN and verified manually:
         *
         * The newly created screen buffer will copy some properties from the
         * active screen buffer at the time that this function is called.
         * The behavior is as follows:
         *     Font - copied from active screen buffer.
         *     Display Window Size - copied from active screen buffer.
         *     Buffer Size - matched to Display Window Size (NOT copied).
         *     Default Attributes (colors) - copied from active screen buffer.
         *     Default Popup Attributes (colors) - copied from active screen buffer.
         */
 
        /* If we have an active screen buffer, use its attributes as the new ones */
        if (Console->ActiveBuffer && GetType(Console->ActiveBuffer) == TEXTMODE_BUFFER)
        {
            PTEXTMODE_SCREEN_BUFFER Buffer = (PTEXTMODE_SCREEN_BUFFER)Console->ActiveBuffer;
 
            TextModeInfo.ScreenAttrib = Buffer->ScreenDefaultAttrib;
            TextModeInfo.PopupAttrib  = Buffer->PopupDefaultAttrib;
 
            TextModeInfo.CursorSize      = Buffer->CursorInfo.dwSize;
            TextModeInfo.IsCursorVisible = Buffer->CursorInfo.bVisible;
 
            /* Use the current view size */
            TextModeInfo.ScreenBufferSize = Buffer->ViewSize;
            TextModeInfo.ViewSize         = Buffer->ViewSize;
        }
        else
        {
            /* Use the current console size */
            TextModeInfo.ScreenBufferSize = Console->ConsoleSize;
            TextModeInfo.ViewSize         = Console->ConsoleSize;
        }
 
        /* Normalize the screen buffer size if needed */
        if (TextModeInfo.ScreenBufferSize.X == 0) TextModeInfo.ScreenBufferSize.X = 1;
        if (TextModeInfo.ScreenBufferSize.Y == 0) TextModeInfo.ScreenBufferSize.Y = 1;
    }
    else if (CreateScreenBufferRequest->ScreenBufferType == CONSOLE_GRAPHICS_BUFFER)
    {
        /* Get information from the graphics buffer information structure */
        if (!CsrValidateMessageBuffer(ApiMessage,
                                      (PVOID*)&CreateScreenBufferRequest->GraphicsBufferInfo.lpBitMapInfo,
                                      CreateScreenBufferRequest->GraphicsBufferInfo.dwBitMapInfoLength,
                                      sizeof(BYTE)))
        {
            return STATUS_INVALID_PARAMETER;
        }
 
        ScreenBufferInfo = &GraphicsInfo;
 
        /* Initialize shared variables */
        // CreateScreenBufferRequest->GraphicsBufferInfo.hMutex
        CreateScreenBufferRequest->hMutex   = GraphicsInfo.Info.hMutex   = INVALID_HANDLE_VALUE;
        // CreateScreenBufferRequest->GraphicsBufferInfo.lpBitMap
        CreateScreenBufferRequest->lpBitMap = GraphicsInfo.Info.lpBitMap = NULL;
 
        /* A graphics screen buffer is never inheritable */
        CreateScreenBufferRequest->InheritHandle = FALSE;
    }
    else
    {
        DPRINT1("Invalid ScreenBuffer type %lu\n", CreateScreenBufferRequest->ScreenBufferType);
        return STATUS_INVALID_PARAMETER;
    }
 
    Status = ConDrvCreateScreenBuffer(&Buff,
                                      (PCONSOLE)Console,
                                      Process->ProcessHandle,
                                      CreateScreenBufferRequest->ScreenBufferType,
                                      ScreenBufferInfo);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Insert the new handle inside the process handles table */
    RtlEnterCriticalSection(&ProcessData->HandleTableLock);
 
    Status = ConSrvInsertObject(ProcessData,
                                &CreateScreenBufferRequest->OutputHandle,
                                &Buff->Header,
                                CreateScreenBufferRequest->DesiredAccess,
                                CreateScreenBufferRequest->InheritHandle,
                                CreateScreenBufferRequest->ShareMode);
 
    RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
 
    if (!NT_SUCCESS(Status))
    {
        ConDrvDeleteScreenBuffer(Buff);
        return Status;
    }
 
    if (CreateScreenBufferRequest->ScreenBufferType == CONSOLE_GRAPHICS_BUFFER)
    {
        PGRAPHICS_SCREEN_BUFFER Buffer = (PGRAPHICS_SCREEN_BUFFER)Buff;
        /*
         * Initialize the graphics buffer information structure
         * and give it back to the client.
         */
        // CreateScreenBufferRequest->GraphicsBufferInfo.hMutex
        CreateScreenBufferRequest->hMutex   = Buffer->ClientMutex;
        // CreateScreenBufferRequest->GraphicsBufferInfo.lpBitMap
        CreateScreenBufferRequest->lpBitMap = Buffer->ClientBitMap;
    }
 
    return Status;
}

CON_API() [2/18]

CON_API	(	SrvFillConsoleOutput	,
		CONSOLE_FILLOUTPUTCODE	,
		FillOutputRequest
	)

Definition at line 888 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
    CODE_TYPE CodeType = FillOutputRequest->CodeType;
 
    if ( (CodeType != CODE_ASCII    ) &&
         (CodeType != CODE_UNICODE  ) &&
         (CodeType != CODE_ATTRIBUTE) )
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     FillOutputRequest->OutputHandle,
                                     &Buffer, GENERIC_WRITE, TRUE);
    if (!NT_SUCCESS(Status))
    {
        FillOutputRequest->NumCodes = 0;
        return Status;
    }
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvFillConsoleOutput((PCONSOLE)Console,
                                     Buffer,
                                     CodeType,
                                     FillOutputRequest->Code,
                                     FillOutputRequest->NumCodes,
                                     &FillOutputRequest->WriteCoord,
                                     &FillOutputRequest->NumCodes);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [3/18]

CON_API	(	SrvGetConsoleCursorInfo	,
		CONSOLE_GETSETCURSORINFO	,
		CursorInfoRequest
	)

Definition at line 124 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     CursorInfoRequest->OutputHandle,
                                     &Buffer, GENERIC_READ, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvGetConsoleCursorInfo((PCONSOLE)Console,
                                        Buffer,
                                        &CursorInfoRequest->Info);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [4/18]

CON_API	(	SrvGetConsoleScreenBufferInfo	,
		CONSOLE_GETSCREENBUFFERINFO	,
		ScreenBufferInfoRequest
	)

Definition at line 935 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     ScreenBufferInfoRequest->OutputHandle,
                                     &Buffer, GENERIC_READ, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvGetConsoleScreenBufferInfo((PCONSOLE)Console,
                                              Buffer,
                                              &ScreenBufferInfoRequest->ScreenBufferSize,
                                              &ScreenBufferInfoRequest->CursorPosition,
                                              &ScreenBufferInfoRequest->ViewOrigin,
                                              &ScreenBufferInfoRequest->ViewSize,
                                              &ScreenBufferInfoRequest->MaximumViewSize,
                                              &ScreenBufferInfoRequest->Attributes);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [5/18]

CON_API	(	SrvInvalidateBitMapRect	,
		CONSOLE_INVALIDATEDIBITS	,
		InvalidateDIBitsRequest
	)

Definition at line 34 of file conoutput.c.

{
    NTSTATUS Status;
    PCONSOLE_SCREEN_BUFFER Buffer;
 
    Status = ConSrvGetScreenBuffer(ProcessData,
                                   InvalidateDIBitsRequest->OutputHandle,
                                   &Buffer, GENERIC_READ, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    /* In text-mode only, draw the VDM buffer if present */
    if (GetType(Buffer) == TEXTMODE_BUFFER && Console->VDMBuffer)
    {
        PTEXTMODE_SCREEN_BUFFER TextBuffer = (PTEXTMODE_SCREEN_BUFFER)Buffer;
 
        /*Status =*/ ConDrvWriteConsoleOutputVDM((PCONSOLE)Console,
                                                 TextBuffer,
                                                 Console->VDMBuffer,
                                                 Console->VDMBufferSize,
                                                 &InvalidateDIBitsRequest->Region);
    }
 
    Status = ConDrvInvalidateBitMapRect((PCONSOLE)Console,
                                        Buffer,
                                        &InvalidateDIBitsRequest->Region);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [6/18]

CON_API	(	SrvReadConsoleOutput	,
		CONSOLE_READOUTPUT	,
		ReadOutputRequest
	)

Definition at line 499 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
    ULONG NumCells;
    PCHAR_INFO CharInfo;
 
    NumCells = ConioRectWidth(&ReadOutputRequest->ReadRegion) *
               ConioRectHeight(&ReadOutputRequest->ReadRegion);
 
    /*
     * For optimization purposes, Windows (and hence ReactOS, too, for
     * compatibility reasons) uses a static buffer if no more than one
     * cell is read. Otherwise a new buffer is used.
     * The client-side expects that we know this behaviour.
     */
    if (NumCells <= 1)
    {
        /*
         * Adjust the internal pointer, because its old value points to
         * the static buffer in the original ApiMessage structure.
         */
        // ReadOutputRequest->CharInfo = &ReadOutputRequest->StaticBuffer;
        CharInfo = &ReadOutputRequest->StaticBuffer;
    }
    else
    {
        if (!CsrValidateMessageBuffer(ApiMessage,
                                      (PVOID*)&ReadOutputRequest->CharInfo,
                                      NumCells,
                                      sizeof(CHAR_INFO)))
        {
            return STATUS_INVALID_PARAMETER;
        }
 
        CharInfo = ReadOutputRequest->CharInfo;
    }
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     ReadOutputRequest->OutputHandle,
                                     &Buffer, GENERIC_READ, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvReadConsoleOutput((PCONSOLE)Console,
                                     Buffer,
                                     ReadOutputRequest->Unicode,
                                     CharInfo,
                                     &ReadOutputRequest->ReadRegion);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [7/18]

CON_API	(	SrvReadConsoleOutputString	,
		CONSOLE_READOUTPUTCODE	,
		ReadOutputCodeRequest
	)

Definition at line 713 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
    ULONG CodeSize;
    PVOID pCode;
 
    switch (ReadOutputCodeRequest->CodeType)
    {
        case CODE_ASCII:
            CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, AsciiChar);
            break;
 
        case CODE_UNICODE:
            CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, UnicodeChar);
            break;
 
        case CODE_ATTRIBUTE:
            CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, Attribute);
            break;
 
        default:
            return STATUS_INVALID_PARAMETER;
    }
 
    /*
     * For optimization purposes, Windows (and hence ReactOS, too, for
     * compatibility reasons) uses a static buffer if no more than eighty
     * bytes are read. Otherwise a new buffer is used.
     * The client-side expects that we know this behaviour.
     */
    if (ReadOutputCodeRequest->NumCodes * CodeSize <= sizeof(ReadOutputCodeRequest->CodeStaticBuffer))
    {
        /*
         * Adjust the internal pointer, because its old value points to
         * the static buffer in the original ApiMessage structure.
         */
        // ReadOutputCodeRequest->pCode = ReadOutputCodeRequest->CodeStaticBuffer;
        pCode = ReadOutputCodeRequest->CodeStaticBuffer;
    }
    else
    {
        if (!CsrValidateMessageBuffer(ApiMessage,
                                      (PVOID*)&ReadOutputCodeRequest->pCode,
                                      ReadOutputCodeRequest->NumCodes,
                                      CodeSize))
        {
            return STATUS_INVALID_PARAMETER;
        }
 
        pCode = ReadOutputCodeRequest->pCode;
    }
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     ReadOutputCodeRequest->OutputHandle,
                                     &Buffer, GENERIC_READ, TRUE);
    if (!NT_SUCCESS(Status))
    {
        ReadOutputCodeRequest->NumCodes = 0;
        return Status;
    }
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvReadConsoleOutputString((PCONSOLE)Console,
                                           Buffer,
                                           ReadOutputCodeRequest->CodeType,
                                           pCode,
                                           ReadOutputCodeRequest->NumCodes,
                                           &ReadOutputCodeRequest->Coord,
                                           // &ReadOutputCodeRequest->EndCoord,
                                           &ReadOutputCodeRequest->NumCodes);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [8/18]

CON_API	(	SrvScrollConsoleScreenBuffer	,
		CONSOLE_SCROLLSCREENBUFFER	,
		ScrollScreenBufferRequest
	)

Definition at line 1026 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     ScrollScreenBufferRequest->OutputHandle,
                                     &Buffer, GENERIC_WRITE, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvScrollConsoleScreenBuffer((PCONSOLE)Console,
                                             Buffer,
                                             ScrollScreenBufferRequest->Unicode,
                                             &ScrollScreenBufferRequest->ScrollRectangle,
                                             ScrollScreenBufferRequest->UseClipRectangle,
                                             &ScrollScreenBufferRequest->ClipRectangle,
                                             &ScrollScreenBufferRequest->DestinationOrigin,
                                             ScrollScreenBufferRequest->Fill);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [9/18]

CON_API	(	SrvSetConsoleActiveScreenBuffer	,
		CONSOLE_SETACTIVESCREENBUFFER	,
		SetScreenBufferRequest
	)

Definition at line 336 of file conoutput.c.

{
    NTSTATUS Status;
    PCONSOLE_SCREEN_BUFFER Buffer;
 
    Status = ConSrvGetScreenBuffer(ProcessData,
                                   SetScreenBufferRequest->OutputHandle,
                                   &Buffer, GENERIC_WRITE, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvSetConsoleActiveScreenBuffer((PCONSOLE)Console, Buffer);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [10/18]

CON_API	(	SrvSetConsoleCursorInfo	,
		CONSOLE_GETSETCURSORINFO	,
		CursorInfoRequest
	)

Definition at line 151 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     CursorInfoRequest->OutputHandle,
                                     &Buffer, GENERIC_WRITE, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvSetConsoleCursorInfo((PCONSOLE)Console,
                                        Buffer,
                                        &CursorInfoRequest->Info);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [11/18]

CON_API	(	SrvSetConsoleCursorPosition	,
		CONSOLE_SETCURSORPOSITION	,
		SetCursorPositionRequest
	)

Definition at line 178 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     SetCursorPositionRequest->OutputHandle,
                                     &Buffer, GENERIC_WRITE, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvSetConsoleCursorPosition((PCONSOLE)Console,
                                            Buffer,
                                            &SetCursorPositionRequest->Position);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [12/18]

CON_API	(	SrvSetConsolePalette	,
		CONSOLE_SETPALETTE	,
		SetPaletteRequest
	)

Definition at line 75 of file conoutput.c.

{
    NTSTATUS Status;
    // PGRAPHICS_SCREEN_BUFFER Buffer;
    PCONSOLE_SCREEN_BUFFER Buffer;
 
    // NOTE: Tests show that this function is used only for graphics screen buffers
    // and otherwise it returns FALSE + sets last error to invalid handle.
    // I think it's ridiculous, because if you are in text mode, simulating
    // a change of VGA palette via DAC registers (done by a call to SetConsolePalette)
    // cannot be done... So I allow it in ReactOS !
    /*
    Status = ConSrvGetGraphicsBuffer(ProcessData,
                                     SetPaletteRequest->OutputHandle,
                                     &Buffer, GENERIC_WRITE, TRUE);
    */
    Status = ConSrvGetScreenBuffer(ProcessData,
                                   SetPaletteRequest->OutputHandle,
                                   &Buffer, GENERIC_WRITE, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    /*
     * Make the palette handle public, so that it can be
     * used by other threads calling GDI functions on it.
     * Indeed, the palette handle comes from a console app
     * calling ourselves, running in CSRSS.
     */
    NtUserConsoleControl(ConsoleMakePalettePublic,
                         &SetPaletteRequest->PaletteHandle,
                         sizeof(SetPaletteRequest->PaletteHandle));
 
    Status = ConDrvSetConsolePalette((PCONSOLE)Console,
                                     Buffer,
                                     SetPaletteRequest->PaletteHandle,
                                     SetPaletteRequest->Usage);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [13/18]

CON_API	(	SrvSetConsoleScreenBufferSize	,
		CONSOLE_SETSCREENBUFFERSIZE	,
		SetScreenBufferSizeRequest
	)

Definition at line 994 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     SetScreenBufferSizeRequest->OutputHandle,
                                     &Buffer, GENERIC_WRITE, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvSetConsoleScreenBufferSize((PCONSOLE)Console,
                                              Buffer,
                                              &SetScreenBufferSizeRequest->Size);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [14/18]

CON_API	(	SrvSetConsoleTextAttribute	,
		CONSOLE_SETTEXTATTRIB	,
		SetTextAttribRequest
	)

Definition at line 967 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     SetTextAttribRequest->OutputHandle,
                                     &Buffer, GENERIC_WRITE, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvSetConsoleTextAttribute((PCONSOLE)Console,
                                           Buffer,
                                           SetTextAttribRequest->Attributes);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [15/18]

CON_API	(	SrvSetConsoleWindowInfo	,
		CONSOLE_SETWINDOWINFO	,
		SetWindowInfoRequest
	)

Definition at line 1059 of file conoutput.c.

{
    NTSTATUS Status;
    // PCONSOLE_SCREEN_BUFFER Buffer;
    PTEXTMODE_SCREEN_BUFFER Buffer;
 
    DPRINT("SrvSetConsoleWindowInfo(0x%08x, %d, {L%d, T%d, R%d, B%d}) called\n",
            SetWindowInfoRequest->OutputHandle, SetWindowInfoRequest->Absolute,
            SetWindowInfoRequest->WindowRect.Left ,
            SetWindowInfoRequest->WindowRect.Top  ,
            SetWindowInfoRequest->WindowRect.Right,
            SetWindowInfoRequest->WindowRect.Bottom);
 
    // ConSrvGetScreenBuffer
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     SetWindowInfoRequest->OutputHandle,
                                     &Buffer, GENERIC_READ, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvSetConsoleWindowInfo((PCONSOLE)Console,
                                        Buffer,
                                        SetWindowInfoRequest->Absolute,
                                        &SetWindowInfoRequest->WindowRect);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [16/18]

CON_API	(	SrvWriteConsole	,
		CONSOLE_WRITECONSOLE	,
		WriteConsoleRequest
	)

Definition at line 663 of file conoutput.c.

{
    NTSTATUS Status;
 
    DPRINT("SrvWriteConsole\n");
 
    /*
     * For optimization purposes, Windows (and hence ReactOS, too, for
     * compatibility reasons) uses a static buffer if no more than eighty
     * bytes are written. Otherwise a new buffer is used.
     * The client-side expects that we know this behaviour.
     */
    if (WriteConsoleRequest->UsingStaticBuffer &&
        WriteConsoleRequest->NumBytes <= sizeof(WriteConsoleRequest->StaticBuffer))
    {
        /*
         * Adjust the internal pointer, because its old value points to
         * the static buffer in the original ApiMessage structure.
         */
        // WriteConsoleRequest->Buffer = WriteConsoleRequest->StaticBuffer;
    }
    else
    {
        if (!CsrValidateMessageBuffer(ApiMessage,
                                      (PVOID)&WriteConsoleRequest->Buffer,
                                      WriteConsoleRequest->NumBytes,
                                      sizeof(BYTE)))
        {
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    Status = DoWriteConsole(ApiMessage, CsrGetClientThread(), TRUE);
 
    if (Status == STATUS_PENDING) *ReplyCode = CsrReplyPending;
 
    return Status;
}

CON_API() [17/18]

CON_API	(	SrvWriteConsoleOutput	,
		CONSOLE_WRITEOUTPUT	,
		WriteOutputRequest
	)

Definition at line 563 of file conoutput.c.

{
    NTSTATUS Status;
    PCSR_PROCESS Process = CsrGetClientThread()->Process;
    // PCONSOLE_PROCESS_DATA ProcessData = ConsoleGetPerProcessData(Process);
    PTEXTMODE_SCREEN_BUFFER Buffer;
    ULONG NumCells;
    PCHAR_INFO CharInfo;
 
    NumCells = ConioRectWidth(&WriteOutputRequest->WriteRegion) *
               ConioRectHeight(&WriteOutputRequest->WriteRegion);
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     WriteOutputRequest->OutputHandle,
                                     &Buffer, GENERIC_WRITE, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    /*
     * Validate the message buffer if we do not use a process' heap buffer
     * (CsrAllocateCaptureBuffer succeeded because we haven't allocated
     * a too large (>= 64 kB, size of the CSR heap) data buffer).
     */
    if (!WriteOutputRequest->UseVirtualMemory)
    {
        /*
         * For optimization purposes, Windows (and hence ReactOS, too, for
         * compatibility reasons) uses a static buffer if no more than one
         * cell is written. Otherwise a new buffer is used.
         * The client-side expects that we know this behaviour.
         */
        if (NumCells <= 1)
        {
            /*
             * Adjust the internal pointer, because its old value points to
             * the static buffer in the original ApiMessage structure.
             */
            // WriteOutputRequest->CharInfo = &WriteOutputRequest->StaticBuffer;
            CharInfo = &WriteOutputRequest->StaticBuffer;
        }
        else
        {
            if (!CsrValidateMessageBuffer(ApiMessage,
                                          (PVOID*)&WriteOutputRequest->CharInfo,
                                          NumCells,
                                          sizeof(CHAR_INFO)))
            {
                Status = STATUS_INVALID_PARAMETER;
                goto Quit;
            }
 
            CharInfo = WriteOutputRequest->CharInfo;
        }
    }
    else
    {
        /*
         * This was not the case: we use a heap buffer. Retrieve its contents.
         */
        ULONG Size = NumCells * sizeof(CHAR_INFO);
 
        CharInfo = ConsoleAllocHeap(HEAP_ZERO_MEMORY, Size);
        if (CharInfo == NULL)
        {
            Status = STATUS_NO_MEMORY;
            goto Quit;
        }
 
        Status = NtReadVirtualMemory(Process->ProcessHandle,
                                     WriteOutputRequest->CharInfo,
                                     CharInfo,
                                     Size,
                                     NULL);
        if (!NT_SUCCESS(Status))
        {
            ConsoleFreeHeap(CharInfo);
            // Status = STATUS_NO_MEMORY;
            goto Quit;
        }
    }
 
    Status = ConDrvWriteConsoleOutput((PCONSOLE)Console,
                                      Buffer,
                                      WriteOutputRequest->Unicode,
                                      CharInfo,
                                      &WriteOutputRequest->WriteRegion);
 
    /* Free the temporary buffer if we used the process' heap buffer */
    if (WriteOutputRequest->UseVirtualMemory && CharInfo)
        ConsoleFreeHeap(CharInfo);
 
Quit:
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

CON_API() [18/18]

CON_API	(	SrvWriteConsoleOutputString	,
		CONSOLE_WRITEOUTPUTCODE	,
		WriteOutputCodeRequest
	)

Definition at line 801 of file conoutput.c.

{
    NTSTATUS Status;
    PTEXTMODE_SCREEN_BUFFER Buffer;
    ULONG CodeSize;
    PVOID pCode;
 
    switch (WriteOutputCodeRequest->CodeType)
    {
        case CODE_ASCII:
            CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, AsciiChar);
            break;
 
        case CODE_UNICODE:
            CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, UnicodeChar);
            break;
 
        case CODE_ATTRIBUTE:
            CodeSize = RTL_FIELD_SIZE(CODE_ELEMENT, Attribute);
            break;
 
        default:
            return STATUS_INVALID_PARAMETER;
    }
 
    /*
     * For optimization purposes, Windows (and hence ReactOS, too, for
     * compatibility reasons) uses a static buffer if no more than eighty
     * bytes are written. Otherwise a new buffer is used.
     * The client-side expects that we know this behaviour.
     */
    if (WriteOutputCodeRequest->NumCodes * CodeSize <= sizeof(WriteOutputCodeRequest->CodeStaticBuffer))
    {
        /*
         * Adjust the internal pointer, because its old value points to
         * the static buffer in the original ApiMessage structure.
         */
        // WriteOutputCodeRequest->pCode = WriteOutputCodeRequest->CodeStaticBuffer;
        pCode = WriteOutputCodeRequest->CodeStaticBuffer;
    }
    else
    {
        if (!CsrValidateMessageBuffer(ApiMessage,
                                      (PVOID*)&WriteOutputCodeRequest->pCode,
                                      WriteOutputCodeRequest->NumCodes,
                                      CodeSize))
        {
            return STATUS_INVALID_PARAMETER;
        }
 
        pCode = WriteOutputCodeRequest->pCode;
    }
 
    Status = ConSrvGetTextModeBuffer(ProcessData,
                                     WriteOutputCodeRequest->OutputHandle,
                                     &Buffer, GENERIC_WRITE, TRUE);
    if (!NT_SUCCESS(Status))
    {
        WriteOutputCodeRequest->NumCodes = 0;
        return Status;
    }
 
    ASSERT((PCONSOLE)Console == Buffer->Header.Console);
 
    Status = ConDrvWriteConsoleOutputString((PCONSOLE)Console,
                                            Buffer,
                                            WriteOutputCodeRequest->CodeType,
                                            pCode,
                                            WriteOutputCodeRequest->NumCodes,
                                            &WriteOutputCodeRequest->Coord,
                                            // &WriteOutputCodeRequest->EndCoord,
                                            &WriteOutputCodeRequest->NumCodes);
 
    ConSrvReleaseScreenBuffer(Buffer, TRUE);
    return Status;
}

ConDrvFillConsoleOutput()

NTSTATUS NTAPI ConDrvFillConsoleOutput	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN CODE_TYPE	CodeType,
		IN CODE_ELEMENT	Code,
		IN ULONG	NumCodesToWrite,
		IN PCOORD	WriteCoord,
		OUT PULONG NumCodesWritten	OPTIONAL
	)

Definition at line 1251 of file text.c.

{
    SHORT X, Y;
    SHORT XStart;
    ULONG nNumChars = 0;
    PCHAR_INFO Ptr;
    BOOLEAN bLead, bFullwidth;
 
    if (Console == NULL || Buffer == NULL || WriteCoord == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    if (NumCodesWritten)
        *NumCodesWritten = 0;
 
    if (NumCodesToWrite == 0)
        return STATUS_SUCCESS; // Nothing to do!
 
    /* Do nothing if the writing starting point is outside of the screen buffer */
    if ( WriteCoord->X < 0 || WriteCoord->X >= Buffer->ScreenBufferSize.X ||
         WriteCoord->Y < 0 || WriteCoord->Y >= Buffer->ScreenBufferSize.Y )
    {
        return STATUS_SUCCESS;
    }
 
    NumCodesToWrite = min(NumCodesToWrite, (ULONG)Buffer->ScreenBufferSize.X * Buffer->ScreenBufferSize.Y);
 
    if (CodeType == CODE_ASCII)
    {
        /* Conversion from the ASCII char to the UNICODE char */
        CODE_ELEMENT tmp;
        ConsoleOutputAnsiToUnicodeChar(Console, &tmp.UnicodeChar, &Code.AsciiChar);
        Code = tmp;
    }
 
    XStart = WriteCoord->X;
 
    /* For Chinese, Japanese and Korean */
    X = XStart;
    Y = WriteCoord->Y;
    bLead = TRUE;
    bFullwidth = FALSE;
    if (Console->IsCJK)
    {
        bFullwidth = IS_FULL_WIDTH(Code.UnicodeChar);
        if (X > 0)
        {
            Ptr = ConioCoordToPointer(Buffer, X - 1, Y);
            if (Ptr->Attributes & COMMON_LVB_LEADING_BYTE)
            {
                Ptr->Char.UnicodeChar = L' ';
                Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
            }
        }
    }
 
    for (Y = WriteCoord->Y; Y < Buffer->ScreenBufferSize.Y; ++Y)
    {
        Ptr = ConioCoordToPointer(Buffer, XStart, Y);
        for (X = XStart; X < Buffer->ScreenBufferSize.X; ++X)
        {
            if (nNumChars >= NumCodesToWrite)
                goto Quit;
 
            switch (CodeType)
            {
                case CODE_ASCII:
                case CODE_UNICODE:
                    Ptr->Char.UnicodeChar = Code.UnicodeChar;
                    Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
                    if (bFullwidth)
                    {
                        if (bLead)
                            Ptr->Attributes |= COMMON_LVB_LEADING_BYTE;
                        else
                            Ptr->Attributes |= COMMON_LVB_TRAILING_BYTE;
                    }
                    bLead = !bLead;
                    break;
 
                case CODE_ATTRIBUTE:
                    Ptr->Attributes &= COMMON_LVB_SBCSDBCS;
                    Ptr->Attributes |= (Code.Attribute & ~COMMON_LVB_SBCSDBCS);
                    break;
            }
 
            ++Ptr;
 
            ++nNumChars;
        }
        /* Restart at the beginning of the next line */
        XStart = 0;
    }
Quit:
 
    if ((nNumChars & 1) & bFullwidth)
    {
        if (X + Y * Buffer->ScreenBufferSize.X > 0)
        {
            Ptr = ConioCoordToPointer(Buffer, X - 1, Y);
            Ptr->Char.UnicodeChar = L' ';
            Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
        }
    }
 
    if (NumCodesWritten)
        *NumCodesWritten = nNumChars;
 
    if ((PCONSOLE_SCREEN_BUFFER)Buffer == Console->ActiveBuffer)
    {
        SMALL_RECT UpdateRect;
        ConioComputeUpdateRect(Buffer, &UpdateRect, WriteCoord, nNumChars);
        TermDrawRegion(Console, &UpdateRect);
    }
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvGetConsoleCursorInfo()

NTSTATUS NTAPI ConDrvGetConsoleCursorInfo	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		OUT PCONSOLE_CURSOR_INFO	CursorInfo
	)

Definition at line 270 of file conoutput.c.

{
    if (Console == NULL || Buffer == NULL || CursorInfo == NULL)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    *CursorInfo = Buffer->CursorInfo;
    // CursorInfo->bVisible = Buffer->CursorInfo.bVisible;
    // CursorInfo->dwSize   = Buffer->CursorInfo.dwSize;
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvGetConsoleScreenBufferInfo()

NTSTATUS NTAPI ConDrvGetConsoleScreenBufferInfo	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		OUT PCOORD	ScreenBufferSize,
		OUT PCOORD	CursorPosition,
		OUT PCOORD	ViewOrigin,
		OUT PCOORD	ViewSize,
		OUT PCOORD	MaximumViewSize,
		OUT PWORD	Attributes
	)

Definition at line 1380 of file text.c.

{
    COORD LargestWindowSize;
 
    if (Console == NULL || Buffer == NULL || ScreenBufferSize == NULL ||
        CursorPosition  == NULL || ViewOrigin == NULL || ViewSize == NULL ||
        MaximumViewSize == NULL || Attributes == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    *ScreenBufferSize = Buffer->ScreenBufferSize;
    *CursorPosition   = Buffer->CursorPosition;
    *ViewOrigin       = Buffer->ViewOrigin;
    *ViewSize         = Buffer->ViewSize;
    *Attributes       = Buffer->ScreenDefaultAttrib;
 
    /*
     * Retrieve the largest possible console window size, taking
     * into account the size of the console screen buffer.
     */
    TermGetLargestConsoleWindowSize(Console, &LargestWindowSize);
    LargestWindowSize.X = min(LargestWindowSize.X, Buffer->ScreenBufferSize.X);
    LargestWindowSize.Y = min(LargestWindowSize.Y, Buffer->ScreenBufferSize.Y);
    *MaximumViewSize = LargestWindowSize;
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvInvalidateBitMapRect()

NTSTATUS NTAPI ConDrvInvalidateBitMapRect	(	IN PCONSOLE	Console,
		IN PCONSOLE_SCREEN_BUFFER	Buffer,
		IN PSMALL_RECT	Region
	)

Definition at line 209 of file conoutput.c.

{
    if (Console == NULL || Buffer == NULL || Region == NULL)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    /* If the output buffer is the current one, redraw the correct portion of the screen */
    if (Buffer == Console->ActiveBuffer) TermDrawRegion(Console, Region);
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvReadConsoleOutput()

NTSTATUS NTAPI ConDrvReadConsoleOutput	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN BOOLEAN	Unicode,
		OUT PCHAR_INFO	CharInfo,
		IN OUT PSMALL_RECT	ReadRegion
	)

Definition at line 569 of file text.c.

{
    SHORT X, Y;
    SMALL_RECT ScreenBuffer;
    PCHAR_INFO CurCharInfo;
    SMALL_RECT CapturedReadRegion;
    PCHAR_INFO Ptr;
 
    if (Console == NULL || Buffer == NULL || CharInfo == NULL || ReadRegion == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    CapturedReadRegion = *ReadRegion;
 
    /* Make sure ReadRegion is inside the screen buffer */
    ConioInitRect(&ScreenBuffer, 0, 0,
                  Buffer->ScreenBufferSize.Y - 1,
                  Buffer->ScreenBufferSize.X - 1);
    if (!ConioGetIntersection(&CapturedReadRegion, &CapturedReadRegion, &ScreenBuffer))
    {
        /*
         * It is okay to have a ReadRegion completely outside
         * the screen buffer. No data is read then.
         */
        return STATUS_SUCCESS;
    }
 
    CurCharInfo = CharInfo;
 
    for (Y = CapturedReadRegion.Top; Y <= CapturedReadRegion.Bottom; ++Y)
    {
        Ptr = ConioCoordToPointer(Buffer, CapturedReadRegion.Left, Y);
        for (X = CapturedReadRegion.Left; X <= CapturedReadRegion.Right; ++X)
        {
            if (Unicode)
            {
                CurCharInfo->Char.UnicodeChar = Ptr->Char.UnicodeChar;
            }
            else
            {
                // ConsoleOutputUnicodeToAnsiChar(Console, &CurCharInfo->Char.AsciiChar, &Ptr->Char.UnicodeChar);
                WideCharToMultiByte(Console->OutputCodePage, 0, &Ptr->Char.UnicodeChar, 1,
                                    &CurCharInfo->Char.AsciiChar, 1, NULL, NULL);
            }
#if (_WIN32_WINNT < _WIN32_WINNT_WIN8)
            /* NOTE: Windows < 8 compatibility: DBCS flags are filtered out */
            CurCharInfo->Attributes = (Ptr->Attributes & ~COMMON_LVB_SBCSDBCS);
#else
            CurCharInfo->Attributes = Ptr->Attributes;
#endif
            ++Ptr;
            ++CurCharInfo;
        }
    }
 
    *ReadRegion = CapturedReadRegion;
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvReadConsoleOutputString()

NTSTATUS NTAPI ConDrvReadConsoleOutputString	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN CODE_TYPE	CodeType,
		OUT PVOID	StringBuffer,
		IN ULONG	NumCodesToRead,
		IN PCOORD	ReadCoord,
		OUT PULONG NumCodesRead	OPTIONAL
	)

Definition at line 942 of file text.c.

{
    if (Console == NULL || Buffer == NULL || ReadCoord == NULL /* || EndCoord == NULL */)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validity checks */
    ASSERT(Console == Buffer->Header.Console);
    ASSERT((StringBuffer != NULL) || (StringBuffer == NULL && NumCodesToRead == 0));
 
    if (NumCodesRead)
        *NumCodesRead = 0;
 
    if (!StringBuffer || (NumCodesToRead == 0))
        return STATUS_SUCCESS; // Nothing to do!
 
    /* Do nothing if the reading starting point is outside of the screen buffer */
    if ( ReadCoord->X < 0 || ReadCoord->X >= Buffer->ScreenBufferSize.X ||
         ReadCoord->Y < 0 || ReadCoord->Y >= Buffer->ScreenBufferSize.Y )
    {
        return STATUS_SUCCESS;
    }
 
    NumCodesToRead = min(NumCodesToRead, (ULONG)Buffer->ScreenBufferSize.X * Buffer->ScreenBufferSize.Y);
 
    switch (CodeType)
    {
        case CODE_ASCII:
        {
            return IntReadConsoleOutputStringChars(Console,
                                                   Buffer,
                                                   StringBuffer,
                                                   FALSE,
                                                   NumCodesToRead,
                                                   ReadCoord,
                                                   NumCodesRead);
        }
 
        case CODE_UNICODE:
        {
            return IntReadConsoleOutputStringChars(Console,
                                                   Buffer,
                                                   StringBuffer,
                                                   TRUE,
                                                   NumCodesToRead,
                                                   ReadCoord,
                                                   NumCodesRead);
        }
 
        case CODE_ATTRIBUTE:
        {
            C_ASSERT(RTL_FIELD_SIZE(CODE_ELEMENT, Attribute) == sizeof(WORD));
            return IntReadConsoleOutputStringAttributes(Console,
                                                        Buffer,
                                                        (PWORD)StringBuffer,
                                                        NumCodesToRead,
                                                        ReadCoord,
                                                        NumCodesRead);
        }
 
        default:
            return STATUS_INVALID_PARAMETER;
    }
}

Referenced by CON_API().

ConDrvScrollConsoleScreenBuffer()

NTSTATUS NTAPI ConDrvScrollConsoleScreenBuffer	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN BOOLEAN	Unicode,
		IN PSMALL_RECT	ScrollRectangle,
		IN BOOLEAN	UseClipRectangle,
		IN PSMALL_RECT ClipRectangle	OPTIONAL,
		IN PCOORD	DestinationOrigin,
		IN CHAR_INFO	FillChar
	)

Definition at line 1454 of file text.c.

{
    COORD CapturedDestinationOrigin;
    SMALL_RECT ScreenBuffer;
    SMALL_RECT CapturedClipRectangle;
    SMALL_RECT SrcRegion;
    SMALL_RECT DstRegion;
    SMALL_RECT UpdateRegion;
 
    if (Console == NULL || Buffer == NULL || ScrollRectangle == NULL ||
        (UseClipRectangle && (ClipRectangle == NULL)) || DestinationOrigin == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    CapturedDestinationOrigin = *DestinationOrigin;
 
    /* Make sure the source rectangle is inside the screen buffer */
    ConioInitRect(&ScreenBuffer, 0, 0,
                  Buffer->ScreenBufferSize.Y - 1,
                  Buffer->ScreenBufferSize.X - 1);
    if (!ConioGetIntersection(&SrcRegion, ScrollRectangle, &ScreenBuffer))
    {
        return STATUS_SUCCESS;
    }
 
    /* If the source was clipped on the left or top, adjust the destination accordingly */
    if (ScrollRectangle->Left < 0)
        CapturedDestinationOrigin.X -= ScrollRectangle->Left;
    if (ScrollRectangle->Top < 0)
        CapturedDestinationOrigin.Y -= ScrollRectangle->Top;
 
    /*
     * If a clip rectangle is provided, clip it to the screen buffer,
     * otherwise use the latter one as the clip rectangle.
     */
    if (UseClipRectangle)
    {
        CapturedClipRectangle = *ClipRectangle;
        if (!ConioGetIntersection(&CapturedClipRectangle, &CapturedClipRectangle, &ScreenBuffer))
        {
            return STATUS_SUCCESS;
        }
    }
    else
    {
        CapturedClipRectangle = ScreenBuffer;
    }
 
    /*
     * Windows compatibility: Do nothing if the intersection of the source region
     * with the clip rectangle is empty, even if the intersection of destination
     * region with the clip rectangle is NOT empty and therefore it would have
     * been possible to copy contents to it...
     */
    if (!ConioGetIntersection(&UpdateRegion, &SrcRegion, &CapturedClipRectangle))
    {
        return STATUS_SUCCESS;
    }
 
    /* Initialize the destination rectangle, of same size as the source rectangle */
    ConioInitRect(&DstRegion,
                  CapturedDestinationOrigin.Y,
                  CapturedDestinationOrigin.X,
                  CapturedDestinationOrigin.Y + ConioRectHeight(&SrcRegion) - 1,
                  CapturedDestinationOrigin.X + ConioRectWidth(&SrcRegion ) - 1);
 
    if (ConioGetIntersection(&DstRegion, &DstRegion, &CapturedClipRectangle))
    {
        /*
         * Build the region image, within the source region,
         * of the destination region we should copy into.
         */
        SrcRegion.Left   += DstRegion.Left - CapturedDestinationOrigin.X;
        SrcRegion.Top    += DstRegion.Top  - CapturedDestinationOrigin.Y;
        SrcRegion.Right  = SrcRegion.Left + (DstRegion.Right - DstRegion.Left);
        SrcRegion.Bottom = SrcRegion.Top  + (DstRegion.Bottom - DstRegion.Top);
 
        /* Do the copy */
        CapturedDestinationOrigin.X = DstRegion.Left;
        CapturedDestinationOrigin.Y = DstRegion.Top;
        ConioCopyRegion(Buffer, &SrcRegion, &CapturedDestinationOrigin);
    }
 
    if (!Unicode)
    {
        /* Conversion from the ASCII char to the UNICODE char */
        WCHAR tmp;
        ConsoleOutputAnsiToUnicodeChar(Console, &tmp, &FillChar.Char.AsciiChar);
        FillChar.Char.UnicodeChar = tmp;
    }
    /* Sanitize the attribute */
    FillChar.Attributes &= ~COMMON_LVB_SBCSDBCS;
 
    /*
     * Fill the intersection (== UpdateRegion) of the source region with the
     * clip rectangle, excluding the destination region.
     */
    ConioFillRegion(Buffer, &UpdateRegion, &DstRegion, FillChar);
 
    if ((PCONSOLE_SCREEN_BUFFER)Buffer == Console->ActiveBuffer)
    {
        ConioGetUnion(&UpdateRegion, &UpdateRegion, &DstRegion);
        if (ConioGetIntersection(&UpdateRegion, &UpdateRegion, &CapturedClipRectangle))
        {
            /* Draw update region */
            TermDrawRegion(Console, &UpdateRegion);
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvSetConsoleActiveScreenBuffer()

NTSTATUS NTAPI ConDrvSetConsoleActiveScreenBuffer	(	IN PCONSOLE	Console,
		IN PCONSOLE_SCREEN_BUFFER	Buffer
	)

Definition at line 177 of file conoutput.c.

{
    if (Console == NULL || Buffer == NULL)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    if (Buffer == Console->ActiveBuffer) return STATUS_SUCCESS;
 
    /* If old buffer has no handles, it's now unreferenced */
    if (Console->ActiveBuffer->Header.ReferenceCount == 0)
    {
        ConDrvDeleteScreenBuffer(Console->ActiveBuffer);
    }
 
    /* Tie console to new buffer and signal the change to the frontend */
    ConioSetActiveScreenBuffer(Buffer);
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvSetConsoleCursorInfo()

NTSTATUS NTAPI ConDrvSetConsoleCursorInfo	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN PCONSOLE_CURSOR_INFO	CursorInfo
	)

Definition at line 288 of file conoutput.c.

{
    ULONG Size;
    BOOLEAN Visible, Success = TRUE;
 
    if (Console == NULL || Buffer == NULL || CursorInfo == NULL)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    Size    = min(max(CursorInfo->dwSize, 1), 100);
    Visible = CursorInfo->bVisible;
 
    if ( (Size != Buffer->CursorInfo.dwSize)         ||
         (Visible && !Buffer->CursorInfo.bVisible)   ||
         (!Visible && Buffer->CursorInfo.bVisible) )
    {
        Buffer->CursorInfo.dwSize   = Size;
        Buffer->CursorInfo.bVisible = Visible;
 
        Success = TermSetCursorInfo(Console, (PCONSOLE_SCREEN_BUFFER)Buffer);
    }
 
    return (Success ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
}

Referenced by CON_API().

ConDrvSetConsoleCursorPosition()

NTSTATUS NTAPI ConDrvSetConsoleCursorPosition	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN PCOORD	Position
	)

Definition at line 318 of file conoutput.c.

{
    SHORT OldCursorX, OldCursorY;
 
    if (Console == NULL || Buffer == NULL || Position == NULL)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    if ( Position->X < 0 || Position->X >= Buffer->ScreenBufferSize.X ||
         Position->Y < 0 || Position->Y >= Buffer->ScreenBufferSize.Y )
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    OldCursorX = Buffer->CursorPosition.X;
    OldCursorY = Buffer->CursorPosition.Y;
    Buffer->CursorPosition = *Position;
 
    if ( ((PCONSOLE_SCREEN_BUFFER)Buffer == Console->ActiveBuffer) &&
         (!TermSetScreenInfo(Console, (PCONSOLE_SCREEN_BUFFER)Buffer, OldCursorX, OldCursorY)) )
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvSetConsolePalette()

NTSTATUS NTAPI ConDrvSetConsolePalette	(	IN PCONSOLE	Console,
		IN PCONSOLE_SCREEN_BUFFER	Buffer,
		IN HPALETTE	PaletteHandle,
		IN UINT	PaletteUsage
	)

Definition at line 226 of file conoutput.c.

{
    BOOL Success;
 
    /*
     * Parameters validation
     */
    if (Console == NULL || Buffer == NULL)
        return STATUS_INVALID_PARAMETER;
 
    if ( PaletteUsage != SYSPAL_STATIC   &&
         PaletteUsage != SYSPAL_NOSTATIC &&
         PaletteUsage != SYSPAL_NOSTATIC256 )
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    /* Change the palette */
    Success = TermSetPalette(Console, PaletteHandle, PaletteUsage);
    if (Success)
    {
        /* Free the old palette handle if there was already one set */
        if ( Buffer->PaletteHandle != NULL &&
             Buffer->PaletteHandle != PaletteHandle )
        {
            DeleteObject(Buffer->PaletteHandle);
        }
 
        /* Save the new palette in the screen buffer */
        Buffer->PaletteHandle = PaletteHandle;
        Buffer->PaletteUsage  = PaletteUsage;
    }
 
    return (Success ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
}

Referenced by CON_API().

ConDrvSetConsoleScreenBufferSize()

NTSTATUS NTAPI ConDrvSetConsoleScreenBufferSize	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN PCOORD	Size
	)

Definition at line 1435 of file text.c.

{
    NTSTATUS Status;
 
    if (Console == NULL || Buffer == NULL || Size == NULL)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    Status = ConioResizeBuffer(Console, Buffer, *Size);
    if (NT_SUCCESS(Status)) TermResizeTerminal(Console);
 
    return Status;
}

Referenced by CON_API().

ConDrvSetConsoleTextAttribute()

NTSTATUS NTAPI ConDrvSetConsoleTextAttribute	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN WORD	Attributes
	)

Definition at line 1420 of file text.c.

{
    if (Console == NULL || Buffer == NULL)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    Buffer->ScreenDefaultAttrib = (Attributes & ~COMMON_LVB_SBCSDBCS);
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvSetConsoleWindowInfo()

NTSTATUS NTAPI ConDrvSetConsoleWindowInfo	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN BOOLEAN	Absolute,
		IN PSMALL_RECT	WindowRect
	)

Definition at line 1579 of file text.c.

{
    SMALL_RECT CapturedWindowRect;
    COORD LargestWindowSize;
 
    if (Console == NULL || Buffer == NULL || WindowRect == NULL)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    CapturedWindowRect = *WindowRect;
 
    if (!Absolute)
    {
        /* Relative positions are given, transform them to absolute ones */
        CapturedWindowRect.Left   += Buffer->ViewOrigin.X;
        CapturedWindowRect.Top    += Buffer->ViewOrigin.Y;
        CapturedWindowRect.Right  += Buffer->ViewOrigin.X + Buffer->ViewSize.X - 1;
        CapturedWindowRect.Bottom += Buffer->ViewOrigin.Y + Buffer->ViewSize.Y - 1;
    }
 
    /*
     * The MSDN documentation on SetConsoleWindowInfo() is partially wrong about
     * the performed checks this API performs. While it is correct that the
     * 'Right'/'Bottom' members cannot be strictly smaller than the 'Left'/'Top'
     * members (the rectangle cannot be empty), they can be equal (describe one cell).
     * Also, if the 'Left' or 'Top' members are negative, this is automatically
     * corrected for, and the window rectangle coordinates are shifted accordingly.
     */
    if (ConioIsRectEmpty(&CapturedWindowRect))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /*
     * Forbid window sizes larger than the largest allowed console window size,
     * taking into account the size of the console screen buffer.
     */
    TermGetLargestConsoleWindowSize(Console, &LargestWindowSize);
    LargestWindowSize.X = min(LargestWindowSize.X, Buffer->ScreenBufferSize.X);
    LargestWindowSize.Y = min(LargestWindowSize.Y, Buffer->ScreenBufferSize.Y);
    if ((ConioRectWidth(&CapturedWindowRect)  > LargestWindowSize.X) ||
        (ConioRectHeight(&CapturedWindowRect) > LargestWindowSize.Y))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Shift the window rectangle coordinates if 'Left' or 'Top' are negative */
    if (CapturedWindowRect.Left < 0)
    {
        CapturedWindowRect.Right -= CapturedWindowRect.Left;
        CapturedWindowRect.Left = 0;
    }
    if (CapturedWindowRect.Top < 0)
    {
        CapturedWindowRect.Bottom -= CapturedWindowRect.Top;
        CapturedWindowRect.Top = 0;
    }
 
    /* Clip the window rectangle to the screen buffer */
    CapturedWindowRect.Right  = min(CapturedWindowRect.Right , Buffer->ScreenBufferSize.X);
    CapturedWindowRect.Bottom = min(CapturedWindowRect.Bottom, Buffer->ScreenBufferSize.Y);
 
    Buffer->ViewOrigin.X = CapturedWindowRect.Left;
    Buffer->ViewOrigin.Y = CapturedWindowRect.Top;
 
    Buffer->ViewSize.X = ConioRectWidth(&CapturedWindowRect);
    Buffer->ViewSize.Y = ConioRectHeight(&CapturedWindowRect);
 
    TermResizeTerminal(Console);
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvWriteConsole()

NTSTATUS NTAPI ConDrvWriteConsole	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	ScreenBuffer,
		IN BOOLEAN	Unicode,
		IN PVOID	StringBuffer,
		IN ULONG	NumCharsToWrite,
		OUT PULONG NumCharsWritten	OPTIONAL
	)

Definition at line 763 of file text.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PWCHAR Buffer = NULL;
    ULONG Written = 0;
    ULONG Length;
 
    if (Console == NULL || ScreenBuffer == NULL /* || StringBuffer == NULL */)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity checks */
    ASSERT(Console == ScreenBuffer->Header.Console);
    ASSERT((StringBuffer != NULL) || (StringBuffer == NULL && NumCharsToWrite == 0));
 
    /* Stop here if the console is paused */
    if (Console->ConsolePaused) return STATUS_PENDING;
 
    /* Convert the string to UNICODE */
    if (Unicode)
    {
        Buffer = StringBuffer;
    }
    else
    {
        Length = MultiByteToWideChar(Console->OutputCodePage, 0,
                                     (PCHAR)StringBuffer,
                                     NumCharsToWrite,
                                     NULL, 0);
        Buffer = ConsoleAllocHeap(0, Length * sizeof(WCHAR));
        if (Buffer)
        {
            MultiByteToWideChar(Console->OutputCodePage, 0,
                                (PCHAR)StringBuffer,
                                NumCharsToWrite,
                                (PWCHAR)Buffer, Length);
        }
        else
        {
            Status = STATUS_NO_MEMORY;
        }
    }
 
    /* Send it */
    if (Buffer)
    {
        if (NT_SUCCESS(Status))
        {
            Status = TermWriteStream(Console,
                                     ScreenBuffer,
                                     Buffer,
                                     NumCharsToWrite,
                                     TRUE);
            if (NT_SUCCESS(Status))
            {
                Written = NumCharsToWrite;
            }
        }
 
        if (!Unicode) ConsoleFreeHeap(Buffer);
    }
 
    if (NumCharsWritten) *NumCharsWritten = Written;
 
    return Status;
}

Referenced by DoWriteConsole().

ConDrvWriteConsoleOutput()

NTSTATUS NTAPI ConDrvWriteConsoleOutput	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN BOOLEAN	Unicode,
		IN PCHAR_INFO	CharInfo,
		IN OUT PSMALL_RECT	WriteRegion
	)

Definition at line 638 of file text.c.

{
    SHORT X, Y;
    SMALL_RECT ScreenBuffer;
    PCHAR_INFO CurCharInfo;
    SMALL_RECT CapturedWriteRegion;
    PCHAR_INFO Ptr;
 
    if (Console == NULL || Buffer == NULL || CharInfo == NULL || WriteRegion == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    CapturedWriteRegion = *WriteRegion;
 
    /* Make sure WriteRegion is inside the screen buffer */
    ConioInitRect(&ScreenBuffer, 0, 0,
                  Buffer->ScreenBufferSize.Y - 1,
                  Buffer->ScreenBufferSize.X - 1);
    if (!ConioGetIntersection(&CapturedWriteRegion, &CapturedWriteRegion, &ScreenBuffer))
    {
        /*
         * It is okay to have a WriteRegion completely outside
         * the screen buffer. No data is written then.
         */
        return STATUS_SUCCESS;
    }
 
    CurCharInfo = CharInfo;
 
    for (Y = CapturedWriteRegion.Top; Y <= CapturedWriteRegion.Bottom; ++Y)
    {
        Ptr = ConioCoordToPointer(Buffer, CapturedWriteRegion.Left, Y);
        for (X = CapturedWriteRegion.Left; X <= CapturedWriteRegion.Right; ++X)
        {
            if (Unicode)
            {
                Ptr->Char.UnicodeChar = CurCharInfo->Char.UnicodeChar;
            }
            else
            {
                ConsoleOutputAnsiToUnicodeChar(Console, &Ptr->Char.UnicodeChar, &CurCharInfo->Char.AsciiChar);
            }
            // TODO: Sanitize DBCS attributes?
            Ptr->Attributes = CurCharInfo->Attributes;
            ++Ptr;
            ++CurCharInfo;
        }
    }
 
    TermDrawRegion(Console, &CapturedWriteRegion);
 
    *WriteRegion = CapturedWriteRegion;
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvWriteConsoleOutputString()

NTSTATUS NTAPI ConDrvWriteConsoleOutputString	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN CODE_TYPE	CodeType,
		IN PVOID	StringBuffer,
		IN ULONG	NumCodesToWrite,
		IN PCOORD	WriteCoord,
		OUT PULONG NumCodesWritten	OPTIONAL
	)

Definition at line 1161 of file text.c.

{
    NTSTATUS Status;
 
    if (Console == NULL || Buffer == NULL || WriteCoord == NULL /* || EndCoord == NULL */)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validity checks */
    ASSERT(Console == Buffer->Header.Console);
    ASSERT((StringBuffer != NULL) || (StringBuffer == NULL && NumCodesToWrite == 0));
 
    if (NumCodesWritten)
        *NumCodesWritten = 0;
 
    if (!StringBuffer || (NumCodesToWrite == 0))
        return STATUS_SUCCESS; // Nothing to do!
 
    /* Do nothing if the writing starting point is outside of the screen buffer */
    if ( WriteCoord->X < 0 || WriteCoord->X >= Buffer->ScreenBufferSize.X ||
         WriteCoord->Y < 0 || WriteCoord->Y >= Buffer->ScreenBufferSize.Y )
    {
        return STATUS_SUCCESS;
    }
 
    NumCodesToWrite = min(NumCodesToWrite, (ULONG)Buffer->ScreenBufferSize.X * Buffer->ScreenBufferSize.Y);
 
    switch (CodeType)
    {
        case CODE_ASCII:
        {
            C_ASSERT(RTL_FIELD_SIZE(CODE_ELEMENT, AsciiChar) == sizeof(CHAR));
            Status = IntWriteConsoleOutputStringChars(Console,
                                                      Buffer,
                                                      StringBuffer,
                                                      FALSE,
                                                      NumCodesToWrite,
                                                      WriteCoord,
                                                      NumCodesWritten);
            break;
        }
 
        case CODE_UNICODE:
        {
            C_ASSERT(RTL_FIELD_SIZE(CODE_ELEMENT, UnicodeChar) == sizeof(WCHAR));
            Status = IntWriteConsoleOutputStringChars(Console,
                                                      Buffer,
                                                      StringBuffer,
                                                      TRUE,
                                                      NumCodesToWrite,
                                                      WriteCoord,
                                                      NumCodesWritten);
            break;
        }
 
        case CODE_ATTRIBUTE:
        {
            C_ASSERT(RTL_FIELD_SIZE(CODE_ELEMENT, Attribute) == sizeof(WORD));
            Status = IntWriteConsoleOutputStringAttribute(Console,
                                                          Buffer,
                                                          (PWORD)StringBuffer,
                                                          NumCodesToWrite,
                                                          WriteCoord,
                                                          NumCodesWritten);
            break;
        }
 
        default:
            return STATUS_INVALID_PARAMETER;
    }
 
    if ((PCONSOLE_SCREEN_BUFFER)Buffer == Console->ActiveBuffer)
    {
        SMALL_RECT UpdateRect;
        ConioComputeUpdateRect(Buffer, &UpdateRect, WriteCoord, NumCodesToWrite);
        TermDrawRegion(Console, &UpdateRect);
    }
 
    return Status;
}

Referenced by CON_API().

ConDrvWriteConsoleOutputVDM()

NTSTATUS NTAPI ConDrvWriteConsoleOutputVDM	(	IN PCONSOLE	Console,
		IN PTEXTMODE_SCREEN_BUFFER	Buffer,
		IN PCHAR_CELL	CharInfo,
		IN COORD	CharInfoSize,
		IN PSMALL_RECT	WriteRegion
	)

Definition at line 708 of file text.c.

{
    SHORT X, Y;
    SMALL_RECT ScreenBuffer;
    PCHAR_CELL CurCharInfo;
    SMALL_RECT CapturedWriteRegion;
    PCHAR_INFO Ptr;
 
    if (Console == NULL || Buffer == NULL || CharInfo == NULL || WriteRegion == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validity check */
    ASSERT(Console == Buffer->Header.Console);
 
    CapturedWriteRegion = *WriteRegion;
 
    /* Make sure WriteRegion is inside the screen buffer */
    ConioInitRect(&ScreenBuffer, 0, 0,
                  Buffer->ScreenBufferSize.Y - 1,
                  Buffer->ScreenBufferSize.X - 1);
    if (!ConioGetIntersection(&CapturedWriteRegion, &CapturedWriteRegion, &ScreenBuffer))
    {
        /*
         * It is okay to have a WriteRegion completely outside
         * the screen buffer. No data is written then.
         */
        return STATUS_SUCCESS;
    }
 
    // CurCharInfo = CharInfo;
 
    for (Y = CapturedWriteRegion.Top; Y <= CapturedWriteRegion.Bottom; ++Y)
    {
        CurCharInfo = CharInfo + Y * CharInfoSize.X + CapturedWriteRegion.Left;
 
        Ptr = ConioCoordToPointer(Buffer, CapturedWriteRegion.Left, Y);
        for (X = CapturedWriteRegion.Left; X <= CapturedWriteRegion.Right; ++X)
        {
            ConsoleOutputAnsiToUnicodeChar(Console, &Ptr->Char.UnicodeChar, &CurCharInfo->Char);
            Ptr->Attributes = CurCharInfo->Attributes;
            ++Ptr;
            ++CurCharInfo;
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

DoWriteConsole()

static NTSTATUS DoWriteConsole ( IN PCSR_API_MESSAGE  ApiMessage, IN PCSR_THREAD  ClientThread, IN BOOLEAN CreateWaitBlock  OPTIONAL  )

static

Definition at line 409 of file conoutput.c.

{
    NTSTATUS Status;
    PCONSOLE_WRITECONSOLE WriteConsoleRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.WriteConsoleRequest;
    PTEXTMODE_SCREEN_BUFFER ScreenBuffer;
 
    PVOID Buffer;
    ULONG NrCharactersWritten = 0;
    ULONG CharSize = (WriteConsoleRequest->Unicode ? sizeof(WCHAR) : sizeof(CHAR));
 
    Status = ConSrvGetTextModeBuffer(ConsoleGetPerProcessData(ClientThread->Process),
                                     WriteConsoleRequest->OutputHandle,
                                     &ScreenBuffer, GENERIC_WRITE, FALSE);
    if (!NT_SUCCESS(Status)) return Status;
 
    /*
     * For optimization purposes, Windows (and hence ReactOS, too, for
     * compatibility reasons) uses a static buffer if no more than eighty
     * bytes are written. Otherwise a new buffer is used.
     * The client-side expects that we know this behaviour.
     */
    if (WriteConsoleRequest->UsingStaticBuffer &&
        WriteConsoleRequest->NumBytes <= sizeof(WriteConsoleRequest->StaticBuffer))
    {
        /*
         * Adjust the internal pointer, because its old value points to
         * the static buffer in the original ApiMessage structure.
         */
        // WriteConsoleRequest->Buffer = WriteConsoleRequest->StaticBuffer;
        Buffer = WriteConsoleRequest->StaticBuffer;
    }
    else
    {
        Buffer = WriteConsoleRequest->Buffer;
    }
 
    DPRINT("Calling ConDrvWriteConsole\n");
    Status = ConDrvWriteConsole(ScreenBuffer->Header.Console,
                                ScreenBuffer,
                                WriteConsoleRequest->Unicode,
                                Buffer,
                                WriteConsoleRequest->NumBytes / CharSize, // NrCharactersToWrite
                                &NrCharactersWritten);
    DPRINT("ConDrvWriteConsole returned (%d ; Status = 0x%08x)\n",
           NrCharactersWritten, Status);
 
    if (Status == STATUS_PENDING)
    {
        if (CreateWaitBlock)
        {
            PCONSRV_CONSOLE Console = (PCONSRV_CONSOLE)ScreenBuffer->Header.Console;
 
            if (!CsrCreateWait(&Console->WriteWaitQueue,
                               WriteConsoleThread,
                               ClientThread,
                               ApiMessage,
                               NULL))
            {
                /* Fail */
                Status = STATUS_NO_MEMORY;
                goto Quit;
            }
        }
 
        /* Wait until we un-pause the console */
        // Status = STATUS_PENDING;
    }
    else
    {
        /* We read all what we wanted. Set the number of bytes written. */
        WriteConsoleRequest->NumBytes = NrCharactersWritten * CharSize;
    }
 
Quit:
    ConSrvReleaseScreenBuffer(ScreenBuffer, FALSE);
    return Status;
}

Referenced by CON_API(), and WriteConsoleThread().

WriteConsoleThread()

static BOOLEAN NTAPI WriteConsoleThread ( IN PLIST_ENTRY  WaitList, IN PCSR_THREAD  WaitThread, IN PCSR_API_MESSAGE  WaitApiMessage, IN PVOID  WaitContext, IN PVOID  WaitArgument1, IN PVOID  WaitArgument2, IN ULONG  WaitFlags  )

static

Definition at line 367 of file conoutput.c.

{
    NTSTATUS Status;
 
    DPRINT("WriteConsoleThread - WaitContext = 0x%p, WaitArgument1 = 0x%p, WaitArgument2 = 0x%p, WaitFlags = %lu\n", WaitContext, WaitArgument1, WaitArgument2, WaitFlags);
 
    /*
     * If we are notified of the process termination via a call
     * to CsrNotifyWaitBlock triggered by CsrDestroyProcess or
     * CsrDestroyThread, just return.
     */
    if (WaitFlags & CsrProcessTerminating)
    {
        Status = STATUS_THREAD_IS_TERMINATING;
        goto Quit;
    }
 
    Status = DoWriteConsole(WaitApiMessage, WaitThread, FALSE);
 
Quit:
    if (Status != STATUS_PENDING)
    {
        WaitApiMessage->Status = Status;
    }
 
    return (Status == STATUS_PENDING ? FALSE : TRUE);
}

Referenced by DoWriteConsole().