ghost.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS user32.dll
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     Window ghosting feature
 * COPYRIGHT:   Copyright 2018 Katayama Hirofumi MZ (katayama.hirofumi.mz@gmail.com)
 */
 
#include <win32k.h>
#include "ghostwnd.h"
 
#define NDEBUG
#include <debug.h>
 
DBG_DEFAULT_CHANNEL(UserInput);
 
static UNICODE_STRING GhostClass = RTL_CONSTANT_STRING(GHOSTCLASSNAME);
static UNICODE_STRING GhostProp = RTL_CONSTANT_STRING(GHOST_PROP);
 
PTHREADINFO gptiGhostThread = NULL;
 
/*
 * GhostThreadMain
 *
 * Creates ghost windows and exits when no non-responsive window remains.
 */
VOID NTAPI
UserGhostThreadEntry(VOID)
{
    TRACE("Ghost thread started\n");
 
    UserEnterExclusive();
 
    gptiGhostThread = PsGetCurrentThreadWin32Thread();
 
    //TODO: Implement. This thread should handle all ghost windows and exit when no ghost window is needed.
 
    gptiGhostThread = NULL;
 
    UserLeave();
}
 
BOOL FASTCALL IntIsGhostWindow(PWND Window)
{
    BOOLEAN Ret = FALSE;
    UNICODE_STRING ClassName;
    INT iCls, Len;
    RTL_ATOM Atom = 0;
 
    if (!Window)
        return FALSE;
 
    if (Window->fnid && !(Window->fnid & FNID_DESTROY))
    {
        if (LookupFnIdToiCls(Window->fnid, &iCls))
        {
            Atom = gpsi->atomSysClass[iCls];
        }
    }
 
    // check class name
    RtlInitUnicodeString(&ClassName, NULL);
    Len = UserGetClassName(Window->pcls, &ClassName, Atom, FALSE);
    if (Len > 0)
    {
        Ret = RtlEqualUnicodeString(&ClassName, &GhostClass, TRUE);
    }
    else
    {
        DPRINT1("Unable to get class name\n");
    }
    RtlFreeUnicodeString(&ClassName);
 
    return Ret;
}
 
HWND FASTCALL IntGhostWindowFromHungWindow(PWND pHungWnd)
{
    RTL_ATOM Atom;
    HWND hwndGhost;
 
    if (!IntGetAtomFromStringOrAtom(&GhostProp, &Atom))
        return NULL;
 
    hwndGhost = UserGetProp(pHungWnd, Atom, TRUE);
    if (hwndGhost)
    {
        if (ValidateHwndNoErr(hwndGhost))
            return hwndGhost;
 
        DPRINT("Not a window\n");
    }
 
    return NULL;
}
 
HWND FASTCALL UserGhostWindowFromHungWindow(HWND hwndHung)
{
    PWND pHungWnd = ValidateHwndNoErr(hwndHung);
    if (!pHungWnd)
    {
        DPRINT("Not a window\n");
        return NULL;
    }
    return IntGhostWindowFromHungWindow(pHungWnd);
}
 
HWND FASTCALL IntHungWindowFromGhostWindow(PWND pGhostWnd)
{
    const GHOST_DATA *UserData;
    HWND hwndTarget;
 
    if (!IntIsGhostWindow(pGhostWnd))
    {
        DPRINT("Not a ghost window\n");
        return NULL;
    }
 
    UserData = (const GHOST_DATA *)pGhostWnd->dwUserData;
    if (UserData)
    {
        _SEH2_TRY
        {
            ProbeForRead(UserData, sizeof(GHOST_DATA), 1);
            hwndTarget = UserData->hwndTarget;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            DPRINT1("Exception!\n");
            hwndTarget = NULL;
        }
        _SEH2_END;
    }
    else
    {
        DPRINT("No user data\n");
        hwndTarget = NULL;
    }
 
    if (hwndTarget)
    {
        if (ValidateHwndNoErr(hwndTarget))
            return hwndTarget;
 
        DPRINT1("Not a window\n");
    }
 
    return NULL;
}
 
HWND FASTCALL UserHungWindowFromGhostWindow(HWND hwndGhost)
{
    PWND pGhostWnd = ValidateHwndNoErr(hwndGhost);
    return IntHungWindowFromGhostWindow(pGhostWnd);
}
 
BOOL FASTCALL IntMakeHungWindowGhosted(HWND hwndHung)
{
    PWND pHungWnd = ValidateHwndNoErr(hwndHung);
    if (!pHungWnd)
    {
        DPRINT1("Not a window\n");
        return FALSE;   // not a window
    }
 
    if (!MsqIsHung(pHungWnd->head.pti, MSQ_HUNG))
    {
        DPRINT1("Not hung window\n");
        return FALSE;   // not hung window
    }
 
    if (!(pHungWnd->style & WS_VISIBLE))
        return FALSE;   // invisible
 
    if (pHungWnd->style & WS_CHILD)
        return FALSE;   // child
 
    if (IntIsGhostWindow(pHungWnd))
    {
        DPRINT1("IntIsGhostWindow\n");
        return FALSE;   // ghost window cannot be ghosted
    }
 
    if (IntGhostWindowFromHungWindow(pHungWnd))
    {
        DPRINT("Already ghosting\n");
        return FALSE;   // already ghosting
    }
 
    // TODO: Find a way to pass the hwnd of pHungWnd to the ghost thread as we can't pass parameters directly
 
    if (!gptiGhostThread)
        UserCreateSystemThread(ST_GHOST_THREAD);
 
    return TRUE;
}