video.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
VOID	ScreenEventHandler (PWINDOW_BUFFER_SIZE_RECORD ScreenEvent)
BOOLEAN	VgaGetDoubleVisionState (PBOOLEAN Horizontal, PBOOLEAN Vertical)
BOOL	VgaAttachToConsole (VOID)
VOID	VgaDetachFromConsole (VOID)
VOID	VgaConsoleUpdateTextCursor (BOOL CursorVisible, BYTE CursorStart, BYTE CursorEnd, BYTE TextSize, DWORD ScanlineSize, WORD Location)
BOOL	VgaConsoleCreateGraphicsScreen (IN PCOORD Resolution, IN HANDLE PaletteHandle)
VOID	VgaConsoleDestroyGraphicsScreen (VOID)
BOOL	VgaConsoleCreateTextScreen (IN PCOORD Resolution, IN HANDLE PaletteHandle)
VOID	VgaConsoleDestroyTextScreen (VOID)
VOID	VgaConsoleRepaintScreen (PSMALL_RECT Rect)
BOOLEAN	VgaConsoleInitialize (HANDLE TextHandle)
VOID	VgaConsoleCleanup (VOID)

Function Documentation

ScreenEventHandler()

VOID ScreenEventHandler

(

PWINDOW_BUFFER_SIZE_RECORD

ScreenEvent

)

Definition at line 448 of file video.c.

{
    /*
     * This function monitors and allows console resizings only if they are triggered by us.
     * User-driven resizings via the console properties, or programmatical console resizings
     * made by explicit calls to SetConsoleScreenBufferSize by external applications, are forbidden.
     * In that case only a console window resize is done in case the size is reduced.
     * This protection is enabled in CONSRV side when NTVDM registers as a VDM to CONSRV,
     * but we also implement it there in case we are running in STANDALONE mode without
     * CONSRV registration.
     *
     * The only potential problem we have is that, when this handler is called,
     * the console is already resized. In case this corresponds to a forbidden resize,
     * we resize the console back to its original size from inside the handler.
     * This will trigger a recursive call to the handler, that should be detected.
     */
 
    if (CurrResolution.X == ScreenEvent->dwSize.X &&
        CurrResolution.Y == ScreenEvent->dwSize.Y)
    {
        /* Allowed resize, we are OK */
        return;
    }
 
    DPRINT1("ScreenEventHandler - Detected forbidden resize! Reset console screenbuffer size back to (X = %d ; Y = %d)\n", CurrResolution.X, CurrResolution.Y);
 
    // FIXME: If we're detaching, then stop monitoring for changes!!
 
    /* Restore the original console size */
    ResizeTextConsole(&CurrResolution, NULL);
 
    /* Force refresh of all the screen */
    NeedsUpdate = TRUE;
    UpdateRectangle.Left = 0;
    UpdateRectangle.Top  = 0;
    UpdateRectangle.Right  = CurrResolution.X;
    UpdateRectangle.Bottom = CurrResolution.Y;
    VgaRefreshDisplay();
}

Referenced by ConsoleEventThread().

VgaAttachToConsole()

BOOL VgaAttachToConsole

(

VOID

)

Definition at line 496 of file video.c.

{
    if (TextResolution.X == 0 || TextResolution.Y == 0)
        DPRINT1("VgaAttachToConsole -- TextResolution uninitialized\n");
 
    if (TextResolution.X == 0) TextResolution.X = 80;
    if (TextResolution.Y == 0) TextResolution.Y = 25;
 
    // DetachFromConsoleInternal();
 
    /*
     * AttachToConsoleInternal sets TextResolution
     * to the new resolution and updates ConsoleInfo.
     */
    if (!AttachToConsoleInternal(&TextResolution))
    {
        DisplayMessage(L"An unexpected error occurred!\n");
        EmulatorTerminate();
        return FALSE;
    }
 
    /* Restore the original screen buffer */
    SetActiveScreenBuffer(ScreenBufferHandle);
    ScreenBufferHandle = NULL;
 
    /* Restore the screen state */
    if (ScreenMode == TEXT_MODE)
    {
        /* The text mode framebuffer was recreated */
        ActiveFramebuffer = TextFramebuffer;
    }
    else
    {
        /* The graphics mode framebuffer is unchanged */
        ActiveFramebuffer = OldConsoleFramebuffer;
    }
    OldConsoleFramebuffer = NULL;
 
    return TRUE;
}

