windows-xp/Source/XPSP1/NT/printscan/ui/printui/archlv.cxx

/*++

Copyright (C) Microsoft Corporation, 1996 - 1998
All rights reserved.

Module Name:

    archlv.hxx

Abstract:

    Driver Architecture List View 

Author:

    Steve Kiraly (SteveKi) 19-Nov-1996

Revision History:

--*/

#include "precomp.hxx"
#pragma hdrstop

#include "psetup.hxx"
#include "drvsetup.hxx"
#include "drvver.hxx"
#include "archlv.hxx"

/********************************************************************

    Arch List - static data.

********************************************************************/

//
// disable MIPS & PPC drivers, since they are not supported from setup
//
static TArchLV::ArchEncode aArchEncode[] = 
{
    {IDS_ARCH_IA64,      IDS_VERSION_51,         L"Windows IA64",          L"3",   DRIVER_IA64_3  },

    {IDS_ARCH_INTEL,     IDS_VERSION_WINDOWS_ME, L"Windows 4.0",           L"0",   DRIVER_WIN95   },

    {IDS_ARCH_INTEL,     IDS_VERSION_40_50,      L"Windows NT x86",        L"2",   DRIVER_X86_2   },
    {IDS_ARCH_INTEL,     IDS_VERSION_50_51,      L"Windows NT x86",        L"3",   DRIVER_X86_3   },

    {IDS_ARCH_ALPHA,     IDS_VERSION_40,         L"Windows NT Alpha_AXP",  L"2",   DRIVER_ALPHA_2 },

#if FALSE 
    {IDS_ARCH_INTEL,     IDS_VERSION_NT_31,      L"Windows NT x86",        L"1",   DRIVER_X86_0   },
    {IDS_ARCH_INTEL,     IDS_VERSION_35X,        L"Windows NT x86",        L"1",   DRIVER_X86_1   },

    {IDS_ARCH_MIPS,      IDS_VERSION_NT_31,      L"Windows NT R4000",      L"1",   DRIVER_MIPS_0  },
    {IDS_ARCH_MIPS,      IDS_VERSION_35X,        L"Windows NT R4000",      L"1",   DRIVER_MIPS_1  },
    {IDS_ARCH_MIPS,      IDS_VERSION_40,         L"Windows NT R4000",      L"2",   DRIVER_MIPS_2  },

    {IDS_ARCH_ALPHA,     IDS_VERSION_NT_31,      L"Windows NT Alpha_AXP",  L"1",   DRIVER_ALPHA_0 },
    {IDS_ARCH_ALPHA,     IDS_VERSION_35X,        L"Windows NT Alpha_AXP",  L"1",   DRIVER_ALPHA_1 },

    {IDS_ARCH_POWERPC,   IDS_VERSION_351,        L"Windows NT PowerPC",    L"1",   DRIVER_PPC_1   },
    {IDS_ARCH_POWERPC,   IDS_VERSION_40,         L"Windows NT PowerPC",    L"2",   DRIVER_PPC_2   }, 
#endif
};

// use this aliases for the driver version string, so we don't break 
// admin scripts written for Win2k.
static DWORD aVersionAliases[] = 
{
    IDS_VERSION_WINDOWS_95,     IDS_VERSION_WINDOWS_ME,
    IDS_VERSION_40,             IDS_VERSION_40_50,
    IDS_VERSION_50,             IDS_VERSION_50_51,
};

/********************************************************************

    Arch List view class.

********************************************************************/

TArchLV::
TArchLV(
    VOID
    ) : _hwnd( NULL ),
        _hwndLV( NULL ),
        _ColumnSortState( kMaxColumns ),
        _wmDoubleClickMsg( 0 ),
        _wmSingleClickMsg( 0 ),
        _uCurrentColumn( 0 ),
        _bNoItemCheck( FALSE )
{
    DBGMSG( DBG_TRACE, ( "TArchLV::ctor\n" ) );
    ArchDataList_vReset();
}

TArchLV::
~TArchLV(
    VOID
    )
{
    DBGMSG( DBG_TRACE, ( "TArchLV::dtor\n" ) );
    vRelease();
}

