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	TEXTMODE_BUFFER_Initialize (OUT PCONSOLE_SCREEN_BUFFER *Buffer, IN PCONSOLE Console, IN HANDLE ProcessHandle, IN PTEXTMODE_BUFFER_INFO TextModeInfo)
NTSTATUS	GRAPHICS_BUFFER_Initialize (OUT PCONSOLE_SCREEN_BUFFER *Buffer, IN PCONSOLE Console, IN HANDLE ProcessHandle, IN PGRAPHICS_BUFFER_INFO GraphicsInfo)
VOID	TEXTMODE_BUFFER_Destroy (IN OUT PCONSOLE_SCREEN_BUFFER Buffer)
VOID	GRAPHICS_BUFFER_Destroy (IN OUT PCONSOLE_SCREEN_BUFFER Buffer)
NTSTATUS	CONSOLE_SCREEN_BUFFER_Initialize (OUT PCONSOLE_SCREEN_BUFFER *Buffer, IN PCONSOLE Console, IN CONSOLE_IO_OBJECT_TYPE Type, IN SIZE_T Size)
VOID	CONSOLE_SCREEN_BUFFER_Destroy (IN OUT PCONSOLE_SCREEN_BUFFER Buffer)
NTSTATUS	ConDrvCreateScreenBuffer (OUT PCONSOLE_SCREEN_BUFFER *Buffer, IN PCONSOLE Console, IN HANDLE ProcessHandle OPTIONAL, IN ULONG BufferType, IN PVOID ScreenBufferInfo)
static VOID	ConioSetActiveScreenBuffer (PCONSOLE_SCREEN_BUFFER Buffer)
VOID NTAPI	ConDrvDeleteScreenBuffer (PCONSOLE_SCREEN_BUFFER Buffer)
NTSTATUS NTAPI	ConDrvSetConsoleActiveScreenBuffer (IN PCONSOLE Console, IN PCONSOLE_SCREEN_BUFFER Buffer)
PCONSOLE_SCREEN_BUFFER	ConDrvGetActiveScreenBuffer (IN PCONSOLE Console)
NTSTATUS NTAPI	ConDrvInvalidateBitMapRect (IN PCONSOLE Console, IN PCONSOLE_SCREEN_BUFFER Buffer, IN PSMALL_RECT Region)
NTSTATUS NTAPI	ConDrvSetConsolePalette (IN PCONSOLE Console, IN PCONSOLE_SCREEN_BUFFER Buffer, IN HPALETTE PaletteHandle, IN UINT PaletteUsage)
NTSTATUS NTAPI	ConDrvGetConsoleCursorInfo (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, OUT PCONSOLE_CURSOR_INFO CursorInfo)
NTSTATUS NTAPI	ConDrvSetConsoleCursorInfo (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN PCONSOLE_CURSOR_INFO CursorInfo)
NTSTATUS NTAPI	ConDrvSetConsoleCursorPosition (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN PCOORD Position)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file conoutput.c.

Function Documentation

ConDrvCreateScreenBuffer()

NTSTATUS ConDrvCreateScreenBuffer	(	OUT PCONSOLE_SCREEN_BUFFER *	Buffer,
		IN PCONSOLE	Console,
		IN HANDLE ProcessHandle	OPTIONAL,
		IN ULONG	BufferType,
		IN PVOID	ScreenBufferInfo
	)

Definition at line 85 of file conoutput.c.

{
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
 
    if ( Console == NULL || Buffer == NULL ||
        (BufferType != CONSOLE_TEXTMODE_BUFFER && BufferType != CONSOLE_GRAPHICS_BUFFER) )
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Use the current process if ProcessHandle is NULL */
    if (ProcessHandle == NULL)
        ProcessHandle = NtCurrentProcess();
 
    switch (BufferType)
    {
    case CONSOLE_TEXTMODE_BUFFER:
        Status = TEXTMODE_BUFFER_Initialize(Buffer, Console, ProcessHandle,
                                            (PTEXTMODE_BUFFER_INFO)ScreenBufferInfo);
        break;
 
    case CONSOLE_GRAPHICS_BUFFER:
        Status = GRAPHICS_BUFFER_Initialize(Buffer, Console, ProcessHandle,
                                            (PGRAPHICS_BUFFER_INFO)ScreenBufferInfo);
        break;
 
    default:
        /* Never ever go there!! */
        ASSERT(FALSE);
    }
 
    /* Insert the newly created screen buffer into the list, if succeeded */
    if (NT_SUCCESS(Status)) InsertHeadList(&Console->BufferList, &(*Buffer)->ListEntry);
 
    return Status;
}

