UserUtil.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: User32 utility functions (Migrated from UtilFunc.cpp)
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/Common.h>
#include <uLib/UtilFunc.h>
#include <uLib/Debug.h>
#include <uLib/StrFunc.h>

//*****************************************************************************
// User32 functions
//*****************************************************************************

UINT DispatchMessagesFor( HWND hWnd )
{
    MSG msg;
    UINT nMsg = 0;
    while( PeekMessage( &msg, hWnd, 0,0, PM_REMOVE ))
    {
        TranslateMessage( &msg );
        DispatchMessage( &msg );
        nMsg++;
    }
    return nMsg;
}

#if 0 // UM wrapper for user32!EndTask
bool EndTask( HWND hAppWnd, BOOL ShutDown, BOOL Force )
{
    static BOOL (WINAPI *_EndTask)( HWND hWnd, BOOL ShutDown, BOOL Force );
    if (!_EndTask)
    {
        HMODULE hMod = GetModuleHandle( _T("User32.dll") );
        if (hMod) (FARPROC&)_EndTask = GetProcAddress( hMod, _T("EndTask") );
    }
    return (_EndTask ? bool_cast(_EndTask( hAppWnd, ShutDown, Force )) : false);
}
#endif


//-----------------------------------------------------------------------------
//  Clipboard
//-----------------------------------------------------------------------------

bool OpenEmptyClipboard( HWND hWnd )
{
    BOOL ok = OpenClipboard( hWnd );
    if (ok) EmptyClipboard();
    return bool_cast( ok );
}

UINT EnumerateClipFormats( HWND hCBOwner, PFClipFmtAction Action, PVOID UserData )
{
    UINT nFmtsEnum = 0;
    // NOTE: EnumClipboardFormats fails if clipboard is opened with a NULL owner.
    if (OpenClipboard( hCBOwner ))
    {
        UINT nFmtsAvail = CountClipboardFormats();
        for( UINT ix = 0, clipFmt = 0; ix < nFmtsAvail; ++ix )
        {
            clipFmt = EnumClipboardFormats( clipFmt );
            if (!clipFmt) break; else nFmtsEnum++;
            if (Action && !Action( clipFmt, UserData )) break;
        }
        CloseClipboard();
    }
    return nFmtsEnum;
}

bool PutClipHandle( HWND hCBOwner, HANDLE hClip, UINT clipFmt )
{
    BOOL ok = OpenEmptyClipboard( hCBOwner );
    if ( ok )
    {
        hClip = SetClipboardData( clipFmt, hClip );
        CloseClipboard();
        ok = (hClip != NULL);
    }
    return bool_cast( ok );
}

HANDLE GetClipHandle( UINT clipFmt )
{
    HANDLE hClip = NULL;
    if (OpenClipboard( NULL ))
    {
        hClip = GetClipboardData( clipFmt ); // Clipboard still owns it!
        // NB: Empirical tests show the clip handle is *still valid* after CloseClipboard.
        // Presumably at least for a moment long enough to copy it...
        CloseClipboard();
    }
    return hClip;
}

static bool putClipStr( HWND hCBOwner, PVOID pDup, WORD Fmt )
{
    bool ok = (pDup != NULL);
    if ( ok )
    {
        HANDLE hDup = GlobalHandle( pDup );
        ok = ((GlobalUnlock( hDup ) == 0) && (GetLastError() == 0));
        if (ok) ok = PutClipHandle( hCBOwner, hDup, Fmt );
        if (!ok) GlobalFree( hDup ); // If Unlock or PutClip failed, free the duplicate.
    }
    return ok;
}

bool PutClipboardStringA( HWND hCBOwner, ACSTR Text )
{
    ASTR pDup = GlobalDupStrA( Text );
    return putClipStr( hCBOwner, pDup, CF_TEXT );
}

bool PutClipboardStringW( HWND hCBOwner, WCSTR Text )
{
    WSTR pDup = GlobalDupStrW( Text );
    return putClipStr( hCBOwner, pDup, CF_UNICODETEXT );
}

CSTR DupClipboardString()
{
   #ifdef _UNICODE
    static const UINT Fmt = CF_UNICODETEXT;
   #else
    static const UINT Fmt = CF_TEXT;
   #endif
    HANDLE hClip = GetClipHandle( Fmt );
    CSTR pzClip = hClip ? (CSTR) GlobalLock( hClip ) : NULL;

    CSTR pzDup = pzClip ? GlobalDupStr( pzClip ) : NULL;

    if (pzClip) GlobalUnlock( hClip );
    return pzDup;
}

PVOID DupClipboardData( UINT clipFmt, PUINT pSize )
{
    PVOID pDup = NULL;
    if (OpenClipboard( NULL ))
    {
        HANDLE hClip = GetClipboardData( clipFmt );
        UINT clipSize = hClip ? (UINT) GlobalSize( hClip ) : 0; // size may be > than usage
        PVOID pClip = clipSize ? GlobalLock( hClip ) : NULL;

        pDup = pClip ? GlobalAllocPtr( GHND, clipSize ) : NULL;
        if (pDup) memcpy( pDup, pClip, clipSize ); // might be inefficient (if size >> usage)
        if (pSize) *pSize = clipSize;

        if (pClip) GlobalUnlock( hClip );
        CloseClipboard();
    }
    return pDup;
}

//-----------------------------------------------------------------------------
// Window cbWndExtra/cbClassExtra floating point data
//-----------------------------------------------------------------------------

BEGIN_ANONYMOUS

typedef union __fp32u {
    long  i;
    float f;
  } _fp32u;

typedef union __fp64u {
    long   i[2];
    INT64  i64;
    double d;
  } _fp64u;

END_ANONYMOUS

void SetWindowFloat( HWND hCtl, int Index, float Value )
{
    _fp32u fp;
    fp.f = Value;
    SetWindowLong( hCtl, Index, fp.i );
}

float GetWindowFloat( HWND hCtl, int Index )
{
    _fp32u fp;
    fp.i = GetWindowLong( hCtl, Index );
    return fp.f;
}

void SetWindowDouble( HWND hCtl, int Index, double Value )
{
    _fp64u fp;
    fp.d = Value;
  #ifdef _WIN64
    SetWindowLongPtr( hCtl, Index, fp.i64 );
  #else
    SetWindowLong( hCtl, Index, fp.i[0] );
    SetWindowLong( hCtl, Index+4, fp.i[1] );
  #endif
}

double GetWindowDouble( HWND hCtl, int Index )
{
    _fp64u fp;
  #ifdef _WIN64
    fp.i64 = GetWindowLongPtr( hCtl, Index );
  #else
    fp.i[0] = GetWindowLong( hCtl, Index );
    fp.i[1] = GetWindowLong( hCtl, Index+4 );
  #endif
    return fp.d;
}

void SetClassFloat( HWND hCtl, int Index, float Value )
{
    _fp32u fp;
    fp.f = Value;
    SetClassLong( hCtl, Index, fp.i );
}

float GetClassFloat( HWND hCtl, int Index )
{
    _fp32u fp;
    fp.i = GetClassLong( hCtl, Index );
    return fp.f;
}

void SetClassDouble( HWND hCtl, int Index, double Value )
{
    _fp64u fp;
    fp.d = Value;
  #ifdef _WIN64
    SetClassLongPtr( hCtl, Index, fp.i64 );
  #else
    SetClassLong( hCtl, Index, fp.i[0] );
    SetClassLong( hCtl, Index+4, fp.i[1] );
  #endif
}

double GetClassDouble( HWND hCtl, int Index )
{
    _fp64u fp;
  #ifdef _WIN64
    fp.i64 = GetClassLongPtr( hCtl, Index );
  #else
    fp.i[0] = GetClassLong( hCtl, Index );
    fp.i[1] = GetClassLong( hCtl, Index+4 );
  #endif
    return fp.d;
}

//-----------------------------------------------------------------------------
// MsgBox
//-----------------------------------------------------------------------------

#define _MAX_DBGMSG_ 512 /* Equal to kernel debugger message buffer size */

static CSTR mbox_Caption( CSTR Caption, HWND Owner )
{
    static TCHAR title[128];
    if (!Caption)
    {
        Caption = title; title[0] = 0;
        // If owner != NULL, use it's window title, else no title.
        if (Owner) GetWindowText( Owner, title, dimof(title) );
    }
    return Caption;
}