BOOL
TArchLV::
bSetUI(
    IN HWND     hwnd,
    IN WPARAM   wmDoubleClickMsg,
    IN WPARAM   wmSingleClickMsg
    )
{
    DBGMSG( DBG_TRACE, ( "TArchLV::bSetUI\n" ) );

    SPLASSERT( hwnd );
    TStatusB bStatus;
    bStatus DBGNOCHK = TRUE;

    //
    // Save the parent window handle.
    //
    _hwnd               = hwnd;
    _wmDoubleClickMsg   = wmDoubleClickMsg;
    _wmSingleClickMsg   = wmSingleClickMsg;                                 

    //
    // Get the driver list view handle.
    //
    _hwndLV = GetDlgItem( _hwnd, IDC_ARCHITECTURE_LIST );

    //
    // Add check boxes.
    //
    HIMAGELIST himlState = ImageList_Create( 16, 16, TRUE, 3, 0 );

    //
    // !! LATER !!
    // Should be created once then shared.
    //
    if( !himlState )
    {
        DBGMSG( DBG_ERROR, ( "ArchLV.bSetUI: ImageList_Create failed %d\n", GetLastError( )));
        return FALSE;
    }

    //
    // Load the bitmap for the check states.
    //
    HBITMAP hbm =  LoadBitmap( ghInst, MAKEINTRESOURCE( IDB_CHECKSTATES ));

    if( !hbm )
    {
        DBGMSG( DBG_ERROR, ( "ArchLV.bSetUI: LoadBitmap failed %d\n", GetLastError( )));
        return FALSE;
    }

    //
    // Add the bitmaps to the image list.
    //
    ImageList_AddMasked( himlState, hbm, RGB( 255, 0, 0 ));

    //
    // Set the new image list.
    //
    SendMessage( _hwndLV, LVM_SETIMAGELIST, LVSIL_STATE, (WPARAM)himlState );

    //
    // Remember to release the bitmap handle.
    //
    DeleteObject( hbm );

    //
    // Initialize the LV_COLUMN structure.
    //
    LV_COLUMN lvc;
    lvc.mask    = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
    lvc.fmt     = LVCFMT_LEFT;
    lvc.cx      = kDefaultHeaderWidth;

    //
    // Calculate the header column width.
    //
    RECT rc;
    if( !GetClientRect( _hwndLV, &rc ))
    {
        DBGMSG( DBG_WARN, ( "ArchLV.bSetUI: GetClientRect failed %d\n", GetLastError( )));
        return FALSE;
    }

    //
    // Get the total size of list view header, less the scroll bar.
    //
    LONG Interval = ( rc.right - rc.left ) - GetSystemMetrics( SM_CYVSCROLL );

    //
    // Column with array.
    //
    DWORD ColumnWidth [] = { Interval * 25, Interval * 55, Interval * 20 };

    //
    // Set the column header text.
    //
    TString strHeader;
    for( INT iCol = 0; iCol < kHeaderMax; ++iCol )
    {
        bStatus DBGCHK  = strHeader.bLoadString( ghInst, IDS_DRIVER_HEAD_ENVIRONMENT + iCol );
        lvc.pszText     = const_cast<LPTSTR>( static_cast<LPCTSTR>( strHeader ) );
        lvc.iSubItem    = iCol;
        lvc.cx          = ColumnWidth[iCol] / 100;

        if( ListView_InsertColumn( _hwndLV, iCol, &lvc ) == -1 )
        {
            DBGMSG( DBG_WARN, ( "ArchLV.bSetUI: LV_Insert failed %d\n", GetLastError( )));
            bStatus DBGCHK = FALSE;
        }
    }

    //
    // Enable full row selection and check boxes.
    //
    if( bStatus )
    {
        DWORD dwExStyle = ListView_GetExtendedListViewStyle( _hwndLV );
    	ListView_SetExtendedListViewStyle( _hwndLV, dwExStyle | LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_LABELTIP );
    }

    return bStatus;
}

BOOL
TArchLV::
bRefreshListView(
    IN LPCTSTR pszServerName,
    IN LPCTSTR pszDriverName
    )
{
    DBGMSG( DBG_TRACE, ( "TArchLV::bRefreshListView\n" ) );

    SPLASSERT( pszDriverName );

    //
    // Release current list view items.
    //
    vRelease();

    //
    // Reset the sort order 
    //
    _ColumnSortState.vResetAll();
    
    //
    // Fill the list view and sort it.
    //        
    BOOL bReturn = bFillListView( pszServerName, pszDriverName );
    
    //
    // Sort the list view         
    (VOID)bListViewSort( kVersionColumn );
    (VOID)bListViewSort( kArchitectureColumn );

    //
    // Reset the sort order 
    //
    _ColumnSortState.vResetAll();
    
    return bReturn;
}