Referenced by CON_API(), and ConDrvInitConsole().

ConDrvDeleteScreenBuffer()

VOID NTAPI ConDrvDeleteScreenBuffer

(

PCONSOLE_SCREEN_BUFFER

Buffer

)

Definition at line 130 of file conoutput.c.

{
    PCONSOLE Console = Buffer->Header.Console;
    PCONSOLE_SCREEN_BUFFER NewBuffer;
 
    /*
     * We should notify temporarily the frontend because we are susceptible
     * to delete the screen buffer it is using (which may be different from
     * the active screen buffer in some cases), and because, if it actually
     * uses the active screen buffer, we are going to nullify its pointer to
     * change it.
     */
    TermReleaseScreenBuffer(Console, Buffer);
 
    RemoveEntryList(&Buffer->ListEntry);
    if (Buffer == Console->ActiveBuffer)
    {
        /* Delete active buffer; switch to most recently created */
        if (!IsListEmpty(&Console->BufferList))
        {
            NewBuffer = CONTAINING_RECORD(Console->BufferList.Flink,
                                          CONSOLE_SCREEN_BUFFER,
                                          ListEntry);
 
            /* Tie console to new buffer and signal the change to the frontend */
            ConioSetActiveScreenBuffer(NewBuffer);
        }
        else
        {
            Console->ActiveBuffer = NULL;
            // InterlockedExchangePointer(&Console->ActiveBuffer, NULL);
        }
    }
 
    CONSOLE_SCREEN_BUFFER_Destroy(Buffer);
}

Referenced by CON_API(), ConDrvDeleteConsole(), ConDrvSetConsoleActiveScreenBuffer(), and ConSrvCloseHandle().

ConDrvGetActiveScreenBuffer()

PCONSOLE_SCREEN_BUFFER ConDrvGetActiveScreenBuffer

(

IN PCONSOLE

Console

)

Definition at line 201 of file conoutput.c.

{
    return (Console ? Console->ActiveBuffer : NULL);
}

Referenced by GuiSetActiveScreenBuffer().

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().

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().

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().

ConioSetActiveScreenBuffer()

static VOID ConioSetActiveScreenBuffer ( PCONSOLE_SCREEN_BUFFER  Buffer )

static

Definition at line 168 of file conoutput.c.

{
    PCONSOLE Console = Buffer->Header.Console;
    Console->ActiveBuffer = Buffer;
    // InterlockedExchangePointer(&Console->ActiveBuffer, Buffer);
    TermSetActiveScreenBuffer(Console);
}

Referenced by ConDrvDeleteScreenBuffer(), and ConDrvSetConsoleActiveScreenBuffer().

CONSOLE_SCREEN_BUFFER_Destroy()

VOID CONSOLE_SCREEN_BUFFER_Destroy

(

IN OUT PCONSOLE_SCREEN_BUFFER

Buffer

)

Definition at line 55 of file conoutput.c.

{
    switch (Buffer->Header.Type)
    {
    case TEXTMODE_BUFFER:
        TEXTMODE_BUFFER_Destroy(Buffer);
        break;
 
    case GRAPHICS_BUFFER:
        GRAPHICS_BUFFER_Destroy(Buffer);
        break;
 
    case SCREEN_BUFFER:
    {
        /* Free the palette handle */
        if (Buffer->PaletteHandle != NULL)
            DeleteObject(Buffer->PaletteHandle);
 
        /* Free the screen buffer memory */
        ConsoleFreeHeap(Buffer);
        break;
    }
 
    default:
        break;
    }
}

Referenced by ConDrvDeleteScreenBuffer(), GRAPHICS_BUFFER_Destroy(), GRAPHICS_BUFFER_Initialize(), TEXTMODE_BUFFER_Destroy(), and TEXTMODE_BUFFER_Initialize().

CONSOLE_SCREEN_BUFFER_Initialize()

NTSTATUS CONSOLE_SCREEN_BUFFER_Initialize	(	OUT PCONSOLE_SCREEN_BUFFER *	Buffer,
		IN PCONSOLE	Console,
		IN CONSOLE_IO_OBJECT_TYPE	Type,
		IN SIZE_T	Size
	)

Definition at line 37 of file conoutput.c.

{
    if (Buffer == NULL || Console == NULL)
        return STATUS_INVALID_PARAMETER;
 
    *Buffer = ConsoleAllocHeap(HEAP_ZERO_MEMORY, max(sizeof(CONSOLE_SCREEN_BUFFER), Size));
    if (*Buffer == NULL) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Initialize the header with the default type */
    ConSrvInitObject(&(*Buffer)->Header, Type /* SCREEN_BUFFER */, Console);
    return STATUS_SUCCESS;
}