int __cdecl MsgBox( HWND owner, UINT type, CSTR cap, CSTR msg, ... )
{
    TCHAR buf[_MAX_DBGMSG_];
    va_list va;

    va_start( va, msg );
    _vstprintf_s( buf, dimof(buf), msg, va );
    va_end( va );

    cap = mbox_Caption( cap, owner );
    return MessageBox( owner, buf, cap, type );
}

bool __cdecl SetCaption( HWND hwnd, CSTR fmt, ... )
{
    TCHAR sbuf[256];
    va_list va;

    va_start( va, fmt );
    _vstprintf_s( sbuf, dimof(sbuf), fmt, va );
    va_end( va );
    return bool_cast( SetWindowText( hwnd, sbuf ));
}

//-----------------------------------------------------------------------------
// AsyncMsgBox[Ex] --> Self threaded message boxes..
//-----------------------------------------------------------------------------

BEGIN_ANONYMOUS

#define MB_SYSICONMASK  0x00000070L
#ifndef MB_ICONMASK
  #define MB_ICONMASK   0x000000F0L
  #define MB_USERICON   0x00000080L
#endif

struct MsgBoxParams : MSGBOXPARAMS // AsyncMsgBox[Ex] control data block..
{
    // UINT         cbSize;
    // HWND         hwndOwner;
    // HINSTANCE    hInstance;
    // LPCTSTR      lpszText;
    // LPCTSTR      lpszCaption;
    // DWORD        dwStyle;
    // LPCTSTR      lpszIcon;
    // DWORD_PTR    dwContextHelpId;
    // MSGBOXCALLBACK lpfnMsgBoxCallback;
    // DWORD        dwLanguageId;

    PINT_PTR pResult; // Pointer to MessageBox result reciever.
    HWND     hBox;    // MessageBox window handle.

    MsgBoxParams( CSTR title, WORD maxText, UINT flags );
    ~MsgBoxParams();
};
typedef MsgBoxParams* PMsgBoxParams;

MsgBoxParams::MsgBoxParams( CSTR sTitle, WORD maxText, UINT uFlags )
{
    cbSize = sizeof(MSGBOXPARAMS);
    lpszText = newStrBuf( maxText );
    lpszCaption = newStr( sTitle );
    pResult = NULL;
    hBox = NULL;

    dwStyle = uFlags;
    hwndOwner = ::hMainWnd; // Default
    hInstance = ::hInstance; // Default
    dwContextHelpId = 0;
    lpfnMsgBoxCallback = NULL;
    dwLanguageId = MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ); // == 0,
    lpszIcon = (dwStyle & MB_USERICON) ? IDI_WINLOGO : NULL; // Default icon.
    TRACE_IF( dwStyle & MB_USERICON, DP_DEBUG, _F("lpszIcon=%p\n"), lpszIcon );
}

MsgBoxParams::~MsgBoxParams()
{
    deleteStr( lpszText );
    deleteStr( lpszCaption );
}

END_ANONYMOUS

// Enable programmatic close of the MessageBox..
// Use a WH_CALLWNDPROC hook to get the MessageBox window handle.
// Use TLS to transfer the control data ptr from __MBThread to __MBHook.
// Return the MessageBox handle so we can to abort it on command.

static HHOOK _hMBCwpHook = NULL;
static DWORD _MBTlsIndex = 0;

static WINHOOKPROC __MBCwpHook( int Code, WPARAM wp, LPARAM lp )
// This hook retrieves the MessageBox window handle and transfers
// the control data ptr to the message box window data.
{
    LRESULT rc = CallNextHookEx( _hMBCwpHook, Code, wp, lp );
    PCWPSTRUCT cwp = (PCWPSTRUCT) lp;
    if ( cwp )
    {
        CHAR clsName[80];
        // Detect the MessageBox window creation..
        if (cwp->hwnd && GetClassNameA( cwp->hwnd, clsName, dimof(clsName) )
        && (strncmp( clsName, "#32770", 6 ) == 0) // WC_DIALOG (i.e. the message box)
        && (cwp->message == WM_CREATE))
        {
            PMsgBoxParams _mbp = (PMsgBoxParams) TlsGetValue( _MBTlsIndex );
            SetWindowLongPtr( cwp->hwnd, DWLP_USER, (LPARAM)_mbp );

            _mbp->hBox = cwp->hwnd; // The MessageBox window handle.

            TRACE( DP_DEBUG, _F("MessageBox (%s) handle = 0x%p\n"), _mbp->lpszCaption, _mbp->hBox );
            // We don't need the hook any further, so unhook to prevent a bunch
            // of internal Win32 exceptions when the message box closes...
            // And we don't need the TLS slot either, so free it.

            if (_hMBCwpHook) {
                UnhookWindowsHookEx( _hMBCwpHook ); _hMBCwpHook = NULL;
                }
            if (_MBTlsIndex) {
                TlsFree( _MBTlsIndex ); _MBTlsIndex = 0;
                }
        }
    }
    return rc;
}

static THREADPROC __MBThread( PVOID pData )
// This thread invokes the MessageBox so it doesn't block the calling thread.
{
    PMsgBoxParams _mbp = (PMsgBoxParams) pData;
    //TRACE( DP_DEBUG, _F("ENTER: %s\n"), _mbp->lpszText );
    if (_mbp->hwndOwner)
    {
        if ( !(_mbp->dwStyle & (MB_SYSTEMMODAL | MB_TASKMODAL)) )
            // Sacrifice MB_APPLMODAL WM_HELP to facilitate non-blocking box.
            _mbp->hwndOwner = NULL; // Un-block...
    }

    DWORD thrId = GetCurrentThreadId();
    while( _hMBCwpHook ) SleepEx( 10,true ); // Serialize the hook...
    _hMBCwpHook = SetWindowsHookEx( WH_CALLWNDPROC, __MBCwpHook, hInstance, thrId );

    // Use TLS to transfer the _mbp pointer to __MBCwpHook..

    if (!_MBTlsIndex) _MBTlsIndex = TlsAlloc();
    TlsSetValue( _MBTlsIndex, _mbp );

    // Invoke the (modal) messge box, which in turns invokes
    // our hook that retrieves the message box window handle.

    TRACE( DP_DEBUG, _F("Invoking MessageBoxIndirect (%s)\n"), _mbp->lpszCaption );
    DWORD ret = MessageBoxIndirect( _mbp ); // Spin internal system message loop.
    TRACE( DP_DEBUG, _F("MessageBoxIndirect (%s) returned %lu\n"), _mbp->lpszCaption, ret );

    if (_mbp->pResult) *_mbp->pResult = ret; // Return the result.
    delete _mbp; // Deallocate the control data.
    return ret; // Ref. GetExitCodeThread..
}

HANDLE __cdecl AsyncMsgBox( UINT Flags, PINT_PTR pResult, CSTR Title, CSTR Fmt, ... )
{
    va_list arg;
    DWORD id;

    PMsgBoxParams mbp = new MsgBoxParams( Title, _MAX_DBGMSG_, Flags );
    mbp->pResult = pResult;

    va_start( arg, Fmt );
    _vstprintf_s( (TSTR)mbp->lpszText, _MAX_DBGMSG_, Fmt, arg );
    va_end( arg );

    TRACE( DP_DEBUG, _F("CreateThread (%s)\n"), Title );
    HANDLE hThr = CreateThread( &DefSec, 0, __MBThread, mbp, 0, &id );
    SleepEx( 0, true ); // Yield the rest of this thread's time slice..

    if (!hThr) delete mbp; // Failed.. Clean up so it doesn't leak.
    else
    {
        while (!mbp->hBox) SleepEx( 10, true ); // Wait for MessageBox to initialize..
        if (pResult) *pResult = (INT_PTR) mbp->hBox; // Return the window handle sideways.
    }
    return hThr;
}