Referenced by VidBiosAttachToConsole().

VgaConsoleCleanup()

VOID VgaConsoleCleanup

(

VOID

)

Definition at line 807 of file video.c.

{
    /* If the console video was not initialized, just return */
    if (!TextConsoleBuffer)
        return;
 
    VgaDetachFromConsole();
 
    // TODO: We need to initialize those events before using them!
    CloseHandle(AnotherEvent);
    CloseHandle(EndEvent);
    CloseHandle(StartEvent);
}

Referenced by VgaCleanup().

VgaConsoleCreateGraphicsScreen()

BOOL VgaConsoleCreateGraphicsScreen	(	IN PCOORD	Resolution,
		IN HANDLE	PaletteHandle
	)

Definition at line 610 of file video.c.

{
    DWORD i;
    CONSOLE_GRAPHICS_BUFFER_INFO GraphicsBufferInfo;
    BYTE BitmapInfoBuffer[VGA_BITMAP_INFO_SIZE];
    LPBITMAPINFO BitmapInfo = (LPBITMAPINFO)BitmapInfoBuffer;
    LPWORD PaletteIndex = (LPWORD)(BitmapInfo->bmiColors);
 
    LONG Width  = Resolution->X;
    LONG Height = Resolution->Y;
 
    /* Use DoubleVision mode if the resolution is too small */
    DoubleWidth = (Width < VGA_MINIMUM_WIDTH);
    if (DoubleWidth) Width *= 2;
    DoubleHeight = (Height < VGA_MINIMUM_HEIGHT);
    if (DoubleHeight) Height *= 2;
 
    /* Fill the bitmap info header */
    RtlZeroMemory(&BitmapInfo->bmiHeader, sizeof(BitmapInfo->bmiHeader));
    BitmapInfo->bmiHeader.biSize   = sizeof(BitmapInfo->bmiHeader);
    BitmapInfo->bmiHeader.biWidth  = Width;
    BitmapInfo->bmiHeader.biHeight = Height;
    BitmapInfo->bmiHeader.biBitCount = 8;
    BitmapInfo->bmiHeader.biPlanes   = 1;
    BitmapInfo->bmiHeader.biCompression = BI_RGB;
    BitmapInfo->bmiHeader.biSizeImage   = Width * Height /* * 1 == biBitCount / 8 */;
 
    /* Fill the palette data */
    for (i = 0; i < (VGA_PALETTE_SIZE / 3); i++) PaletteIndex[i] = (WORD)i;
 
    /* Fill the console graphics buffer info */
    GraphicsBufferInfo.dwBitMapInfoLength = VGA_BITMAP_INFO_SIZE;
    GraphicsBufferInfo.lpBitMapInfo = BitmapInfo;
    GraphicsBufferInfo.dwUsage = DIB_PAL_COLORS;
 
    /* Create the buffer */
    GraphicsConsoleBuffer = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
                                                      FILE_SHARE_READ | FILE_SHARE_WRITE,
                                                      NULL,
                                                      CONSOLE_GRAPHICS_BUFFER,
                                                      &GraphicsBufferInfo);
    if (GraphicsConsoleBuffer == INVALID_HANDLE_VALUE) return FALSE;
 
    /* Save the framebuffer address and mutex */
    // *GraphicsFramebuffer = GraphicsBufferInfo.lpBitMap;
    GraphicsFramebuffer = GraphicsBufferInfo.lpBitMap;
    ConsoleMutex = GraphicsBufferInfo.hMutex;
 
    /* Clear the framebuffer */
    // RtlZeroMemory(*GraphicsFramebuffer, BitmapInfo->bmiHeader.biSizeImage);
    RtlZeroMemory(GraphicsFramebuffer, BitmapInfo->bmiHeader.biSizeImage);
 
    /* Set the graphics mode palette */
    SetConsolePalette(GraphicsConsoleBuffer,
                      PaletteHandle,
                      SYSPAL_NOSTATIC256);
 
    /* Set the active buffer */
    SetActiveScreenBuffer(GraphicsConsoleBuffer);
 
    return TRUE;
}

