//---------------------------------------------------------------------------
//  Info.cpp - implements the information services of the CRenderObj object
//---------------------------------------------------------------------------
#include "stdafx.h"
#include "Render.h"
#include "Utils.h"
#include "Loader.h"
#include "sethook.h"
#include "info.h"
#include "RenderList.h"
#include "Services.h"
#include "appinfo.h"
#include "tmutils.h"
#include "borderfill.h"
#include "imagefile.h"
#include "textdraw.h"
//---------------------------------------------------------------------------
HRESULT MatchThemeClass(LPCTSTR pszAppName, LPCTSTR pszClassId, 
    CUxThemeFile *pThemeFile, int *piOffset, int *piClassNameOffset)
{
    THEMEHDR *pHdr = (THEMEHDR *)pThemeFile->_pbThemeData; 
    MIXEDPTRS u;
    u.pb = pThemeFile->_pbThemeData + pHdr->iSectionIndexOffset;

    DWORD dwCount = pHdr->iSectionIndexLength/sizeof(APPCLASSLIVE);
    APPCLASSLIVE *acl = (APPCLASSLIVE *)u.pb;

    for (DWORD i=0; i < dwCount; i++, acl++)
    {
        if (acl->dwAppNameIndex) 
        {
            if ((! pszAppName) || (! *pszAppName))
                continue;       // not a match

            LPCWSTR pszApp = ThemeString(pThemeFile, acl->dwAppNameIndex);

            if (AsciiStrCmpI(pszAppName, pszApp) != 0)
                continue;       // not a match
        }

        if (acl->dwClassNameIndex)
        {
            LPCWSTR pszClass = ThemeString(pThemeFile, acl->dwClassNameIndex);

            if (AsciiStrCmpI(pszClassId, pszClass)==0)        // matches
            {
                *piOffset = acl->iIndex;
                *piClassNameOffset = acl->dwClassNameIndex;
                return S_OK;
            }
        }
    }

    return MakeError32(ERROR_NOT_FOUND);      // not found
}
//---------------------------------------------------------------------------
HRESULT MatchThemeClassList(HWND hwnd, LPCTSTR pszClassIdList, 
    CUxThemeFile *pThemeFile, int *piOffset, int *piClassNameOffset)
{
    LPCTSTR pszAppName = NULL;
    WCHAR *pszIdListBuff = NULL;
    WCHAR szAppSubName[MAX_PATH];
    WCHAR szIdSubName[MAX_PATH];
    int len;
    Log(LOG_TM, L"MatchThemeClassList(): classlist=%s", pszClassIdList);
    HRESULT hr = S_OK;

    if (! pszClassIdList)
        return MakeError32(E_INVALIDARG);

    //---- first check Hwnd IdList substitutions ----
    if (hwnd)
    {
        ATOM atomIdSub = (ATOM)GetProp(hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_SUBIDLIST)));

        if (atomIdSub)
        {
            if (GetAtomName(atomIdSub, szIdSubName, ARRAYSIZE(szIdSubName)))
            {
                pszClassIdList = szIdSubName;
                Log(LOG_TM, L"MatchThemeClassList: hwnd prop IdList OVERRIDE: %s", pszClassIdList);
            }
        }
    }

    //---- now check Hwnd AppName substitutions ----
    if (hwnd)
    {
        ATOM atomAppSub = (ATOM)GetProp(hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_SUBAPPNAME)));

        if (atomAppSub)
        {
            if (GetAtomName(atomAppSub, szAppSubName, ARRAYSIZE(szAppSubName)))
            {
                pszAppName = szAppSubName;
                Log(LOG_TM, L"MatchThemeClassList: hwnd prop AppName OVERRIDE: %s", pszAppName);
            }
        }
    }

    //---- make a copy of pszClassIdList ----
    len = lstrlen(pszClassIdList);
    pszIdListBuff = new WCHAR[len+1];
    if (! pszIdListBuff)
    {
        hr = MakeError32(E_OUTOFMEMORY);
        goto exit;
    }

    lstrcpy(pszIdListBuff, pszClassIdList);

    LPTSTR classId;
    BOOL fContinue;

    classId = pszIdListBuff;
    fContinue = TRUE;

    //---- check each ClassId in the list ----
    while (fContinue)
    {
        fContinue = lstrtoken(classId, _TEXT(';'));
        hr = MatchThemeClass(pszAppName, classId, pThemeFile, piOffset, piClassNameOffset);
        if (SUCCEEDED(hr))
            break;

        classId += lstrlen(classId)+1;
    }