HANDLE __cdecl AsyncMsgBoxEx( // Parameter explanations are in the header.
    HWND Owner, UINT Flags, CSTR Title,
    HINSTANCE hInst, CSTR IconId, DWORD LangId,
    DWORD_PTR HelpId, MSGBOXCALLBACK Callback,
    PINT_PTR pResult, CSTR TextFmt, ...
    )
{
    va_list arg;
    DWORD thrId;

    Title = mbox_Caption( Title, Owner );
    PMsgBoxParams mbp = new MsgBoxParams( Title, _MAX_DBGMSG_, Flags );

    va_start( arg, TextFmt );
    _vstprintf_s( (TSTR)mbp->lpszText, _MAX_DBGMSG_, TextFmt, arg );
    va_end( arg );

    mbp->hwndOwner = Owner;
    mbp->dwContextHelpId = HelpId;
    mbp->dwLanguageId = LangId;
    mbp->lpfnMsgBoxCallback = Callback;
    mbp->pResult = pResult;

    // MessageBoxIndirect sets a standard icon based on MB_ICONMASK,
    // so only setup lpszIcon/hInstance if a custom icon is specified.

    if (IconId)
    {
        mbp->hInstance = hInst;
        mbp->lpszIcon = IconId;
        mbp->dwStyle &= ~MB_SYSICONMASK;
        mbp->dwStyle |= MB_USERICON;
    }

    HANDLE hThr = CreateThread( &DefSec, 0, __MBThread, mbp, 0, &thrId );
    SleepEx( 0, true ); // Yield the rest of this thread's time slice..

    if (!hThr) delete mbp; // Failed.. Clean up so it doesn't leak.
    else
    {
        while (!mbp->hBox) SleepEx( 10, true ); // Wait for MessageBox to initialize..
        if (pResult) *pResult = (INT_PTR) mbp->hBox; // Return the window handle.
    }
    return hThr;
}

//-----------------------------------------------------------------------------
//  Window routines
//-----------------------------------------------------------------------------

// Get window height

UINT GetWndHeight( HWND hWnd )
{
    RECT R; GetWindowRect( hWnd, &R );
    return R.bottom - R.top;
}

// Get window width

UINT GetWndWidth( HWND hWnd )
{
    RECT R; GetWindowRect( hWnd, &R );
    return R.right - R.left;
}

// Get size of the window

bool GetWndSize( HWND hWnd, SIZE* pSize )
{
    RECT R = { 0,0,0,0 };
    bool ok = bool_cast( GetWindowRect( hWnd, &R ));
    if (ok) {
        AbsToDimRect( &R );
        //if (pSize) *pSize = *(SIZE*) &R.right; //<< May possibly beget misalignment issues...
        if (pSize) *pSize = MkSize( R.right, R.bottom );
        }
    return ok;
}

// Get pos of the window, in screen coords.

bool GetWndPos( HWND hWnd, POINT* pPos )
{
    RECT R = { 0,0,0,0 };
    bool ok = bool_cast( GetWindowRect( hWnd, &R ));
    if (ok && pPos) *pPos = MkPoint( R.left, R.top );
    return ok;
}

// Undoc: user32.dll, Vista+, Export=Name/Ordinal
// If hTrayApp is an eligible tray window, the returned rect
// contains the coords of the taskbar button.

BOOL GetWindowMinimizeRect( HWND hTrayApp, RECT* pRect )
{
    BOOL ok = false;
    static BOOL (WINAPI *_GetWindowMinimizeRect)( HWND hTrayApp, RECT* pRect );
    if (!_GetWindowMinimizeRect)
    {
        HMODULE hModule = GetOrLoadModule( _T("user32") );
        if (hModule) (FARPROC&)_GetWindowMinimizeRect =
             GetProcAddress( hModule, "GetWindowMinimizeRect" );
    }
    if (_GetWindowMinimizeRect) ok = _GetWindowMinimizeRect( hTrayApp, pRect );
    return ok;
}

bool CenterWindow( HWND hChild, HWND hParent )
{
    RECT rCh, rPar, rWk;
    int  xNew, yNew;
    bool ok = false;

    if (!hChild) SetLastError( ERROR_INVALID_PARAMETER );
    else
    {
        if (!hParent) hParent = GetDesktopWindow();
        GetWindowRect( hChild, &rCh );
        GetWindowRect( hParent, &rPar );
        AbsToDimRect( &rCh ); // right,bottom == width,height
        AbsToDimRect( &rPar );
        if (!SystemParametersInfo( SPI_GETWORKAREA, sizeof(RECT), &rWk, 0 ))
        {
            rWk.left = rWk.top = 0;
            rWk.right = GetSystemMetrics( SM_CXSCREEN );
            rWk.bottom = GetSystemMetrics( SM_CYSCREEN );
        }

        // Calculate new X & Y  position, then adjust for workarea
        xNew = rPar.left + ((rPar.right - rCh.right) / 2);
        if (xNew < rWk.left) xNew = rWk.left;
        else if ((xNew + rCh.right) > rWk.right) xNew = rWk.right - rCh.right;

        yNew = rPar.top  + ((rPar.bottom - rCh.bottom) / 2);
        if (yNew < rWk.top) yNew = rWk.top;
        else if ((yNew + rCh.bottom) > rWk.bottom) yNew = rWk.bottom - rCh.bottom;

        ok = bool_cast(
            SetWindowPos( hChild,NULL, xNew,yNew, 0,0, SWP_NOSIZE| SWP_NOZORDER )
            );
    }
    return ok;
}

// Get the window rect of a control, in parent client coordinates.

void GetChildWndRect( HWND hCtl, RECT* R )
{
    GetWindowRect( hCtl, R );
    MapWindowPoints( HWND_DESKTOP, GetParent( hCtl ), (LPPOINT) R, 2 );
}

bool EnableChildWnd( HWND Owner, UINT Id, bool Enable )
{
    HWND hchild = GetDlgItem( Owner, Id );
    if (hchild) EnableWindow( hchild, Enable );
    return hchild ? Enable : false;
}

// Find child window with given Id.

HWND GetChildWndWithId( HWND hParent, UINT ChildId )
{
    HWND hCh = GetWindow( hParent, GW_CHILD );
    while( hCh && ChildId != (UINT)GetWindowLong( hCh, GWL_ID )) {
        hCh = GetWindow( hCh, GW_HWNDNEXT );
    }
    return hCh;
}

// Icon convenience routine

HICON WINAPI LoadSmallIcon( HINSTANCE hInst, CSTR Id )
{
    return (HICON) LoadImage( hInst, Id, IMAGE_ICON, 16,16, LR_SHARED );
}

//-----------------------------------------------------------------------------
//  Menu routines
//-----------------------------------------------------------------------------

// Load an internationalized menu resource

HMENU LoadMenuEx( HMODULE hModule, CSTR Id, LANGID Language )
{
    HMENU hMenu = NULL;
    PVOID pRes = LoadCustomResourceEx( hInstance, Id, RT_MENU, Language );
    if (!pRes) SetLastError( ERROR_INVALID_PARAMETER );
    else hMenu = LoadMenuIndirect( (MENUTEMPLATE*) pRes );
    return  hMenu;
}

// Find menu item by it's name.

LPMENUITEMINFO GetMenuItemByName( HMENU hMenu, CSTR Name )
{
    static TCHAR szBuf[80];
    static MENUITEMINFO mii = { sizeof(MENUITEMINFO),0,0,0,0,0,0,0,0,0,0,0 };

    mii.fMask = MIIM_FTYPE | MIIM_STRING; // (On NT4 use MIIM_TYPE)
    mii.dwTypeData = szBuf;

    for( int i=0, N = GetMenuItemCount( hMenu ); i < N; ++i )
    {
        mii.cch = dimof(szBuf) - 1; // Reserve 1 ch for terminating NUL.

        BOOL ok = GetMenuItemInfo( hMenu, i, TRUE, &mii );

        if (ok && BITS_SET( MFT_STRING, mii.fType )
        && (_tcsicmp( mii.dwTypeData, Name ) == 0))
            return &mii;
    }
    return NULL;
}

// Get menu item id by it's name.

int GetMenuItemIdByName( HMENU hMenu, CSTR Name )
{
    LPMENUITEMINFO pmii = GetMenuItemByName( hMenu, Name );
    return pmii ? pmii->wID : -1;
}

// Get menu item data, if any..

PVOID GetMenuItemData( HMENU hMenu, UINT Id )
{
    PVOID pData = NULL;
    MENUITEMINFO mii; IF_DEBUG( memset( &mii, 0, sizeof(mii) ));
    mii.cbSize = sizeof(MENUITEMINFO);
    mii.fMask = MIIM_DATA;
    if (GetMenuItemInfo( hMenu, Id, false, &mii ))
        pData = (PVOID) mii.dwItemData;
    return pData;
}

// Check/unckeck a menu item.