Referenced by VgaEnterNewMode().

VgaConsoleCreateTextScreen()

BOOL VgaConsoleCreateTextScreen	(	IN PCOORD	Resolution,
		IN HANDLE	PaletteHandle
	)

Definition at line 698 of file video.c.

{
    /* Switch to the text buffer */
    // FIXME: Wouldn't it be preferrable to switch to it AFTER we reset everything??
    SetActiveScreenBuffer(TextConsoleBuffer);
 
    /* Adjust the text framebuffer if we changed the resolution */
    if (TextResolution.X != Resolution->X ||
        TextResolution.Y != Resolution->Y)
    {
        DetachFromConsoleInternal();
 
        /*
         * AttachToConsoleInternal sets TextResolution
         * to the new resolution and updates ConsoleInfo.
         */
        if (!AttachToConsoleInternal(Resolution))
        {
            DisplayMessage(L"An unexpected error occurred!\n");
            EmulatorTerminate();
            return FALSE;
        }
    }
    else
    {
        UpdateCursorPosition();
    }
 
    /*
     * Set the text mode palette.
     *
     * INFORMATION: This call should fail on Windows (and therefore
     * we get the default palette and our external behaviour is
     * just like Windows' one), but it should success on ReactOS
     * (so that we get console palette changes even for text-mode
     * screen buffers, which is a new feature on ReactOS).
     */
    SetConsolePalette(TextConsoleBuffer,
                      PaletteHandle,
                      SYSPAL_NOSTATIC256);
 
    return TRUE;
}

Referenced by VgaEnterNewMode().

VgaConsoleDestroyGraphicsScreen()

VOID VgaConsoleDestroyGraphicsScreen

(

VOID

)

Definition at line 675 of file video.c.

{
    /* Release the console framebuffer mutex */
    ReleaseMutex(ConsoleMutex);
 
    /* Switch back to the default console text buffer */
    // SetActiveScreenBuffer(TextConsoleBuffer);
 
    /* Cleanup the video data */
    CloseHandle(ConsoleMutex);
    ConsoleMutex = NULL;
    // GraphicsFramebuffer = NULL;
    CloseHandle(GraphicsConsoleBuffer);
    GraphicsConsoleBuffer = NULL;
 
    // /* Reset the active framebuffer */
    // ActiveFramebuffer = NULL;
 
    DoubleWidth  = FALSE;
    DoubleHeight = FALSE;
}

Referenced by VgaLeaveCurrentMode().

VgaConsoleDestroyTextScreen()

VOID VgaConsoleDestroyTextScreen

(

VOID

)

Definition at line 744 of file video.c.

{
}

Referenced by VgaLeaveCurrentMode().

VgaConsoleInitialize()

BOOLEAN VgaConsoleInitialize

(

HANDLE

TextHandle

)

Definition at line 783 of file video.c.

{
    /*
     * Initialize the console video by saving the default
     * text-mode console output handle, if it is valid.
     */
    if (!IsConsoleHandle(TextHandle)) return FALSE;
    TextConsoleBuffer = TextHandle;
 
    /* Save the original cursor and console screen buffer information */
    if (!GetConsoleCursorInfo(TextConsoleBuffer, &OrgConsoleCursorInfo) ||
        !GetConsoleScreenBufferInfo(TextConsoleBuffer, &OrgConsoleBufferInfo))
    {
        TextConsoleBuffer = NULL;
        return FALSE;
    }
    ConsoleInfo = OrgConsoleBufferInfo;
 
    /* Switch to the text buffer, but do not enter into a text mode */
    SetActiveScreenBuffer(TextConsoleBuffer);
 
    return TRUE;
}

Referenced by VgaInitialize().

VgaConsoleRepaintScreen()

VOID VgaConsoleRepaintScreen

(

PSMALL_RECT

Rect

)

Definition at line 750 of file video.c.