BOOL
TArchLV::
bSetCheckDefaultArch(
    IN LPCTSTR pszServerName
    )
{
    TStatusB bStatus;
    DWORD dwCurrentEncode;
    TArchData *pArchData;

    //
    // Get the current machines architecture.
    //
    bStatus DBGCHK = bGetCurrentDriver( pszServerName, &dwCurrentEncode );

    if( bStatus )
    {
        bStatus DBGNOCHK = FALSE;

        DWORD cItems = ListView_GetItemCount( _hwndLV );

        for( UINT i = 0; i < cItems; i++ )
        {
            if( bGetItemData( i, &pArchData ) )
            {
                if( dwCurrentEncode == pArchData->_Encode )
                {
                    if( ( ListView_GetItemState( _hwndLV, i, kStateMask ) & kStateChecked ) && pArchData->_bInstalled )
                    {
                        vCheckItem( i, 2 );
                    }
                    else
                    {
                        vCheckItem( i, TRUE );
                    }

                    bStatus DBGNOCHK = TRUE;
                    break;
                }
            }
        }
    }
    return bStatus;
}

BOOL
TArchLV::
bHandleNotifyMessage(
    IN UINT     uMsg,
    IN WPARAM   wParam,
    IN LPARAM   lParam
    )
{
    BOOL bStatus = TRUE;

    UNREFERENCED_PARAMETER( wParam );

    switch( uMsg )
    {
    case WM_NOTIFY:
        {
            if( (INT)wParam == GetDlgCtrlID( _hwndLV ) )
            {
                LPNMHDR pnmh = (LPNMHDR)lParam;

                switch( pnmh->code )
                {
                case NM_DBLCLK:
                    DBGMSG( DBG_TRACE, ("ArchLV::NM_DBLCLK\n" ) );
                    vCheckItemClicked( (LPNMHDR)lParam );
                    if( _wmDoubleClickMsg )                                 
                    {
                        PostMessage( _hwnd, WM_COMMAND, _wmDoubleClickMsg, 0 );
                    }
                    break;

                case NM_CLICK:
                    DBGMSG( DBG_TRACE, ("ArchLV::NM_CLICK\n" ) );
                    vCheckItemClicked( (LPNMHDR)lParam );
                    if( _wmSingleClickMsg )                                 
                    {
                        PostMessage( _hwnd, WM_COMMAND, _wmSingleClickMsg, 0 );
                    }
                    break;

                case LVN_COLUMNCLICK:
                    DBGMSG( DBG_TRACE, ("ArchLV::LVN_COLUMNCLICK\n" ) );
                    {
                        NM_LISTVIEW *pNm = (NM_LISTVIEW *)lParam;
                        (VOID)bListViewSort( pNm->iSubItem );
                    }
                    break;

                case LVN_KEYDOWN:
                    DBGMSG( DBG_TRACE, ("ArchLV::LVN_KEYDOWN\n" ) );
                    {
                        if( bListVeiwKeydown( lParam ) )
                        {                            
                            if( _wmDoubleClickMsg )                                 
                            {
                                PostMessage( _hwnd, WM_COMMAND, _wmDoubleClickMsg, 0 );
                            }
                        }
                    }
                    break;

                default:
                    bStatus = FALSE;
                    break;
                }
            }
            else
            {
                bStatus = FALSE;
            }
        }
        break;

    //
    // Message not handled.
    //
    default:
        bStatus = FALSE;
        break;
    }

    return bStatus;
}

VOID
TArchLV::
vSelectItem(
    IN UINT iIndex
    )
{ 
    //
    // Select the specified item.
    //
    if( iIndex != -1 )
    {
        ListView_SetItemState( _hwndLV, iIndex, LVIS_SELECTED | LVIS_FOCUSED, 0x000F );
        ListView_EnsureVisible( _hwndLV, iIndex, FALSE );
    }
}

VOID
TArchLV::
vNoItemCheck(
    VOID
    )
{
    _bNoItemCheck = TRUE;
}