bool SetMenuItemCheck( HMENU hMenu, UINT Id, bool Check )
{
  #if 0
    DWORD rc = CheckMenuItem( hMenu, Id, Check ? MF_CHECKED : MF_UNCHECKED );
    return (rc != DWORD(-1));
  #else // Supercedent: Doesn't clobber other state flag (if any)..
    MENUITEMINFO mii; IF_DEBUG( memset( &mii, 0, sizeof(mii) ));

    mii.cbSize = sizeof(mii);
    mii.fMask = MIIM_STATE;
    mii.wID = Id;
    BOOL ok = GetMenuItemInfo( hMenu, Id, false, &mii );
    if (ok)
    {
        if (Check) mii.fState |= MFS_CHECKED; else mii.fState &= ~MFS_CHECKED;
        // Note: MFS_UNCHECKED = MF_UNCHECKED = 0
        ok = SetMenuItemInfo( hMenu, Id, false, &mii );
    }
    return bool_cast( ok );
  #endif
}

// Add a submenu with optional paraphernalia..

HMENU AddSubMenu(
    HMENU hMenu, UINT Index, CSTR Text,
    WORD Id, WORD State, PVOID Data, HBITMAP Image
    )
{
    DWORD err = 0;
    MENUITEMINFO mii; IF_DEBUG( memset( &mii, 0, sizeof(mii) ));

    mii.hSubMenu = CreatePopupMenu();
    if (mii.hSubMenu)
    {
        mii.cbSize = sizeof(MENUITEMINFO);
        mii.fMask = MIIM_STRING| MIIM_FTYPE| MIIM_SUBMENU;
        mii.fType = MFT_STRING;
        mii.dwTypeData = (TSTR)Text;
        if (Id)
        {
            mii.wID = Id;
            mii.fMask |= MIIM_ID;
        }
        if (State)
        {
            mii.fState = State;
            mii.fMask |= MIIM_STATE;
        }
        if (Data)
        {
            mii.dwItemData = (ULONG_PTR) Data;
            mii.fMask |= MIIM_DATA;
        }
        if (Image)
        {
            mii.hbmpItem = Image;
            mii.fMask |= MIIM_BITMAP;
        }

        if (!InsertMenuItem( hMenu, Index, true, &mii ))
        {
            err = GetLastError(); // Hold error past DestroyMenu
            DestroyMenu( mii.hSubMenu );
            mii.hSubMenu = NULL;
        }
        if (err) SetLastError( err );
    }
    return mii.hSubMenu;
}

// Add a menu item with optional paraphernalia..

bool AddMenuItem(
    HMENU hMenu, UINT Index, CSTR Text, WORD cmdId,
    WORD State, PVOID Data, HBITMAP Image
    )
{
    MENUITEMINFO mi; IF_DEBUG( memset( &mi, 0, sizeof(mi) ));
    mi.cbSize = sizeof(mi);
    mi.wID = cmdId;
    if (!IsString( Text ))
    {
        mi.fMask = MIIM_FTYPE | MIIM_ID;
        mi.fType = MFT_SEPARATOR;
    }
    else
    {
        mi.fMask = MIIM_STRING | MIIM_ID;
        mi.dwTypeData = (TSTR) Text;
        if (State)
        {
            mi.fState = State;
            mi.fMask |= MIIM_STATE;
        }
        if (Data)
        {
            mi.dwItemData = (ULONG_PTR) Data;
            mi.fMask |= MIIM_DATA;
        }
        if (Image)
        {
            mi.hbmpItem = Image;
            mi.fMask |= MIIM_BITMAP;
        }
    }
    return bool_cast( InsertMenuItem( hMenu, Index, true, &mi ));
}

// Enumerate the items in a menu..
// typedef bool (__stdcall *PFnMenuItemAction)( HMENU hMenu, MENUITEMINFO* pInfo, PVOID Ctx );

UINT EnumerateMenuItems( HMENU hMenu, PFnMenuItemAction Action, PVOID Ctx )
{
    UINT nItems = 0; // Nr of items actually processed
    MENUITEMINFO mii; IF_DEBUG( memset( &mii, 0, sizeof(mii) ));
    static const short bufLen = 128;
    TSTR textBuf = newStrBuf( bufLen ); // Not on the stack please!

    int count = GetMenuItemCount( hMenu );
    for( int ix = 0; ix < count; ++ix )
    {
        mii.cbSize = sizeof(MENUITEMINFO);
        mii.dwTypeData = textBuf;
        mii.cch = bufLen;
        mii.fMask = MIIM_ALL;
        if (GetMenuItemInfo( hMenu, ix, true, &mii ))
        {
            if (!Action( hMenu, &mii, Ctx )) break;
            ++nItems;
        }
    }

    deleteStr( textBuf );
    return nItems;
}

//-----------------------------------------------------------------------------
// Find, Load, and Lock a resource of arbitrary type
//-----------------------------------------------------------------------------

// Note: Under Win32, resources are automatically unloaded on program termination.
// Calling UnlockResource and FreeResource is obsolete, according to MSDN.
// (Time was when we did it, to reduce the working set size.)
// See FreeResource..

PVOID WINAPI LoadCustomResource( HMODULE hModule, CSTR Id, CSTR Type, UINT* pSize )
{
    // FindResource, according to all sources, picks up the resource who's
    // LANGUAGE statement (or fallback) matches the current user locale..

    HRSRC hrInfo = FindResource( hModule, Id, Type );
    if (pSize && hrInfo) *pSize = SizeofResource( hModule, hrInfo );
    HGLOBAL hRes = hrInfo ? LoadResource( hModule, hrInfo ) : NULL;
    return hRes ? LockResource( hRes ) : NULL;
}

PVOID WINAPI LoadCustomResourceEx(
    HMODULE hModule, CSTR Id, CSTR Type, LANGID Language, UINT* pSize )
{
    HRSRC hrInfo = FindResourceEx( hModule, Type, Id, Language );
    if (!hrInfo) // If language (or finder fallback) not found ...
    {
        TRACE( DP_DEBUG, _F("FindResourceEx: LangId %u not found - %s.\n"), Language, SysErrorMsg() );
        // Presumably these fallbacks were already tried by FindResourceEx,
        // but have a go at it anyway, in case it didn't..
        LANGID priLang = PRIMARYLANGID( Language );
        LANGID usrLang = GetUserDefaultLangID();
        LANGID sysLang = GetSystemDefaultLangID();

        if (priLang != Language)
            hrInfo = FindResourceEx( hModule, Type, Id, priLang );

        if (!hrInfo && (usrLang != Language) )
            hrInfo = FindResourceEx( hModule, Type, Id, usrLang );

        if (!hrInfo && (sysLang != Language) && (sysLang != usrLang))
            hrInfo = FindResourceEx( hModule, Type, Id, sysLang );

        if (!hrInfo)
        {
            TRACE( DP_WARNING, _F("No fallback found, deferring to FindResource.\n") );
          #if _DEBUG // Where the hell are we anyway..?
            LCID Locale = GetThreadLocale();
            Language    = LANGIDFROMLCID( Locale );
            priLang     = PRIMARYLANGID( Language );
            WORD subLang = SUBLANGID( Language );
            TRACE( DP_VERBOSE,_F("Thread locale: %lu. LangId: %u (primary=%u, sub=%u).\n"),
                Locale, Language, priLang, subLang
                );
          #endif
            hrInfo = FindResource( hModule, Id, Type );
            TRACE_IF( !hrInfo, DP_WARNING, _F("FindResource failed: %s.\n"), SysErrorMsg() );
        }
    }
    // Finally, load and lock.

    if (pSize && hrInfo) *pSize = SizeofResource( hModule, hrInfo );
    HGLOBAL hRes = hrInfo ? LoadResource( hModule, hrInfo ) : NULL;
    return hRes ? LockResource( hRes ) : NULL;
}

//-----------------------------------------------------------------------------
// Load a picture stored as a resource.
//-----------------------------------------------------------------------------