exit:
    if (pszIdListBuff)
        delete [] pszIdListBuff;

    return hr;
}
//---------------------------------------------------------------------------
HTHEME _OpenThemeDataFromFile(HTHEMEFILE hLoadedThemeFile, HWND hwnd, 
    LPCWSTR pszClassIdList, DWORD dwFlags)
{
    HRESULT hr = S_OK;
    RESOURCE CUxThemeFile *pThemeFile = (CUxThemeFile *)hLoadedThemeFile;
    int iOffset;
    int iClassNameOffset;
    HTHEME hTheme = NULL;

    //---- match classid list to theme and get the offset ----
    hr = MatchThemeClassList(hwnd, pszClassIdList, pThemeFile, &iOffset,
        &iClassNameOffset);
    if (FAILED(hr))
    {
        Log(LOG_TMOPEN, L"hLoadedThemeFile: No match for class=%s", pszClassIdList);
        goto exit;
    }
    
    hr = g_pRenderList->OpenRenderObject(pThemeFile, iOffset, iClassNameOffset, NULL,
        NULL, hwnd, dwFlags, &hTheme);
    if (FAILED(hr))
        goto exit;

    //---- store hTheme with window ----
    if (! (dwFlags & OTD_NONCLIENT))
    {
        //---- store the hTheme so we know its themed ----
        if (hwnd)
            SetProp(hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_HTHEME)), (void *)hTheme);
    }

    Log(LOG_TMOPEN, L"hLoadedThemeFile: returning hTheme=0x%x", hTheme);

exit:
    SET_LAST_ERROR(hr);
    return hTheme;
}
//---------------------------------------------------------------------------
HTHEME _OpenThemeData(HWND hwnd, LPCWSTR pszClassIdList, DWORD dwFlags)
{
    HRESULT hr = S_OK;
    RESOURCE CUxThemeFile *pThemeFile = NULL;
    HTHEME hTheme = NULL;
    BOOL fOk;
    DWORD dwAppFlags;

    SET_LAST_ERROR(hr);

    if (! g_fUxthemeInitialized)
        goto exit;

    Log(LOG_TMOPEN, L"_OpenThemeData: hwnd=0x%x, ClassIdList=%s", hwnd, pszClassIdList);

    //---- remove previous HTHEME property ----
    if (hwnd)
        RemoveProp(hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_HTHEME)));

    if (! g_pAppInfo->AppIsThemed())     // this process has been excluded from theming
    {
        Log(LOG_TMOPEN, L"App not themed");
        hr = MakeError32(ERROR_NOT_FOUND);
        SET_LAST_ERROR(hr);
        goto exit;
    }

    //---- ensure app allows this type of themeing ----
    dwAppFlags = g_pAppInfo->GetAppFlags();

    if (dwFlags & OTD_NONCLIENT)
    {
        fOk = ((dwAppFlags & STAP_ALLOW_NONCLIENT) != 0);    
    }
    else
    {
        fOk = ((dwAppFlags & STAP_ALLOW_CONTROLS) != 0);
    }

    if (! fOk)
    {
        Log(LOG_TMOPEN, L"AppFlags don't allow theming client/nonclient windows");
        hr = MakeError32(ERROR_NOT_FOUND);
        SET_LAST_ERROR(hr);
        goto exit;
    }

    //---- find Theme File for this HWND and REFCOUNT it for _OpenThemeDataFromFile call ----
    hr = GetHwndThemeFile(hwnd, pszClassIdList, &pThemeFile);
    if (FAILED(hr))
    {
        Log(LOG_TMOPEN, L"no theme entry for this classidlist: %s", pszClassIdList);
        SET_LAST_ERROR(hr);
        goto exit;
    }

    hTheme = _OpenThemeDataFromFile(pThemeFile, hwnd, pszClassIdList, dwFlags);
    
