mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2842 lines
86 KiB
2842 lines
86 KiB
//#define __DEBUG2
|
|
//This var. is TRUE if we want the TVN_SELCHANGED to be processed process after a NM_RCLCK msg,
|
|
//this is FALSE when we send Tree_SelectItem(, NULL)
|
|
|
|
|
|
|
|
|
|
#include "compatadmin.h"
|
|
#include "dbviewer.h"
|
|
#include "xmldialog.h"
|
|
|
|
#ifndef __CAPPHELPWIZARD_H
|
|
#include "CAppHelpWizard.h"
|
|
#endif
|
|
|
|
#include "customlayer.h"
|
|
|
|
//#define __DEBUG
|
|
|
|
HSDB g_hSDB = NULL;
|
|
WNDPROC g_OldTreeProc = NULL;
|
|
|
|
extern HWND g_hWndLastFocus;
|
|
extern BOOL g_DEBUG;
|
|
|
|
BOOL g_do_notProcess = FALSE;
|
|
|
|
LRESULT CALLBACK TreeViewProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch ( uMsg ) {
|
|
case WM_KEYDOWN:
|
|
{
|
|
if ( VK_TAB == wParam ) {
|
|
NMKEY Key;
|
|
|
|
Key.hdr.hwndFrom = hWnd;
|
|
Key.hdr.idFrom = 0;
|
|
Key.hdr.code = NM_KEYDOWN;
|
|
Key.nVKey = VK_TAB;
|
|
|
|
SendMessage(GetParent(hWnd),WM_NOTIFY,0,(LPARAM) &Key);
|
|
}
|
|
}
|
|
break;
|
|
case WM_KILLFOCUS:
|
|
g_hWndLastFocus = hWnd;
|
|
break;
|
|
}
|
|
|
|
return CallWindowProc(g_OldTreeProc,hWnd,uMsg,wParam,lParam);
|
|
}
|
|
|
|
CDBView::CDBView()
|
|
{
|
|
m_pCurrentRecord = NULL;
|
|
m_pListRecord = NULL;
|
|
m_uContext = -1;
|
|
m_hSelectedItem = NULL;
|
|
m_bDrag = FALSE;
|
|
}
|
|
|
|
BOOL CDBView::Initialize(void)
|
|
{
|
|
|
|
if ( !Create( TEXT("DBViewClass"),
|
|
TEXT("This is the first window in the DBViewer::Initialize"),
|
|
0,0,
|
|
10,10,
|
|
&g_theApp,
|
|
(HMENU)VIEW_DATABASE,
|
|
0,
|
|
WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN) ) {
|
|
return FALSE;
|
|
}
|
|
// These two windows are child of the window created above. So now we have 3 generations.....
|
|
|
|
if ( ! m_GlobalList.Create(TEXT("CListView"),
|
|
TEXT("Microsoft Application Database"),
|
|
0,0,10,10,
|
|
this,
|
|
0,
|
|
0,
|
|
WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE | WS_VSCROLL | WS_BORDER)
|
|
) return FALSE;
|
|
|
|
if ( !m_LocalList.Create(TEXT("CListView"),
|
|
TEXT("Untitled.SDB"),
|
|
0,0,10,10,
|
|
this,
|
|
0,
|
|
0,
|
|
WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE | WS_VSCROLL | WS_BORDER)
|
|
)
|
|
return FALSE;
|
|
|
|
|
|
m_hMenu = LoadMenu(g_hInstance,MAKEINTRESOURCE(IDR_DBVIEWER));
|
|
|
|
// Create the listview for displaying the applications in the database.
|
|
|
|
m_uListSize = 250;
|
|
|
|
g_theApp.ReadReg(TEXT("DBVIEW_SIZE"),&m_uListSize,sizeof(UINT));
|
|
|
|
RECT rRect;
|
|
|
|
GetClientRect(g_theApp.m_hWnd,&rRect);
|
|
|
|
m_uListHeight = rRect.bottom / 2 -2 ;
|
|
|
|
g_theApp.ReadReg(TEXT("DBVIEW_HEIGHT"),&m_uListHeight,sizeof(UINT));
|
|
|
|
m_hListView = CreateWindowEx( 0,
|
|
WC_LISTVIEW,
|
|
TEXT(""),
|
|
WS_CHILD |/* WS_VISIBLE |*/ WS_BORDER | WS_CLIPSIBLINGS | LVS_REPORT | LVS_OWNERDRAWFIXED,
|
|
0,0,
|
|
10,10,
|
|
m_hWnd,
|
|
NULL,
|
|
g_hInstance,
|
|
NULL);
|
|
|
|
// Subclass the window to prevent paint flashing.
|
|
|
|
LONG uStyle = ListView_GetExtendedListViewStyle(m_hListView);
|
|
|
|
ListView_SetExtendedListViewStyle(m_hListView,LVS_EX_FULLROWSELECT | uStyle);
|
|
|
|
CoInitialize(NULL);
|
|
|
|
// Create the treeview for showing the files affected by the application
|
|
|
|
m_hTreeView = CreateWindowEx( 0,
|
|
WC_TREEVIEW,
|
|
TEXT(""),
|
|
WS_CHILD | WS_VISIBLE | WS_BORDER | WS_CLIPSIBLINGS | TVS_HASLINES | TVS_LINESATROOT | TVS_HASBUTTONS | TVS_INFOTIP,
|
|
0,0,
|
|
10,10,
|
|
m_hWnd,
|
|
NULL,
|
|
g_hInstance,
|
|
NULL);
|
|
//PREFIX
|
|
if ( m_hTreeView == NULL ) {
|
|
return FALSE;
|
|
}
|
|
|
|
g_OldTreeProc = (WNDPROC) GetWindowLongPtr(m_hTreeView,GWLP_WNDPROC);
|
|
|
|
SetWindowLongPtr(m_hTreeView,GWLP_WNDPROC,(LONG_PTR) TreeViewProc);
|
|
|
|
m_hImageList = ImageList_Create(16,15,ILC_COLORDDB | ILC_MASK,24,1);
|
|
|
|
|
|
ImageList_Add(m_hImageList,LoadBitmap(g_hInstance,MAKEINTRESOURCE(IDR_MAINTOOLBAR)),NULL);
|
|
|
|
ImageList_AddIcon(m_hImageList,LoadIcon(g_hInstance,MAKEINTRESOURCE(IDI_FIXES)));
|
|
ImageList_AddIcon(m_hImageList,LoadIcon(g_hInstance,MAKEINTRESOURCE(IDI_HELP)));
|
|
ImageList_AddIcon(m_hImageList,LoadIcon(g_hInstance,MAKEINTRESOURCE(IDI_MODE)));
|
|
|
|
ZeroMemory(&m_uImageRedirector,sizeof(m_uImageRedirector));
|
|
|
|
TreeView_SetImageList(m_hTreeView,m_hImageList,TVSIL_NORMAL);
|
|
|
|
// Create the headers for the report list view.
|
|
|
|
LV_COLUMN Col;
|
|
|
|
Col.mask = LVCF_TEXT | LVCF_WIDTH;
|
|
Col.pszText = TEXT("Application");
|
|
Col.cchTextMax = lstrlen(Col.pszText);
|
|
Col.cx = m_uListSize;
|
|
|
|
ListView_InsertColumn(m_hListView,0,&Col);
|
|
/*
|
|
Col.pszText = "Layer";
|
|
Col.cchTextMax = lstrlen(Col.pszText);
|
|
Col.cx = (m_uListSize - Col.cx)-1;
|
|
|
|
ListView_InsertColumn(m_hListView,1,&Col);
|
|
*/
|
|
/*
|
|
LOGBRUSH Brush;
|
|
|
|
Brush.lbStyle = BS_SOLID;
|
|
Brush.lbColor = RGB(235,235,235);
|
|
|
|
m_hFillBrush = CreateBrushIndirect(&Brush);
|
|
*/
|
|
MENUITEMINFO Info;
|
|
|
|
Info.cbSize = sizeof(MENUITEMINFO);
|
|
Info.fMask = MIIM_STATE;
|
|
Info.fState = MF_CHECKED;
|
|
|
|
SetMenuItemInfo(m_hMenu,ID_VIEW_VIEWSHIMFIXES,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_VIEW_VIEWLAYERFIXES,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_VIEW_VIEWAPPHELPENTRIES,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_VIEW_VIEWPATCHES,MF_BYCOMMAND,&Info);
|
|
|
|
SyncMenu();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CDBView::msgClose(void)
|
|
{
|
|
//g_theApp.WriteReg("DBVIEW_HEIGHT",REG_DWORD,&m_uListHeight,sizeof(UINT));
|
|
//g_theApp.WriteReg("DBVIEW_SIZE",REG_DWORD,&m_uListSize,sizeof(UINT));
|
|
}
|
|
|
|
BOOL CDBView::Activate(BOOL fNewCreate)
|
|
{
|
|
|
|
if ( g_hWndLastFocus != NULL ) SetFocus(g_hWndLastFocus );
|
|
else SetFocus(m_LocalList.m_hWnd);
|
|
|
|
|
|
|
|
|
|
g_theApp.AddToolbarButton( IMAGE_SHIMWIZARD,
|
|
DBCMD_FIXWIZARD,
|
|
(NULL == CDatabase::m_pDB) ? 0:TBSTATE_ENABLED,
|
|
TBSTYLE_BUTTON);
|
|
|
|
g_theApp.AddToolbarButton( 0,
|
|
0,
|
|
0,
|
|
TBSTYLE_SEP);
|
|
|
|
g_theApp.AddToolbarButton( IMAGE_DISABLEUSER,
|
|
DBCMD_DISABLEUSER,
|
|
(NULL == CDatabase::m_pDB) ? 0:TBSTATE_ENABLED,
|
|
TBSTYLE_BUTTON);
|
|
|
|
g_theApp.AddToolbarButton( IMAGE_DISABLEGLOBAL,
|
|
DBCMD_DISABLEGLOBAL,
|
|
(NULL == CDatabase::m_pDB) ? 0:TBSTATE_ENABLED,
|
|
TBSTYLE_BUTTON);
|
|
/*
|
|
g_theApp.AddToolbarButton( IMAGE_PROPERTIES,
|
|
DBCMD_PROPERTIES,
|
|
TBSTATE_ENABLED,
|
|
TBSTYLE_BUTTON);
|
|
*/
|
|
g_theApp.AddToolbarButton( IMAGE_DELETE,
|
|
DBCMD_DELETE,
|
|
0,
|
|
TBSTYLE_BUTTON);
|
|
|
|
g_theApp.AddToolbarButton( 0,
|
|
0,
|
|
0,
|
|
TBSTYLE_SEP);
|
|
|
|
g_theApp.AddToolbarButton( IMAGE_VIEWSHIM,
|
|
DBCMD_VIEWSHIMS,
|
|
TBSTATE_ENABLED,
|
|
TBSTYLE_BUTTON | TBSTYLE_CHECK);
|
|
|
|
g_theApp.AddToolbarButton( IMAGE_VIEWHELP,
|
|
DBCMD_VIEWAPPHELP,
|
|
TBSTATE_ENABLED,
|
|
TBSTYLE_BUTTON | TBSTYLE_CHECK);
|
|
|
|
g_theApp.AddToolbarButton( IMAGE_VIEWPATCH,
|
|
DBCMD_VIEWPATCH,
|
|
TBSTATE_ENABLED,
|
|
TBSTYLE_BUTTON | TBSTYLE_CHECK);
|
|
|
|
g_theApp.AddToolbarButton( IMAGE_SHOWLAYERS,
|
|
DBCMD_VIEWLAYERS,
|
|
TBSTATE_ENABLED,
|
|
TBSTYLE_BUTTON | TBSTYLE_CHECK);
|
|
|
|
g_theApp.AddToolbarButton( IMAGE_VIEWDISABLED,
|
|
DBCMD_VIEWDISABLED,
|
|
TBSTATE_ENABLED,
|
|
TBSTYLE_BUTTON | TBSTYLE_CHECK);
|
|
|
|
|
|
/*
|
|
g_theApp.AddToolbarButton( IMAGE_VIEWGLOBAL,
|
|
DBCMD_VIEWGLOBAL,
|
|
TBSTATE_ENABLED,
|
|
TBSTYLE_BUTTON | TBSTYLE_CHECK);
|
|
*/
|
|
//SendMessage(g_theApp.m_hToolBar,TB_CHECKBUTTON,DBCMD_VIEWSHIMS,MAKELONG(TRUE,0));
|
|
//SendMessage(g_theApp.m_hToolBar,TB_CHECKBUTTON,DBCMD_VIEWAPPHELP,MAKELONG(TRUE,0));
|
|
//SendMessage(g_theApp.m_hToolBar,TB_CHECKBUTTON,DBCMD_VIEWPATCH,MAKELONG(TRUE,0));
|
|
//SendMessage(g_theApp.m_hToolBar,TB_CHECKBUTTON,DBCMD_VIEWLAYERS,MAKELONG(TRUE,0));
|
|
|
|
SyncStates(ID_VIEW_VIEWSHIMFIXES,DBCMD_VIEWSHIMS,TRUE,FALSE);
|
|
SyncStates(ID_VIEW_VIEWLAYERFIXES,DBCMD_VIEWLAYERS,TRUE,FALSE);
|
|
SyncStates(ID_VIEW_SHOWDISABLEDENTRIES,DBCMD_VIEWDISABLED,TRUE,FALSE);
|
|
SyncStates(ID_VIEW_VIEWPATCHES,DBCMD_VIEWPATCH,TRUE,FALSE);
|
|
SyncStates(ID_VIEW_VIEWAPPHELPENTRIES,DBCMD_VIEWAPPHELP,TRUE,FALSE);
|
|
|
|
Update(fNewCreate);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int CALLBACK lvSortAscend(LPARAM p1, LPARAM p2, LPARAM p3)
|
|
{
|
|
PDBRECORD pRecord1 = (PDBRECORD) p1;
|
|
PDBRECORD pRecord2 = (PDBRECORD) p2;
|
|
|
|
return lstrcmpi(pRecord1->szAppName,pRecord2->szAppName);
|
|
}
|
|
|
|
void CDBView::Update(BOOL fNewCreate)
|
|
{
|
|
|
|
|
|
|
|
BOOL bShowShims = (MF_CHECKED == GetMenuState(m_hMenu,ID_VIEW_VIEWSHIMFIXES,MF_BYCOMMAND)) ? TRUE:FALSE;
|
|
BOOL bShowApphelp = (MF_CHECKED == GetMenuState(m_hMenu,ID_VIEW_VIEWAPPHELPENTRIES,MF_BYCOMMAND)) ? TRUE:FALSE;
|
|
BOOL bShowPatch = (MF_CHECKED == GetMenuState(m_hMenu,ID_VIEW_VIEWPATCHES,MF_BYCOMMAND)) ? TRUE:FALSE;
|
|
BOOL bShowLayers = (MF_CHECKED == GetMenuState(m_hMenu,ID_VIEW_VIEWLAYERFIXES,MF_BYCOMMAND)) ? TRUE:FALSE;
|
|
BOOL bShowDisabledOnly = (MF_CHECKED == GetMenuState(m_hMenu,ID_VIEW_SHOWDISABLEDENTRIES,MF_BYCOMMAND)) ? TRUE:FALSE;
|
|
TCHAR szTemp[MAX_PATH_BUFFSIZE];
|
|
CSTRING szName;
|
|
|
|
|
|
|
|
HWND hWnd = GetFocus();
|
|
//The GetFocus function retrieves the handle to the window that has the
|
|
//keyboard focus, if the window is attached to the calling thread's message queue.
|
|
|
|
if ( m_GlobalList.m_hWnd != hWnd && m_hTreeView != hWnd && m_LocalList.m_hWnd != hWnd ) {
|
|
SetFocus(m_GlobalList.m_hWnd);
|
|
}
|
|
|
|
|
|
|
|
if ( g_theApp.GetDBLocal().m_szCurrentDatabase.Length() > 0 )
|
|
szName = g_theApp.GetDBLocal().m_szCurrentDatabase;//Name of the SDB File
|
|
else
|
|
szName = TEXT("Untitled.SDB");
|
|
|
|
if ( szName.Length() == 0 ) {
|
|
MEM_ERR;
|
|
return;
|
|
}
|
|
szName.ShortFilename();
|
|
|
|
_snwprintf(szTemp,sizeof(szTemp)/sizeof(TCHAR), TEXT("%s (%s)"),(LPCTSTR)szName,(LPCTSTR)g_theApp.GetDBLocal().m_DBName);
|
|
|
|
|
|
//First the name of the SDB, then the name of the database.
|
|
|
|
SetWindowText(m_LocalList.m_hWnd,szTemp);
|
|
|
|
if ( NULL == g_theApp.GetDBLocal().m_pDB )
|
|
//K The database is closed, that is we are working on the system DB
|
|
{
|
|
g_theApp.SetButtonState(DBCMD_FIXWIZARD,0);
|
|
}
|
|
|
|
g_theApp.SetButtonState(DBCMD_FIXWIZARD,TBSTATE_ENABLED);
|
|
|
|
// Enumerate the applications
|
|
|
|
//SendMessage(m_hListView,WM_SETREDRAW,FALSE,0);
|
|
SendMessage(m_GlobalList.m_hWnd,WM_SETREDRAW,FALSE,0);
|
|
|
|
|
|
|
|
|
|
|
|
if ( fNewCreate ) {
|
|
m_GlobalList.RemoveAllEntries();
|
|
m_LocalList.RemoveAllEntries();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Clear and update the list view with current information.
|
|
|
|
|
|
|
|
PDBRECORD pWalk = g_theApp.GetDBGlobal().m_pRecordHead;
|
|
PDBRECORD pWalk2 = g_theApp.GetDBGlobal().m_pRecordHead;
|
|
|
|
int nItem = 0;
|
|
|
|
for (int iLoop = 0 ; iLoop <= 1 ; ++iLoop) {
|
|
|
|
while ( NULL != pWalk2 && fNewCreate )//For all exes
|
|
//Loop control by pWalk2
|
|
{
|
|
BOOL bShow = FALSE;
|
|
pWalk = pWalk2;
|
|
|
|
while ( NULL != pWalk )
|
|
//Follows all exes of the same application as that of the pWalk2 exe
|
|
// including pWalk2, with the help of the pWalk->pDup
|
|
{
|
|
//LV_ITEM Item;
|
|
PDBENTRY pEntry = pWalk->pEntries;
|
|
|
|
if ( 0 != pWalk->szLayerName.Length() && bShowLayers )
|
|
bShow = TRUE;
|
|
|
|
while ( NULL != pEntry && !bShow ) {// Not for layers
|
|
/*
|
|
Note that both Shims and Patches have the same uTupe as
|
|
ENTRY_SHIM and they are distinguished by only the SHIMDESC.bSim
|
|
*/
|
|
|
|
if ( ENTRY_SHIM == pEntry->uType ) {
|
|
PSHIMENTRY pShim = (PSHIMENTRY) pEntry;
|
|
|
|
if ( NULL != pShim->pDesc ) {
|
|
if ( bShowShims && pShim->pDesc->bShim )//This is a shim and not Patch
|
|
bShow = TRUE;
|
|
|
|
if ( bShowPatch && !pShim->pDesc->bShim )//Patch
|
|
bShow = TRUE;
|
|
} else
|
|
#ifdef __DEBUG
|
|
__asm int 3;//Trap to debugger.
|
|
|
|
#endif
|
|
;
|
|
}
|
|
|
|
|
|
if ( ENTRY_APPHELP == pEntry->uType && bShowApphelp )
|
|
bShow = TRUE;
|
|
|
|
pEntry = pEntry->pNext;
|
|
}
|
|
|
|
|
|
|
|
if ( bShow ) {
|
|
// Determine if we're showing disabled only.
|
|
/* This "if" condition is TRUE then it means that the entry is enabled but we
|
|
are interested in viwing only "disabled entries".
|
|
|
|
So we skip this EXE entry and look for other exes/entries in the same
|
|
application as this one, hoping to find one that is disabled.
|
|
So that this application can be included in the list of
|
|
applications to be shown
|
|
|
|
*/
|
|
if ( 0 == pWalk->dwUserFlags && 0 == pWalk->dwGlobalFlags && bShowDisabledOnly ) {
|
|
bShow = FALSE;
|
|
pWalk = pWalk->pDup;
|
|
continue;//Go to next file of the same application
|
|
}
|
|
break;
|
|
}
|
|
pWalk = pWalk->pDup;//Go to next file of the same application, bShow was FALSE
|
|
}//while (NULL != pWalk)
|
|
|
|
if ( bShow ) {
|
|
if ( pWalk2->bGlobal )
|
|
m_GlobalList.AddEntry(pWalk2->szAppName,0,pWalk2);
|
|
else
|
|
m_LocalList.AddEntry(pWalk2->szAppName,0,pWalk2);
|
|
}
|
|
|
|
|
|
|
|
pWalk2 = pWalk2->pNext;// Go to the next exe.
|
|
|
|
}//while (NULL != pWalk2 && fNewCreate)
|
|
pWalk = g_theApp.GetDBLocal().m_pRecordHead;
|
|
pWalk2 = g_theApp.GetDBLocal().m_pRecordHead;
|
|
} //for
|
|
|
|
//ListView_SortItems(m_hListView,lvSortAscend,0);
|
|
// Update the list view
|
|
|
|
//SendMessage(m_hListView,WM_SETREDRAW,TRUE,0);
|
|
//UpdateWindow(m_hListView);
|
|
|
|
|
|
|
|
SendMessage(m_GlobalList.m_hWnd,WM_SETREDRAW,TRUE,0);
|
|
|
|
|
|
m_GlobalList.Refresh();
|
|
m_LocalList.Refresh();
|
|
|
|
|
|
}
|
|
|
|
void CDBView::msgResize(UINT uWidth, UINT uHeight)
|
|
{
|
|
//MoveWindow(m_hListView,0,0,m_uListSize,uHeight/2,TRUE);
|
|
|
|
MoveWindow(m_GlobalList.m_hWnd,0,0,m_uListSize,m_uListHeight,TRUE);
|
|
MoveWindow(m_LocalList.m_hWnd,0,m_uListHeight + SLIDER_WIDTH,m_uListSize,(uHeight - m_uListHeight) - SLIDER_WIDTH,TRUE);
|
|
|
|
MoveWindow(m_hTreeView,m_uListSize + SLIDER_WIDTH,0,uWidth - m_uListSize,uHeight,TRUE);
|
|
|
|
//InvalidateRect(m_hListView,NULL,TRUE);
|
|
//UpdateWindow(m_hListView);
|
|
UpdateWindow(m_hTreeView);
|
|
|
|
Refresh();
|
|
}
|
|
|
|
void CDBView::RefreshTree(void)
|
|
{
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,FALSE,0);
|
|
|
|
TreeView_DeleteAllItems(m_hTreeView);
|
|
|
|
PDBRECORD pRecord = m_pListRecord;
|
|
|
|
while ( NULL != pRecord ) {
|
|
AddRecordToTree(pRecord);
|
|
|
|
pRecord = pRecord->pDup;
|
|
}
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,TRUE,0);
|
|
|
|
SyncMenu();
|
|
}
|
|
|
|
void CDBView::msgCommand(UINT uID, HWND hSender)
|
|
{
|
|
switch ( uID ) {
|
|
case ID_DATABASE_CHANGEDATABASENAME:
|
|
{
|
|
g_theApp.GetDBLocal().ChangeDatabaseName();
|
|
|
|
m_LocalList.Refresh();
|
|
}
|
|
break;
|
|
|
|
case ID_FILE_EXPORTXML:
|
|
case ID_DATABASE_GENERATEXML:
|
|
{
|
|
CXMLDialog XML;
|
|
|
|
XML.BeginXMLView(g_theApp.GetDBLocal().m_pRecordHead,m_hWnd,TRUE,TRUE,TRUE,TRUE,FALSE);
|
|
}
|
|
break;
|
|
|
|
case ID_EDIT_ADDMATCHINGINFORMATION:
|
|
case ID_NA2_ADDMATCHINGINFORMATION:
|
|
{
|
|
CSTRING szFilename;
|
|
|
|
|
|
if (m_pCurrentRecord == NULL) {
|
|
MessageBox(this->m_hWnd, TEXT("Please select a file for the specified operation\nYou might need to re-select the application on the left first."), TEXT("CompatAdmin"),MB_ICONWARNING);
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
if ( g_theApp.GetFilename(TEXT("Find matching file"),TEXT("All files (*.*)\0*.*\0\0"),TEXT(""),TEXT(""),OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST,TRUE,szFilename) ) {
|
|
CShimWizard Wiz;
|
|
PMATCHENTRY pEntry = new MATCHENTRY;
|
|
if ( pEntry == NULL ) {
|
|
MEM_ERR;
|
|
break;
|
|
}
|
|
|
|
|
|
if (m_pCurrentRecord == NULL) {
|
|
MessageBox(this->m_hWnd, TEXT("Please select a file for the specified operation\nYou might need to re-select the application on the left first."), TEXT("Compatadmin"),MB_ICONWARNING);
|
|
break;
|
|
}
|
|
|
|
|
|
PDBENTRY pWalk = m_pCurrentRecord->pEntries;
|
|
PMATCHENTRY pSrc = NULL;
|
|
CSTRING szCheck = szFilename;
|
|
szCheck.ShortFilename();
|
|
|
|
while ( NULL != pWalk ) {
|
|
if ( ENTRY_MATCH == pWalk->uType ) {
|
|
PMATCHENTRY pTest = (PMATCHENTRY) pWalk;
|
|
CSTRING szShort = pTest->szMatchName;
|
|
|
|
szShort.ShortFilename();
|
|
|
|
if ( pTest->szMatchName == TEXT("*") )
|
|
pSrc = pTest;
|
|
|
|
if ( szShort == szCheck ) {
|
|
MessageBox(m_hWnd,TEXT("This file is already being used for matching information. To update, please remove and re-add it."),TEXT("File matching error"),MB_OK);
|
|
return;
|
|
}
|
|
}
|
|
|
|
pWalk = pWalk->pNext;
|
|
}
|
|
|
|
//BUG: NULL pSrc
|
|
//if (pSrc->szFullName.Length() == 0)
|
|
|
|
if ( (pSrc->szFullName.Length() == 0) ) {
|
|
CSTRING szSrc;
|
|
|
|
MessageBox(m_hWnd,TEXT("In order to properly resolve the relative path of the file to be matched, the source executable must be specified.\n\nThis next step will ask for the source executable location."),TEXT("Locate source executable"),MB_ICONWARNING);
|
|
|
|
if ( g_theApp.GetFilename(TEXT("Find source executable"),TEXT("All files (*.*)\0*.*\0\0"),TEXT(""),TEXT(""),OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST,TRUE,szSrc) ) {
|
|
szCheck = szSrc;
|
|
|
|
szCheck.ShortFilename();
|
|
|
|
if ( szCheck == m_pCurrentRecord->szEXEName )
|
|
pSrc->szFullName = szSrc;
|
|
else {
|
|
MessageBox(m_hWnd,TEXT("The source executable must have the same name as file to be fixed"),TEXT("Source file error"),MB_ICONERROR);
|
|
break;
|
|
}
|
|
} else
|
|
break;
|
|
}
|
|
|
|
// BUGBUG: THIS SUCKS. Move GetFileAttributes() et al to someplace
|
|
// more utility oriented.. like CDatabase or something.
|
|
|
|
if ( NULL != pEntry ) {
|
|
ZeroMemory(pEntry,sizeof(MATCHENTRY));
|
|
|
|
HANDLE hFile = CreateFile((LPCTSTR) szFilename,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
|
|
|
|
if ( INVALID_HANDLE_VALUE != hFile ) {
|
|
pEntry->dwSize = GetFileSize(hFile,NULL);
|
|
|
|
CloseHandle(hFile);
|
|
}
|
|
|
|
pEntry->Entry.uType = ENTRY_MATCH;
|
|
pEntry->Entry.uIconID = 0;
|
|
pEntry->szFullName = szFilename;
|
|
|
|
if (szFilename.RelativeFile(pSrc->szFullName) == FALSE) {
|
|
|
|
//
|
|
//The matching file is not on the same drive as the matching file
|
|
//
|
|
|
|
MessageBox( NULL,
|
|
TEXT("The matching file and the matched file are not on the same drive."),
|
|
TEXT("Matching Error"),
|
|
MB_ICONWARNING
|
|
);
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
pEntry->szMatchName = szFilename;
|
|
|
|
Wiz.GetFileAttributes(pEntry);
|
|
|
|
// Take this file and add it to the current record.
|
|
|
|
// Insert at the end
|
|
|
|
PDBENTRY pWalk = m_pCurrentRecord->pEntries;
|
|
PDBENTRY pHold = NULL;
|
|
|
|
while ( NULL != pWalk ) {
|
|
pHold = pWalk;
|
|
pWalk = pWalk->pNext;
|
|
}
|
|
|
|
if ( pHold != NULL ) {
|
|
pHold->pNext = (PDBENTRY) pEntry;
|
|
}
|
|
|
|
|
|
pEntry->Entry.pNext = NULL;
|
|
|
|
// Update the tree.
|
|
|
|
RefreshTree();
|
|
|
|
g_theApp.GetDBLocal().m_bDirty = TRUE;
|
|
g_theApp.UpdateView(TRUE);
|
|
}
|
|
}
|
|
}//case ID_NA2_ADDMATCHINGINFORMATION:
|
|
break;
|
|
|
|
case ID_DATABASE_REMOVEENTRY:
|
|
case ID_NA_REMOVEANENTRY:
|
|
{
|
|
HTREEITEM hParent = TreeView_GetParent(m_hTreeView,m_hSelectedItem);
|
|
|
|
while ( NULL != hParent ) {
|
|
HTREEITEM hNew = TreeView_GetParent(m_hTreeView,hParent);
|
|
|
|
if ( NULL != hNew )
|
|
hParent = hNew;
|
|
else
|
|
break;
|
|
}
|
|
|
|
//
|
|
//hParent is the item whose parent is NULL
|
|
//
|
|
|
|
if ( NULL == hParent )
|
|
hParent = m_hSelectedItem;
|
|
|
|
DeleteDBWithTree(hParent);
|
|
|
|
}
|
|
break;
|
|
|
|
|
|
case ID_EDIT_REMOVEMATCHINGINFORMATION:
|
|
case ID_NA2_REMOVEMATCHINGINFORMATION:
|
|
{
|
|
DeleteDBWithTree(m_hSelectedItem);
|
|
}
|
|
break;
|
|
|
|
case ID_DATABASE_DEFINECUSTOMLAYER:
|
|
{
|
|
CCustomLayer Layer;
|
|
HWND hWnd = GetFocus();
|
|
|
|
if ( Layer.AddCustomLayer() ) {
|
|
g_theApp.GetDBLocal().m_bDirty = TRUE;
|
|
|
|
g_theApp.UpdateView(TRUE);
|
|
|
|
SetFocus(hWnd);
|
|
|
|
SyncMenu();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ID_DATABASE_EDITCUSTOMCOMPATIBILITYMODE:
|
|
{
|
|
CCustomLayer Layer;
|
|
|
|
if ( Layer.EditCustomLayer() ) {
|
|
g_theApp.GetDBLocal().m_bDirty = TRUE;
|
|
|
|
g_theApp.UpdateView(TRUE);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ID_DATABASE_REMOVECUSTOMCOMPATIBILITYMODE:
|
|
{
|
|
CCustomLayer Layer;
|
|
HWND hWnd = GetFocus();
|
|
|
|
if ( Layer.RemoveCustomLayer() ) {
|
|
g_theApp.GetDBLocal().m_bDirty = TRUE;
|
|
|
|
g_theApp.UpdateView(TRUE);
|
|
|
|
SetFocus(hWnd);
|
|
|
|
SyncMenu();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DBCMD_VIEWSHIMS:
|
|
SyncStates(ID_VIEW_VIEWSHIMFIXES,DBCMD_VIEWSHIMS,TRUE,FALSE);
|
|
Update();
|
|
break;
|
|
|
|
case DBCMD_VIEWDISABLED:
|
|
SyncStates(ID_VIEW_SHOWDISABLEDENTRIES,DBCMD_VIEWDISABLED,TRUE,FALSE);
|
|
Update();
|
|
break;
|
|
|
|
case ID_VIEW_VIEWSHIMFIXES:
|
|
SyncStates(ID_VIEW_VIEWSHIMFIXES,DBCMD_VIEWSHIMS,FALSE,TRUE);
|
|
Update();
|
|
break;
|
|
|
|
case DBCMD_VIEWPATCH:
|
|
SyncStates(ID_VIEW_VIEWPATCHES,DBCMD_VIEWPATCH,TRUE,FALSE);
|
|
Update();
|
|
break;
|
|
|
|
case DBCMD_VIEWLAYERS:
|
|
SyncStates(ID_VIEW_VIEWLAYERFIXES,DBCMD_VIEWLAYERS,TRUE,FALSE);
|
|
Update();
|
|
break;
|
|
|
|
case DBCMD_VIEWAPPHELP:
|
|
SyncStates(ID_VIEW_VIEWAPPHELPENTRIES,DBCMD_VIEWAPPHELP,TRUE,FALSE);
|
|
Update();
|
|
break;
|
|
|
|
case ID_VIEW_VIEWAPPHELPENTRIES:
|
|
SyncStates(ID_VIEW_VIEWAPPHELPENTRIES,DBCMD_VIEWAPPHELP,FALSE,TRUE);
|
|
Update();
|
|
break;
|
|
|
|
case ID_VIEW_VIEWLAYERFIXES:
|
|
SyncStates(ID_VIEW_VIEWLAYERFIXES,DBCMD_VIEWLAYERS,FALSE,TRUE);
|
|
Update();
|
|
break;
|
|
|
|
case ID_VIEW_VIEWPATCHES:
|
|
SyncStates(ID_VIEW_VIEWPATCHES,DBCMD_VIEWPATCH,FALSE,TRUE);
|
|
Update();
|
|
break;
|
|
|
|
case ID_VIEW_SHOWDISABLEDENTRIES:
|
|
SyncStates(ID_VIEW_SHOWDISABLEDENTRIES,DBCMD_VIEWDISABLED,FALSE,TRUE);
|
|
Update();
|
|
break;
|
|
|
|
|
|
case ID_TEST_TESTRUN:
|
|
case ID_TESTRUN:
|
|
{
|
|
HWND hwndFocus = GetFocus();
|
|
if ( NULL != m_pCurrentRecord )
|
|
g_theApp.TestRun(m_pCurrentRecord,NULL,NULL,g_theApp.m_hWnd);
|
|
|
|
SetFocus(hwndFocus);
|
|
}
|
|
break;
|
|
|
|
case ID_VIEWXML:
|
|
{
|
|
CXMLDialog XML;
|
|
|
|
if ( NULL != m_pCurrentRecord )
|
|
XML.BeginXMLView(m_pCurrentRecord,m_hWnd,FALSE);
|
|
else
|
|
XML.BeginXMLView(m_pListRecord,m_hWnd,TRUE);
|
|
}
|
|
break;
|
|
|
|
case ID_DATABASE_CREATENEWAPPHELPMESSAGE:
|
|
{
|
|
CAppHelpWizard wizAppHelp;
|
|
|
|
if ( wizAppHelp.BeginWizard(m_hWnd) ) {
|
|
g_theApp.GetDBLocal().m_bDirty = TRUE;
|
|
|
|
g_theApp.UpdateView(TRUE);
|
|
|
|
Update();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ID_ADDENTRY:
|
|
case ID_DATABASE_ADDANENTRY:
|
|
case DBCMD_FIXWIZARD:
|
|
{
|
|
CShimWizard Wiz;
|
|
|
|
if ( Wiz.BeginWizard(m_hWnd) ) {
|
|
g_theApp.GetDBLocal().m_bDirty = TRUE;
|
|
|
|
g_theApp.UpdateView(TRUE);
|
|
|
|
Update();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ID_EDIT_ENABLEDISABLEGLOBALLY:
|
|
case ID_DISABLEGLOBALLY:
|
|
case DBCMD_DISABLEGLOBAL:
|
|
{
|
|
|
|
if ( NULL == m_pCurrentRecord )
|
|
break;
|
|
|
|
//DWORD dwFlags = DialogBoxParam(g_hInstance,MAKEINTRESOURCE(IDD_DISABLE),m_hWnd,DisableDialog,(LPARAM) m_pCurrentRecord->dwGlobalFlags);
|
|
|
|
|
|
DWORD dwFlags = !m_pCurrentRecord->dwGlobalFlags;
|
|
|
|
//if (dwFlags != m_pCurrentRecord->dwGlobalFlags)
|
|
//{
|
|
// Save new flags
|
|
|
|
m_pCurrentRecord->dwGlobalFlags = dwFlags;
|
|
|
|
// Update the registry
|
|
|
|
CDatabase::SetEntryFlags(HKEY_LOCAL_MACHINE,m_pCurrentRecord->guidID,dwFlags);
|
|
|
|
// Refresh tree view
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,FALSE,0);
|
|
|
|
PDBRECORD pHoldCurrent = m_pCurrentRecord;
|
|
|
|
TreeView_DeleteAllItems(m_hTreeView);
|
|
|
|
PDBRECORD pRecord = m_pListRecord;
|
|
|
|
while ( NULL != pRecord ) {
|
|
AddRecordToTree(pRecord);
|
|
|
|
pRecord = pRecord->pDup;
|
|
}
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,TRUE,0);
|
|
|
|
InvalidateRect(m_hListView,NULL,TRUE);
|
|
UpdateWindow(m_hListView);
|
|
|
|
TreeView_SelectItem(m_hTreeView,NULL);
|
|
|
|
m_pCurrentRecord = pHoldCurrent;
|
|
|
|
SyncMenu();
|
|
//}
|
|
}
|
|
break;
|
|
|
|
case ID_EDIT_ENABLEDISABLELOCALLY:
|
|
case ID_DISABLEFORUSER:
|
|
case DBCMD_DISABLEUSER:
|
|
{
|
|
if ( NULL == m_pCurrentRecord )
|
|
break;
|
|
|
|
//DWORD dwFlags = DialogBoxParam(g_hInstance,MAKEINTRESOURCE(IDD_DISABLE),m_hWnd,DisableDialog,(LPARAM) m_pCurrentRecord->dwUserFlags | 0x80000000);
|
|
|
|
DWORD dwFlags = !m_pCurrentRecord->dwUserFlags;
|
|
|
|
//if (dwFlags != m_pCurrentRecord->dwUserFlags)
|
|
//{
|
|
// Save new flags
|
|
|
|
m_pCurrentRecord->dwUserFlags = dwFlags;
|
|
|
|
// Update the registry
|
|
|
|
CDatabase::SetEntryFlags(HKEY_CURRENT_USER,m_pCurrentRecord->guidID,dwFlags);
|
|
|
|
// Refresh tree view
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,FALSE,0);
|
|
|
|
PDBRECORD pHoldCurrent = m_pCurrentRecord;
|
|
|
|
TreeView_DeleteAllItems(m_hTreeView);
|
|
|
|
PDBRECORD pRecord = m_pListRecord;
|
|
|
|
while ( NULL != pRecord ) {
|
|
AddRecordToTree(pRecord);
|
|
|
|
pRecord = pRecord->pDup;
|
|
}
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,TRUE,0);
|
|
InvalidateRect(m_hListView,NULL,TRUE);
|
|
UpdateWindow(m_hListView);
|
|
|
|
TreeView_SelectItem(m_hTreeView,NULL);
|
|
|
|
m_pCurrentRecord = pHoldCurrent;
|
|
|
|
SyncMenu();
|
|
//}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CDBView::msgPaint(HDC hDC)
|
|
{
|
|
RECT rRect;
|
|
|
|
// Draw the slider bar
|
|
|
|
GetClientRect(m_hWnd,&rRect);
|
|
|
|
SetRect(&rRect,m_uListSize+1,0,m_uListSize + SLIDER_WIDTH - 1,rRect.bottom);
|
|
FillRect(hDC,&rRect,(HBRUSH) (COLOR_BTNFACE + 1));
|
|
|
|
SetRect(&rRect,m_uListSize-1,0,m_uListSize+1,rRect.bottom);
|
|
FillRect(hDC,&rRect,(HBRUSH) GetStockObject(WHITE_BRUSH));
|
|
|
|
SetRect(&rRect,m_uListSize+SLIDER_WIDTH - 1,0,m_uListSize + SLIDER_WIDTH + 1,rRect.bottom);
|
|
FillRect(hDC,&rRect,(HBRUSH) GetStockObject(GRAY_BRUSH));
|
|
|
|
|
|
// Draw horizontal bar.
|
|
|
|
SetRect(&rRect,0,m_uListHeight ,rRect.right,m_uListHeight + SLIDER_WIDTH - 1);
|
|
FillRect(hDC,&rRect,(HBRUSH) (COLOR_BTNFACE + 1));
|
|
|
|
SetRect(&rRect,0,m_uListHeight + SLIDER_WIDTH,rRect.right,m_uListHeight + SLIDER_WIDTH + 1);
|
|
FillRect(hDC,&rRect,(HBRUSH) GetStockObject(GRAY_BRUSH));
|
|
}
|
|
|
|
void CDBView::AddRecordToTree(PDBRECORD pRecord)
|
|
{
|
|
PDBENTRY pEntry;
|
|
HTREEITEM hRoot;
|
|
HTREEITEM hShim = NULL;
|
|
HTREEITEM hMatch = NULL;
|
|
HTREEITEM hAppHelp = NULL;
|
|
UINT uImage;
|
|
|
|
uImage = LookupFileImage(pRecord->szEXEName,IMAGE_APPLICATION);
|
|
|
|
// Add the main .EXE/.DLL or other file that's affected by this record.
|
|
|
|
if ( 0 != (pRecord->dwUserFlags | pRecord->dwGlobalFlags) )
|
|
uImage = IMAGE_WARNING;
|
|
|
|
hRoot = AddTreeItem(TVI_ROOT,
|
|
TVIF_TEXT | TVIF_STATE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
|
|
TVIS_EXPANDED,
|
|
pRecord->szEXEName,
|
|
uImage,
|
|
(LPARAM) pRecord);
|
|
/*
|
|
if (0 != pRecord->guidID.Data1)
|
|
{
|
|
TCHAR szGUID[80];
|
|
|
|
// NOTE: We could use StringFromGUID2, or StringfromIID, but that
|
|
// would require loading OLE32.DLL. Unless we have to, avoid it.
|
|
|
|
wsprintf(szGUID, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
|
|
pRecord->guidID.Data1,
|
|
pRecord->guidID.Data2,
|
|
pRecord->guidID.Data3,
|
|
pRecord->guidID.Data4[0],
|
|
pRecord->guidID.Data4[1],
|
|
pRecord->guidID.Data4[2],
|
|
pRecord->guidID.Data4[3],
|
|
pRecord->guidID.Data4[4],
|
|
pRecord->guidID.Data4[5],
|
|
pRecord->guidID.Data4[6],
|
|
pRecord->guidID.Data4[7]);
|
|
|
|
AddTreeItem( hRoot,
|
|
TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
|
|
0,
|
|
szGUID,
|
|
IMAGE_GUID);
|
|
}
|
|
*/
|
|
//
|
|
//The tree tip is done here
|
|
//
|
|
|
|
if ( 0 != pRecord->dwGlobalFlags ) {
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_UI;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
HTREEITEM hGlobal;
|
|
|
|
hGlobal = AddTreeItem( hRoot,
|
|
TVIF_TEXT | TVIF_STATE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
|
|
TVIS_EXPANDED,
|
|
TEXT("Disabled"),
|
|
IMAGE_DISABLEGLOBAL,
|
|
(LPARAM) pTip);
|
|
|
|
//WriteFlagsToTree(hGlobal,pRecord->dwGlobalFlags);
|
|
}
|
|
/*
|
|
if (0 != pRecord->dwUserFlags)
|
|
{
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_UI;
|
|
pTip->uContext = 3;
|
|
|
|
if (pRecord->bGlobal)
|
|
pTip->uContext = 2;
|
|
|
|
HTREEITEM hUser;
|
|
|
|
hUser = AddTreeItem(hRoot,
|
|
TVIF_TEXT | TVIF_STATE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
|
|
TVIS_EXPANDED,
|
|
"Disabled Locally",
|
|
IMAGE_DISABLEUSER,
|
|
(LPARAM) pTip);
|
|
|
|
//WriteFlagsToTree(hUser,pRecord->dwUserFlags);
|
|
}
|
|
*/
|
|
pEntry = pRecord->pEntries;
|
|
|
|
BOOL bHasMatch = FALSE;
|
|
BOOL bHasShim = FALSE;
|
|
BOOL bHasAppHelp = FALSE;
|
|
BOOL bHasLayer = FALSE;
|
|
|
|
while ( NULL != pEntry ) {
|
|
if ( ENTRY_MATCH == pEntry->uType )
|
|
bHasMatch = TRUE;
|
|
|
|
if ( ENTRY_SHIM == pEntry->uType )
|
|
bHasShim = TRUE;
|
|
|
|
if ( pRecord->szLayerName.Length() > 0 )
|
|
bHasLayer = TRUE;
|
|
|
|
if ( ENTRY_APPHELP == pEntry->uType )
|
|
bHasAppHelp = TRUE;
|
|
|
|
pEntry = pEntry->pNext;
|
|
}
|
|
|
|
if ( bHasAppHelp ) {
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_UI;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
hAppHelp = AddTreeItem( hRoot,
|
|
TVIF_TEXT | TVIF_STATE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
|
|
TVIS_EXPANDED,
|
|
TEXT("Application Help"),
|
|
IMAGE_APPHELP,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( bHasLayer ) {
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_UI;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
TCHAR szText[ MAX_PATH * 10 ];
|
|
|
|
wsprintf(szText,TEXT("Applied Compatibility Modes: %s"),pRecord->szLayerName);
|
|
|
|
hShim = AddTreeItem(hRoot,
|
|
TVIF_TEXT | TVIF_STATE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
|
|
TVIS_EXPANDED,
|
|
szText,
|
|
IMAGE_LAYERS,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( bHasShim ) {
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_UI;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
hShim = AddTreeItem(hRoot,
|
|
TVIF_TEXT | TVIF_STATE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM,
|
|
0,
|
|
TEXT("Applied Compatability Fixes"),
|
|
IMAGE_SHIM,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( bHasMatch ) {
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_UI;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
hMatch = AddTreeItem(hRoot,
|
|
TVIF_TEXT | TVIF_STATE | TVIF_PARAM,
|
|
0, //TVIS_EXPANDED,
|
|
TEXT("File Matching"),
|
|
0,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
pEntry = pRecord->pEntries;
|
|
|
|
while ( NULL != pEntry ) {
|
|
switch ( pEntry->uType ) {
|
|
case ENTRY_APPHELP:
|
|
{
|
|
PHELPENTRY pHelp = (PHELPENTRY) pEntry;
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
TCHAR * szText[]={ TEXT("None"),
|
|
TEXT("Non-Blocking"),
|
|
TEXT("Hard Block"),
|
|
TEXT("Minor Problem"),
|
|
TEXT("Reinstall application"),
|
|
TEXT("Version Sub"),
|
|
TEXT("Shim")};
|
|
|
|
pTip->uType = ENTRY_APPHELP;
|
|
pTip->pHelp = pHelp;
|
|
pTip->uContext = 0;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
AddTreeItem(hAppHelp,
|
|
TVIF_TEXT | TVIF_PARAM,
|
|
0,
|
|
szText[pHelp->uSeverity],
|
|
0,
|
|
(LPARAM) pTip);
|
|
}
|
|
break;
|
|
case ENTRY_SHIM:
|
|
{
|
|
PSHIMENTRY pShim = (PSHIMENTRY) pEntry;
|
|
PSHIMDESC pDesc;
|
|
HTREEITEM hShimName;
|
|
|
|
pDesc = g_theApp.GetDBGlobal().m_pShimList;
|
|
|
|
while ( NULL != pDesc ) {
|
|
if ( 0 == lstrcmpi(pDesc->szShimName,pShim->szShimName) )
|
|
break;
|
|
|
|
pDesc=pDesc->pNext;
|
|
}
|
|
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_SHIM;
|
|
pTip->pShim = pDesc;
|
|
pTip->uContext = 0;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
TCHAR szText[MAX_PATH * 10];
|
|
|
|
if ( NULL != pDesc ) {
|
|
if ( pDesc->bShim )
|
|
wsprintf(szText,TEXT("Compat Fix: %s"),pShim->szShimName);
|
|
else
|
|
wsprintf(szText,TEXT("Patch: %s"),pShim->szShimName);
|
|
} else
|
|
lstrcpy(szText,pShim->szShimName);
|
|
|
|
//
|
|
//Always look up the image or use the default image for all the shims. the foll 2 lines not required
|
|
//
|
|
//
|
|
//Also look for the include, exclude items.
|
|
|
|
if ( 0 == pShim->Entry.uIconID )
|
|
pShim->Entry.uIconID = LookupFileImage(pShim->szShimName,IMAGE_APPLICATION);
|
|
|
|
hShimName = AddTreeItem(hShim,
|
|
TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
|
|
0,
|
|
szText,
|
|
IMAGE_SHIM,//pShim->Entry.uIconID,
|
|
(LPARAM) pTip);
|
|
|
|
if ( lstrlen(pShim->szCmdLine) > 0 ) {
|
|
wsprintf(szText,TEXT("Command Line: %s"),(LPCTSTR) pShim->szCmdLine);
|
|
|
|
AddTreeItem(hShimName,
|
|
TVIF_TEXT,
|
|
0,
|
|
szText);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ENTRY_MATCH:
|
|
{
|
|
PMATCHENTRY pMatch = (PMATCHENTRY) pEntry;
|
|
TCHAR szText[MAX_PATH * 10];
|
|
HTREEITEM hFile = hMatch;
|
|
|
|
if ( lstrlen(pMatch->szMatchName) > 0 ) {
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_MATCH;
|
|
pTip->pMatch = pMatch;
|
|
pTip->uContext = 1;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
if ( TEXT('*') != *(LPCTSTR)pMatch->szMatchName )
|
|
wsprintf(szText,TEXT("Match File: %s"),pMatch->szMatchName);
|
|
else {
|
|
pTip->uContext = 3;
|
|
wsprintf(szText,TEXT("Match File: %s"),pRecord->szEXEName);
|
|
}
|
|
|
|
if ( 0 == pMatch->Entry.uIconID )
|
|
pMatch->Entry.uIconID = LookupFileImage(pMatch->szMatchName,IMAGE_APPLICATION);
|
|
|
|
hFile = AddTreeItem(hMatch,
|
|
TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
|
|
0,
|
|
szText,
|
|
pMatch->Entry.uIconID,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( lstrlen(pMatch->szDescription) > 0 ) {
|
|
wsprintf(szText,TEXT("Description: %s"),pMatch->szDescription);
|
|
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_SUBMATCH;
|
|
pTip->pMatch = pMatch;
|
|
pTip->uID = MATCH_DESCRIPTION;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
AddTreeItem(hFile,
|
|
TVIF_TEXT | TVIF_PARAM,
|
|
0,
|
|
szText,
|
|
0,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( lstrlen(pMatch->szCompanyName) > 0 ) {
|
|
wsprintf(szText,TEXT("Company Name: %s"),pMatch->szCompanyName);
|
|
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_SUBMATCH;
|
|
pTip->pMatch = pMatch;
|
|
pTip->uID = MATCH_COMPANY;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
AddTreeItem(hFile,
|
|
TVIF_TEXT | TVIF_PARAM,
|
|
0,
|
|
szText,
|
|
0,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( pMatch->dwSize > 0 ) {
|
|
DWORD dwSize = pMatch->dwSize;
|
|
TCHAR szSize[80];
|
|
|
|
FormatFileSize(pMatch->dwSize,szSize);
|
|
|
|
wsprintf(szText,TEXT("File Size: %s bytes"),szSize);
|
|
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_SUBMATCH;
|
|
pTip->pMatch = pMatch;
|
|
pTip->uID = MATCH_SIZE;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
AddTreeItem(hFile,
|
|
TVIF_TEXT | TVIF_PARAM,
|
|
0,
|
|
szText,
|
|
0,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( pMatch->dwChecksum > 0 ) {
|
|
wsprintf(szText,TEXT("Checksum: %08X"),pMatch->dwChecksum);
|
|
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_SUBMATCH;
|
|
pTip->pMatch = pMatch;
|
|
pTip->uID = MATCH_CHECKSUM;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
AddTreeItem(hFile,
|
|
TVIF_TEXT | TVIF_PARAM,
|
|
0,
|
|
szText,
|
|
0,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( lstrlen(pMatch->szProductVersion) > 0 ) {
|
|
wsprintf(szText,TEXT("Product Version: %s"),pMatch->szProductVersion);
|
|
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_SUBMATCH;
|
|
pTip->pMatch = pMatch;
|
|
pTip->uID = MATCH_PRODUCTVERSTRING;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
AddTreeItem(hFile,
|
|
TVIF_TEXT | TVIF_PARAM,
|
|
0,
|
|
szText,
|
|
0,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( lstrlen(pMatch->szFileVersion) > 0 ) {
|
|
wsprintf(szText,TEXT("File Version: %s"),pMatch->szFileVersion);
|
|
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_SUBMATCH;
|
|
pTip->pMatch = pMatch;
|
|
pTip->uID = MATCH_FILEVERSTRING;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
AddTreeItem(hFile,
|
|
TVIF_TEXT | TVIF_PARAM,
|
|
0,
|
|
szText,
|
|
0,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( pMatch->FileVersion.QuadPart > 0 ) {
|
|
wsprintf( szText,
|
|
TEXT("Binary File Version: %u.%u.%u.%u"),
|
|
HIWORD(pMatch->FileVersion.HighPart),
|
|
LOWORD(pMatch->FileVersion.HighPart),
|
|
HIWORD(pMatch->FileVersion.LowPart),
|
|
LOWORD(pMatch->FileVersion.LowPart));
|
|
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_SUBMATCH;
|
|
pTip->pMatch = pMatch;
|
|
pTip->uID = MATCH_FILEVERSION;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
AddTreeItem(hFile,
|
|
TVIF_TEXT | TVIF_PARAM,
|
|
0,
|
|
szText,
|
|
0,
|
|
(LPARAM) pTip);
|
|
}
|
|
|
|
if ( pMatch->ProductVersion.QuadPart > 0 ) {
|
|
wsprintf( szText,
|
|
TEXT("Binary Product Version: %u.%u.%u.%u"),
|
|
HIWORD(pMatch->ProductVersion.HighPart),
|
|
LOWORD(pMatch->ProductVersion.HighPart),
|
|
HIWORD(pMatch->ProductVersion.LowPart),
|
|
LOWORD(pMatch->ProductVersion.LowPart));
|
|
|
|
PDBTREETIP pTip = &m_TipList[m_uNextTip++];
|
|
|
|
pTip->uType = ENTRY_SUBMATCH;
|
|
pTip->pMatch = pMatch;
|
|
pTip->uID = MATCH_PRODUCTVERSION;
|
|
pTip->uContext = 3;
|
|
|
|
if ( pRecord->bGlobal )
|
|
pTip->uContext = 2;
|
|
|
|
AddTreeItem(hFile,
|
|
TVIF_TEXT | TVIF_PARAM,
|
|
0,
|
|
szText,
|
|
0,
|
|
(LPARAM) pTip);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
pEntry = pEntry->pNext;
|
|
}
|
|
}
|
|
|
|
void CDBView::msgChar(TCHAR chChar)
|
|
{
|
|
// send notifications to the list views to update their views.
|
|
|
|
m_GlobalList.msgChar(chChar);
|
|
m_LocalList.msgChar(chChar);
|
|
}
|
|
|
|
void CDBView::DeleteDBWithTree(HTREEITEM hItem)
|
|
{
|
|
HTREEITEM hHold = NULL;
|
|
TV_ITEM Item;
|
|
PDBRECORD pRecord;
|
|
HTREEITEM hParent = hItem;
|
|
|
|
// Lookup the current record.
|
|
|
|
while ( NULL != hParent ) {
|
|
hHold = hParent;
|
|
|
|
hParent = TreeView_GetParent(m_hTreeView,hParent);
|
|
}
|
|
|
|
//PREFAST
|
|
if ( hHold == NULL ) {
|
|
return;
|
|
}
|
|
|
|
Item.mask = TVIF_PARAM;
|
|
Item.hItem = hHold;
|
|
|
|
TreeView_GetItem(m_hTreeView,&Item);
|
|
|
|
pRecord = (PDBRECORD) Item.lParam;
|
|
|
|
if ( pRecord->bGlobal ) {
|
|
MessageBeep(MB_OK);
|
|
return;
|
|
}
|
|
|
|
g_theApp.GetDBLocal().m_bDirty = TRUE;
|
|
|
|
g_theApp.UpdateView(TRUE);
|
|
|
|
if ( hHold != hItem ) {
|
|
PDBENTRY pEntry;
|
|
PDBENTRY pWalk;
|
|
PDBENTRY pHold;
|
|
PDBTREETIP pTip;
|
|
|
|
Item.mask = TVIF_PARAM;
|
|
Item.hItem = hItem;
|
|
|
|
TreeView_GetItem(m_hTreeView,&Item);
|
|
|
|
// Delete only the entry information;
|
|
|
|
pTip = (PDBTREETIP) Item.lParam;
|
|
|
|
if ( NULL == pTip ) {
|
|
MessageBeep(MB_OK);
|
|
return;
|
|
}
|
|
|
|
if ( ENTRY_UI == pTip->uType )
|
|
return;
|
|
|
|
if ( ENTRY_SUBMATCH == pTip->uType ) {
|
|
PMATCHENTRY pMatch = pTip->pMatch;
|
|
|
|
switch ( pTip->uID ) {
|
|
case MATCH_NAME:
|
|
MessageBeep(MB_OK);
|
|
return;
|
|
|
|
case MATCH_SIZE:
|
|
pMatch->dwSize = 0;
|
|
break;
|
|
|
|
case MATCH_CHECKSUM:
|
|
pMatch->dwChecksum = 0;
|
|
break;
|
|
|
|
case MATCH_FILEVERSION:
|
|
pMatch->FileVersion.QuadPart = 0;
|
|
break;
|
|
|
|
case MATCH_PRODUCTVERSION:
|
|
pMatch->ProductVersion.QuadPart = 0;
|
|
break;
|
|
|
|
case MATCH_COMPANY:
|
|
pMatch->szCompanyName.Release();
|
|
break;
|
|
|
|
case MATCH_DESCRIPTION:
|
|
pMatch->szDescription.Release();
|
|
break;
|
|
|
|
case MATCH_FILEVERSTRING:
|
|
pMatch->szFileVersion.Release();
|
|
break;
|
|
|
|
case MATCH_PRODUCTVERSTRING:
|
|
pMatch->szProductVersion.Release();
|
|
break;
|
|
}
|
|
} else {
|
|
pEntry = (PDBENTRY) pTip->pShim;
|
|
|
|
pWalk = pRecord->pEntries;
|
|
|
|
while ( NULL != pWalk ) {
|
|
if ( pEntry == pWalk )
|
|
break;
|
|
|
|
pHold = pWalk;
|
|
pWalk = pWalk->pNext;
|
|
}
|
|
|
|
if ( NULL == pWalk )
|
|
return;
|
|
|
|
if ( ENTRY_MATCH == pEntry->uType ) {
|
|
// Cannot delete self reference
|
|
|
|
PMATCHENTRY pMatch = (PMATCHENTRY) pEntry;
|
|
|
|
if ( pMatch->szMatchName == TEXT("*") ) {
|
|
MessageBeep(MB_OK);
|
|
return;
|
|
}
|
|
} else {
|
|
MessageBeep(MB_OK);
|
|
return;
|
|
}
|
|
|
|
if ( pWalk == pRecord->pEntries )
|
|
pRecord->pEntries = pRecord->pEntries->pNext;
|
|
else
|
|
pHold->pNext = pEntry->pNext;
|
|
}
|
|
} else {
|
|
if ( DELRES_RECORDREMOVED == g_theApp.GetDBLocal().DeleteRecord(pRecord) )
|
|
Update();
|
|
}
|
|
|
|
TreeView_DeleteItem(m_hTreeView,hItem);
|
|
}
|
|
|
|
void CDBView::msgNotify(LPNMHDR pHdr)
|
|
{
|
|
switch ( pHdr->code ) {
|
|
case NM_KEYDOWN:
|
|
{
|
|
LPNMKEY pKey = (LPNMKEY) pHdr;
|
|
|
|
if ( VK_TAB == pKey->nVKey ) {
|
|
if ( pKey->hdr.hwndFrom == m_LocalList.m_hWnd ) {
|
|
SetFocus(m_hTreeView);
|
|
|
|
}
|
|
|
|
else if ( pKey->hdr.hwndFrom == m_GlobalList.m_hWnd ) {
|
|
SetFocus(m_hTreeView);
|
|
|
|
}
|
|
|
|
else if ( pKey->hdr.hwndFrom == m_hTreeView ) {
|
|
if (g_hWndLastFocus != NULL ) {
|
|
if (g_hWndLastFocus == m_LocalList.m_hWnd) SetFocus(m_GlobalList.m_hWnd);
|
|
|
|
|
|
else SetFocus(m_LocalList.m_hWnd);
|
|
|
|
|
|
}
|
|
else
|
|
SetFocus(m_LocalList.m_hWnd);
|
|
}//else if ( pKey->hdr.hwndFrom == m_hTreeView )
|
|
}//if ( VK_TAB == pKey->nVKey )
|
|
}
|
|
break;
|
|
|
|
case LVN_SELCHANGED:////This is a user defined NM. Here we are building the tree.....
|
|
|
|
{
|
|
PLISTVIEWNOTIFY plvn = (PLISTVIEWNOTIFY) pHdr;
|
|
|
|
if ( pHdr->hwndFrom == m_GlobalList.m_hWnd )
|
|
g_theApp.SetStatusText(2,CSTRING(TEXT("Read Only")));
|
|
else
|
|
g_theApp.SetStatusText(2,CSTRING(TEXT("")));
|
|
|
|
g_theApp.SetButtonState(DBCMD_DISABLEGLOBAL, 0);
|
|
g_theApp.SetButtonState(DBCMD_DISABLEUSER, 0);
|
|
|
|
// Update the tree view.
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,FALSE,0);
|
|
|
|
TreeView_DeleteAllItems(m_hTreeView);
|
|
|
|
PDBRECORD pRecord = (PDBRECORD) plvn->pData;
|
|
|
|
if ( m_pListRecord != pRecord )
|
|
m_pCurrentRecord = NULL;
|
|
|
|
m_pListRecord = pRecord;
|
|
|
|
UINT uFiles = 0;
|
|
|
|
m_uNextTip = 0;
|
|
|
|
while ( NULL != pRecord ) {
|
|
++uFiles;
|
|
|
|
AddRecordToTree(pRecord);
|
|
|
|
pRecord = pRecord->pDup;
|
|
}
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,TRUE,0);
|
|
UpdateWindow(m_hTreeView);
|
|
|
|
TCHAR szText[MAX_PATH * 10];
|
|
|
|
if (uFiles == 0)
|
|
lstrcpy(szText,TEXT("No affected file found"));
|
|
else
|
|
wsprintf(szText,TEXT("%d affected file(s) found associated with this application"),uFiles);
|
|
|
|
SetWindowText(g_theApp.m_hStatusBar,szText);
|
|
|
|
SyncMenu();
|
|
}
|
|
break;
|
|
|
|
case NM_SETFOCUS:
|
|
{
|
|
if ( pHdr->hwndFrom == m_GlobalList.m_hWnd ) {
|
|
m_GlobalList.ShowHilight(TRUE);
|
|
m_LocalList.ShowHilight(FALSE);
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,FALSE,0);
|
|
TreeView_DeleteAllItems(m_hTreeView);
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,TRUE,0);
|
|
|
|
UINT uEntry = m_GlobalList.GetSelectedEntry();
|
|
|
|
if ( -1 != uEntry ) {
|
|
m_pListRecord = (PDBRECORD)m_GlobalList.GetEntryData(uEntry);
|
|
RefreshTree();
|
|
} else
|
|
m_pListRecord = NULL;
|
|
|
|
m_pCurrentRecord = NULL;
|
|
|
|
SyncMenu();
|
|
}
|
|
|
|
if ( pHdr->hwndFrom == m_LocalList.m_hWnd ) {
|
|
m_GlobalList.ShowHilight(FALSE);
|
|
m_LocalList.ShowHilight(TRUE);
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,FALSE,0);
|
|
TreeView_DeleteAllItems(m_hTreeView);
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,TRUE,0);
|
|
|
|
UINT uEntry = m_LocalList.GetSelectedEntry();
|
|
|
|
if ( -1 != uEntry ) {
|
|
m_pListRecord = (PDBRECORD)m_LocalList.GetEntryData(uEntry);
|
|
RefreshTree();
|
|
} else
|
|
m_pListRecord = NULL;
|
|
|
|
m_pCurrentRecord = NULL;
|
|
|
|
SyncMenu();
|
|
}
|
|
|
|
if ( pHdr->hwndFrom == m_GlobalList.m_hWnd )
|
|
g_theApp.SetStatusText(2,CSTRING(TEXT("Read Only")));
|
|
else if ( pHdr->hwndFrom == m_LocalList.m_hWnd )
|
|
g_theApp.SetStatusText(2,CSTRING(TEXT("")));
|
|
|
|
PDBRECORD pRecord = m_pListRecord;
|
|
|
|
UINT uFiles = 0;
|
|
|
|
while ( NULL != pRecord ) {
|
|
++uFiles;
|
|
|
|
pRecord = pRecord->pDup;
|
|
}
|
|
|
|
TCHAR szText[MAX_PATH * 10];
|
|
|
|
if (uFiles == 0)
|
|
lstrcpy(szText,TEXT("No affected file found"));
|
|
else
|
|
wsprintf(szText,TEXT("%d affected file(s) found associated with this application."),uFiles);
|
|
|
|
SetWindowText(g_theApp.m_hStatusBar,szText);
|
|
}
|
|
break;
|
|
|
|
case NM_RCLICK:
|
|
{
|
|
if ( pHdr->hwndFrom == m_hTreeView ) {
|
|
|
|
#ifdef __DEBUG
|
|
MessageBox(NULL,TEXT("NM_RCLICK"),TEXT("NM_RCLICK"),MB_OK);
|
|
|
|
#endif
|
|
TVHITTESTINFO ht;
|
|
|
|
GetCursorPos(&ht.pt);
|
|
ScreenToClient(m_hTreeView, &ht.pt);
|
|
|
|
TreeView_HitTest(m_hTreeView,&ht);
|
|
|
|
if ( 0 != ht.hItem ){
|
|
g_do_notProcess = TRUE;
|
|
TreeView_SelectItem(m_hTreeView,NULL);
|
|
g_do_notProcess = FALSE;
|
|
TreeView_SelectItem(m_hTreeView,ht.hItem);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TVN_KEYDOWN:
|
|
{
|
|
LPNMTVKEYDOWN pKey = (LPNMTVKEYDOWN) pHdr;
|
|
|
|
switch ( pKey->wVKey ) {
|
|
case VK_DELETE:
|
|
{
|
|
DeleteDBWithTree(m_hSelectedItem);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case TVN_SELCHANGED:
|
|
{
|
|
|
|
//MessageBox(NULL,NULL,NULL,MB_OK);
|
|
if (g_do_notProcess) {
|
|
break;
|
|
}
|
|
|
|
LPNMTREEVIEW pItem = (LPNMTREEVIEW) pHdr;
|
|
|
|
if ( pItem == NULL ) {
|
|
break;
|
|
}
|
|
|
|
BOOL bEnabled = FALSE;
|
|
HTREEITEM hItem = TreeView_GetParent(m_hTreeView,pItem->itemNew.hItem);
|
|
HTREEITEM hHold = pItem->itemNew.hItem;
|
|
TV_ITEM Item;
|
|
PDBTREETIP pTip = (PDBTREETIP) pItem->itemNew.lParam;
|
|
|
|
m_hSelectedItem = pItem->itemNew.hItem;
|
|
|
|
// Lookup the current record.
|
|
|
|
while ( NULL != hItem ) {
|
|
hHold = hItem;
|
|
|
|
hItem = TreeView_GetParent(m_hTreeView,hItem);
|
|
}
|
|
|
|
// Determine which context menu to use.
|
|
|
|
// Root level item.
|
|
|
|
if ( pItem->itemNew.hItem == hHold )
|
|
m_uContext = 0;
|
|
else
|
|
if ( NULL != pTip )
|
|
m_uContext = pTip->uContext;
|
|
else
|
|
m_uContext = 0;
|
|
|
|
Item.mask = TVIF_PARAM;
|
|
Item.hItem = hHold;
|
|
|
|
TreeView_GetItem(m_hTreeView,&Item);
|
|
|
|
//
|
|
//The m_pCurrentRecord is changed here !!
|
|
//
|
|
|
|
|
|
|
|
|
|
m_pCurrentRecord = (PDBRECORD) Item.lParam;
|
|
|
|
#ifdef __DEBUG
|
|
CSTRING message;
|
|
|
|
message.sprintf(
|
|
TEXT("%s : % u Message: = %u"),
|
|
TEXT(__FILE__),
|
|
__LINE__,
|
|
TEXT("m_pCurrentRecord"),
|
|
m_pCurrentRecord
|
|
);
|
|
|
|
MessageBox(NULL,message,TEXT("Inside TVN_SELCHANGED/NM_RCLICK"),MB_OK);
|
|
#endif
|
|
|
|
|
|
if ( NULL != m_pCurrentRecord ) {
|
|
g_theApp.SetButtonState(DBCMD_DISABLEGLOBAL,TBSTATE_ENABLED);
|
|
g_theApp.SetButtonState(DBCMD_DISABLEUSER,TBSTATE_ENABLED);
|
|
|
|
if ( m_pCurrentRecord->bGlobal )
|
|
m_uContext = 2;
|
|
} else {
|
|
g_theApp.SetButtonState(DBCMD_DISABLEGLOBAL, 0);
|
|
g_theApp.SetButtonState(DBCMD_DISABLEUSER, 0);
|
|
}
|
|
|
|
SyncMenu();
|
|
}
|
|
break;
|
|
|
|
case LVN_ITEMCHANGED:
|
|
{
|
|
g_theApp.SetButtonState(DBCMD_DISABLEGLOBAL, 0);
|
|
g_theApp.SetButtonState(DBCMD_DISABLEUSER, 0);
|
|
|
|
// Update the tree view.
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,FALSE,0);
|
|
|
|
TreeView_DeleteAllItems(m_hTreeView);
|
|
|
|
LPNMLISTVIEW pList = (LPNMLISTVIEW) pHdr;
|
|
PDBRECORD pRecord = (PDBRECORD) pList->lParam;
|
|
|
|
if ( m_pListRecord != pRecord )
|
|
m_pCurrentRecord = NULL;
|
|
|
|
m_pListRecord = pRecord;
|
|
|
|
UINT uFiles = 0;
|
|
|
|
m_uNextTip = 0;
|
|
|
|
do {
|
|
++uFiles;
|
|
|
|
AddRecordToTree(pRecord);
|
|
|
|
pRecord = pRecord->pDup;
|
|
}
|
|
while ( NULL != pRecord );
|
|
|
|
SendMessage(m_hTreeView,WM_SETREDRAW,TRUE,0);
|
|
UpdateWindow(m_hTreeView);
|
|
|
|
SyncMenu();
|
|
|
|
TCHAR szText[MAX_PATH * 10];
|
|
|
|
wsprintf(szText,TEXT("%d files affected"),uFiles);
|
|
|
|
SetWindowText(g_theApp.m_hStatusBar,szText);
|
|
}
|
|
break;
|
|
|
|
case TBN_GETINFOTIP:
|
|
{
|
|
LPNMTBGETINFOTIP pTip = (LPNMTBGETINFOTIP) pHdr;
|
|
static TCHAR * szTips[] = { TEXT("Properties"),
|
|
TEXT("Delete Entry"),
|
|
TEXT("Enable/Disable for user"),
|
|
TEXT("Enable/Disable global"),
|
|
TEXT("View Shims"),
|
|
TEXT("View Application Help"),
|
|
TEXT("Application Fix Wizard"),
|
|
TEXT("View Global Database"),
|
|
TEXT("View Patches"),
|
|
TEXT("View Compatibility Modes"),
|
|
TEXT("View Disabled")};
|
|
|
|
switch ( pTip->iItem ) {
|
|
case DBCMD_PROPERTIES:
|
|
case DBCMD_DELETE:
|
|
case DBCMD_DISABLEUSER:
|
|
case DBCMD_DISABLEGLOBAL:
|
|
case DBCMD_VIEWSHIMS:
|
|
case DBCMD_VIEWAPPHELP:
|
|
case DBCMD_FIXWIZARD:
|
|
case DBCMD_VIEWPATCH:
|
|
case DBCMD_VIEWLAYERS:
|
|
case DBCMD_VIEWDISABLED:
|
|
lstrcpy(pTip->pszText,szTips[pTip->iItem - DBCMD_PROPERTIES]);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TVN_GETINFOTIP:
|
|
{
|
|
LPNMTVGETINFOTIP pTip = (LPNMTVGETINFOTIP) pHdr;
|
|
|
|
*(pTip->pszText) = 0;
|
|
|
|
GenerateTreeToolTip((PDBTREETIP) pTip->lParam,pTip->pszText);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
LRESULT CDBView::MsgProc(UINT uMsg,WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch ( uMsg ) {
|
|
case WM_LBUTTONDOWN:
|
|
{
|
|
SetCapture(m_hWnd);
|
|
|
|
if ( LOWORD(lParam) > m_uListSize - SLIDER_WIDTH/2 ) {
|
|
m_uCapturePos = LOWORD(lParam);
|
|
m_bHorzDrag = TRUE;
|
|
} else {
|
|
m_uCapturePos = HIWORD(lParam);
|
|
m_bHorzDrag = FALSE;
|
|
}
|
|
|
|
m_bDrag = TRUE;
|
|
}
|
|
break;
|
|
|
|
case WM_CONTEXTMENU:
|
|
{
|
|
|
|
UINT uX = LOWORD(lParam);
|
|
UINT uY = HIWORD(lParam);
|
|
HWND hWnd = (HWND) wParam;
|
|
|
|
if ( hWnd == m_hTreeView ) {
|
|
|
|
#ifdef __DEBUG
|
|
MessageBox(NULL,TEXT("WM_CONTEXT"),TEXT("WM_CONTEXT"),MB_OK);
|
|
#endif
|
|
|
|
TVHITTESTINFO ht;
|
|
|
|
GetCursorPos(&ht.pt);
|
|
ScreenToClient(m_hTreeView, &ht.pt);
|
|
|
|
TreeView_HitTest(m_hTreeView,&ht);
|
|
|
|
if ( 0 != ht.hItem ) {
|
|
TVITEM Item;
|
|
|
|
Item.mask = TVIF_PARAM;
|
|
Item.hItem = ht.hItem;
|
|
TreeView_GetItem(m_hTreeView,&Item);
|
|
|
|
HTREEITEM hParent = TreeView_GetParent(m_hTreeView,ht.hItem);
|
|
|
|
HMENU hMenu = LoadMenu(g_hInstance,MAKEINTRESOURCE(IDR_DBVCONTEXT1));
|
|
HMENU hContext = NULL;
|
|
|
|
if ( NULL == hParent ) {
|
|
PDBRECORD pRecord = (PDBRECORD) Item.lParam;
|
|
|
|
if ( pRecord->bGlobal )
|
|
hContext = GetSubMenu(hMenu,2);
|
|
else
|
|
hContext = GetSubMenu(hMenu,3);
|
|
} else {
|
|
PDBTREETIP pTip = (PDBTREETIP) Item.lParam;
|
|
|
|
if ( NULL != pTip )
|
|
hContext = GetSubMenu(hMenu,pTip->uContext);
|
|
}
|
|
|
|
if ( hContext == NULL ) { //prefast
|
|
break;
|
|
}
|
|
|
|
if ( NULL != m_pCurrentRecord ) {
|
|
MENUITEMINFO Info;
|
|
|
|
Info.cbSize = sizeof(MENUITEMINFO);
|
|
Info.fMask = MIIM_STRING;
|
|
/*
|
|
if (0 == m_pCurrentRecord->dwUserFlags)
|
|
Info.dwTypeData = "Disable for User";
|
|
else
|
|
Info.dwTypeData = "Enable for User";
|
|
|
|
SetMenuItemInfo(hContext,ID_DISABLEFORUSER,MF_BYCOMMAND,&Info);
|
|
*/
|
|
if ( 0 == m_pCurrentRecord->dwGlobalFlags )
|
|
Info.dwTypeData = TEXT("Disable Entry");
|
|
else
|
|
Info.dwTypeData = TEXT("Enable Entry");
|
|
|
|
SetMenuItemInfo(hContext,ID_DISABLEGLOBALLY,MF_BYCOMMAND,&Info);
|
|
}
|
|
|
|
|
|
|
|
TrackPopupMenuEx(hContext,
|
|
TPM_LEFTALIGN | TPM_TOPALIGN,
|
|
uX,
|
|
uY,
|
|
m_hWnd,
|
|
NULL);
|
|
|
|
DestroyMenu(hMenu);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
m_bDrag = FALSE;
|
|
ReleaseCapture();
|
|
break;
|
|
|
|
case WM_MOUSEMOVE:
|
|
{
|
|
if ( LOWORD(lParam) > m_uListSize - SLIDER_WIDTH/2 )
|
|
SetCursor(LoadCursor(NULL,IDC_SIZEWE));
|
|
else
|
|
SetCursor(LoadCursor(NULL,IDC_SIZENS));
|
|
|
|
if ( 0 != (wParam & MK_LBUTTON) && m_bDrag ) {
|
|
RECT rRect;
|
|
short int nX = (short int) LOWORD(lParam);
|
|
short int nY = (short int) HIWORD(lParam);
|
|
|
|
if ( m_bHorzDrag )
|
|
m_uListSize = m_uCapturePos + (nX - m_uCapturePos);
|
|
else
|
|
m_uListHeight = m_uCapturePos + (nY - m_uCapturePos);
|
|
|
|
GetClientRect(m_hWnd,&rRect);
|
|
|
|
if ( (int)m_uListHeight < 100 )
|
|
m_uListHeight = 100;
|
|
|
|
if ( (int)m_uListSize < 100 )
|
|
m_uListSize = 100;
|
|
|
|
if ( (int)m_uListHeight > (int)(rRect.bottom * 0.75f) )
|
|
m_uListHeight = (UINT)(rRect.bottom * 0.75f);
|
|
|
|
if ( (int)m_uListSize > (int)(rRect.right * 0.75f) )
|
|
m_uListSize = (UINT)(rRect.right * 0.75f);
|
|
|
|
msgResize(rRect.right,rRect.bottom);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_DRAWITEM:
|
|
|
|
{
|
|
|
|
//***Probably this is never called.
|
|
|
|
|
|
LPDRAWITEMSTRUCT pDraw = (LPDRAWITEMSTRUCT) lParam;
|
|
LV_ITEM Item;
|
|
HDC hDC = CreateCompatibleDC(pDraw->hDC);
|
|
HBITMAP hBmp = CreateCompatibleBitmap(pDraw->hDC,pDraw->rcItem.right - pDraw->rcItem.left,pDraw->rcItem.bottom - pDraw->rcItem.top);
|
|
HBITMAP hOldBmp = (HBITMAP) SelectObject(hDC,hBmp);
|
|
RECT rBmpRect;
|
|
HFONT hFont = (HFONT) SendMessage(m_hListView,WM_GETFONT,0,0);
|
|
HBRUSH hFillBrush = GetSysColorBrush(COLOR_WINDOW);
|
|
|
|
hFont = (HFONT) SelectObject(hDC,hFont);
|
|
|
|
SetRect(&rBmpRect,0,0,pDraw->rcItem.right - pDraw->rcItem.left,pDraw->rcItem.bottom - pDraw->rcItem.top);
|
|
|
|
Item.mask = LVIF_PARAM;
|
|
Item.iItem = pDraw->itemID;
|
|
Item.iSubItem = 0;
|
|
|
|
LV_COLUMN Col;
|
|
|
|
Col.mask = LVCF_WIDTH;
|
|
|
|
ListView_GetColumn(m_hListView,0,&Col);
|
|
|
|
Col.cx = pDraw->rcItem.right;
|
|
|
|
ListView_GetItem(m_hListView,&Item);
|
|
|
|
pDraw->rcItem.right = m_uListSize;
|
|
|
|
if ( 0 != (pDraw->itemState & ODS_FOCUS) ) {
|
|
//FillRect(pDraw->hDC,&pDraw->rcItem,GetSysColorBrush(COLOR_HIGHLIGHT));
|
|
FillRect(hDC,&rBmpRect,GetSysColorBrush(COLOR_HIGHLIGHT));
|
|
SetBkColor(hDC,GetSysColor(COLOR_HIGHLIGHT));
|
|
|
|
} else
|
|
if ( 0 == pDraw->itemID % 2 ) {
|
|
//FillRect(pDraw->hDC,&pDraw->rcItem,(HBRUSH) GetStockObject(WHITE_BRUSH));
|
|
FillRect(hDC,&rBmpRect,(HBRUSH) GetStockObject(WHITE_BRUSH));
|
|
|
|
SetBkColor(hDC,RGB(255,255,255));
|
|
} else {
|
|
//FillRect(pDraw->hDC,&pDraw->rcItem,hFillBrush);
|
|
FillRect(hDC,&rBmpRect,hFillBrush);
|
|
SetBkColor(hDC,RGB(235,235,235));
|
|
}
|
|
|
|
//SelectObject(pDraw->hDC,(HPEN) GetStockObject(BLACK_PEN));
|
|
SelectObject(hDC,(HPEN) GetStockObject(BLACK_PEN));
|
|
|
|
//MoveToEx(pDraw->hDC,Col.cx-1,pDraw->rcItem.top,NULL);
|
|
//LineTo(pDraw->hDC,Col.cx-1,pDraw->rcItem.bottom);
|
|
|
|
MoveToEx(hDC,Col.cx-1,0,NULL);
|
|
LineTo(hDC,Col.cx-1,rBmpRect.bottom);
|
|
|
|
//MoveToEx(pDraw->hDC,pDraw->rcItem.left,pDraw->rcItem.bottom-1,NULL);
|
|
//LineTo(pDraw->hDC,pDraw->rcItem.right,pDraw->rcItem.bottom-1);
|
|
|
|
MoveToEx(hDC,0,rBmpRect.bottom-1,NULL);
|
|
LineTo(hDC,rBmpRect.right,rBmpRect.bottom-1);
|
|
|
|
// Draw the actual name.
|
|
|
|
PDBRECORD pRecord = (PDBRECORD) Item.lParam;
|
|
|
|
//pDraw->rcItem.right = Col.cx - 2;
|
|
//pDraw->rcItem.bottom --;
|
|
|
|
BOOL bDisableUser = FALSE;
|
|
BOOL bDisableGlobal = FALSE;
|
|
BOOL bShim = FALSE;
|
|
BOOL bHelp = FALSE;
|
|
|
|
PDBRECORD pWalk = pRecord;
|
|
|
|
while ( NULL != pWalk ) {
|
|
if ( 0 != pWalk->dwUserFlags )
|
|
bDisableUser = TRUE;
|
|
|
|
if ( 0 != pWalk->dwGlobalFlags )
|
|
bDisableGlobal = TRUE;
|
|
|
|
PDBENTRY pEntry = pWalk->pEntries;
|
|
|
|
while ( NULL != pEntry ) {
|
|
if ( ENTRY_SHIM == pEntry->uType )
|
|
bShim = TRUE;
|
|
|
|
if ( ENTRY_APPHELP == pEntry->uType )
|
|
bHelp = TRUE;
|
|
|
|
pEntry = pEntry->pNext;
|
|
}
|
|
|
|
pWalk = pWalk->pDup;
|
|
}
|
|
|
|
{
|
|
HDC hBmpDC = CreateCompatibleDC(hDC);
|
|
HBITMAP hOldBmp = (HBITMAP) SelectObject(hBmpDC,g_theApp.m_hToolBitmap);
|
|
UINT uIndex;
|
|
|
|
if ( bShim )
|
|
uIndex = IMAGE_SHIM;
|
|
|
|
if ( bHelp )
|
|
uIndex = IMAGE_APPHELP;
|
|
|
|
if ( bDisableGlobal | bDisableUser ) {
|
|
uIndex = IMAGE_WARNING;
|
|
SetTextColor(hDC,RGB(128,128,128));
|
|
}
|
|
|
|
// Draw the appropriate bitmap
|
|
|
|
UINT uSize = pDraw->rcItem.bottom - pDraw->rcItem.top;
|
|
|
|
if ( IMAGE_SHIM != uIndex )
|
|
StretchBlt( hDC,
|
|
3,0,
|
|
uSize - 1, uSize - 1,
|
|
hBmpDC,
|
|
16 * uIndex,0,
|
|
16,16,
|
|
SRCCOPY);
|
|
|
|
SelectObject(hBmpDC,hOldBmp);
|
|
DeleteDC(hBmpDC);
|
|
}
|
|
|
|
LPTSTR szText = pRecord->szAppName;
|
|
|
|
if ( 0 == lstrlen(szText) )
|
|
szText = pRecord->szEXEName;
|
|
|
|
//ExtTextOut(pDraw->hDC,pDraw->rcItem.left + 20, pDraw->rcItem.top, ETO_OPAQUE | ETO_CLIPPED, &pDraw->rcItem, szText, lstrlen(szText), NULL);
|
|
|
|
RECT rClipRect = rBmpRect;
|
|
|
|
rClipRect.left = 20;
|
|
rClipRect.right = Col.cx - 2;
|
|
--rClipRect.bottom;
|
|
|
|
ExtTextOut( hDC,
|
|
20, 0,
|
|
ETO_OPAQUE | ETO_CLIPPED,
|
|
&rClipRect,
|
|
szText, lstrlen(szText),
|
|
NULL);
|
|
|
|
BitBlt( pDraw->hDC,
|
|
pDraw->rcItem.left,
|
|
pDraw->rcItem.top,
|
|
(pDraw->rcItem.right - pDraw->rcItem.left),
|
|
(pDraw->rcItem.bottom - pDraw->rcItem.top)+1,
|
|
hDC,
|
|
0,0,
|
|
SRCCOPY);
|
|
|
|
SelectObject(hDC,hOldBmp);
|
|
SelectObject(hDC,hFont);
|
|
|
|
DeleteObject(hBmp);
|
|
DeleteDC(hDC);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return CView::MsgProc(uMsg,wParam,lParam);
|
|
}
|
|
|
|
void CDBView::GenerateTreeToolTip(PDBTREETIP pTip, LPTSTR szText)
|
|
{
|
|
if ( NULL != pTip )
|
|
switch ( pTip->uType ) {
|
|
case ENTRY_SHIM:
|
|
{
|
|
PSHIMDESC pShim = pTip->pShim;
|
|
|
|
if (NULL == pShim ) {
|
|
return;
|
|
}
|
|
|
|
if ( 0 != pShim->szShimDesc.Length() ){
|
|
lstrcpy(szText,pShim->szShimDesc);
|
|
|
|
}else{
|
|
|
|
if (pShim->bGeneral == false) {
|
|
|
|
lstrcpy(szText,TEXT("No description available"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
case ENTRY_APPHELP:
|
|
{
|
|
PHELPENTRY pHelp = pTip->pHelp;
|
|
TCHAR * szToolHelp[] = {
|
|
TEXT("No application help is available. Nothing will be done."),
|
|
TEXT("An update may be available for the application.\nThis application will execute."),
|
|
TEXT("This application is not allowed to execute\non this machine."),
|
|
TEXT("This application will run with minor problems."),
|
|
TEXT("The application needs to be reinstalled."),
|
|
TEXT("Versionsub"),
|
|
TEXT("Shim")};
|
|
|
|
if ( NULL != pHelp )
|
|
lstrcpy(szText,szToolHelp[pHelp->uSeverity]);
|
|
}
|
|
break;
|
|
|
|
case ENTRY_MATCH:
|
|
{
|
|
PMATCHENTRY pMatch = pTip->pMatch;
|
|
TCHAR szTemp[1024];
|
|
|
|
wsprintf(szText,TEXT("Match File: %s\n"),pMatch->szMatchName);
|
|
|
|
if ( lstrlen(pMatch->szDescription) > 0 ) {
|
|
wsprintf(szTemp,TEXT("Description: %s\n"),pMatch->szDescription);
|
|
lstrcat(szText,szTemp);
|
|
}
|
|
|
|
if ( lstrlen(pMatch->szCompanyName) > 0 ) {
|
|
wsprintf(szTemp,TEXT("Company Name: %s\n"),pMatch->szCompanyName);
|
|
lstrcat(szText,szTemp);
|
|
}
|
|
|
|
if ( pMatch->dwSize > 0 ) {
|
|
TCHAR szSize[80];
|
|
|
|
FormatFileSize(pMatch->dwSize,szSize);
|
|
|
|
wsprintf(szTemp,TEXT("File Size: %s bytes\n"),szSize);
|
|
lstrcat(szText,szTemp);
|
|
}
|
|
|
|
if ( pMatch->dwChecksum > 0 ) {
|
|
wsprintf(szTemp,TEXT("Checksum: %08X\n"),pMatch->dwChecksum);
|
|
lstrcat(szText,szTemp);
|
|
}
|
|
|
|
if ( lstrlen(pMatch->szProductVersion) > 0 ) {
|
|
wsprintf(szTemp,TEXT("Product Version: %s\n"),pMatch->szProductVersion);
|
|
lstrcat(szText,szTemp);
|
|
}
|
|
|
|
if ( lstrlen(pMatch->szFileVersion) > 0 ) {
|
|
wsprintf(szTemp,TEXT("File Version: %s\n"),pMatch->szFileVersion);
|
|
lstrcat(szText,szTemp);
|
|
}
|
|
if ( pMatch->FileVersion.QuadPart > 0 ) {
|
|
wsprintf( szTemp,
|
|
TEXT("File Version: %u.%04u.%04u.%04u\n"),
|
|
HIWORD(pMatch->FileVersion.HighPart),
|
|
LOWORD(pMatch->FileVersion.HighPart),
|
|
HIWORD(pMatch->FileVersion.LowPart),
|
|
LOWORD(pMatch->FileVersion.LowPart));
|
|
|
|
lstrcat(szText,szTemp);
|
|
}
|
|
if ( pMatch->ProductVersion.QuadPart > 0 ) {
|
|
wsprintf( szTemp,
|
|
TEXT("Product Version: %u.%04u.%04u.%04u\n"),
|
|
HIWORD(pMatch->ProductVersion.HighPart),
|
|
LOWORD(pMatch->ProductVersion.HighPart),
|
|
HIWORD(pMatch->ProductVersion.LowPart),
|
|
LOWORD(pMatch->ProductVersion.LowPart));
|
|
|
|
lstrcat(szText,szTemp);
|
|
}
|
|
|
|
// Terminate 1 character early... effectively removing
|
|
// the very last <CR>.
|
|
|
|
szText[lstrlen(szText)-1] = 0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void FormatFileSize(UINT uSize, LPTSTR szText)
|
|
{
|
|
DWORD dwSize = uSize;
|
|
DWORD dwMax = 1000000000;
|
|
BOOL bFirst = TRUE;
|
|
|
|
szText[0] = 0;
|
|
|
|
while ( dwSize > 0 ) {
|
|
if ( dwSize / dwMax > 0 ) {
|
|
TCHAR szTemp[5];
|
|
|
|
if ( bFirst )
|
|
wsprintf(szTemp,TEXT("%d,"),dwSize/dwMax);
|
|
else
|
|
wsprintf(szTemp,TEXT("%03d,"),dwSize/dwMax);
|
|
|
|
bFirst = FALSE;
|
|
|
|
lstrcat(szText,szTemp);
|
|
}
|
|
|
|
dwSize -= (dwSize / dwMax) * dwMax;
|
|
dwMax /= 1000;
|
|
}
|
|
|
|
szText[lstrlen(szText)-1] = 0;
|
|
}
|
|
|
|
void FormatVersion(LARGE_INTEGER liVer, LPTSTR szText)
|
|
{
|
|
wsprintf( szText,
|
|
TEXT("%u.%u.%u.%u"),
|
|
HIWORD(liVer.HighPart),
|
|
LOWORD(liVer.HighPart),
|
|
HIWORD(liVer.LowPart),
|
|
LOWORD(liVer.LowPart));
|
|
}
|
|
|
|
HTREEITEM CDBView::AddTreeItem(HTREEITEM hParent,DWORD dwFlags,DWORD dwState,LPCTSTR szText,UINT uImage, LPARAM lParam)
|
|
{
|
|
TVINSERTSTRUCT Item;
|
|
|
|
Item.hParent = hParent;
|
|
Item.hInsertAfter = TVI_LAST;
|
|
Item.item.mask = dwFlags;
|
|
Item.item.stateMask = dwState;
|
|
Item.item.state = dwState;
|
|
Item.item.pszText = (LPTSTR) szText;
|
|
Item.item.cchTextMax = lstrlen(Item.item.pszText);
|
|
Item.item.iImage = uImage;
|
|
Item.item.iSelectedImage = Item.item.iImage;
|
|
Item.item.lParam = lParam;
|
|
|
|
return TreeView_InsertItem(m_hTreeView,&Item);
|
|
}
|
|
|
|
UINT CDBView::LookupFileImage(LPCTSTR szFilename, UINT uDefault)
|
|
{
|
|
return uDefault;
|
|
|
|
SHFILEINFO Info;
|
|
HIMAGELIST hList;
|
|
UINT uImage;
|
|
|
|
ZeroMemory(&Info,sizeof(Info));
|
|
|
|
hList = (HIMAGELIST) SHGetFileInfo(szFilename,FILE_ATTRIBUTE_NORMAL,&Info,sizeof(Info),SHGFI_ICON | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES);
|
|
|
|
if ( NULL != hList ) {
|
|
if ( 0 == m_uImageRedirector[Info.iIcon] )
|
|
m_uImageRedirector[Info.iIcon] = ImageList_AddIcon(m_hImageList,Info.hIcon);
|
|
|
|
uImage = m_uImageRedirector[Info.iIcon];
|
|
} else
|
|
uImage = uDefault;
|
|
|
|
return uImage;
|
|
}
|
|
|
|
void CDBView::WriteFlagsToTree(HTREEITEM hParent, DWORD dwFlags)
|
|
{
|
|
|
|
//
|
|
// NOT USED ANYWHERE !!!
|
|
//
|
|
if ( 0 != (dwFlags & SHIMREG_DISABLE_SHIM) ) {
|
|
AddTreeItem(hParent,
|
|
TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
|
|
0,
|
|
TEXT("Disable Shims"),
|
|
IMAGE_WARNING);
|
|
}
|
|
|
|
if ( 0 != (dwFlags & SHIMREG_DISABLE_APPHELP) ) {
|
|
AddTreeItem(hParent,
|
|
TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
|
|
0,
|
|
TEXT("Disable App Help"),
|
|
IMAGE_WARNING);
|
|
}
|
|
|
|
if ( 0 != (dwFlags & SHIMREG_DISABLE_LAYER) ) {
|
|
AddTreeItem(hParent,
|
|
TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
|
|
0,
|
|
TEXT("Disable Layer"),
|
|
IMAGE_WARNING);
|
|
}
|
|
|
|
if ( 0 != (dwFlags & SHIMREG_APPHELP_NOUI) ) {
|
|
AddTreeItem(hParent,
|
|
TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
|
|
0,
|
|
TEXT("Disable UI"),
|
|
IMAGE_WARNING);
|
|
}
|
|
|
|
}
|
|
|
|
BOOL CALLBACK DisableDialog(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch ( uMsg ) {
|
|
case WM_INITDIALOG:
|
|
{
|
|
SetWindowLongPtr(hDlg,GWLP_USERDATA,lParam);
|
|
|
|
if ( 0 != (lParam & SHIMREG_DISABLE_SHIM) )
|
|
SendDlgItemMessage(hDlg,IDC_SHIMS,BM_SETCHECK,BST_CHECKED,0);
|
|
|
|
if ( 0 != (lParam & SHIMREG_DISABLE_APPHELP) )
|
|
SendDlgItemMessage(hDlg,IDC_APPHELP,BM_SETCHECK,BST_CHECKED,0);
|
|
|
|
if ( 0 != (lParam & SHIMREG_DISABLE_LAYER) )
|
|
SendDlgItemMessage(hDlg,IDC_LAYERS,BM_SETCHECK,BST_CHECKED,0);
|
|
|
|
if ( 0 != (lParam & SHIMREG_APPHELP_NOUI) )
|
|
SendDlgItemMessage(hDlg,IDC_HELPUI,BM_SETCHECK,BST_CHECKED,0);
|
|
|
|
if ( 0 != (lParam & 0x80000000) )
|
|
SetWindowText(hDlg,TEXT("Set user specific app flags"));
|
|
else
|
|
SetWindowText(hDlg,TEXT("Set global application flags"));
|
|
}
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
switch ( LOWORD(wParam) ) {
|
|
case IDC_DISABLEALL:
|
|
{
|
|
SendDlgItemMessage(hDlg,IDC_SHIMS,BM_SETCHECK,BST_CHECKED,0);
|
|
SendDlgItemMessage(hDlg,IDC_APPHELP,BM_SETCHECK,BST_CHECKED,0);
|
|
SendDlgItemMessage(hDlg,IDC_LAYERS,BM_SETCHECK,BST_CHECKED,0);
|
|
SendDlgItemMessage(hDlg,IDC_HELPUI,BM_SETCHECK,BST_CHECKED,0);
|
|
}
|
|
break;
|
|
|
|
case IDOK:
|
|
{
|
|
DWORD dwFlags = 0;
|
|
|
|
// Construct final flags
|
|
|
|
dwFlags |= (SendDlgItemMessage(hDlg,IDC_SHIMS,BM_GETCHECK,0,0) == BST_CHECKED) ? SHIMREG_DISABLE_SHIM:0;
|
|
dwFlags |= (SendDlgItemMessage(hDlg,IDC_LAYERS,BM_GETCHECK,0,0) == BST_CHECKED) ? SHIMREG_DISABLE_LAYER:0;
|
|
dwFlags |= (SendDlgItemMessage(hDlg,IDC_HELPUI,BM_GETCHECK,0,0) == BST_CHECKED) ? SHIMREG_APPHELP_NOUI:0;
|
|
dwFlags |= (SendDlgItemMessage(hDlg,IDC_APPHELP,BM_GETCHECK,0,0) == BST_CHECKED) ? SHIMREG_DISABLE_APPHELP:0;
|
|
|
|
// Terminate the dialog.
|
|
|
|
EndDialog(hDlg,dwFlags);
|
|
}
|
|
break;
|
|
case IDCANCEL:
|
|
{
|
|
DWORD dwState = GetWindowLongPtr(hDlg, GWLP_USERDATA);
|
|
|
|
EndDialog(hDlg,dwState);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void CDBView::SyncStates(UINT uMenuCMD, UINT uToolCmd, BOOL bToolbar, BOOL bToggle)
|
|
{
|
|
BOOL bOn = FALSE;
|
|
/*
|
|
if (bToolbar)
|
|
bOn = SendMessage(g_theApp.m_hToolBar,TB_ISBUTTONCHECKED,uToolCmd,0) ? TRUE:FALSE;
|
|
else
|
|
{
|
|
*/
|
|
UINT uState = GetMenuState(m_hMenu,uMenuCMD,MF_BYCOMMAND);
|
|
|
|
bOn = (0 != (uState & MF_CHECKED)) ? TRUE:FALSE;
|
|
// }
|
|
|
|
if ( bToggle )
|
|
bOn = !bOn;
|
|
|
|
MENUITEMINFO Info;
|
|
|
|
Info.cbSize = sizeof(MENUITEMINFO);
|
|
Info.fMask = MIIM_STATE;
|
|
Info.fState = bOn ? MF_CHECKED:0;
|
|
|
|
// SendMessage(g_theApp.m_hToolBar,TB_CHECKBUTTON,uToolCmd,MAKELONG(bOn ? TRUE:FALSE,0));
|
|
|
|
SetMenuItemInfo(m_hMenu,uMenuCMD,MF_BYCOMMAND,&Info);
|
|
|
|
//return;
|
|
|
|
//Update();
|
|
}
|
|
|
|
void CDBView::SyncMenu(void)
|
|
{
|
|
|
|
//
|
|
//Enables or disables the entries in the menu
|
|
//
|
|
|
|
// This varaile reflects whether we should disable entries because we are working on the global database.
|
|
|
|
BOOL bDisableGlobal=TRUE;
|
|
|
|
|
|
|
|
if ( NULL != m_pListRecord )
|
|
bDisableGlobal = m_pListRecord->bGlobal;
|
|
else
|
|
if ( m_LocalList.m_hWnd == GetFocus() )
|
|
bDisableGlobal = FALSE;
|
|
|
|
MENUITEMINFO Info;
|
|
|
|
Info.cbSize = sizeof(MENUITEMINFO);
|
|
Info.fMask = MIIM_STATE;
|
|
Info.fState = bDisableGlobal ? MFS_DISABLED:MFS_ENABLED;
|
|
|
|
//
|
|
//Disable the enties if we are working on a global database.
|
|
//
|
|
|
|
SetMenuItemInfo(m_hMenu,ID_DATABASE_CHANGEDATABASENAME,MF_BYCOMMAND,&Info);
|
|
//SetMenuItemInfo(m_hMenu,ID_DATABASE_ADDANENTRY,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_DATABASE_DEFINECUSTOMLAYER,MF_BYCOMMAND,&Info);
|
|
|
|
SetMenuItemInfo(m_hMenu,ID_DATABASE_CREATENEWAPPHELPMESSAGE,MF_BYCOMMAND,&Info);
|
|
|
|
|
|
|
|
SetMenuItemInfo(m_hMenu,ID_FILE_SAVEDATABASE,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_FILE_SAVEDATABASEAS,MF_BYCOMMAND,&Info);
|
|
|
|
Info.fState = MFS_DISABLED;
|
|
|
|
SetMenuItemInfo(m_hMenu,ID_DATABASE_EDITCUSTOMCOMPATIBILITYMODE,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_DATABASE_REMOVECUSTOMCOMPATIBILITYMODE,MF_BYCOMMAND,&Info);
|
|
|
|
//
|
|
//Disable add matching, removing matching, remove entry
|
|
//
|
|
|
|
|
|
SetMenuItemInfo(m_hMenu,ID_EDIT_ADDMATCHINGINFORMATION,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_EDIT_REMOVEMATCHINGINFORMATION,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_DATABASE_REMOVEENTRY,MF_BYCOMMAND,&Info);
|
|
|
|
|
|
|
|
if ( !bDisableGlobal ) {
|
|
HTREEITEM hItem;
|
|
|
|
Info.cbSize = sizeof(MENUITEMINFO);
|
|
Info.fMask = MIIM_STATE;
|
|
Info.fState = MFS_ENABLED;
|
|
|
|
// Determine if file matching stuff is presently selected to enable remove.
|
|
|
|
hItem = TreeView_GetSelection(m_hTreeView);
|
|
|
|
if ( NULL != hItem ) {
|
|
TVITEM Item;
|
|
|
|
Item.mask = TVIF_PARAM;
|
|
Item.hItem = hItem;
|
|
TreeView_GetItem(m_hTreeView,&Item);
|
|
|
|
PDBTREETIP pTip = (PDBTREETIP) Item.lParam;
|
|
|
|
// The tip is only valid if not on the root.
|
|
|
|
if ( NULL != pTip && NULL != TreeView_GetParent(m_hTreeView,hItem) )
|
|
if ( 1 == pTip->uContext )
|
|
SetMenuItemInfo(m_hMenu,ID_EDIT_REMOVEMATCHINGINFORMATION,MF_BYCOMMAND,&Info);
|
|
}
|
|
|
|
// Determine if we can edit or remove compat modes
|
|
|
|
PDBLAYER pWalk = g_theApp.GetDBLocal().m_pLayerList;
|
|
|
|
while ( NULL != pWalk ) {
|
|
if ( !pWalk->bPermanent )
|
|
break;
|
|
|
|
pWalk = pWalk->pNext;
|
|
}
|
|
|
|
if ( NULL != pWalk ) {
|
|
SetMenuItemInfo(m_hMenu,ID_DATABASE_EDITCUSTOMCOMPATIBILITYMODE,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_DATABASE_REMOVECUSTOMCOMPATIBILITYMODE,MF_BYCOMMAND,&Info);
|
|
}
|
|
|
|
// Determine if we can remove the entry
|
|
|
|
if ( NULL != m_pCurrentRecord ) {
|
|
SetMenuItemInfo(m_hMenu,ID_EDIT_ADDMATCHINGINFORMATION,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_DATABASE_REMOVEENTRY,MF_BYCOMMAND,&Info);
|
|
}
|
|
}
|
|
|
|
if ( NULL == m_pCurrentRecord )
|
|
Info.fState = MFS_DISABLED;
|
|
else
|
|
Info.fState = MFS_ENABLED;
|
|
|
|
SetMenuItemInfo(m_hMenu,ID_TEST_TESTRUN,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_EDIT_ENABLEDISABLEGLOBALLY,MF_BYCOMMAND,&Info);
|
|
SetMenuItemInfo(m_hMenu,ID_EDIT_ENABLEDISABLELOCALLY,MF_BYCOMMAND,&Info);
|
|
|
|
if ( NULL != m_pCurrentRecord ) {
|
|
// Find this one and make sure it's selected.
|
|
|
|
if ( NULL == TreeView_GetSelection(m_hTreeView) ) {
|
|
HTREEITEM hItem = TreeView_GetRoot(m_hTreeView);
|
|
TVITEM Item;
|
|
|
|
while ( NULL != hItem ) {
|
|
Item.mask = TVIF_PARAM;
|
|
Item.hItem = hItem;
|
|
|
|
TreeView_GetItem(m_hTreeView,&Item);
|
|
|
|
if ( Item.lParam == (LPARAM) m_pCurrentRecord ) {
|
|
TreeView_SelectItem(m_hTreeView,hItem);
|
|
break;
|
|
}
|
|
|
|
hItem = TreeView_GetNextItem(m_hTreeView,hItem,TVGN_NEXT);
|
|
}
|
|
}
|
|
}
|
|
}
|