IPicture* WINAPI LoadPictureResource( HMODULE hMod, CSTR Id, CSTR Type )
{
    IPicture* pPic = NULL;

    // Use LoadCustomResource and SHCreateMemStream to get an IStream.
    // Then use OleLoadPicture to get an IPicture.

    UINT cbData = 0;
    PBYTE pData = (PBYTE) LoadCustomResource( hMod, Id, Type, &cbData );
    if (pData)
    {
        IStream* pStrm = SHCreateMemStream( pData, cbData ); // Doesn't SetLastError
        if (!pStrm) SetLastError( ERROR_RESOURCE_DATA_NOT_FOUND );
        else
        {
            HRESULT rc = OleLoadPicture( pStrm, cbData, TRUE, IID_IPicture, (void**)&pPic );
            if (FAILED( rc )) SetLastError( HRESULT_CODE( rc ));
            TRACE_IF( FAILED(rc), DP_ERROR, _F("OleLoadPicture failed: %s\n"), SysErrorMsg( rc ));
            pStrm->Release();
        }
    }
    return pPic;
}

//-----------------------------------------------------------------------------
// Use SHCreateStreamOnFile and OleLoadPicture to get an IPicture.
//-----------------------------------------------------------------------------

IPicture* WINAPI LoadPictureFile( CSTR FName )
{
    IPicture* pPic = NULL;

    ACCESS_MASK mode = STGM_READ| STGM_SHARE_DENY_WRITE;
    IStream* pStrm = NULL;
    HRESULT rc = SHCreateStreamOnFile( FName, mode, &pStrm );
    if (!SUCCEEDED( rc )) SetLastError( HRESULT_CODE( rc ));
    else
    {
        STATSTG stat; IF_DEBUG( memset( &stat, 0, sizeof(stat) ));
        rc = pStrm->Stat( &stat, STATFLAG_NONAME );
        TRACE_IF( stat.cbSize.HighPart, DP_WARNING, _F("Too large: %s\n"), FName );
        if (SUCCEEDED( rc ) && !stat.cbSize.HighPart)
        {
            // OleLoadPicture won't handle an image larger than 32bit addressing permits.

            rc = OleLoadPicture( pStrm, stat.cbSize.LowPart, true, IID_IPicture, (void**)&pPic );

            if (!SUCCEEDED( rc )) SetLastError( HRESULT_CODE( rc ));
            TRACE_IF( FAILED(rc), DP_ERROR, _F("OleLoadPicture failed: %s\n"), SysErrorMsg( rc ));
        }
        pStrm->Release();
    }
    return pPic;
}

static POINT lpi = {0,0}; // Logical pixels per inch (on screen).
static const int hpi = 2540; // HiMetric units per inch.

long WINAPI HiMetricToPix( long hiMetric )
{
    // PONDER: Does assymetric lpi ever occur..? If so, this must be revised into cx/cy.
    if (!lpi.x) GetScreenLPI( &lpi );
    return MulDiv( hiMetric, lpi.x, hpi );
}

long WINAPI PixToHiMetric( long Pix )
{
    // PONDER: Does assymetric lpi ever occur..? If so, this must be revised into cx/cy.
    if (!lpi.x) GetScreenLPI( &lpi );
    return MulDiv( Pix, hpi, lpi.x );
}

//-----------------------------------------------------------------------------
// Paint an IPicture on a normal MM_TEXT mode HDC.
// cx, cy = Image size in pixels. If 0, the full image size is computed.
//-----------------------------------------------------------------------------

void WINAPI PaintPicture( IPicture* pPic, HDC hdc, int x, int y, int cx, int cy )
{
    LONG wIm, hIm;  // HiMetric image size

    pPic->get_Width( &wIm );
    pPic->get_Height( &hIm );
    // Convert himetric size to pixels (if no cx/cy given)
    if (!lpi.x) GetScreenLPI( &lpi );
    if (!cx) cx = MulDiv( wIm, lpi.x, hpi );
    if (!cy) cy = MulDiv( hIm, lpi.y, hpi );

    // By default, HDC has MM_TEXT mapping (IPicture assumes MM_HIMETRIC),
    // so flip the cy sign, and set y to the bottom left image pos.
    // Don't bother with SetMapMode( hdc,MM_HIMETRIC ), since that would
    // seriously complicate all other drawing, just mollycoddle IPic a bit.

    pPic->Render( hdc, x, y+cy, cx,-(cy+1), 0,0, wIm,hIm, NULL );
}

// CHANGE LOG:
// LN   2022  Corrected flawed imw/imh logic.

bool WINAPI PaintPictureEx( IPicture* pPic,
    HDC hdc, long x, long y, long cx, long cy,
    long imx, long imy, long imw, long imh, PRECT prMeta
    )
{
    long imgWidth, imgHeight;
    bool ok = ((pPic != NULL) && (hdc != NULL));
    if (!ok) SetLastError( ERROR_INVALID_PARAMETER );
    else
    {
        HRESULT rc;
        ok = SUCCEEDED( rc = pPic->get_Width( &imgWidth ));
        if (!ok) SetLastError( HRESULT_CODE( rc ));
        else
        {
            ok = SUCCEEDED( rc = pPic->get_Height( &imgHeight ));
            if (!ok) SetLastError( HRESULT_CODE( rc ));
            else
            {
                if (imx) imx = PixToHiMetric( imx );
                if (imy) imy = PixToHiMetric( imy );
                if (!imw) imw = imgWidth; else imw = PixToHiMetric( imw );
                if (!imh) imh = imgHeight; else imw = PixToHiMetric( imh );;
                // Sacrifice a tiny reconversion CPU time to avoid kludgy assignment logic above..
                if (!cx) cx = HiMetricToPix( imw );
                if (!cy) cy = HiMetricToPix( imh );

                // By default, HDC has MM_TEXT mapping (IPicture assumes MM_HIMETRIC),
                // so flip the cy sign, and set y to the bottom left image pos.
                // Don't bother with SetMapMode( hdc,MM_HIMETRIC ), since that would
                // seriously complicate all other drawing, just mollycoddle IPic a bit.

                // NOTE: IPicture::Render expects x,y,cx,cy in pixels
                // and imx,imy,imw,imh in himetric coords!

                ok = SUCCEEDED( rc = pPic->Render(
                    hdc, x, y+cy, cx,-(cy+1), imx, imy, imw, imh, prMeta
                    ));
                if (!ok) SetLastError( HRESULT_CODE( rc ));
            }
        }
    }
    return ok;
}

//-----------------------------------------------------------------------------
//  More window routines
//-----------------------------------------------------------------------------

// Create window by means of a CREATESTRUCT

HWND CreateWindowIndirect( LPCREATESTRUCT pc )
{
    return CreateWindowEx(
        pc->dwExStyle, pc->lpszClass, pc->lpszName, pc->style,
        pc->x, pc->y, pc->cx, pc->cy,
        pc->hwndParent, pc->hMenu, pc->hInstance, pc->lpCreateParams
        );
}

// Execute a modal internationalized dialog.

INT_PTR DialogBoxParamEx(
    HINSTANCE hInstance, CSTR Template, HWND hParent,
    DLGPROC DlgProc, LPARAM lParam, LANGID Language
    )
{
    INT_PTR rc = -1;
    PVOID pRes = LoadCustomResourceEx( hInstance, Template, RT_DIALOG, Language );
    if (!pRes) SetLastError( ERROR_INVALID_PARAMETER );
    else rc = DialogBoxIndirectParam(
        hInstance, (LPCDLGTEMPLATE)pRes, hParent, DlgProc, lParam
        );
    return rc;
}

// Create a modeless internationalized dialog.

HWND CreateDialogParamEx(
    HINSTANCE hInstance, CSTR Template, HWND hParent,
    DLGPROC DlgProc, LPARAM lParam, LANGID Language
    )
{
    HWND hDlg = NULL;
    PVOID pRes = LoadCustomResourceEx( hInstance, Template, RT_DIALOG, Language );
    if (!pRes) SetLastError( ERROR_INVALID_PARAMETER );
    else hDlg = CreateDialogIndirectParam(
        hInstance, (LPCDLGTEMPLATE)pRes, hParent, DlgProc, lParam
        );
    return hDlg;
}

// Compute required window size for a given client size
// TODO: Be kind and make RECT versions of these two..

bool GetRequiredWindowSize( HWND hWnd, IN const PSIZE pClient, OUT PSIZE pWindow )
{
    DWORD style = GWL( hWnd, STYLE );
    DWORD xstyle = GWL( hWnd, EXSTYLE );
    HMENU menu = GetMenu( hWnd );
    RECT rWnd = MkRect( 0,0, pClient->cx, pClient->cy );
    BOOL ok = AdjustWindowRectEx( &rWnd, style, (menu != NULL), xstyle );
    AbsToRelRect( &rWnd ); // Make it zero-based..
    pWindow->cx = rWnd.right;
    pWindow->cy = rWnd.bottom;
    return bool_cast( ok );
}