BOOL
TArchLV::
bEncodeToArchAndVersion(
    IN  DWORD    dwEncode,
    OUT TString &strArch,
    OUT TString &strVersion
    )
{
    TStatusB bStatus;
    bStatus DBGNOCHK = FALSE;

    for( UINT i = 0; i < COUNTOF( aArchEncode ); i++ )
    {
        if( aArchEncode[i].Encode == dwEncode )
        {
            bStatus DBGCHK = strArch.bLoadString( ghInst, aArchEncode[i].ArchId );
            bStatus DBGCHK = strVersion.bLoadString( ghInst, aArchEncode[i].VersionId );
            break;
        }
    }
    return bStatus;
}

BOOL
TArchLV::
bArchAndVersionToEncode(
    OUT DWORD       *pdwEncode,
    IN  LPCTSTR     pszArchitecture,
    IN  LPCTSTR     pszVersion,
    IN  BOOL        bUseNonLocalizedStrings
    )
{
    BOOL        bReturn         = FALSE;
    TString     strArch;
    TString     strVersion;
    TStatusB    bStatus;
    
    if (pdwEncode && pszArchitecture && pszVersion) 
    {
        if (bUseNonLocalizedStrings) 
        {
            for (UINT i = 0; i < COUNTOF(aArchEncode); i++)
            {
                if (!_tcsicmp(aArchEncode[i].NonLocalizedEnvironment, pszArchitecture) && 
                    !_tcsicmp(aArchEncode[i].NonLocalizedVersion, pszVersion))
                {
                    *pdwEncode = aArchEncode[i].Encode;
                    bReturn = TRUE;
                    break;
                }
            }            
        }
        else
        {
            UINT i;
            TString strMappedVersion;

            // check to remap the version string if necessary. 
            for (i = 0; (i+1) < COUNTOF( aVersionAliases ); i+=2)
            {
                bStatus DBGCHK = strMappedVersion.bLoadString(ghInst, aVersionAliases[i]);
                if( bStatus && 0 == lstrcmp(strMappedVersion, pszVersion) )
                {
                    // this version string was remapped, map to the new string.
                    bStatus DBGCHK = strMappedVersion.bLoadString(ghInst, aVersionAliases[i+1]);
                    if( bStatus )
                    {
                        pszVersion = strMappedVersion;
                    }
                }
            }

            // find the arch & version, and do the encode
            for (i = 0; i < COUNTOF( aArchEncode ); i++)
            {
                bStatus DBGCHK = strArch.bLoadString(ghInst, aArchEncode[i].ArchId);
                bStatus DBGCHK = strVersion.bLoadString(ghInst, aArchEncode[i].VersionId);
        
                if (!_tcsicmp(strArch, pszArchitecture) && !_tcsicmp(strVersion, pszVersion))
                {
                    *pdwEncode = aArchEncode[i].Encode;
                    bReturn = TRUE;
                    break;
                }
            }
        }
    }
    
    return bReturn;                     
}

BOOL
TArchLV::
bGetEncodeFromIndex( 
    IN  UINT    uIndex, 
    OUT DWORD   *pdwEncode 
    ) 
{
    BOOL bReturn = FALSE;

    //
    // Validate the passed in index.
    //
    if( uIndex < COUNTOF( aArchEncode ) )
    {
        //
        // Return back the encode for the given index.
        //
        *pdwEncode = aArchEncode[uIndex].Encode;
        bReturn = TRUE;
    }
    return bReturn;
}

/********************************************************************

    Private member functions.

********************************************************************/
BOOL
TArchLV::
vCheckItemClicked(
    IN LPNMHDR pnmh
    )
{
    BOOL bReturn = FALSE;

    DWORD dwPoints = GetMessagePos();
    POINTS &pt = MAKEPOINTS( dwPoints );
    LV_HITTESTINFO lvhti;

    lvhti.pt.x = pt.x;
    lvhti.pt.y = pt.y;

    MapWindowPoints( HWND_DESKTOP, _hwndLV, &lvhti.pt, 1 );

    INT iItem = ListView_HitTest( _hwndLV, &lvhti );

    //
    // Allow either a double click, or a single click on the
    // check box to toggle the check mark.
    //
    if( pnmh->code == NM_DBLCLK || lvhti.flags & LVHT_ONITEMSTATEICON )
    {
        vItemClicked( iItem );
        bReturn = TRUE;
    }

    return bReturn;
}


