popup.c File Reference

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

Include dependency graph for popup.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
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)
NTSTATUS NTAPI	ConDrvReadConsoleOutput (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN BOOLEAN Unicode, OUT PCHAR_INFO CharInfo, IN OUT PSMALL_RECT ReadRegion)
NTSTATUS NTAPI	ConDrvWriteConsoleOutput (IN PCONSOLE Console, IN PTEXTMODE_SCREEN_BUFFER Buffer, IN BOOLEAN Unicode, IN PCHAR_INFO CharInfo, IN OUT PSMALL_RECT WriteRegion)
static VOID	DrawBox (PTEXTMODE_SCREEN_BUFFER Buffer, IN SHORT xLeft, IN SHORT yTop, IN SHORT Width, IN SHORT Height)
PPOPUP_WINDOW	CreatePopupWindow (IN PCONSRV_CONSOLE Console, IN PCONSOLE_SCREEN_BUFFER ScreenBuffer, IN SHORT xLeft, IN SHORT yTop, IN SHORT Width, IN SHORT Height)
VOID	DestroyPopupWindow (IN PPOPUP_WINDOW Popup)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 20 of file popup.c.

Function Documentation

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

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

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

CreatePopupWindow()

PPOPUP_WINDOW CreatePopupWindow	(	IN PCONSRV_CONSOLE	Console,
		IN PCONSOLE_SCREEN_BUFFER	ScreenBuffer,
		IN SHORT	xLeft,
		IN SHORT	yTop,
		IN SHORT	Width,
		IN SHORT	Height
	)

Definition at line 184 of file popup.c.

{
    PTEXTMODE_SCREEN_BUFFER Buffer;
    PPOPUP_WINDOW Popup;
    SMALL_RECT Region;
 
    ASSERT((PCONSOLE)Console == ScreenBuffer->Header.Console);
 
    if (GetType(ScreenBuffer) != TEXTMODE_BUFFER)
        return NULL;
 
    Buffer = (PTEXTMODE_SCREEN_BUFFER)ScreenBuffer;
 
    /* Create the popup window */
    Popup = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(*Popup));
    if (Popup == NULL) return NULL;
 
    Popup->ScreenBuffer = Buffer;
    Popup->Origin.X = xLeft;
    Popup->Origin.Y = yTop;
    Popup->Size.X = Width;
    Popup->Size.Y = Height;
 
    /* Save old contents */
    Popup->OldContents = ConsoleAllocHeap(HEAP_ZERO_MEMORY,
                                          Popup->Size.X * Popup->Size.Y *
                                            sizeof(*Popup->OldContents));
    if (Popup->OldContents == NULL)
    {
        ConsoleFreeHeap(Popup);
        return NULL;
    }
    Region.Left   = Popup->Origin.X;
    Region.Top    = Popup->Origin.Y;
    Region.Right  = Popup->Origin.X + Popup->Size.X - 1;
    Region.Bottom = Popup->Origin.Y + Popup->Size.Y - 1;
    ConDrvReadConsoleOutput(Buffer->Header.Console,
                            Buffer,
                            TRUE,
                            Popup->OldContents,
                            &Region);
 
    /* Draw it */
    DrawBox(Buffer,
            xLeft, yTop,
            Width, Height);
 
    /* Add it into the list of popups */
    InsertTailList(&Console->PopupWindows, &Popup->ListEntry);
 
    return Popup;
}

Referenced by HistoryDisplayCurrentHistory().

DestroyPopupWindow()

VOID DestroyPopupWindow

(

IN PPOPUP_WINDOW

Popup

)

Definition at line 244 of file popup.c.

{
    SMALL_RECT Region;
 
    if (Popup == NULL) return;
 
    /* Remove it from the list of popups */
    RemoveEntryList(&Popup->ListEntry);
 
    /* Restore the old screen-buffer contents */
    Region.Left   = Popup->Origin.X;
    Region.Top    = Popup->Origin.Y;
    Region.Right  = Popup->Origin.X + Popup->Size.X - 1;
    Region.Bottom = Popup->Origin.Y + Popup->Size.Y - 1;
    ConDrvWriteConsoleOutput(Popup->ScreenBuffer->Header.Console,
                             Popup->ScreenBuffer,
                             TRUE,
                             Popup->OldContents,
                             &Region);
 
    /* Free memory */
    ConsoleFreeHeap(Popup->OldContents);
    ConsoleFreeHeap(Popup);
}