exit:
    //---- always close the pThemeFile here and decrement its refcnt ----
    //---- case 1: if we failed to get an HTHEME, we don't want a refcnt on it ----
    //---- case 2: if we do get an HTHEME, it get's its own refcnt on it ----
    if (pThemeFile)
        g_pAppInfo->CloseThemeFile(pThemeFile);

    return hTheme;
}
//---------------------------------------------------------------------------
HRESULT GetHwndThemeFile(HWND hwnd, LPCWSTR pszClassIdList, CUxThemeFile **ppThemeFile)
{
    HRESULT hr = S_OK;

    //----- check input params ----
    if ((! pszClassIdList) || (! *pszClassIdList))
    {
        hr = MakeError32(E_INVALIDARG);
        goto exit;
    }

    //---- get a shared CUxThemeFile object for the hwnd ----
    hr = g_pAppInfo->OpenWindowThemeFile(hwnd, ppThemeFile);
    if (FAILED(hr))
        goto exit;

exit:
    return hr;
}
//---------------------------------------------------------------------------
HRESULT _OpenThemeFileFromData(CRenderObj *pRender, HTHEMEFILE *phThemeFile)
{
    LogEntry(L"OpenThemeFileFromData");

    HRESULT hr = S_OK;

    *phThemeFile = pRender->_pThemeFile;

    LogExit(L"OpenThemeFileFromData");
    return hr;
}
//---------------------------------------------------------------------------
void ClearExStyleBits(HWND hwnd)
{
    Log(LOG_COMPOSITE, L"ClearExStyleBits called for hwnd=0x%x", hwnd);
    
    //---- see if window needs its exstyle cleared ----
    DWORD dwFlags = PtrToInt(GetProp(hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_PROPFLAGS))));

    if (dwFlags & (PROPFLAGS_RESET_TRANSPARENT | PROPFLAGS_RESET_COMPOSITED))
    {
        DWORD dwExStyle = GetWindowLong(hwnd, GWL_EXSTYLE);

        if (dwFlags & PROPFLAGS_RESET_TRANSPARENT)
        {
            Log(LOG_COMPOSITE, L"Clearning WS_EX_TRANSPARENT for hwnd=0x%x", hwnd);
            dwExStyle &= ~(WS_EX_TRANSPARENT);
        }

        if (dwFlags & PROPFLAGS_RESET_COMPOSITED)
        {
            Log(LOG_COMPOSITE, L"Clearning WS_EX_COMPOSITED for hwnd=0x%x", hwnd);
            dwExStyle &= ~(WS_EX_COMPOSITED);
        }

        //---- reset the correct ExStyle bits ----
        SetWindowLong(hwnd, GWL_EXSTYLE, dwExStyle);

        //---- reset the property flags ----
        dwFlags &= ~(PROPFLAGS_RESET_TRANSPARENT | PROPFLAGS_RESET_COMPOSITED);
        SetProp(hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_PROPFLAGS)), IntToPtr(dwFlags));
    }
}
//---------------------------------------------------------------------------
void AddPropFlags(HWND hwnd, DWORD dwNewFlags)
{
    DWORD dwFlags = PtrToInt(GetProp(hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_PROPFLAGS))));

    dwFlags |= dwNewFlags;

    if (dwNewFlags & PROPFLAGS_RESET_TRANSPARENT)
        Log(LOG_COMPOSITE, L"Setting TRANSPARENT prop flag for hwnd=0x%x", hwnd);

    if (dwNewFlags & PROPFLAGS_RESET_COMPOSITED)
        Log(LOG_COMPOSITE, L"Setting COMPOSITED prop flag for hwnd=0x%x", hwnd);

    SetProp(hwnd, MAKEINTATOM(GetThemeAtom(THEMEATOM_PROPFLAGS)), IntToPtr(dwFlags));
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
struct EPW
{
    WNDENUMPROC lpCallBackCaller;
    LPARAM lParamCaller;
    