BOOL
TArchLV::
bListVeiwKeydown( 
    IN LPARAM lParam 
    )
{
    BOOL bReturn = FALSE;

    LV_KEYDOWN* plvnkd = (LV_KEYDOWN *)lParam;

    //
    // !! LATER !!
    //
    // Is this the best way to check whether the ALT
    // key is _not_ down?
    //
    if( plvnkd->wVKey == TEXT( ' ' ) &&
        !( GetKeyState( VK_LMENU ) & 0x80000000 ) &&
        !( GetKeyState( VK_RMENU ) & 0x80000000 ))
    {
        //
        // Get the selected item index.
        //
        INT iIndex = ListView_GetNextItem( _hwndLV, -1, LVNI_SELECTED );
         
        if( iIndex != -1 )
        {                            
            vItemClicked( iIndex );
            bReturn = TRUE;
        }
    }

    return bReturn;
}

VOID
TArchLV::
vRelease(
    VOID
    )
{
    //
    // Release all the list view items.
    //
    ListView_DeleteAllItems( _hwndLV );

    // 
    // Release the data from the architecture data list.
    //
    TIter Iter;
    TArchData *pArchData;

    for( ArchDataList_vIterInit( Iter ), Iter.vNext(); Iter.bValid(); ){

        pArchData = ArchDataList_pConvert( Iter );
        Iter.vNext();

        delete pArchData;
    }
}

BOOL
TArchLV::
bFillListView(
    IN LPCTSTR pszServerName,
    IN LPCTSTR pszDriverName
    )
{
    DBGMSG( DBG_TRACE, ( "TArchLV::bFillListView\n" ) );

    //
    // Fill the list view.
    //
    TStatusB bStatus;
    bStatus DBGNOCHK = FALSE;

    TPrinterDriverInstallation Di( pszServerName );
    
    if( VALID_OBJ( Di ) )
    {
        TString strArchitecture;
        TString strVersion;
        TString strInstalled;
        TString strNotInstalled;
        LPCTSTR pszInstalled;
        BOOL    bInstalled;

        //
        // Tell the driver installation class the driver name.
        //
        bStatus DBGCHK = Di.bSetDriverName( pszDriverName );

        //
        // Load the string "(installed)" from the resource file.
        //
        bStatus DBGCHK = strInstalled.bLoadString( ghInst, IDS_DRIVER_INSTALLED );
        bStatus DBGCHK = strNotInstalled.bLoadString( ghInst, IDS_DRIVER_NOTINSTALLED );

        for( UINT i = 0; i < COUNTOF( aArchEncode ); i++ )
        {
            //
            // some of the new env (like "Windows IA64") are not supported
            // in the old versions of the OS, so we need to check explicitly
            //
            if( IDS_ARCH_IA64 == aArchEncode[i].ArchId )
            {
                DWORD cbBuffer = 0;
                DWORD cDrivers = 0;
                CAutoPtrSpl<DRIVER_INFO_3> spDI1;

                if( !VDataRefresh::bEnumDrivers(pszServerName, aArchEncode[i].NonLocalizedEnvironment, 1,
                                                spDI1.GetPPV(), &cbBuffer, &cDrivers) )
                {
                    // this environment is not supported from the (remote) spooler - just skip it!
                    continue;
                }
            }

            //
            // Load the string driver name string from the resource file.
            //
            bStatus DBGCHK = strArchitecture.bLoadString( ghInst, aArchEncode[i].ArchId );
            bStatus DBGCHK = strVersion.bLoadString( ghInst, aArchEncode[i].VersionId );

            //
            // If the driver is installed, tell the user.
            //
            bInstalled = Di.bIsDriverInstalled( aArchEncode[i].Encode );

            //
            // Set the installed string.
            //
            pszInstalled = bInstalled ? static_cast<LPCTSTR>( strInstalled ) : static_cast<LPCTSTR>( strNotInstalled );

            //
            // Allocate the architecture data.
            //
            TArchData *pArchData = new TArchData( strArchitecture, strVersion, pszInstalled, aArchEncode[i].Encode, bInstalled );

            //
            // If valid 
            //
            if( VALID_PTR( pArchData ) )
            {
                //
                // Add the architecture data to the linked list.
                //
                ArchDataList_vAppend( pArchData );

                //
                // Add the string to the list view.
                //
                LRESULT iIndex = iAddToListView( strArchitecture, strVersion, pszInstalled, (LPARAM)pArchData );

                //
                // Check this item if the driver is installed.
                //
                if( bInstalled && (iIndex != -1) )
                {
                    vCheckItem( iIndex,  2 );
                }
            }
            else
            {
                //
                // The object may have been allocated, however failed construction.
                //
                delete pArchData;
            }
        }
    }

    return bStatus;
}