Referenced by GRAPHICS_BUFFER_Initialize(), and TEXTMODE_BUFFER_Initialize().

GRAPHICS_BUFFER_Destroy()

VOID GRAPHICS_BUFFER_Destroy

(

IN OUT PCONSOLE_SCREEN_BUFFER

Buffer

)

Definition at line 236 of file graphics.c.

{
    PGRAPHICS_SCREEN_BUFFER Buff = (PGRAPHICS_SCREEN_BUFFER)Buffer;
 
    /*
     * IMPORTANT !! Reinitialize the type so that we don't enter a recursive
     * infinite loop when calling CONSOLE_SCREEN_BUFFER_Destroy.
     */
    Buffer->Header.Type = SCREEN_BUFFER;
 
    /*
     * Uninitialize the graphics screen buffer
     * in the reverse way we initialized it.
     */
    NtUnmapViewOfSection(Buff->ClientProcess, Buff->ClientBitMap);
    NtUnmapViewOfSection(NtCurrentProcess(), Buff->BitMap);
    NtClose(Buff->hSection);
    NtDuplicateObject(Buff->ClientProcess, Buff->ClientMutex,
                      NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
    NtClose(Buff->Mutex);
    ConsoleFreeHeap(Buff->BitMapInfo);
 
    CONSOLE_SCREEN_BUFFER_Destroy(Buffer);
}

Referenced by CONSOLE_SCREEN_BUFFER_Destroy().

GRAPHICS_BUFFER_Initialize()

NTSTATUS GRAPHICS_BUFFER_Initialize	(	OUT PCONSOLE_SCREEN_BUFFER *	Buffer,
		IN PCONSOLE	Console,
		IN HANDLE	ProcessHandle,
		IN PGRAPHICS_BUFFER_INFO	GraphicsInfo
	)

Definition at line 33 of file graphics.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PGRAPHICS_SCREEN_BUFFER NewBuffer = NULL;
 
    LARGE_INTEGER SectionSize;
    SIZE_T ViewSize = 0;
 
    if (Buffer == NULL || Console == NULL || GraphicsInfo == NULL)
        return STATUS_INVALID_PARAMETER;
 
    *Buffer = NULL;
 
    Status = CONSOLE_SCREEN_BUFFER_Initialize((PCONSOLE_SCREEN_BUFFER*)&NewBuffer,
                                              Console,
                                              GRAPHICS_BUFFER,
                                              sizeof(GRAPHICS_SCREEN_BUFFER));
    if (!NT_SUCCESS(Status)) return Status;
 
    /*
     * Remember the handle to the process so that we can close or unmap
     * correctly the allocated resources when the client releases the
     * screen buffer.
     */
    NewBuffer->ClientProcess = ProcessHandle;
 
    /* Get information from the graphics buffer information structure */
    NewBuffer->BitMapInfoLength = GraphicsInfo->Info.dwBitMapInfoLength;
 
    NewBuffer->BitMapInfo = ConsoleAllocHeap(HEAP_ZERO_MEMORY, NewBuffer->BitMapInfoLength);
    if (NewBuffer->BitMapInfo == NULL)
    {
        CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Adjust the bitmap height if needed (bottom-top vs. top-bottom). Use always bottom-up. */
    if (GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biHeight > 0)
        GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biHeight = -GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biHeight;
 
    /* We do not use anything else than uncompressed bitmaps */
    if (GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biCompression != BI_RGB)
    {
        DPRINT1("biCompression == %d != BI_RGB, fix that!\n",
                GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biCompression);
        GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biCompression = BI_RGB;
    }
 
    RtlCopyMemory(NewBuffer->BitMapInfo,
                  GraphicsInfo->Info.lpBitMapInfo,
                  GraphicsInfo->Info.dwBitMapInfoLength);
 
    NewBuffer->BitMapUsage = GraphicsInfo->Info.dwUsage;
 
    /* Set the screen buffer size. Fight against overflows. */
    if ( GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biWidth  <= 0xFFFF &&
        -GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biHeight <= 0xFFFF )
    {
        /* Be careful about the sign of biHeight */
        NewBuffer->ScreenBufferSize.X =  (SHORT)GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biWidth ;
        NewBuffer->ScreenBufferSize.Y = (SHORT)-GraphicsInfo->Info.lpBitMapInfo->bmiHeader.biHeight;
 
        NewBuffer->OldViewSize = NewBuffer->ViewSize =
            NewBuffer->OldScreenBufferSize = NewBuffer->ScreenBufferSize;
    }
    else
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        ConsoleFreeHeap(NewBuffer->BitMapInfo);
        CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
        goto Quit;
    }
 
    /*
     * Create a mutex to synchronize bitmap memory access
     * between ourselves and the client.
     */
    Status = NtCreateMutant(&NewBuffer->Mutex, MUTANT_ALL_ACCESS, NULL, FALSE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtCreateMutant() failed: %lu\n", Status);
        ConsoleFreeHeap(NewBuffer->BitMapInfo);
        CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
        goto Quit;
    }
 
    /*
     * Duplicate the Mutex for the client. We must keep a trace of it
     * so that we can close it when the client releases the screen buffer.
     */
    Status = NtDuplicateObject(NtCurrentProcess(),
                               NewBuffer->Mutex,
                               ProcessHandle,
                               &NewBuffer->ClientMutex,
                               0, 0, DUPLICATE_SAME_ACCESS);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDuplicateObject() failed: %lu\n", Status);
        NtClose(NewBuffer->Mutex);
        ConsoleFreeHeap(NewBuffer->BitMapInfo);
        CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
        goto Quit;
    }
 
    /*
     * Create a memory section for the bitmap area, to share with the client.
     */
    SectionSize.QuadPart = NewBuffer->BitMapInfo->bmiHeader.biSizeImage;
    Status = NtCreateSection(&NewBuffer->hSection,
                             SECTION_ALL_ACCESS,
                             NULL,
                             &SectionSize,
                             PAGE_READWRITE,
                             SEC_COMMIT,
                             NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Error: Impossible to create a shared section, Status = 0x%08lx\n", Status);
        NtDuplicateObject(ProcessHandle, NewBuffer->ClientMutex,
                          NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
        NtClose(NewBuffer->Mutex);
        ConsoleFreeHeap(NewBuffer->BitMapInfo);
        CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
        goto Quit;
    }
 
    /*
     * Create a view for our needs.
     */
    ViewSize = 0;
    NewBuffer->BitMap = NULL;
    Status = NtMapViewOfSection(NewBuffer->hSection,
                                NtCurrentProcess(),
                                (PVOID*)&NewBuffer->BitMap,
                                0,
                                0,
                                NULL,
                                &ViewSize,
                                ViewUnmap,
                                0,
                                PAGE_READWRITE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Error: Impossible to map the shared section, Status = 0x%08lx\n", Status);
        NtClose(NewBuffer->hSection);
        NtDuplicateObject(ProcessHandle, NewBuffer->ClientMutex,
                          NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
        NtClose(NewBuffer->Mutex);
        ConsoleFreeHeap(NewBuffer->BitMapInfo);
        CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
        goto Quit;
    }
 
    /*
     * Create a view for the client. We must keep a trace of it so that
     * we can unmap it when the client releases the screen buffer.
     */
    ViewSize = 0;
    NewBuffer->ClientBitMap = NULL;
    Status = NtMapViewOfSection(NewBuffer->hSection,
                                ProcessHandle,
                                (PVOID*)&NewBuffer->ClientBitMap,
                                0,
                                0,
                                NULL,
                                &ViewSize,
                                ViewUnmap,
                                0,
                                PAGE_READWRITE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Error: Impossible to map the shared section, Status = 0x%08lx\n", Status);
        NtUnmapViewOfSection(NtCurrentProcess(), NewBuffer->BitMap);
        NtClose(NewBuffer->hSection);
        NtDuplicateObject(ProcessHandle, NewBuffer->ClientMutex,
                          NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
        NtClose(NewBuffer->Mutex);
        ConsoleFreeHeap(NewBuffer->BitMapInfo);
        CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
        goto Quit;
    }
 
    NewBuffer->ViewOrigin.X = NewBuffer->ViewOrigin.Y = 0;
 
    NewBuffer->CursorBlinkOn  = FALSE;
    NewBuffer->ForceCursorOff = TRUE;
    NewBuffer->CursorInfo.bVisible = FALSE;
    NewBuffer->CursorInfo.dwSize   = 0;
    NewBuffer->CursorPosition.X = NewBuffer->CursorPosition.Y = 0;
 
    NewBuffer->Mode = 0;
 
    *Buffer = (PCONSOLE_SCREEN_BUFFER)NewBuffer;
    Status = STATUS_SUCCESS;
 
Quit:
    return Status;
}

Referenced by ConDrvCreateScreenBuffer().

TEXTMODE_BUFFER_Destroy()

VOID TEXTMODE_BUFFER_Destroy

(

IN OUT PCONSOLE_SCREEN_BUFFER

Buffer

)

Definition at line 126 of file text.c.

{
    PTEXTMODE_SCREEN_BUFFER Buff = (PTEXTMODE_SCREEN_BUFFER)Buffer;
 
    /*
     * IMPORTANT !! Reinitialize the type so that we don't enter a recursive
     * infinite loop when calling CONSOLE_SCREEN_BUFFER_Destroy.
     */
    Buffer->Header.Type = SCREEN_BUFFER;
 
    ConsoleFreeHeap(Buff->Buffer);
 
    CONSOLE_SCREEN_BUFFER_Destroy(Buffer);
}

Referenced by CONSOLE_SCREEN_BUFFER_Destroy().

TEXTMODE_BUFFER_Initialize()

NTSTATUS TEXTMODE_BUFFER_Initialize	(	OUT PCONSOLE_SCREEN_BUFFER *	Buffer,
		IN PCONSOLE	Console,
		IN HANDLE	ProcessHandle,
		IN PTEXTMODE_BUFFER_INFO	TextModeInfo
	)

Definition at line 54 of file text.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PTEXTMODE_SCREEN_BUFFER NewBuffer = NULL;
 
    UNREFERENCED_PARAMETER(ProcessHandle);
 
    if (Console == NULL || Buffer == NULL || TextModeInfo == NULL)
        return STATUS_INVALID_PARAMETER;
 
    if ((TextModeInfo->ScreenBufferSize.X == 0) ||
        (TextModeInfo->ScreenBufferSize.Y == 0))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    *Buffer = NULL;
 
    Status = CONSOLE_SCREEN_BUFFER_Initialize((PCONSOLE_SCREEN_BUFFER*)&NewBuffer,
                                              Console,
                                              TEXTMODE_BUFFER,
                                              sizeof(TEXTMODE_SCREEN_BUFFER));
    if (!NT_SUCCESS(Status)) return Status;
 
    NewBuffer->Buffer = ConsoleAllocHeap(HEAP_ZERO_MEMORY,
                                         TextModeInfo->ScreenBufferSize.X *
                                         TextModeInfo->ScreenBufferSize.Y *
                                            sizeof(CHAR_INFO));
    if (NewBuffer->Buffer == NULL)
    {
        CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    NewBuffer->ScreenBufferSize = TextModeInfo->ScreenBufferSize;
    NewBuffer->OldScreenBufferSize = NewBuffer->ScreenBufferSize;
 
    /*
     * Set and fix the view size if needed.
     * The rule is: ScreenBufferSize >= ViewSize (== ConsoleSize)
     */
    NewBuffer->ViewSize.X = min(max(TextModeInfo->ViewSize.X, 1), NewBuffer->ScreenBufferSize.X);
    NewBuffer->ViewSize.Y = min(max(TextModeInfo->ViewSize.Y, 1), NewBuffer->ScreenBufferSize.Y);
    NewBuffer->OldViewSize = NewBuffer->ViewSize;
 
    NewBuffer->ViewOrigin.X = NewBuffer->ViewOrigin.Y = 0;
    NewBuffer->VirtualY = 0;
 
    NewBuffer->CursorBlinkOn = NewBuffer->ForceCursorOff = FALSE;
    NewBuffer->CursorInfo.bVisible = (TextModeInfo->IsCursorVisible && (TextModeInfo->CursorSize != 0));
    NewBuffer->CursorInfo.dwSize   = min(max(TextModeInfo->CursorSize, 0), 100);
 
    NewBuffer->ScreenDefaultAttrib = (TextModeInfo->ScreenAttrib & ~COMMON_LVB_SBCSDBCS);
    NewBuffer->PopupDefaultAttrib  = (TextModeInfo->PopupAttrib  & ~COMMON_LVB_SBCSDBCS);
 
    /* Initialize buffer to be empty with default attributes */
    for (NewBuffer->CursorPosition.Y = 0 ; NewBuffer->CursorPosition.Y < NewBuffer->ScreenBufferSize.Y; NewBuffer->CursorPosition.Y++)
    {
        ClearLineBuffer(NewBuffer);
    }
    NewBuffer->CursorPosition.X = NewBuffer->CursorPosition.Y = 0;
 
    NewBuffer->Mode = ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT;
 
    *Buffer = (PCONSOLE_SCREEN_BUFFER)NewBuffer;
    return STATUS_SUCCESS;
}

Referenced by ConDrvCreateScreenBuffer().