// Get effective client size for a given window size

bool GetWindowClientSize( HWND hWnd, IN const PSIZE pWindow, OUT PSIZE pClient )
{
    DWORD style = GWL( hWnd, STYLE );
    DWORD xstyle = GWL( hWnd, EXSTYLE );
    HMENU menu = GetMenu( hWnd );
    RECT rWnd = MkRect( 0,0, pWindow->cx, pWindow->cy );
    BOOL ok = AdjustWindowRectEx( &rWnd, style, (menu != NULL), xstyle );
    AbsToRelRect( &rWnd ); // Make it zero-based (w,h)..
    long cxDiff = rWnd.right - pWindow->cx;
    long cyDiff = rWnd.bottom - pWindow->cy;
    pClient->cx = pWindow->cx - cxDiff;
    pClient->cy = pWindow->cy - cyDiff;
    return bool_cast( ok );
}

// Refresh window

bool RefreshWnd( HWND hwnd )
{
    InvalidateRect( hwnd, NULL, TRUE );
    return bool_cast( UpdateWindow( hwnd ));
}

// Redraw all or part of window

bool RedrawWnd( HWND hwnd, UINT flags )
{
    return bool_cast( ::RedrawWindow( hwnd, NULL, NULL, flags ));
}

bool RedrawWndRect( HWND hwnd, PRECT prect, UINT flags )
{
    return bool_cast( ::RedrawWindow( hwnd, prect, NULL, flags ));
}

bool RedrawWndRgn( HWND hwnd, HRGN hrgn, UINT flags )
{
    return bool_cast( ::RedrawWindow( hwnd, NULL, hrgn, flags ));
}

// Move window without resizing or Z order change

bool MoveWnd( HWND hwnd, int X, int Y, bool repaint )
{
    UINT flags = SWP_NOSIZE| SWP_NOZORDER| (repaint ? 0:SWP_NOREDRAW);
    return bool_cast( SetWindowPos( hwnd, NULL, X, Y, 0, 0, flags ));
}

// Resize window without moving or changing Z order

bool ResizeWnd( HWND hwnd, int W, int H, bool repaint )
{
    UINT flags = SWP_NOMOVE| SWP_NOZORDER| (repaint ? 0:SWP_NOREDRAW);
    return bool_cast( SetWindowPos( hwnd, NULL, 0, 0, W, H, flags ));
}

// SetParent need some cotton-gloving to succeed in special cases

HWND SetParentWnd( HWND wnd, HWND newParent )
{
    SetLastError( 0 ); // Since we might return NULL as a *valid result*.
    HWND parent = GetParent( wnd );
    if (GetLastError() != 0) return NULL; // Failed: Cannot get parent
    if (newParent == parent) return parent; // Already (NB: NULL is valid parent)

    DWORD style = GetWndStyle( wnd );
    DWORD save = style;

    if (newParent != NULL && parent == NULL)
    {
        // If changing from top level, must change window style too

        style &= ~(WS_POPUP| WS_OVERLAPPED);
        style |= WS_CHILD; // Set this style *before* SetParent
        SetWndStyle( wnd, style );
    }

    SetParent( wnd, newParent ); // Try to change parent
    if (GetLastError() != 0)
    {
        if (style != save) SetWndStyle( wnd, save ); // Restore changed style
        return NULL; // Failed: Cannot set parent
    }

    if (newParent == NULL && parent != NULL)
    {
        // If changing to top level, must change window style too

        style &= ~WS_CHILD;
        style |= WS_OVERLAPPED; // Set this style *after* SetParent
        SetWndStyle( wnd, style );
    }
    return parent; // Return previous parent
}

// A combo has 3 window handles, one for the aggregate, and two handles
// for the editor and listbox parts. Retrieve the editor and list handles.

#define COMBO_LISTCLASS  _T("ComboLBox")
#define COMBO_EDITCLASS  _T("Edit")

bool IsWndClass( HWND hWnd, CSTR clsName )
{
    TCHAR buf[ 80 ];
    bool ok = bool_cast( GetClassName( hWnd, buf, dimof(buf) ));
    if (ok) ok = (_tcsicmp( buf, clsName ) == 0);
    return ok;
}

HWND GetComboEditor( HWND hCombo )
{
    HWND hSub = GetWindow( hCombo, GW_CHILD );
    if (IsWndClass( hSub, COMBO_EDITCLASS )) return hSub;
    return GetWindow( hSub, GW_HWNDNEXT );
}

HWND GetComboList( HWND hCombo ) // FIXME: Malfunc on W7sp1 !
{
    HWND hSub = GetWindow( hCombo, GW_CHILD );
    if (IsWndClass( hSub, COMBO_LISTCLASS )) return hSub;
    return GetWindow( hSub, GW_HWNDNEXT );
}

CSTR GetWndClassName( HWND hWnd ) // Get the window's class name
{
    static __thread_local TCHAR buf[ 80 ];
    if (!GetClassName( hWnd, buf, dimof(buf) )) buf[0] = 0;
    return buf;
}

//-----------------------------------------------------------------------------
//  Controls ...
//-----------------------------------------------------------------------------

double GetWndReal( HWND hCtl )
{
    TCHAR sBuf[64], *pEnd;
    int len = GetWindowText( hCtl, sBuf, dimof(sBuf) );
    return (len ? _tcstod( sBuf, &pEnd ) : HUGE_VAL); // NB: HUGE_VAL comply w strtod error.
}
double GetDlgItemReal( HWND hDlg, UINT Id )
{
    return GetWndReal( GetDlgItem( hDlg, Id ));
}

bool SetWndReal( HWND hCtl, double Value, BYTE nDeci, CSTR Suffix )
{
    static CCSTR FmtSuff = _T("%.*f %s"), FmtNoSuff = _T("%.*f");
    TCHAR sBuf[64];
    CSTR Fmt = Suffix ? FmtSuff : FmtNoSuff;
    _stprintf_s( sBuf, dimof(sBuf), Fmt, nDeci, Value, Suffix );
    return bool_cast( SetWindowText( hCtl, sBuf ));
}
bool SetDlgItemReal( HWND hDlg, UINT Id, double Value, BYTE nDeci, CSTR Suffix )
{
    return SetWndReal( GetDlgItem( hDlg, Id ), Value, nDeci, Suffix );
}

//== Multiple Document Interface ==--------------------------------------------

HWND GetMDIClient( HWND hMdiFrame )
{
    HWND W = GetWindow( hMdiFrame, GW_CHILD );
    while( W )
    {
        if (IsWndClass( W, MDI_CLIENTCLASS )) return W;
        W = GetWindow( W, GW_HWNDNEXT );
    }
    return NULL;
}

//== Buttons ==----------------------------------------------------------------

bool ButtonChecked( HWND hBtn )
{
    return (Button_GetCheck( hBtn ) == BST_CHECKED);
}
bool ButtonCtrlChecked( HWND hDlg, UINT Id )
{
    return ButtonChecked( GetDlgItem( hDlg,Id ));
}

bool CheckButton( HWND hBtn, bool Check )
{
    Button_SetCheck( hBtn, Check ? BST_CHECKED : BST_UNCHECKED );
    return Check;
}
bool CheckButtonCtrl( HWND hDlg, UINT Id, bool Check )
{
    return CheckButton( GetDlgItem( hDlg,Id ), Check );
}

//== Listboxes ==--------------------------------------------------------------

int __cdecl AddListString( HWND hLB, CSTR Fmt, ... )
{
    TCHAR sbuf[256];
    va_list va;

    va_start( va, Fmt );
    _vstprintf_s( sbuf, dimof(sbuf), Fmt, va );
    va_end( va );

    return ListBox_AddString( hLB, sbuf );
}

int AddListItem( HWND hLB, CSTR Text, LPARAM Data )
{
    int ix = ListBox_FindStringExact( hLB, -1, Text );
    if (ix < 0)
    {
        ix = ListBox_AddString( hLB, Text );
        if (ix >= 0) ListBox_SetItemData( hLB, ix, Data );
    }
    return ix;
}

//== Combo boxes ==------------------------------------------------------------