Referenced by LineInputKeyDown().

DrawBox()

static VOID DrawBox ( PTEXTMODE_SCREEN_BUFFER  Buffer, IN SHORT  xLeft, IN SHORT  yTop, IN SHORT  Width, IN SHORT  Height  )

static

Definition at line 49 of file popup.c.

{
    COORD coPos;
    DWORD Written;
    CODE_ELEMENT Code;
 
    /* Set screen attributes */
    coPos.X = xLeft;
    Code.Attribute = Buffer->PopupDefaultAttrib;
    for (coPos.Y = yTop; coPos.Y < yTop + Height; coPos.Y++)
    {
        ConDrvFillConsoleOutput(Buffer->Header.Console,
                                Buffer,
                                CODE_ATTRIBUTE,
                                Code,
                                Width,
                                &coPos,
                                &Written);
    }
 
    /* draw upper left corner */
    coPos.X = xLeft;
    coPos.Y = yTop;
    Code.AsciiChar = 0xDA; // '+'
    ConDrvFillConsoleOutput(Buffer->Header.Console,
                            Buffer,
                            CODE_ASCII,
                            Code,
                            1,
                            &coPos,
                            &Written);
 
    /* draw upper edge */
    coPos.X = xLeft + 1;
    coPos.Y = yTop;
    Code.AsciiChar = 0xC4; // '-'
    ConDrvFillConsoleOutput(Buffer->Header.Console,
                            Buffer,
                            CODE_ASCII,
                            Code,
                            Width - 2,
                            &coPos,
                            &Written);
 
    /* draw upper right corner */
    coPos.X = xLeft + Width - 1;
    coPos.Y = yTop;
    Code.AsciiChar = 0xBF; // '+'
    ConDrvFillConsoleOutput(Buffer->Header.Console,
                            Buffer,
                            CODE_ASCII,
                            Code,
                            1,
                            &coPos,
                            &Written);
 
    /* Draw right edge, inner space and left edge */
    for (coPos.Y = yTop + 1; coPos.Y < yTop + Height - 1; coPos.Y++)
    {
        coPos.X = xLeft;
        Code.AsciiChar = 0xB3; // '|'
        ConDrvFillConsoleOutput(Buffer->Header.Console,
                                Buffer,
                                CODE_ASCII,
                                Code,
                                1,
                                &coPos,
                                &Written);
 
        coPos.X = xLeft + 1;
        Code.AsciiChar = ' ';
        ConDrvFillConsoleOutput(Buffer->Header.Console,
                                Buffer,
                                CODE_ASCII,
                                Code,
                                Width - 2,
                                &coPos,
                                &Written);
 
        coPos.X = xLeft + Width - 1;
        Code.AsciiChar = 0xB3; // '|'
        ConDrvFillConsoleOutput(Buffer->Header.Console,
                                Buffer,
                                CODE_ASCII,
                                Code,
                                1,
                                &coPos,
                                &Written);
    }
 
    /* draw lower left corner */
    coPos.X = xLeft;
    coPos.Y = yTop + Height - 1;
    Code.AsciiChar = 0xC0; // '+'
    ConDrvFillConsoleOutput(Buffer->Header.Console,
                            Buffer,
                            CODE_ASCII,
                            Code,
                            1,
                            &coPos,
                            &Written);
 
    /* draw lower edge */
    coPos.X = xLeft + 1;
    coPos.Y = yTop + Height - 1;
    Code.AsciiChar = 0xC4; // '-'
    ConDrvFillConsoleOutput(Buffer->Header.Console,
                            Buffer,
                            CODE_ASCII,
                            Code,
                            Width - 2,
                            &coPos,
                            &Written);
 
    /* draw lower right corner */
    coPos.X = xLeft + Width - 1;
    coPos.Y = yTop + Height - 1;
    Code.AsciiChar = 0xD9; // '+'
    ConDrvFillConsoleOutput(Buffer->Header.Console,
                            Buffer,
                            CODE_ASCII,
                            Code,
                            1,
                            &coPos,
                            &Written);
}

Referenced by CreatePopupWindow().