    HWND *pHwnds;           // OPTIONAL list of hwnds to remove as they are enum-ed
    int iCountHwnds;        // count of remaining HWND's in pHwnds
};
//---------------------------------------------------------------------------
BOOL CALLBACK ChildWinCallBack(HWND hwnd, LPARAM lParam)
{
    BOOL fResult = TRUE;

    if (IsWindowProcess(hwnd, g_dwProcessId))
    {
        EPW *pEpw = (EPW *)lParam;
        
        fResult = pEpw->lpCallBackCaller(hwnd, pEpw->lParamCaller);

        //---- remove from list ----
        if (pEpw->pHwnds) 
        {
            for (int i=0; i < pEpw->iCountHwnds; i++)
            {
                if (pEpw->pHwnds[i] == hwnd)     // found it
                {
                    pEpw->iCountHwnds--;     

                    if (i != pEpw->iCountHwnds)       // switch last with current
                        pEpw->pHwnds[i] = pEpw->pHwnds[pEpw->iCountHwnds];

                    break;
                }
            }
        }
    }

    return fResult;
}
//---------------------------------------------------------------------------
BOOL CALLBACK TopWinCallBack(HWND hwnd, LPARAM lParam)
{
    BOOL fResult = ChildWinCallBack(hwnd, lParam);
    if (fResult)
    {
        //---- we need to check for hwnd having at least one child ----
        //---- since EnumChildWindows() of a hwnd without children ----
        //---- returns an error ----

        if (GetWindow(hwnd, GW_CHILD))      // if hwnd has at least one child
        {
            fResult = EnumChildWindows(hwnd, ChildWinCallBack, lParam);
        }
    }

    return fResult;
}
//---------------------------------------------------------------------------
BOOL CALLBACK DesktopWinCallBack(LPTSTR lpszDesktop, LPARAM lParam)
{
    //---- open the desktop ----
    HDESK hDesk = OpenDesktop(lpszDesktop, DF_ALLOWOTHERACCOUNTHOOK, FALSE, 
        DESKTOP_READOBJECTS | DESKTOP_ENUMERATE);

    if (hDesk)
    {
        //---- enum windows on desktop ----
        EnumDesktopWindows(hDesk, TopWinCallBack, lParam);

        CloseDesktop(hDesk);
    }

    return TRUE;        // return values from EnumDesktopWindows() not reliable
}
//---------------------------------------------------------------------------
BOOL EnumProcessWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)
{
    HWND *pHwnds = NULL;
    int iCount = 0;
    EPW epw = {lpEnumFunc, lParam};

    //---- get list of themed windows on "foreign" desktops for this process ----
    BOOL fGotForeignList = g_pAppInfo->GetForeignWindows(&pHwnds, &iCount);
    if (fGotForeignList)
    {
        epw.pHwnds = pHwnds;
        epw.iCountHwnds = iCount;
    }

    //---- this will enum all windows for this process (all desktops, all child levels) ----
    BOOL fOk = EnumDesktops(GetProcessWindowStation(), DesktopWinCallBack, (LPARAM)&epw);
    if ((fOk) && (fGotForeignList) && (epw.iCountHwnds))
    {
        //---- get updated count ----
        iCount = epw.iCountHwnds;

        //---- turn off list maintainance ----
        epw.pHwnds = NULL;
        epw.iCountHwnds = 0;

        Log(LOG_TMHANDLE, L"---- Enuming %d Foreign Windows ----", iCount);

        //---- enumerate remaining hwnd's in list ----
        for (int i=0; i < iCount; i++)
        {
            fOk = ChildWinCallBack(pHwnds[i], (LPARAM)&epw);

            if (! fOk)
                break;
        }
    }

    if (pHwnds)
        delete [] pHwnds;

    return fOk;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
BOOL CALLBACK DumpCallback(HWND hwnd, LPARAM lParam)
{
    WCHAR szName[MAX_PATH];
    WCHAR szDeskName[MAX_PATH] = {0};
    BOOL fIsForeign = TRUE;

    //---- get classname of window ----
    GetClassName(hwnd, szName, MAX_PATH);

    //---- get desktop name for window ----
    if (GetWindowDesktopName(hwnd, szDeskName, ARRAYSIZE(szDeskName)))
    {
        if (AsciiStrCmpI(szDeskName, L"default")==0)
        {
            fIsForeign = FALSE;
        }
    }

    if (fIsForeign)
    {
        Log(LOG_WINDUMP, L"    hwnd=0x%x, class=%s, DESK=%s", hwnd, szName, szDeskName); 
    }
    else
    {
        Log(LOG_WINDUMP, L"    hwnd=0x%x, class=%s", hwnd, szName); 
    }

    return TRUE;
}
//---------------------------------------------------------------------------
void WindowDump(LPCWSTR pszWhere)
{
    if (LogOptionOn(LO_WINDUMP))
    {
        Log(LOG_WINDUMP, L"---- Window Dump for Process [%s] ----", pszWhere);

        EnumProcessWindows(DumpCallback, NULL);
    }
    else
    {
        Log(LOG_TMHANDLE, L"---- %s ----", pszWhere);
    }
}
//---------------------------------------------------------------------------