int __cdecl AddComboString( HWND hCB, CSTR Fmt, ... )
{
    TCHAR sbuf[256];
    va_list va;

    va_start( va, Fmt );
    _vstprintf_s( sbuf, dimof(sbuf), Fmt, va );
    va_end( va );

    return ComboBox_AddString( hCB, sbuf );
}

int AddComboItem( HWND hCB, CSTR Text, LPARAM Data )
{
    int ix = ComboBox_FindStringExact( hCB, -1, Text );
    if (ix < 0)
    {
        ix = ComboBox_AddString( hCB, Text );
        if (ix >= 0) ComboBox_SetItemData( hCB, ix, Data );
    }
    return ix;
}

//== Status bars ==------------------------------------------------------------

//bool __cdecl SetStatusParts( HWND hStat, UINT nParts, ... ) // Original
//{
//    va_list va;
//    bool simple = (nParts < 2);
//    bool ok = simple;
//    SendMessage( hStat, SB_SIMPLE, simple, 0 );
//    if (!simple)
//    {
//        va_start( va, nParts );
//        int ix, w, *parts = new int[ nParts ];
//        parts[ 0 ] = va_arg( va, int );
//        for( ix=1; ix < (int)nParts; ++ix )
//        {
//            w = va_arg( va, int );
//            parts[ ix ] = (w == -1) ? w : parts[ ix-1 ] + w;
//        }
//        ok = bool_cast( SB_SetParts( hStat, nParts, (LPARAM)parts ));
//
//        delete[] parts;
//        va_end( va );
//    }
//    return ok;
//}

bool __cdecl SetStatusParts( HWND hStat, UINT nParts, ... ) // Revised to use the new SetStatusWidths API...
{
    va_list va;
    bool simple = (nParts < 2);
    bool ok = simple;
    SendMessage( hStat, SB_SIMPLE, simple, 0 );
    if (!simple)
    {
        int *parts = new int[ nParts ];

        va_start( va, nParts );
        int *part = parts, n = nParts;
        while( n-- ) *part++ = va_arg( va, int ); //for( UINT ix = 0; ix < nParts; ++ix ) parts[ ix ] = va_arg( va, int );
        va_end( va );

        ok = SetStatusWidths( hStat, nParts, parts );
        delete[] parts;
    }
    return ok;
}

bool __cdecl SetStatusWidths( HWND hStat, UINT nParts, int* Width )
{
    bool simple = (nParts < 2);
    bool ok = simple;
    SendMessage( hStat, SB_SIMPLE, simple, 0 );
    if (!simple)
    {
        register int* pos = Width + 1;
        // Note FYI: Using pointer access to the array
        // generates faster machine code than indexing the array.
        for( UINT ix = 1; ix < nParts; ++ix, ++pos )
        {
            if (*pos != -1) *pos += *(pos - 1);
            else // -1
            {
                nParts = ix + 1; // In case we're cut short by -1.
                break; // Whether we reached nParts or not.
            }
        }
        ok = bool_cast( SB_SetParts( hStat, nParts, (LPARAM) Width ));
    }
    return ok;
}

bool __cdecl SetStatusText( HWND hStat, UINT Part, CSTR Fmt, ... )
{
    static __thread_local TCHAR sbuf[ MAX_PATH ];
    va_list va;

    *sbuf = SPACE; // Status text looks better with a little left padding.
    va_start( va, Fmt );
    _vstprintf_s( &sbuf[1], dimof(sbuf)-1, Fmt, va );
    va_end( va );
    return bool_cast( SB_SetText( hStat, Part, sbuf ));
}

HWND CreateStatusbar( HWND hParent, UINT Id, CSTR Text, UINT Style  )
{
    static const WORD STAT_HEIGHT = 24; // Incl static edge
    static const UINT UNSUPP = WS_POPUP| CCS_TOP| CCS_LEFT| CCS_RIGHT;
    RECT r;

    // Resize the parent to make room for a status bar ...

    GetWindowRect( hParent, &r );
    r.right -= r.left; r.bottom -= r.top;
    r.bottom += STAT_HEIGHT;
    SetWindowPos( hParent, NULL, 0,0, r.right, r.bottom, SWP_NOZORDER| SWP_NOMOVE );

    // And create the statusbar window ...

    Style = (Style & ~UNSUPP) | (WS_CHILD| WS_VISIBLE| CCS_BOTTOM); // Must be so.
    HINSTANCE hInst = GetWindowInstance( hParent );
    GetClientRect( hParent, &r );

    return CreateWindowEx( WS_EX_STATICEDGE, STATUSCLASSNAME,
        Text, Style, 0, r.bottom - STAT_HEIGHT, r.right, STAT_HEIGHT,
        hParent, HMENU(UINT_PTR( Id )), hInst, NULL
        );
}

//== List controls ==----------------------------------------------------------

UINT ListView_ForEach( HWND hLv, PFLvItemAction Action, PVOID pCtx )
{
    static __thread_local TCHAR Text[256];

    UINT N, nItems, ix;
    LVITEM lvi; IF_DEBUG( memset( &lvi, 0, sizeof(lvi) ));

    N = 0;
    nItems = ListView_GetItemCount( hLv );
    if (nItems)
    {
        for( ix = 0; ix < nItems; ++ix )
        {
            lvi.mask = LVIF_TEXT| LVIF_PARAM| LVIF_IMAGE| LVIF_STATE;
            lvi.iItem = ix;
            lvi.iSubItem = 0;
            lvi.pszText = Text;
            lvi.cchTextMax = dimof(Text);
            lvi.stateMask = UINT(-1);

            if (ListView_GetItem( hLv, &lvi ))
            {
                if (!Action( hLv, &lvi, pCtx )) break;
                N++;
            }
        }
    }
    return N;
}

//== Tree controls ==----------------------------------------------------------

bool TreeView_GetItemText( HWND hTree, HTREEITEM hItem, TSTR Buf, UINT bufLen )
{
    BOOL ok = (hTree && hItem && Buf && bufLen);
    if (!ok) SetLastError( ERROR_INVALID_PARAMETER );
    else
    {
        TVITEM tvi;// = { TVIF_TEXT, hItem };
        IF_DEBUG( memset( &tvi, 0, sizeof(tvi) ));
        tvi.mask = TVIF_TEXT;
        tvi.hItem = hItem;
        tvi.pszText = Buf;
        tvi.cchTextMax = bufLen;
        ok = TreeView_GetItem( hTree, &tvi );
        if (!ok) *Buf = 0;
        else if (tvi.pszText != Buf) _tcscpy_s( Buf, bufLen, tvi.pszText );
        // [MSDN:TVM_GETITEM] "The returned text will not necessarily be stored in
        // the original buffer passed by the application. It is possible that pszText
        // will point to text in a new buffer rather than place it in the old buffer."
    }
    return bool_cast( ok );
}

//== Trackbar ==---------------------------------------------------------------

static const UINT _SI_SIZE = sizeof(SCROLLINFO);

bool GetTrackbarInfo( HWND hCtl, LPSCROLLINFO psi )
{
    bool ok = ((psi->cbSize == _SI_SIZE) && !IsBadWritePtr( psi, _SI_SIZE ));
    if (!ok) SetLastError( ERROR_INVALID_PARAMETER );
    else
    {
        if (psi->fMask & SIF_PAGE) psi->nPage = (UINT) SendMessage( hCtl, TBM_GETPAGESIZE, 0,0 );
        if (psi->fMask & SIF_RANGE)
        {
            psi->nMin = (int) SendMessage( hCtl, TBM_GETRANGEMIN, 0,0 );
            psi->nMax = (int) SendMessage( hCtl, TBM_GETRANGEMAX, 0,0 );
        }
        bool getPos = bool_cast( psi->fMask & SIF_POS );
        bool getTrkPos = bool_cast( psi->fMask & SIF_TRACKPOS );
        if (getPos || getTrkPos)
        {
            int pos = (int) SendMessage( hCtl, TBM_GETPOS, 0,0 );
            if (getTrkPos) psi->nTrackPos = pos;
            if (getPos) psi->nPos = pos;
        }
    }
    return ok;
}