LRESULT
TArchLV::
iAddToListView(
    IN LPCTSTR  pszArchitecture,
    IN LPCTSTR  pszVersion,
    IN LPCTSTR  pszInstalled,
    IN LPARAM   lParam
    )
{
    DBGMSG( DBG_TRACE, ( "TArchLV::AddToListView\n" ) );

    SPLASSERT( pszArchitecture );
    SPLASSERT( pszVersion );
    SPLASSERT( pszInstalled );

    LV_ITEM lvi = { 0 };

    //
    // Add driver information to the listview.
    //
    lvi.mask        = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE | LVIF_STATE;
    lvi.iItem       = ListView_GetItemCount( _hwndLV );
    lvi.pszText     = const_cast<LPTSTR>( pszArchitecture );
    lvi.lParam      = lParam;
    lvi.state       = kStateUnchecked;

    LRESULT iIndex = ListView_InsertItem( _hwndLV, &lvi );
    if( -1 != iIndex )
    {
        ListView_SetItemText( _hwndLV, iIndex, 1, const_cast<LPTSTR>( pszVersion ) );
        ListView_SetItemText( _hwndLV, iIndex, 2, const_cast<LPTSTR>( pszInstalled ) );
    }

    return iIndex;
}

BOOL
TArchLV::
bListViewSort(
    UINT uColumn
    )
{
    //
    // Set the surrent column number.
    //
    _uCurrentColumn = uColumn;

    //
    // Tell the list view to sort.
    //
    TStatusB bStatus;
    bStatus DBGCHK = ListView_SortItems( _hwndLV, iCompareProc, (LPARAM)this );

    //
    // Toggle the specified column sort state.
    //
    _ColumnSortState.bToggle( uColumn );

    return bStatus;
}

INT 
CALLBACK 
TArchLV::
iCompareProc(
    IN LPARAM lParam1, 
    IN LPARAM lParam2, 
    IN LPARAM RefData
    )
{
    TArchData   *pArchData1 = reinterpret_cast<TArchData *>( lParam1 );
    TArchData   *pArchData2 = reinterpret_cast<TArchData *>( lParam2 );
    TArchLV     *pArchLV    = reinterpret_cast<TArchLV *>( RefData );
    INT         iResult     = 0;
    LPCTSTR     strName1    = NULL;
    LPCTSTR     strName2    = NULL;

    if( pArchLV && pArchData1 && pArchData2 )
    {
        BOOL bStatus = TRUE;

        switch( pArchLV->_uCurrentColumn )
        {

        case kArchitectureColumn:
            strName1 = pArchData1->_strArchitecture;
            strName2 = pArchData2->_strArchitecture;
            break;

        case kVersionColumn:
            strName1 = pArchData1->_strVersion;
            strName2 = pArchData2->_strVersion;
            break;

        case kInstalledColumn:
            strName1 = pArchData1->_strInstalled;
            strName2 = pArchData2->_strInstalled;
            break;

        default:
            bStatus = FALSE;
            break;
    
        }

        if( bStatus )
        {
            if( pArchLV->_ColumnSortState.bRead( pArchLV->_uCurrentColumn ) )
                iResult = _tcsicmp( strName2, strName1 );
            else
                iResult = _tcsicmp( strName1, strName2 );
        }
    }

    return iResult;
}

UINT
TArchLV::
uGetCheckedItemCount(
    VOID
    )
{
    DWORD cItems = ListView_GetItemCount( _hwndLV );

    UINT uItemCount = 0;

    for( UINT i = 0; i < cItems; i++ )
    {
        if( ListView_GetItemState( _hwndLV, i, kStateMask ) & kStateChecked )
        {
            uItemCount++;
        }
    }
    return uItemCount;
}

BOOL
TArchLV::
bGetCheckedItems(
    IN UINT   uIndex,
    IN BOOL  *pbInstalled,
    IN DWORD *pdwEncode
    )
{   
    TArchData *pArchData;
    UINT uItemCount = 0;
    BOOL bReturn = FALSE;

    DWORD cItems = ListView_GetItemCount( _hwndLV );

    for( UINT i = 0; i < cItems; i++ )
    {
        if( ListView_GetCheckState( _hwndLV, i ) )
        {
            if( uItemCount++ == uIndex )
            {
                if( bGetItemData( i, &pArchData ) )
                {
                    *pdwEncode      = pArchData->_Encode;
                    *pbInstalled    = pArchData->_bInstalled;
                    bReturn         = TRUE;
                    break;
                }                    
            }
        }
    }
    return bReturn;
}