{
    HANDLE ConsoleBufferHandle = NULL;
    SMALL_RECT UpdateRectangle = *Rect;
 
    /* Check if we are in text or graphics mode */
    if (ScreenMode == GRAPHICS_MODE)
    {
        /* Graphics mode */
        ConsoleBufferHandle = GraphicsConsoleBuffer;
 
        /* In DoubleVision mode, scale the update rectangle */
        if (DoubleWidth)
        {
            UpdateRectangle.Left *= 2;
            UpdateRectangle.Right = UpdateRectangle.Right * 2 + 1;
        }
        if (DoubleHeight)
        {
            UpdateRectangle.Top *= 2;
            UpdateRectangle.Bottom = UpdateRectangle.Bottom * 2 + 1;
        }
    }
    else
    {
        /* Text mode */
        ConsoleBufferHandle = TextConsoleBuffer;
    }
 
    /* Redraw the screen */
    __InvalidateConsoleDIBits(ConsoleBufferHandle, &UpdateRectangle);
}

Referenced by VgaVerticalRetrace().

VgaConsoleUpdateTextCursor()

VOID VgaConsoleUpdateTextCursor	(	BOOL	CursorVisible,
		BYTE	CursorStart,
		BYTE	CursorEnd,
		BYTE	TextSize,
		DWORD	ScanlineSize,
		WORD	Location
	)

Definition at line 575 of file video.c.

{
    COORD Position;
    CONSOLE_CURSOR_INFO CursorInfo;
 
    if (CursorStart < CursorEnd)
    {
        /* Visible cursor */
        CursorInfo.bVisible = CursorVisible;
        CursorInfo.dwSize   = (100 * (CursorEnd - CursorStart)) / TextSize;
    }
    else
    {
        /* Hidden cursor */
        CursorInfo.bVisible = FALSE;
        CursorInfo.dwSize   = 1; // The size needs to be non-zero for SetConsoleCursorInfo to succeed.
    }
 
    /* Find the coordinates of the new position */
    Position.X = (SHORT)(Location % ScanlineSize);
    Position.Y = (SHORT)(Location / ScanlineSize);
 
    DPRINT("VgaConsoleUpdateTextCursor: (X = %d ; Y = %d)\n", Position.X, Position.Y);
 
    /* Update the physical cursor */
    SetConsoleCursorInfo(TextConsoleBuffer, &CursorInfo);
    SetConsoleCursorPosition(TextConsoleBuffer, Position);
}

Referenced by VgaUpdateTextCursor().

VgaDetachFromConsole()

VOID VgaDetachFromConsole

(

VOID

)

• Update the physical cursor *‍/

Definition at line 537 of file video.c.

{
    DetachFromConsoleInternal();
 
    /* Save the screen state */
    if (ScreenMode == TEXT_MODE)
        ScreenBufferHandle = TextConsoleBuffer;
    else
        ScreenBufferHandle = GraphicsConsoleBuffer;
 
    /* Reset the active framebuffer */
    OldConsoleFramebuffer = ActiveFramebuffer;
    ActiveFramebuffer = NULL;
 
    /* Restore the original console size */
    ResizeTextConsole(&OrgConsoleBufferInfo.dwSize, &OrgConsoleBufferInfo.srWindow);
 
    /* Restore the original cursor shape */
    SetConsoleCursorInfo(TextConsoleBuffer, &OrgConsoleCursorInfo);
 
    // FIXME: Should we copy back the screen data to the screen buffer??
    // WriteConsoleOutputA(...);
 
    // FIXME: Should we change cursor POSITION??
    // VgaUpdateTextCursor();
 
    //SetConsoleCursorInfo(TextConsoleBuffer, &CursorInfo);
    //SetConsoleCursorPosition(TextConsoleBuffer, Position /*OrgConsoleBufferInfo.dwCursorPosition*/);
 
    /* Restore the old text-mode screen buffer */
    SetActiveScreenBuffer(TextConsoleBuffer);
}

Referenced by VgaConsoleCleanup(), and VidBiosDetachFromConsole().

VgaGetDoubleVisionState()

BOOLEAN VgaGetDoubleVisionState	(	PBOOLEAN	Horizontal,
		PBOOLEAN	Vertical
	)

Definition at line 488 of file video.c.

{
    if (GraphicsConsoleBuffer == NULL) return FALSE;
    if (Horizontal) *Horizontal = DoubleWidth;
    if (Vertical)   *Vertical   = DoubleHeight;
    return TRUE;
}

Referenced by DosMouseService(), DosUpdatePosition(), FromMouseCoordinates(), MouseEventHandler(), and ToMouseCoordinates().