bool SetTrackbarInfo( HWND hCtl, LPSCROLLINFO psi, bool Redraw )
{
    bool ok = ((psi->cbSize == _SI_SIZE) && !IsBadReadPtr( psi, _SI_SIZE ));
    if (!ok) SetLastError( ERROR_INVALID_PARAMETER );
    else
    {
        SendMessage( hCtl, TBM_SETLINESIZE, 0, 1 ); // Scrollbar compatible default

        if (psi->fMask & SIF_PAGE) SendMessage( hCtl, TBM_SETPAGESIZE, 0, psi->nPage );
        if (psi->fMask & SIF_RANGE)
        {
            SendMessage( hCtl, TBM_SETRANGEMIN, false, psi->nMin );
            SendMessage( hCtl, TBM_SETRANGEMAX, Redraw, psi->nMax );
        }
        if (psi->fMask & SIF_POS) SendMessage( hCtl, TBM_SETPOS, Redraw, psi->nPos );
    }
    return ok;
}

//== Imagelist ==--------------------------------------------------------------

HIMAGELIST ImageList_CreateMapped(
    HINSTANCE hInst, UINT Id, LPCOLORMAP Map, UINT nMap,
    UINT cxImg, UINT Flags, UINT nGrow
    )
{
    HIMAGELIST hIml = NULL;
    HBITMAP hBmp = CreateMappedBitmap( hInstance, Id, 0, Map, nMap );
    if (hBmp)
    {
        BITMAP bm; GetObject( hBmp, sizeof(BITMAP), &bm );
        UINT imgCount = bm.bmWidth / cxImg;
        hIml = ImageList_Create( cxImg, bm.bmHeight, Flags, imgCount, nGrow );
        ImageList_Add( hIml, hBmp, NULL );
        DeleteBitmap( hBmp );
    }
    return hIml;
}

//== Toolbar ==----------------------------------------------------------------

// The toolbars and rebars have so many quirks that I lost count.. :/
// That the MSDN documentation for them is dismally incomplete doesn't help one iota.
// Caveat Emptor

static const DWORD  TBSTYLE_EX_MASK =
    TBSTYLE_EX_MIXEDBUTTONS | TBSTYLE_EX_DRAWDDARROWS
    | TBSTYLE_EX_HIDECLIPPEDBUTTONS | TBSTYLE_EX_DOUBLEBUFFER;

//static SIZES _smSize( DWORD dw ) { return LITERAL( SIZES, dw ); }
//static void _trace_BarExt( HWND hBar, CSTR Where, int ww, int hh, int cxBtn, int cyBtn )
//{
//    SIZES btnExt, btnPad; SIZE barExt;
//    btnExt = _smSize( (DWORD)SendMessage( hBar, TB_GETBUTTONSIZE, 0,0 ));
//    btnPad = _smSize( (DWORD)SendMessage( hBar, TB_GETPADDING, 0,0 ));
//    GetWndSize( hBar, &barExt );
//    TRACE( DP_DEBUG, _F("%s: cxBtn=%u(%u), cyBtn=%u(%u), btnPad={%u,%u}, barExt={%u(%u),%u(%u)}\n"),
//        Where, btnExt.cx, cxBtn, btnExt.cy, cyBtn, btnPad.cx, btnPad.cy, barExt.cx, ww, barExt.cy, hh
//        );
//}

HWND CreateToolbar(
    HWND hParent, UINT Id, UINT x, UINT y, UINT w, UINT h,
    UINT cxBtn, UINT cyBtn, HIMAGELIST hImages, LPTBBUTTON Buttons, UINT nButtons,
    DWORD Style, DWORD ExStyle
    )
{
    HWND hBar = NULL;
    if (!Buttons || !nButtons) SetLastError( ERROR_INVALID_PARAMETER );
    else
    {
        HINSTANCE hInst = (HINSTANCE) GWLP( hParent, HINSTANCE );
        DWORD wsEx = ExStyle & ~TBSTYLE_EX_MASK; // WS_EX_nn
        DWORD tbEx = ExStyle & TBSTYLE_EX_MASK;  // TBSTYLE_EX_nn

        hBar = CreateWindowEx( wsEx, TOOLBARCLASSNAME,
            S_BLANK, Style, x, y, w, h, hParent, (HMENU)(UINT_PTR) Id, hInst, NULL
            );
        if (hBar)
        {
            if (tbEx) SendMessage( hBar, TB_SETEXTENDEDSTYLE, 0, tbEx );
            if (hImages) SendMessage( hBar, TB_SETIMAGELIST, 0, LPARAM( hImages ));
          #if 1
            int cxIm, cyIm; // Better safe than sorry..
            ImageList_GetIconSize( hImages, &cxIm, &cyIm );
            SendMessage( hBar, TB_SETBITMAPSIZE, 0, MAKELPARAM( cxIm, cyIm ));
          #endif
            SendMessage( hBar, TB_SETINDENT, 2,0 ); // Indent the first button 2 pix..
            SendMessage( hBar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0 );
            SendMessage( hBar, TB_ADDBUTTONS, nButtons, LPARAM( Buttons ));
            SendMessage( hBar, TB_SETBUTTONSIZE, 0, MAKELPARAM( cxBtn, cyBtn )); // NOT HONORED
            //SendMessage( hBar, TB_SETBUTTONWIDTH, 0, MAKELPARAM( cxBtn, cxBtn*5 )); // NOT HONORED
        }
    }
    return hBar;
}

HWND CreateStdToolbar(
    HWND hParent, UINT Id, UINT x, UINT y, UINT w, UINT h,
    UINT imgType, LPTBBUTTON Buttons, UINT nButtons, DWORD Style, DWORD ExStyle
    )
{
    HWND hBar = NULL;
    if ((imgType > 9) || (imgType & 1)) // Large toolbuttons and IE travel images seem dysfunctional.. :(
        SetLastError( ERROR_INVALID_PARAMETER );
    else
    {
        HINSTANCE hInst = GetWindowInstance( hParent );
        DWORD wsEx = ExStyle & ~TBSTYLE_EX_MASK;
        DWORD tbEx = ExStyle & TBSTYLE_EX_MASK;
        UINT cxyBtn = (h - 2); // Sadly, the button size is disregarded... we might as well say 2px here :(

        hBar = CreateWindowEx( wsEx, TOOLBARCLASSNAME,
            S_BLANK, Style, x, y, w, h, hParent, (HMENU)(UINT_PTR) Id, hInst, NULL
            );
        SendMessage( hBar, TB_SETEXTENDEDSTYLE, 0, tbEx );
        SendMessage( hBar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0 );
        SendMessage( hBar, TB_SETINDENT, 2, 0 );
        SendMessage( hBar, TB_LOADIMAGES, imgType, LPARAM( HINST_COMMCTRL ));
        SendMessage( hBar, TB_SETBUTTONSIZE, 0, MAKELPARAM( cxyBtn, cxyBtn ));
        SendMessage( hBar, TB_ADDBUTTONS, nButtons, LPARAM( Buttons ));
        SendMessage( hBar, TB_SETBUTTONSIZE, 0, MAKELPARAM( cxyBtn, cxyBtn )); // NOT HONORED... :(
    }
    return hBar;
}

//== Rebar ==------------------------------------------------------------------

WORD RebarBandInfoSize() // Life saver!
{
    WORD size;
    UINT ver = GetDLLVersion( _T("comctl32.dll") );

    if (ver < PACKVERSION( 4,71 )) // initial guesstimate..
        size = CCSIZEOF_STRUCT( REBARBANDINFO, wID );
    else if (ver < PACKVERSION( 6,0 ))
        size = CCSIZEOF_STRUCT( REBARBANDINFO, cxHeader ); // Yup..
  #if (_WIN32_WINNT >= 0x0600)
    else // >= 6.0
        size = CCSIZEOF_STRUCT( REBARBANDINFO, uChevronState );
           //= sizeof(REBARBANDINFO);
  #endif
    return size;
}
//WORD RebarBandInfoSize()
//{
//    WORD size = sizeof(REBARBANDINFO);
//    //or: WORD size = CCSIZEOF_STRUCT( REBARBANDINFO, uChevronState );
//    UINT ver = GetDLLVersion( "comctl32.dll" );
//    if (ver < PACKVERSION( 6,0 ))
//      #if (_WIN32_IE < 0x0400) // comctl32 4.71... wasn't it..?
//        size = REBARBANDINFOA_V3_SIZE;
//      #else
//        size = CCSIZEOF_STRUCT( REBARBANDINFO, cxHeader );
//      #endif
//    return size;
//}

//==---------------------------------------------------------------------------
// EOF