BOOL
TArchLV::
bGetItemData(
    IN INT          iItem,
    IN TArchData  **ppArchData
    ) const
{
    BOOL bStatus;

    LV_ITEM lvItem  = { 0 };
    lvItem.mask     = LVIF_PARAM;
    lvItem.iItem    = iItem; 
    
    bStatus = ListView_GetItem( _hwndLV, &lvItem );

    if( bStatus )
    {
        *ppArchData = reinterpret_cast<TArchData *>( lvItem.lParam );
    }

    return bStatus;         
}

/*++

Name:
    
    vItemClicked

Routine Description:

    User clicked in listview.  Check if item state should
    be changed.

    The item will also be selected.

Arguments:

    iItem - Item that has been clicked.

Return Value:

    Nothing.

--*/
VOID
TArchLV::
vItemClicked(
    IN INT iItem
    )
{
    TStatusB bStatus;
    TArchData *pArchData;

    //
    // Do nothing when an invalid index is passed.
    //
    if( iItem != -1 &&  !_bNoItemCheck )
    {
        //
        // Retrieve the old state, toggle it, then set it.
        //
        DWORD dwState = ListView_GetItemState( _hwndLV, iItem, kStateMask );

        //
        // Get the item data.
        //
        bStatus DBGCHK = bGetItemData( iItem, &pArchData );

        //
        // If item data was fetched.
        //
        if( bStatus && pArchData )
        {
            //
            // Only allow checking of the item that are not installed.
            //
            if( !pArchData->_bInstalled )
            {
                //
                // Toggle the current state.
                //
                vCheckItem( iItem,  dwState != kStateChecked );
            }
        }
    }
}

/*++

Name:
    
    vCheckItem

Routine Description:

    Change the specified items check state.

Arguments:

    iItem       - Item index to change the check state for.
    bCheckState - The new item check state, TRUE check, FALSE uncheck.

Return Value:

    Nothing.

--*/
VOID
TArchLV::
vCheckItem(
    IN INT      iItem,
    IN BOOL     bCheckState
    )
{
    //
    // Do nothing when an invalid index is passed.
    //
    if( iItem != -1 )
    {
        if( bCheckState == 2 )
        {
            //
            // Set the new check state.
            //
            ListView_SetItemState( _hwndLV, iItem, kStateDisabled, kStateMask | LVIS_SELECTED | LVIS_FOCUSED );
            return;
        }

        //
        // Set the item check state.
        //
        DWORD dwState = bCheckState ? kStateChecked | LVIS_SELECTED | LVIS_FOCUSED : kStateUnchecked | LVIS_SELECTED | LVIS_FOCUSED;

        //
        // Set the new check state.
        //
        ListView_SetItemState( _hwndLV, iItem, dwState, kStateMask | LVIS_SELECTED | LVIS_FOCUSED );
    }
}

/********************************************************************

    Architecure data.

********************************************************************/
TArchLV::TArchData::
TArchData(
    IN LPCTSTR pszArchitecture,
    IN LPCTSTR pszVersion,
    IN LPCTSTR pszInstalled,
    IN DWORD   Encode,
    IN BOOL    bInstalled
    ) : _strArchitecture( pszArchitecture ),
        _strVersion( pszVersion ),
        _strInstalled( pszInstalled ),
        _Encode( Encode ),
        _bInstalled( bInstalled )
{
    DBGMSG( DBG_TRACE, ( "TArchLV::TArchData::ctor\n" ) );
}

TArchLV::TArchData::
~TArchData(
    VOID
    )
{
    DBGMSG( DBG_TRACE, ( "TArchLV::TArchData::dtor\n" ) );

    //
    // If we are linked then remove ourself.
    //
    if( ArchData_bLinked() )
    {
        ArchData_vDelinkSelf();
    }
}

BOOL
TArchLV::TArchData::
bValid(
    VOID
    )
{
    return VALID_OBJ( _strArchitecture ) &&
           VALID_OBJ( _strVersion ) &&
           VALID_OBJ( _strInstalled );
}