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.
1565 lines
54 KiB
1565 lines
54 KiB
// adm.cpp
|
|
|
|
#include "precomp.h"
|
|
#include "admparse.h"
|
|
#include "adm.h"
|
|
|
|
typedef struct Category
|
|
{
|
|
LPTSTR pszName;
|
|
HWND hWnd;
|
|
HKEY hKeyClass;
|
|
LPVOID pData;
|
|
BOOL fRSoPMode;
|
|
} ADMCategory;
|
|
|
|
typedef struct ADM
|
|
{
|
|
LPTSTR pszName;
|
|
TCHAR szFileName[MAX_PATH];
|
|
DWORD dwAdm;
|
|
LPVOID pData;
|
|
} ADMFile;
|
|
|
|
#define ADM_DSCRLEN 32767
|
|
#define ADM_DSCRLINELEN 100
|
|
#define ADM_TITLELEN 100
|
|
|
|
TCHAR g_szLogFileName[MAX_PATH];
|
|
HTREEITEM g_hPolicyRootItem = NULL; // only used by profile manager
|
|
int g_ADMClose, g_ADMCategory;
|
|
|
|
#define GetFirstPolicyItem(hTreeView) ((g_hPolicyRootItem != NULL) ? TreeView_GetChild(hTreeView, g_hPolicyRootItem) : TreeView_GetRoot(hTreeView))
|
|
#define PolicyRoot() ((g_hPolicyRootItem != NULL) ? g_hPolicyRootItem : NULL)
|
|
#define IsWizard() ((g_hPolicyRootItem == NULL) ? TRUE : FALSE)
|
|
|
|
// private helper functions
|
|
static HFONT getBoldFont(HWND hWnd);
|
|
static BOOL isADMFileVisibleHelper(LPCTSTR pcszFileName, int nRole, DWORD dwPlatformId);
|
|
static BOOL loadADMFilesHelper(HWND hTreeView, HTREEITEM hPolicyRootItem,
|
|
LPCTSTR pcszADMFilePath, LPCTSTR pcszWorkDir,
|
|
DWORD dwPlatformId, int nRole,
|
|
int nIconADMClose, int nIconADMCategory);
|
|
static void deleteADMItemHelper(HWND hTreeView, HTREEITEM hParentItem, LPCTSTR pcszWorkDir,
|
|
LPCTSTR pcszInsFile, BOOL bDeleteFile, BOOL bSave);
|
|
static void deleteADMItemsHelper(HWND hTreeView, LPCTSTR pcszWorkDir, LPCTSTR pcszInsFile,
|
|
BOOL bSave);
|
|
static void getADMDescriptionTitle(LPCTSTR pcszFileName, LPTSTR pszDscrTitle);
|
|
static void getADMDescription(LPCTSTR pcszFileName, LPTSTR pszDscr);
|
|
static void importADMFileHelper(HWND hMainWnd, HWND hTreeView, LPCTSTR pcszADMFilePath,
|
|
LPCTSTR pcszWorkDir, int nRole, LPCTSTR pcszInsFile);
|
|
static void resetAdmFilesHelper(HWND hTreeView, LPCTSTR pcszWorkDir, BOOL bReset);
|
|
static void saveAdmFilesHelper(HWND hTreeView, LPCTSTR pcszWorkDir, LPCTSTR pcszInsFile);
|
|
static INT_PTR CALLBACK logDialogProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM);
|
|
static BOOL getAdmFileListHelper(LPRESULTITEM* pResultItems, int* pnResultItems, int nRole);
|
|
static HTREEITEM addADMItemHelper(HWND hTreeView, LPCTSTR pcszADMFilePath, LPCTSTR pcszFileName,
|
|
LPCTSTR pcszWorkDir, int nRole, BSTR bstrRSoPNamespace);
|
|
|
|
void WINAPI CreateADMWindow(HWND hOwner, HWND hWndInsertAfter, int nXPos, int nYPos,
|
|
int nWidth, int nHeight)
|
|
{
|
|
CDscrWnd* pDscrWnd = new CDscrWnd;
|
|
if (pDscrWnd != NULL)
|
|
{
|
|
SetWindowLongPtr(hOwner, GWLP_USERDATA, (LONG_PTR)pDscrWnd);
|
|
pDscrWnd->Create(GetParent(hOwner), hWndInsertAfter, nXPos, nYPos, nWidth, nHeight);
|
|
}
|
|
}
|
|
|
|
void WINAPI ShowADMWindow(HWND hOwner, BOOL fShow)
|
|
{
|
|
CDscrWnd* pDscrWnd = (CDscrWnd*)GetWindowLongPtr(hOwner, GWLP_USERDATA);
|
|
|
|
if (pDscrWnd != NULL)
|
|
pDscrWnd->ShowWindow(fShow);
|
|
}
|
|
|
|
void WINAPI MoveADMWindow(HWND hOwner, int nXPos, int nYPos, int nWidth, int nHeight)
|
|
{
|
|
CDscrWnd* pDscrWnd = (CDscrWnd*)GetWindowLongPtr(hOwner, GWLP_USERDATA);
|
|
|
|
if (pDscrWnd != NULL)
|
|
pDscrWnd->MoveWindow(nXPos, nYPos, nWidth, nHeight);
|
|
}
|
|
|
|
void WINAPI SetADMWindowTextA(HWND hOwner, LPCSTR pcszTitle, LPCSTR pcszText,
|
|
BOOL fUpdateWindowState /* = TRUE */)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
CDscrWnd* pDscrWnd = (CDscrWnd*)GetWindowLongPtr(hOwner, GWLP_USERDATA);
|
|
|
|
if (pDscrWnd != NULL)
|
|
pDscrWnd->SetText(A2CT(pcszTitle), A2CT(pcszText), fUpdateWindowState);
|
|
}
|
|
|
|
void WINAPI SetADMWindowTextW(HWND hOwner, LPCWSTR pcwszTitle, LPCWSTR pcwszText,
|
|
BOOL fUpdateWindowState /* = TRUE */)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
CDscrWnd* pDscrWnd = (CDscrWnd*)GetWindowLongPtr(hOwner, GWLP_USERDATA);
|
|
|
|
if (pDscrWnd != NULL)
|
|
pDscrWnd->SetText(W2CT(pcwszTitle), W2CT(pcwszText), fUpdateWindowState);
|
|
}
|
|
|
|
void WINAPI DestroyADMWindow(HWND hOwner)
|
|
{
|
|
CDscrWnd* pDscrWnd = (CDscrWnd*)GetWindowLongPtr(hOwner, GWLP_USERDATA);
|
|
|
|
if (pDscrWnd != NULL)
|
|
{
|
|
delete pDscrWnd;
|
|
SetWindowLongPtr(hOwner, GWLP_USERDATA, 0L);
|
|
}
|
|
}
|
|
|
|
BOOL WINAPI IsADMFileVisibleA(LPCSTR pcszFileName, int nRole, DWORD dwPlatformId)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
return isADMFileVisibleHelper(A2CT(pcszFileName), nRole, dwPlatformId);
|
|
}
|
|
|
|
BOOL WINAPI IsADMFileVisibleW(LPCWSTR pcwszFileName, int nRole, DWORD dwPlatformId)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
return isADMFileVisibleHelper(W2CT(pcwszFileName), nRole, dwPlatformId);
|
|
}
|
|
|
|
BOOL WINAPI LoadADMFilesA(HWND hTreeView, HTREEITEM hPolicyRootItem, LPCSTR pcszADMFilePath,
|
|
LPCSTR pcszWorkDir, DWORD dwPlatformId, int nRole,
|
|
int nIconADMClose, int nIconADMCategory)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
return loadADMFilesHelper(hTreeView, hPolicyRootItem, A2CT(pcszADMFilePath),
|
|
A2CT(pcszWorkDir), dwPlatformId, nRole, nIconADMClose, nIconADMCategory);
|
|
}
|
|
|
|
BOOL WINAPI LoadADMFilesW(HWND hTreeView, HTREEITEM hPolicyRootItem, LPCWSTR pcwszADMFilePath,
|
|
LPCWSTR pcwszWorkDir, DWORD dwPlatformId, int nRole,
|
|
int nIconADMClose, int nIconADMCategory)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
return loadADMFilesHelper(hTreeView, hPolicyRootItem, W2CT(pcwszADMFilePath),
|
|
W2CT(pcwszWorkDir), dwPlatformId, nRole, nIconADMClose, nIconADMCategory);
|
|
}
|
|
|
|
void WINAPI DeleteADMItemA(HWND hTreeView, HTREEITEM hParentItem, LPCSTR pcszWorkDir,
|
|
LPCSTR pcszInsFile, BOOL bDeleteFile, BOOL bSave)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
deleteADMItemHelper(hTreeView, hParentItem, A2CT(pcszWorkDir), A2CT(pcszInsFile),
|
|
bDeleteFile, bSave);
|
|
}
|
|
|
|
void WINAPI DeleteADMItemW(HWND hTreeView, HTREEITEM hParentItem, LPCWSTR pcwszWorkDir,
|
|
LPCWSTR pcwszInsFile, BOOL bDeleteFile, BOOL bSave)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
deleteADMItemHelper(hTreeView, hParentItem, W2CT(pcwszWorkDir), W2CT(pcwszInsFile),
|
|
bDeleteFile, bSave);
|
|
}
|
|
|
|
void WINAPI DeleteADMItemsA(HWND hTreeView, LPCSTR pcszWorkDir, LPCSTR pcszInsFile,
|
|
BOOL bSave)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
deleteADMItemsHelper(hTreeView, A2CT(pcszWorkDir), A2CT(pcszInsFile), bSave);
|
|
}
|
|
|
|
void WINAPI DeleteADMItemsW(HWND hTreeView, LPCWSTR pcwszWorkDir, LPCWSTR pcwszInsFile,
|
|
BOOL bSave)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
deleteADMItemsHelper(hTreeView, W2CT(pcwszWorkDir), W2CT(pcwszInsFile), bSave);
|
|
}
|
|
|
|
// Displays the description of the adm file or displays the category window
|
|
// depending on whether the selected item was an ADMFile Item or a category item.
|
|
void WINAPI DisplayADMItem(HWND hWnd, HWND hTreeView, LPTVITEM lpSelectedItem,
|
|
BOOL fShowDisabled)
|
|
{
|
|
TV_ITEM tvitem;
|
|
HWND hAdmWnd = NULL;
|
|
RECT rect;
|
|
RECT wndRect;
|
|
HTREEITEM hParentItem = TreeView_GetParent(hTreeView, lpSelectedItem->hItem);
|
|
int nWidth, nHeight;
|
|
TCHAR szDscrTitle[ADM_TITLELEN];
|
|
TCHAR szDscr[ADM_DSCRLEN];
|
|
ADMFile* pADMFile;
|
|
|
|
if(hParentItem != PolicyRoot())
|
|
{ // item is a category
|
|
ShowADMWindow(hTreeView, FALSE);
|
|
if(lpSelectedItem->lParam != NULL)
|
|
{
|
|
ADMCategory* pADMCategory;
|
|
|
|
tvitem.mask = TVIF_PARAM;
|
|
tvitem.hItem = hParentItem;
|
|
TreeView_GetItem(hTreeView, &tvitem);
|
|
|
|
// get the cooridnates to display the window
|
|
// the coordinates are the same as the static instruction window
|
|
GetWindowRect(hWnd, &wndRect);
|
|
|
|
if(!IsWizard())
|
|
{
|
|
wndRect.left += GetSystemMetrics(SM_CXFIXEDFRAME);
|
|
wndRect.top += (GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYMENU) +
|
|
GetSystemMetrics(SM_CYFIXEDFRAME));
|
|
}
|
|
|
|
CDscrWnd* pDscrWnd = (CDscrWnd*)GetWindowLongPtr(hTreeView, GWLP_USERDATA);
|
|
if (pDscrWnd != NULL)
|
|
{
|
|
pDscrWnd->GetRect(&rect);
|
|
|
|
rect.right = (rect.left - wndRect.left) + (rect.right - rect.left);
|
|
rect.bottom = (rect.top - wndRect.top) + (rect.bottom - rect.top);
|
|
rect.left = rect.left - wndRect.left;
|
|
rect.top = rect.top - wndRect.top;
|
|
}
|
|
else
|
|
{
|
|
RECT rectTreeView;
|
|
|
|
GetWindowRect(hTreeView, &rectTreeView);
|
|
|
|
rect.left = rectTreeView.right - wndRect.left + 7;
|
|
rect.top = rectTreeView.top - wndRect.top + 2;
|
|
rect.right = (wndRect.right - wndRect.left - 7 -
|
|
((!IsWizard()) ? GetSystemMetrics(SM_CXFIXEDFRAME) : 0));
|
|
rect.bottom = rect.top + rectTreeView.bottom - rectTreeView.top - 4;
|
|
}
|
|
|
|
nWidth = rect.right - rect.left;
|
|
nHeight = rect.bottom - rect.top;
|
|
|
|
pADMFile = (ADMFile*)tvitem.lParam;
|
|
pADMCategory = (ADMCategory*)lpSelectedItem->lParam;
|
|
|
|
// Display the window associated with the item/category
|
|
CreateAdmUi(pADMFile->dwAdm, hWnd, rect.left, rect.top, nWidth, nHeight,
|
|
WS_TABSTOP, 0, pADMCategory->pszName, pADMCategory->hKeyClass, &hAdmWnd,
|
|
pADMFile->pData, &pADMCategory->pData, pADMCategory->fRSoPMode);
|
|
pADMCategory->hWnd = hAdmWnd;
|
|
|
|
if(fShowDisabled)
|
|
EnableWindow(hAdmWnd, FALSE);
|
|
else
|
|
EnableWindow(hAdmWnd, TRUE);
|
|
}
|
|
}
|
|
else
|
|
{ // item is a adm file
|
|
ShowADMWindow(hTreeView, TRUE);
|
|
ZeroMemory(szDscrTitle, ADM_TITLELEN);
|
|
ZeroMemory(szDscr, ADM_DSCRLEN);
|
|
|
|
if(lpSelectedItem->lParam != NULL)
|
|
{
|
|
pADMFile = (ADMFile*)lpSelectedItem->lParam;
|
|
getADMDescriptionTitle(pADMFile->szFileName, szDscrTitle);
|
|
getADMDescription(pADMFile->szFileName, szDscr);
|
|
}
|
|
else
|
|
{
|
|
if(!IsWizard())
|
|
{
|
|
LoadString(g_hInst, IDS_POLICYBRANCHTITLE, szDscrTitle, ADM_TITLELEN);
|
|
LoadString(g_hInst, IDS_POLICYBRANCHTEXT, szDscr, ADM_DSCRLEN);
|
|
}
|
|
}
|
|
SetADMWindowText(hTreeView, szDscrTitle, szDscr);
|
|
}
|
|
}
|
|
|
|
// Displays an ADM file description or category window depending
|
|
// on the type of the selected item
|
|
void WINAPI SelectADMItem(HWND hWnd, HWND hTreeView, LPTVITEM lpTVItem,
|
|
BOOL bSelect, BOOL fShowDisabled)
|
|
{
|
|
HTREEITEM hParentItem;
|
|
TCHAR szDscrTitle[ADM_TITLELEN];
|
|
TCHAR szDscr[ADM_DSCRLEN];
|
|
|
|
hParentItem = TreeView_GetParent(hTreeView, lpTVItem->hItem);
|
|
|
|
if(bSelect == FALSE)
|
|
{
|
|
// if the previously selected item was a category item,
|
|
// save the category information and destroy the window
|
|
// associated with that category
|
|
if(hParentItem != g_hPolicyRootItem)
|
|
{
|
|
if(lpTVItem->lParam != NULL)
|
|
SaveADMItem(hTreeView, lpTVItem, ITEM_SAVE | ITEM_DESTROY);
|
|
}
|
|
else
|
|
ShowADMWindow(hTreeView, FALSE);
|
|
}
|
|
else
|
|
{
|
|
if(hParentItem == NULL)
|
|
{
|
|
LoadString(g_hInst, IDS_POLICYBRANCHTITLE, szDscrTitle, ADM_TITLELEN);
|
|
LoadString(g_hInst, IDS_POLICYBRANCHTEXT, szDscr, ADM_DSCRLEN);
|
|
SetADMWindowText(hTreeView, szDscrTitle, szDscr);
|
|
return;
|
|
}
|
|
// display the information for the newly selected item
|
|
DisplayADMItem(hWnd, hTreeView, lpTVItem, fShowDisabled);
|
|
}
|
|
}
|
|
|
|
void WINAPI ImportADMFileA(HWND hMainWnd, HWND hTreeView, LPCSTR pcszADMFilePath,
|
|
LPCSTR pcszWorkDir, int nRole, LPCSTR pcszInsFile)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
importADMFileHelper(hMainWnd, hTreeView, A2CT(pcszADMFilePath), A2CT(pcszWorkDir),
|
|
nRole, A2CT(pcszInsFile));
|
|
}
|
|
|
|
void WINAPI ImportADMFileW(HWND hMainWnd, HWND hTreeView, LPCWSTR pcwszADMFilePath,
|
|
LPCWSTR pcwszWorkDir, int nRole, LPCWSTR pcwszInsFile)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
importADMFileHelper(hMainWnd, hTreeView, W2CT(pcwszADMFilePath), W2CT(pcwszWorkDir),
|
|
nRole, W2CT(pcwszInsFile));
|
|
}
|
|
|
|
|
|
void WINAPI CheckForDupKeys(HWND hMainWnd, HWND hTreeView, HTREEITEM hItem,
|
|
BOOL bDispSuccessMsg)
|
|
{
|
|
TV_ITEM tvitem;
|
|
TV_ITEM tvitem1;
|
|
HANDLE hFile;
|
|
HRESULT hResult;
|
|
TCHAR szMessage[MAX_PATH];
|
|
BOOL bClearLog = TRUE;
|
|
HTREEITEM hPolicyItem = GetFirstPolicyItem(hTreeView);
|
|
TCHAR szRoot[MAX_PATH];
|
|
TCHAR szTitle[MAX_PATH];
|
|
|
|
tvitem.mask = TVIF_PARAM;
|
|
tvitem.hItem = hItem;
|
|
TreeView_GetItem(hTreeView, &tvitem);
|
|
|
|
LoadString(g_hInst, IDS_TITLE, szTitle, ARRAYSIZE(szTitle));
|
|
if(ISNULL(g_szLogFileName))
|
|
{
|
|
LPTSTR pLastSlash;
|
|
DWORD dwSize = sizeof(szRoot);
|
|
|
|
GetModuleFileName(GetModuleHandle(NULL), szRoot, MAX_PATH);
|
|
if(ISNULL(szRoot))
|
|
SHGetValue(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\IEAK6WIZ.EXE"), NULL, NULL, (LPVOID) szRoot, &dwSize);
|
|
if(ISNONNULL(szRoot))
|
|
{
|
|
pLastSlash = StrRChr(szRoot, NULL, TEXT('\\'));
|
|
if (pLastSlash)
|
|
*(++pLastSlash) = 0;
|
|
CharUpper(szRoot);
|
|
}
|
|
wnsprintf(g_szLogFileName, ARRAYSIZE(g_szLogFileName), TEXT("%sadmlog.txt"), szRoot);
|
|
}
|
|
|
|
do
|
|
{
|
|
tvitem1.mask = TVIF_PARAM;
|
|
tvitem1.hItem = hPolicyItem;
|
|
TreeView_GetItem(hTreeView, &tvitem1);
|
|
|
|
hResult = CheckDuplicateKeys(((ADMFile*)tvitem.lParam)->dwAdm, ((ADMFile*)tvitem1.lParam)->dwAdm,
|
|
g_szLogFileName, bClearLog);
|
|
if(hResult != S_OK)
|
|
{
|
|
if(GetLastError() == STATUS_NO_MEMORY)
|
|
{
|
|
LoadString(g_hInst, IDS_MEMORY_ERROR, szMessage, ARRAYSIZE(szMessage));
|
|
}
|
|
else if(GetLastError() == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
LoadString(g_hInst, IDS_FILE_ERROR, szMessage, ARRAYSIZE(szMessage));
|
|
}
|
|
MessageBox(hTreeView, szMessage, szTitle, MB_ICONINFORMATION|MB_OK);
|
|
return;
|
|
}
|
|
bClearLog = FALSE;
|
|
}while((hPolicyItem = TreeView_GetNextSibling(hTreeView, hPolicyItem)) != NULL); // get next item
|
|
|
|
hFile = CreateFile( g_szLogFileName, GENERIC_READ, FILE_SHARE_READ,
|
|
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
|
|
if( hFile == INVALID_HANDLE_VALUE )
|
|
{
|
|
LoadString(g_hInst, IDS_NO_DUPLICATEKEYS, szMessage, ARRAYSIZE(szMessage));
|
|
MessageBox(hTreeView, szMessage, szTitle, MB_ICONINFORMATION|MB_OK);
|
|
return;
|
|
}
|
|
|
|
if(GetFileSize( hFile, NULL ) == 0)
|
|
{
|
|
CloseHandle(hFile);
|
|
if(bDispSuccessMsg)
|
|
{
|
|
LoadString(g_hInst, IDS_NO_DUPLICATEKEYS, szMessage, ARRAYSIZE(szMessage));
|
|
MessageBox(hTreeView, szMessage, szTitle, MB_ICONINFORMATION|MB_OK);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CloseHandle(hFile);
|
|
|
|
DialogBox(g_hInst, MAKEINTRESOURCE(IDD_ERRORLOG), hMainWnd, logDialogProc);
|
|
}
|
|
SetFocus(hMainWnd);
|
|
}
|
|
|
|
void WINAPI ResetAdmFilesA(HWND hTreeView, LPCSTR pcszWorkDir, BOOL bReset)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
resetAdmFilesHelper(hTreeView, A2CT(pcszWorkDir), bReset);
|
|
}
|
|
|
|
void WINAPI ResetAdmFilesW(HWND hTreeView, LPCWSTR pcwszWorkDir, BOOL bReset)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
resetAdmFilesHelper(hTreeView, W2CT(pcwszWorkDir), bReset);
|
|
}
|
|
|
|
void WINAPI SaveAdmFilesA(HWND hTreeView, LPCSTR pcszWorkDir, LPCSTR pcszInsFile)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
saveAdmFilesHelper(hTreeView, A2CT(pcszWorkDir), A2CT(pcszInsFile));
|
|
}
|
|
|
|
void WINAPI SaveAdmFilesW(HWND hTreeView, LPCWSTR pcwszWorkDir, LPCWSTR pcwszInsFile)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
saveAdmFilesHelper(hTreeView, W2CT(pcwszWorkDir), W2CT(pcwszInsFile));
|
|
}
|
|
|
|
BOOL WINAPI CanDeleteADM(HWND hTreeView, HTREEITEM hItem)
|
|
{
|
|
TV_ITEM tvitem;
|
|
int nDeleteLock = 0;
|
|
|
|
tvitem.mask = TVIF_PARAM;
|
|
tvitem.hItem = hItem;
|
|
TreeView_GetItem(hTreeView, &tvitem);
|
|
if(tvitem.lParam != NULL)
|
|
{
|
|
nDeleteLock = GetPrivateProfileInt(TEXT("IEAK"), TEXT("Lock"), 0,
|
|
((ADMFile*)tvitem.lParam)->szFileName);
|
|
}
|
|
return (BOOL) !nDeleteLock;
|
|
}
|
|
|
|
HWND WINAPI GetAdmWindowHandle(HWND hTreeView, HTREEITEM hItem)
|
|
{
|
|
TV_ITEM tvitem;
|
|
|
|
tvitem.mask = TVIF_PARAM;
|
|
tvitem.hItem = hItem;
|
|
if (TreeView_GetItem(hTreeView, &tvitem) == TRUE)
|
|
return ((ADMCategory*)tvitem.lParam)->hWnd;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
void WINAPI SaveADMItem(HWND hTreeView, LPTVITEM lpTVItem, DWORD dwFlags)
|
|
{
|
|
if (lpTVItem != NULL && lpTVItem->lParam != NULL)
|
|
{
|
|
TVITEM tvitem;
|
|
|
|
tvitem.mask = TVIF_PARAM;
|
|
tvitem.hItem = TreeView_GetParent(hTreeView, lpTVItem->hItem);
|
|
TreeView_GetItem(hTreeView, &tvitem);
|
|
|
|
if (dwFlags)
|
|
{
|
|
DWORD dwAdmFlags = 0;
|
|
ADMFile* pADMFile = (ADMFile*)tvitem.lParam;
|
|
ADMCategory* pADMCategory = (ADMCategory*)lpTVItem->lParam;
|
|
|
|
if (pADMCategory != NULL)
|
|
{
|
|
if (HasFlag(dwFlags, ITEM_SAVE))
|
|
dwAdmFlags |= ADM_SAVE;
|
|
if (HasFlag(dwFlags, ITEM_DESTROY))
|
|
dwAdmFlags |= ADM_DESTROY;
|
|
AdmSaveData(pADMFile->dwAdm, pADMFile->pData, pADMCategory->pData, dwAdmFlags);
|
|
|
|
if (HasFlag(dwFlags, ITEM_DESTROY))
|
|
{
|
|
DestroyWindow(pADMCategory->hWnd);
|
|
pADMCategory->hWnd = NULL;
|
|
pADMCategory->pData = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL WINAPI GetAdmFileListA(LPRESULTITEMA* pResultItemsArrayA, int* pnResultItems, int nRole)
|
|
{
|
|
LPRESULTITEM pResultItemArray = NULL;
|
|
BOOL fRet;
|
|
|
|
fRet = getAdmFileListHelper(&pResultItemArray, pnResultItems, nRole);
|
|
|
|
if (pResultItemArray != NULL)
|
|
{
|
|
int i;
|
|
|
|
if ((i = *pnResultItems) != 0)
|
|
{
|
|
if ((*pResultItemsArrayA = (LPRESULTITEMA)CoTaskMemAlloc(i * sizeof(RESULTITEMA))) != NULL)
|
|
{
|
|
for (i--; i >= 0; i--)
|
|
{
|
|
// must used StrLen manually here to figure out how many bytes to allocate!
|
|
|
|
if (pResultItemArray[i].pszName != NULL)
|
|
(*pResultItemsArrayA)[i].pszName =
|
|
(LPSTR)CoTaskMemAlloc((StrLen(pResultItemArray[i].pszName)+1)*2);
|
|
if (pResultItemArray[i].pszDesc != NULL)
|
|
(*pResultItemsArrayA)[i].pszDesc =
|
|
(LPSTR)CoTaskMemAlloc((StrLen(pResultItemArray[i].pszDesc)+1)*2);
|
|
ResultItemT2A(&pResultItemArray[i], &(*pResultItemsArrayA)[i]);
|
|
if (pResultItemArray[i].pszName != NULL)
|
|
CoTaskMemFree(pResultItemArray[i].pszName);
|
|
if (pResultItemArray[i].pszDesc != NULL)
|
|
CoTaskMemFree(pResultItemArray[i].pszDesc);
|
|
}
|
|
}
|
|
}
|
|
|
|
CoTaskMemFree(pResultItemArray);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL WINAPI GetAdmFileListW(LPRESULTITEMW* pResultItemsArrayW, int* pnResultItems, int nRole)
|
|
{
|
|
LPRESULTITEM pResultItemArray = NULL;
|
|
BOOL fRet;
|
|
|
|
fRet = getAdmFileListHelper(&pResultItemArray, pnResultItems, nRole);
|
|
|
|
if (pResultItemArray != NULL)
|
|
{
|
|
int i;
|
|
|
|
if ((i = *pnResultItems) != 0)
|
|
{
|
|
if ((*pResultItemsArrayW = (LPRESULTITEMW)CoTaskMemAlloc(i * sizeof(RESULTITEMW))) != NULL)
|
|
{
|
|
for (i--; i >= 0; i--)
|
|
{
|
|
// must used StrLen manually here to figure out how many bytes to allocate!
|
|
|
|
if (pResultItemArray[i].pszName != NULL)
|
|
(*pResultItemsArrayW)[i].pszName =
|
|
(LPWSTR)CoTaskMemAlloc((StrLen(pResultItemArray[i].pszName)+1) * sizeof(WCHAR));
|
|
if (pResultItemArray[i].pszDesc != NULL)
|
|
(*pResultItemsArrayW)[i].pszDesc =
|
|
(LPWSTR)CoTaskMemAlloc((StrLen(pResultItemArray[i].pszDesc)+1) * sizeof(WCHAR));
|
|
ResultItemT2W(&pResultItemArray[i], &(*pResultItemsArrayW)[i]);
|
|
if (pResultItemArray[i].pszName != NULL)
|
|
CoTaskMemFree(pResultItemArray[i].pszName);
|
|
if (pResultItemArray[i].pszDesc != NULL)
|
|
CoTaskMemFree(pResultItemArray[i].pszDesc);
|
|
}
|
|
}
|
|
}
|
|
|
|
CoTaskMemFree(pResultItemArray);
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
HTREEITEM WINAPI AddADMItemA(HWND hTreeView, LPCSTR pcszADMFilePath, LPCSTR pcszFileName,
|
|
LPCSTR pcszWorkDir, int nRole, BSTR bstrRSOPNamespace)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
return addADMItemHelper(hTreeView, A2CT(pcszADMFilePath), A2CT(pcszFileName),
|
|
A2CT(pcszWorkDir), nRole, bstrRSOPNamespace);
|
|
}
|
|
|
|
HTREEITEM WINAPI AddADMItemW(HWND hTreeView, LPCWSTR pcwszADMFilePath, LPCWSTR pcwszFileName,
|
|
LPCWSTR pcwszWorkDir, int nRole, BSTR bstrRSOPNamespace)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
return addADMItemHelper(hTreeView, W2CT(pcwszADMFilePath), W2CT(pcwszFileName),
|
|
W2CT(pcwszWorkDir), nRole, bstrRSOPNamespace);
|
|
}
|
|
|
|
// Converts the .adm filename to .inf filename and concatenates the
|
|
// appropriate path for the .inf file
|
|
static void getInfFileName(LPCTSTR pcszADMFileName, LPTSTR pszInfFileName, DWORD cchInfFile, LPCTSTR pcszWorkDir)
|
|
{
|
|
TCHAR szBaseFileName[MAX_PATH];
|
|
|
|
ZeroMemory(pszInfFileName, cchInfFile*sizeof(TCHAR));
|
|
StrCpy(szBaseFileName, PathFindFileName(pcszADMFileName));
|
|
PathRemoveExtension(szBaseFileName);
|
|
if(ISNONNULL(pcszWorkDir))
|
|
wnsprintf(pszInfFileName, cchInfFile, TEXT("%s\\%s.inf"), pcszWorkDir, szBaseFileName);
|
|
}
|
|
|
|
// Loads all the categories for a specified .adm file
|
|
static void loadCategories(HWND hTreeView, HTREEITEM hParentItem, DWORD dwAdm,
|
|
BOOL fRSoPMode)
|
|
{
|
|
int nSize = 0;
|
|
int nCategorySize = 0;
|
|
TV_INSERTSTRUCT tvis;
|
|
TCHAR szCategories[2048];
|
|
TCHAR szCategory[1024];
|
|
HKEY hKeyCurrentClass = HKEY_CURRENT_USER;
|
|
|
|
// Get the category list. The category strings are concatenated into a
|
|
// single string with '\0' as the seperator and the last string is
|
|
// terminated with "\0\0"
|
|
GetAdmCategories(dwAdm, szCategories, ARRAYSIZE(szCategories), &nSize);
|
|
|
|
for(int nIndex = 0; nIndex < (nSize - 2); nIndex++)
|
|
{
|
|
memset(szCategory, 0, sizeof(szCategory));
|
|
nCategorySize = 0;
|
|
while(szCategories[nIndex] != TEXT('\0'))
|
|
{
|
|
szCategory[nCategorySize++] = szCategories[nIndex++];
|
|
}
|
|
|
|
if(StrCmpI(szCategory, TEXT("HKLM")) == 0)
|
|
{
|
|
hKeyCurrentClass = HKEY_LOCAL_MACHINE;
|
|
continue;
|
|
}
|
|
else if(StrCmpI(szCategory, TEXT("HKCU")) == 0)
|
|
{
|
|
hKeyCurrentClass = HKEY_CURRENT_USER;
|
|
continue;
|
|
}
|
|
|
|
ADMCategory* pCategory = (ADMCategory*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ADMCategory));
|
|
if(pCategory == NULL) // not enough memory available
|
|
{
|
|
return;
|
|
}
|
|
memset(pCategory, 0, sizeof(ADMCategory));
|
|
pCategory->pszName = (LPTSTR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
(lstrlen(szCategory) + 1)*sizeof(TCHAR));
|
|
if(pCategory->pszName == NULL) // not enough memory available
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, pCategory);
|
|
return;
|
|
}
|
|
StrCpy(pCategory->pszName, szCategory);
|
|
pCategory->hKeyClass = hKeyCurrentClass;
|
|
pCategory->fRSoPMode = fRSoPMode;
|
|
|
|
tvis.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
|
|
tvis.item.pszText = pCategory->pszName;
|
|
tvis.item.cchTextMax = lstrlen(pCategory->pszName);
|
|
tvis.item.lParam = (LPARAM) pCategory;
|
|
tvis.item.iImage = tvis.item.iSelectedImage = g_ADMCategory;
|
|
|
|
tvis.hInsertAfter = (HTREEITEM) TVI_LAST;
|
|
tvis.hParent = hParentItem;
|
|
if(TreeView_InsertItem( hTreeView, &tvis) == NULL)
|
|
{ // insert failure
|
|
HeapFree(GetProcessHeap(), 0, pCategory->pszName);
|
|
HeapFree(GetProcessHeap(), 0, pCategory);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Checks whether a particular .adm file is to be displayed in the tree view
|
|
// depending on the PLATFORM key in the IEAK section
|
|
static BOOL isADMFileVisibleHelper(LPCTSTR pcszFileName, int nRole, DWORD dwPlatformId)
|
|
{
|
|
TCHAR szRoles[5];
|
|
TCHAR szPlatform[10];
|
|
|
|
ZeroMemory(szRoles,sizeof(szRoles));
|
|
ZeroMemory(szPlatform, sizeof(szPlatform));
|
|
|
|
if(IsWizard())
|
|
{
|
|
// if the Roles are not specified or are not of the proper format,
|
|
// the adm file is assumed to be visible
|
|
if(GetPrivateProfileString(TEXT("IEAK"), TEXT("Roles"), TEXT(""), szRoles, ARRAYSIZE(szRoles), pcszFileName) == 3)
|
|
{
|
|
if(!((szRoles[0] == TEXT('0') || szRoles[0] == TEXT('1')) &&
|
|
(szRoles[1] == TEXT('0') || szRoles[1] == TEXT('1')) &&
|
|
(szRoles[2] == TEXT('0') || szRoles[2] == TEXT('1')) &&
|
|
((szRoles[0] == TEXT('1') && nRole == ROLE_ICP) || // ICP
|
|
(szRoles[1] == TEXT('1') && nRole == ROLE_ISP) || // ISP
|
|
(szRoles[2] == TEXT('1') && nRole == ROLE_CORP)))) // Corp. Admin
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
GetPrivateProfileString(TEXT("IEAK"), TEXT("Platform"), TEXT(""), szPlatform, ARRAYSIZE(szPlatform), pcszFileName);
|
|
if(!((szPlatform[1] == TEXT('1') && dwPlatformId == PLATFORM_WIN32) || // WIN32
|
|
(szPlatform[3] == TEXT('1') && dwPlatformId == PLATFORM_W2K))) // W2K
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Adds an item (.adm file) to the tree view
|
|
static HTREEITEM addADMItemHelper(HWND hTreeView, LPCTSTR pcszADMFilePath, LPCTSTR pcszFileName,
|
|
LPCTSTR pcszWorkDir, int nRole, BSTR bstrRSOPNamespace)
|
|
{
|
|
TV_INSERTSTRUCT tvis;
|
|
HTREEITEM hItem = NULL;
|
|
DWORD dwAdm = 0;
|
|
TCHAR szADMFileName[MAX_PATH];
|
|
TCHAR szOutputFile[MAX_PATH];
|
|
TCHAR szTitle[ADM_TITLELEN];
|
|
PathCombine(szADMFileName, pcszADMFilePath, pcszFileName);
|
|
|
|
// check for the visibility of the adm file
|
|
if(!IsADMFileVisible(szADMFileName, nRole, g_dwPlatformId))
|
|
return NULL;
|
|
|
|
ADMFile* pADMFile = (ADMFile*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ADMFile));
|
|
if(pADMFile == NULL) // not enough memory available
|
|
{
|
|
return NULL;
|
|
}
|
|
ZeroMemory(pADMFile, sizeof(ADMFile));
|
|
StrCpy(pADMFile->szFileName, szADMFileName);
|
|
ZeroMemory(szTitle, sizeof(szTitle));
|
|
GetPrivateProfileString(TEXT("Strings"), TEXT("IEAK_Title"), pcszFileName, szTitle,
|
|
ARRAYSIZE(szTitle), pADMFile->szFileName);
|
|
pADMFile->pszName = (LPTSTR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
(StrLen(szTitle) + 1)*sizeof(TCHAR));
|
|
if(pADMFile->pszName == NULL) // not enough memory available
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, pADMFile);
|
|
return NULL;
|
|
}
|
|
StrCpy(pADMFile->pszName, szTitle);
|
|
|
|
tvis.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
|
|
tvis.item.pszText = pADMFile->pszName;
|
|
tvis.item.cchTextMax = StrLen(pADMFile->pszName);
|
|
tvis.item.lParam = (LPARAM) pADMFile;
|
|
if (IsWizard())
|
|
{
|
|
tvis.item.mask |= TVIF_STATE;
|
|
tvis.item.stateMask = tvis.item.state = TVIS_BOLD;
|
|
}
|
|
tvis.item.iImage = tvis.item.iSelectedImage = g_ADMClose;
|
|
|
|
tvis.hInsertAfter = (HTREEITEM) TVI_LAST;
|
|
tvis.hParent = PolicyRoot();
|
|
|
|
getInfFileName(pADMFile->szFileName, szOutputFile, ARRAYSIZE(szOutputFile), pcszWorkDir);
|
|
if(AdmInit(pADMFile->szFileName, szOutputFile, bstrRSOPNamespace, &dwAdm, &pADMFile->pData) == S_OK)
|
|
{
|
|
pADMFile->dwAdm = dwAdm;
|
|
if((hItem = TreeView_InsertItem( hTreeView, &tvis)) != NULL)
|
|
{ // insert success
|
|
loadCategories(hTreeView, hItem, dwAdm, (NULL == bstrRSOPNamespace) ? FALSE : TRUE);
|
|
}
|
|
}
|
|
|
|
if(hItem == NULL)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, pADMFile->pszName);
|
|
HeapFree(GetProcessHeap(), 0, pADMFile);
|
|
hItem = NULL;
|
|
}
|
|
return hItem;
|
|
}
|
|
|
|
static void addAdmItems(HWND hTreeView, LPCTSTR pcszFileType, LPCTSTR pcszADMFilePath,
|
|
LPCTSTR pcszWorkDir, int nRole)
|
|
{
|
|
WIN32_FIND_DATA FindFileData;
|
|
TCHAR szFileName[MAX_PATH];
|
|
|
|
PathCombine(szFileName, pcszADMFilePath, pcszFileType);
|
|
|
|
HANDLE hFind = FindFirstFile(szFileName, &FindFileData);
|
|
if(hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
// addAdmItems is called from loadADMFiles which is never called in RSoP mode,
|
|
// so just pass in FALSE always.
|
|
addADMItemHelper(hTreeView, pcszADMFilePath, FindFileData.cFileName,
|
|
pcszWorkDir, nRole, NULL);
|
|
}while(FindNextFile(hFind, &FindFileData));
|
|
FindClose(hFind);
|
|
}
|
|
}
|
|
|
|
// Loads all the .adm files from a specific path
|
|
static BOOL loadADMFilesHelper(HWND hTreeView, HTREEITEM hPolicyRootItem,
|
|
LPCTSTR pcszADMFilePath, LPCTSTR pcszWorkDir,
|
|
DWORD dwPlatformId, int nRole,
|
|
int nIconADMClose, int nIconADMCategory)
|
|
{
|
|
g_hPolicyRootItem = hPolicyRootItem;
|
|
g_dwPlatformId = dwPlatformId;
|
|
g_ADMClose = nIconADMClose;
|
|
g_ADMCategory = nIconADMCategory;
|
|
ZeroMemory(g_szLogFileName, sizeof(g_szLogFileName));
|
|
|
|
addAdmItems(hTreeView, TEXT("*.adm"), pcszADMFilePath, pcszWorkDir, nRole);
|
|
// add also files with .opa extension, Office requirement - 06/08/98
|
|
addAdmItems(hTreeView, TEXT("*.opa"), pcszADMFilePath, pcszWorkDir, nRole);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Returns the item handle for the requested filename if any
|
|
static HTREEITEM getADMItemHandle(HWND hTreeView, LPTSTR pszADMFileName)
|
|
{
|
|
HTREEITEM hItem = NULL;
|
|
TV_ITEM tvitem;
|
|
|
|
hItem = GetFirstPolicyItem(hTreeView);
|
|
while(hItem != NULL) // if items in the tree view
|
|
{
|
|
tvitem.mask = TVIF_PARAM;
|
|
tvitem.hItem = hItem;
|
|
TreeView_GetItem(hTreeView, &tvitem);
|
|
if(tvitem.lParam != NULL &&
|
|
StrCmp(((ADMFile*) tvitem.lParam)->szFileName, pszADMFileName) == 0)
|
|
{
|
|
return hItem;
|
|
}
|
|
hItem = TreeView_GetNextSibling(hTreeView, hItem); // get next item
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// Deletes an item from the tree view and releases any memory
|
|
// allocated with that item
|
|
static void deleteADMItemHelper(HWND hTreeView, HTREEITEM hParentItem, LPCTSTR pcszWorkDir,
|
|
LPCTSTR pcszInsFile, BOOL bDeleteFile, BOOL bSave)
|
|
{
|
|
ADMFile* pADMFile = NULL;
|
|
ADMCategory* pADMCategory = NULL;
|
|
HTREEITEM hItem = NULL;
|
|
HTREEITEM hNextItem = NULL;
|
|
TCHAR szRegistryData[MAX_PATH + 15];
|
|
TCHAR szBaseFileName[_MAX_FNAME];
|
|
TV_ITEM tvitem;
|
|
TV_ITEM tvparentitem;
|
|
TCHAR szOutputFile[MAX_PATH];
|
|
|
|
tvparentitem.mask = TVIF_PARAM;
|
|
tvparentitem.hItem = hParentItem;
|
|
TreeView_GetItem(hTreeView, &tvparentitem);
|
|
if(tvparentitem.lParam != NULL)
|
|
{
|
|
pADMFile = (ADMFile*) tvparentitem.lParam;
|
|
hItem = TreeView_GetChild(hTreeView, hParentItem); // get child item
|
|
while(hItem != NULL)
|
|
{
|
|
hNextItem = TreeView_GetNextSibling(hTreeView, hItem); // get next child item
|
|
tvitem.mask = TVIF_PARAM;
|
|
tvitem.hItem = hItem;
|
|
TreeView_GetItem(hTreeView, &tvitem);
|
|
if(tvitem.lParam != NULL)
|
|
{
|
|
pADMCategory = (ADMCategory*) tvitem.lParam;
|
|
HeapFree(GetProcessHeap(), 0, pADMCategory->pszName);
|
|
HeapFree(GetProcessHeap(), 0, pADMCategory);
|
|
|
|
TreeView_DeleteItem(hTreeView, hItem);
|
|
}
|
|
hItem = hNextItem;
|
|
}
|
|
|
|
getInfFileName(pADMFile->szFileName, szOutputFile, ARRAYSIZE(szOutputFile),
|
|
pcszWorkDir);
|
|
StrCpy(szBaseFileName, PathFindFileName(szOutputFile));
|
|
PathRemoveExtension(szBaseFileName);
|
|
if(bDeleteFile == TRUE)
|
|
{
|
|
DeleteFile(pADMFile->szFileName);
|
|
DeleteFile(szOutputFile);
|
|
|
|
}
|
|
else
|
|
{
|
|
if (bSave)
|
|
{
|
|
AdmFinished(pADMFile->dwAdm, szOutputFile, pADMFile->pData);
|
|
if (PathFileExists(szOutputFile))
|
|
{
|
|
wnsprintf(szRegistryData, ARRAYSIZE(szRegistryData),
|
|
TEXT("*,%s,DefaultInstall"), PathFindFileName(szOutputFile));
|
|
InsWriteString(IS_EXTREGINF, szBaseFileName, szRegistryData, pcszInsFile);
|
|
|
|
if (!InsIsSectionEmpty(TEXT("AddRegSection.HKLM"), szOutputFile))
|
|
{
|
|
wnsprintf(szRegistryData, ARRAYSIZE(szRegistryData),
|
|
TEXT("%s,IEAKInstall.HKLM"), PathFindFileName(szOutputFile));
|
|
InsWriteString(IS_EXTREGINF_HKLM, szBaseFileName, szRegistryData, pcszInsFile);
|
|
|
|
}
|
|
if (!InsIsSectionEmpty(TEXT("AddRegSection.HKCU"), szOutputFile))
|
|
{
|
|
wnsprintf(szRegistryData, ARRAYSIZE(szRegistryData),
|
|
TEXT("%s,IEAKInstall.HKCU"), PathFindFileName(szOutputFile));
|
|
InsWriteString(IS_EXTREGINF_HKCU, szBaseFileName, szRegistryData, pcszInsFile);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
AdmClose(pADMFile->dwAdm, &pADMFile->pData, bDeleteFile);
|
|
HeapFree(GetProcessHeap(), 0, pADMFile->pszName);
|
|
HeapFree(GetProcessHeap(), 0, pADMFile);
|
|
|
|
TreeView_DeleteItem(hTreeView, hParentItem);
|
|
if(TreeView_GetCount(hTreeView) == 0) // if no items in the tree view
|
|
SetADMWindowText(hTreeView, TEXT(""), TEXT(""));
|
|
}
|
|
WritePrivateProfileString(NULL, NULL, NULL, pcszInsFile);
|
|
}
|
|
|
|
// Deletes all the items from the tree view
|
|
static void deleteADMItemsHelper(HWND hTreeView, LPCTSTR pcszWorkDir, LPCTSTR pcszInsFile,
|
|
BOOL bSave)
|
|
{
|
|
HTREEITEM hItem = GetFirstPolicyItem(hTreeView); // get policy fisrt item
|
|
HTREEITEM hNextItem = NULL;
|
|
HTREEITEM hSelectedItem = TreeView_GetSelection(hTreeView); // get selected item
|
|
|
|
if(hSelectedItem != NULL)
|
|
{
|
|
TreeView_Select(hTreeView, NULL, TVGN_CARET);
|
|
}
|
|
|
|
while(hItem != NULL) // if items in the tree view
|
|
{
|
|
hNextItem = TreeView_GetNextSibling(hTreeView, hItem); // get next item
|
|
deleteADMItemHelper(hTreeView, hItem, pcszWorkDir, pcszInsFile, FALSE, bSave);
|
|
hItem = hNextItem;
|
|
}
|
|
}
|
|
|
|
static void getADMDescriptionTitle(LPCTSTR pcszFileName, LPTSTR pszDscrTitle)
|
|
{
|
|
GetPrivateProfileString(TEXT("Strings"), TEXT("IEAK_DescriptionTitle"), TEXT(""),
|
|
pszDscrTitle, ADM_DSCRLINELEN, pcszFileName);
|
|
}
|
|
|
|
// Reads the description from the specified adm file
|
|
static void getADMDescription(LPCTSTR pcszFileName, LPTSTR pszDscr)
|
|
{
|
|
DWORD dwSize = 0;
|
|
TCHAR szDscrText[ADM_DSCRLEN];
|
|
TCHAR szDscrKey[20];
|
|
int nIndex = 0;
|
|
|
|
int nDscrLines = GetPrivateProfileInt(TEXT("IEAK"), TEXT("NumOfDescLines"), 0, pcszFileName);
|
|
|
|
*pszDscr = TEXT('\0');
|
|
for(nIndex = 1; nIndex <= nDscrLines; nIndex++)
|
|
{
|
|
wnsprintf(szDscrKey, ARRAYSIZE(szDscrKey), TEXT("IEAK_Description%d"), nIndex);
|
|
dwSize = GetPrivateProfileString(TEXT("Strings"), szDscrKey, NULL,
|
|
szDscrText, ADM_DSCRLEN, pcszFileName);
|
|
if (dwSize)
|
|
{
|
|
if(nIndex == 1)
|
|
StrCpy(pszDscr, szDscrText);
|
|
else
|
|
{
|
|
StrCat(pszDscr, TEXT("\r\n\r\n"));
|
|
StrCat(pszDscr, szDscrText);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Imports ADM file from the directory specified by the user to the
|
|
// adm directory and calls addADMItemHelper to show the item on the tree list
|
|
static void importADMFileHelper(HWND hMainWnd, HWND hTreeView, LPCTSTR pcszADMFilePath,
|
|
LPCTSTR pcszWorkDir, int nRole, LPCTSTR pcszInsFile)
|
|
{
|
|
HTREEITEM hItem = NULL;
|
|
TCHAR szFileName[MAX_PATH]=TEXT("");
|
|
LPTSTR pExt = NULL;
|
|
TCHAR szADMFileName[MAX_PATH];
|
|
TCHAR szMessage[512];
|
|
TCHAR szTitle[MAX_PATH];
|
|
|
|
LoadString(g_hDLLInst, IDS_ENGINE_TITLE, szTitle, ARRAYSIZE(szTitle));
|
|
if( BrowseForFile( hTreeView, szFileName, ARRAYSIZE(szFileName), GFN_ADM ))
|
|
{
|
|
pExt = PathFindExtension(szFileName);
|
|
if(pExt != NULL)
|
|
pExt++;
|
|
// Only .adm file extensions to be added to the list
|
|
if(StrCmpI(pExt, TEXT("adm")) == 0 || StrCmpI(pExt, TEXT("opa")) == 0)
|
|
{
|
|
PathCombine(szADMFileName, pcszADMFilePath, PathFindFileName(szFileName));
|
|
|
|
// if already there exists a file with the same name, prompt
|
|
// the user for overwrite confirmation.
|
|
if(!CopyFile(szFileName, szADMFileName, TRUE))
|
|
{
|
|
LoadString(g_hInst, IDS_ADMOVRWWARN, szMessage, ARRAYSIZE(szMessage));
|
|
if(MessageBox(hTreeView, szMessage, szTitle, MB_ICONQUESTION|MB_YESNO) == IDYES)
|
|
{
|
|
CopyFile(szFileName, szADMFileName, FALSE);
|
|
hItem = getADMItemHandle(hTreeView, szADMFileName);
|
|
if(hItem != NULL)
|
|
{
|
|
TreeView_Select(hTreeView, NULL, TVGN_CARET);
|
|
deleteADMItemHelper(hTreeView, hItem, pcszWorkDir, pcszInsFile,
|
|
FALSE, TRUE);
|
|
}
|
|
|
|
// importADMFile is never called in RSoP mode,
|
|
// so just pass in FALSE always.
|
|
hItem = addADMItemHelper(hTreeView, pcszADMFilePath,
|
|
PathFindFileName(szADMFileName), pcszWorkDir, nRole, NULL);
|
|
if(hItem != NULL)
|
|
{
|
|
TreeView_Select(hTreeView, hItem, TVGN_CARET);
|
|
CheckForDupKeys(hMainWnd, hTreeView, hItem, FALSE);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// importADMFile is never called in RSoP mode,
|
|
// so just pass in FALSE always.
|
|
if((hItem = addADMItemHelper(hTreeView, pcszADMFilePath,
|
|
PathFindFileName(szADMFileName), pcszWorkDir, nRole, NULL)) != NULL)
|
|
{
|
|
TreeView_Select(hTreeView, hItem, TVGN_CARET);
|
|
CheckForDupKeys(hMainWnd, hTreeView, hItem, FALSE);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LoadString(g_hInst, IDS_ADMINVALIDEXTN, szMessage, ARRAYSIZE(szMessage));
|
|
MessageBox(hTreeView, szMessage, szTitle, MB_ICONINFORMATION|MB_OK);
|
|
}
|
|
}
|
|
}
|
|
|
|
static INT_PTR CALLBACK logDialogProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM)
|
|
{
|
|
HANDLE hFile = NULL;
|
|
HGLOBAL hFileMem = NULL;
|
|
int nFileSize = 0;
|
|
DWORD dwRead = 0;
|
|
|
|
switch( msg )
|
|
{
|
|
case WM_INITDIALOG:
|
|
EnableDBCSChars(hDlg, IDC_LOGTEXT);
|
|
|
|
hFile = CreateFile( g_szLogFileName, GENERIC_READ, FILE_SHARE_READ,
|
|
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
|
|
if( hFile == INVALID_HANDLE_VALUE )
|
|
{
|
|
EndDialog(hDlg, 1);
|
|
break;
|
|
}
|
|
|
|
nFileSize = GetFileSize( hFile, NULL );
|
|
hFileMem = LocalAlloc( LPTR, nFileSize + 2);
|
|
if( hFileMem != NULL )
|
|
{
|
|
if (ReadFile( hFile, (LPSTR) hFileMem, (DWORD) nFileSize, &dwRead, NULL)==TRUE)
|
|
SetWindowTextA(GetDlgItem(hDlg, IDC_LOGTEXT), (LPCSTR) hFileMem);
|
|
PostMessage(GetDlgItem(hDlg, IDC_LOGTEXT), EM_SETSEL, 0, 0L);
|
|
LocalFree(hFileMem);
|
|
hFileMem = NULL;
|
|
}
|
|
CloseHandle( hFile );
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
if(HIWORD(wParam) == BN_CLICKED && LOWORD( wParam ) == IDOK)
|
|
EndDialog(hDlg, 1);
|
|
break;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//*********
|
|
// All the below functions is used only by the Profile Manager
|
|
|
|
static BOOL isPolicyTree(HWND hTreeView, HTREEITEM hItem)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
HTREEITEM hParentItem = NULL;
|
|
|
|
while(1)
|
|
{
|
|
hParentItem = TreeView_GetParent(hTreeView, hItem);
|
|
if(hParentItem == NULL)
|
|
{
|
|
bRet = (hItem == g_hPolicyRootItem) ? TRUE : FALSE;
|
|
break;
|
|
}
|
|
hItem = hParentItem;
|
|
};
|
|
|
|
return bRet;
|
|
}
|
|
|
|
static void resetAdmFilesHelper(HWND hTreeView, LPCTSTR pcszWorkDir, BOOL bReset)
|
|
{
|
|
HTREEITEM hItem = TreeView_GetChild(hTreeView, g_hPolicyRootItem); // get first policy item
|
|
HTREEITEM hNextItem = NULL;
|
|
TV_ITEM tvitem;
|
|
TCHAR szInfFile[MAX_PATH];
|
|
HTREEITEM hSelectedItem = TreeView_GetSelection(hTreeView); // get selected item
|
|
ADMFile* pADMFile = NULL;
|
|
ADMCategory* pADMCategory = NULL;
|
|
|
|
if(g_hPolicyRootItem == NULL) // no elements under policy item
|
|
return;
|
|
|
|
while(hItem != NULL) // if items in the tree view
|
|
{
|
|
hNextItem = TreeView_GetNextSibling(hTreeView, hItem); // get next item
|
|
|
|
tvitem.mask = TVIF_PARAM;
|
|
tvitem.hItem = hItem;
|
|
TreeView_GetItem(hTreeView, &tvitem);
|
|
|
|
pADMFile = (ADMFile*)tvitem.lParam;
|
|
|
|
if (hSelectedItem != NULL &&
|
|
TreeView_GetParent(hTreeView, hSelectedItem) == hItem)
|
|
{
|
|
TV_ITEM tvItem;
|
|
|
|
tvItem.mask = TVIF_PARAM;
|
|
tvItem.hItem = hSelectedItem;
|
|
TreeView_GetItem(hTreeView, &tvItem);
|
|
|
|
pADMCategory = (ADMCategory*)tvitem.lParam;
|
|
}
|
|
else
|
|
pADMCategory = NULL;
|
|
|
|
ZeroMemory(szInfFile, sizeof(szInfFile));
|
|
if(bReset)
|
|
{
|
|
getInfFileName(pADMFile->szFileName, szInfFile,
|
|
ARRAYSIZE(szInfFile), pcszWorkDir);
|
|
if (pADMCategory != NULL)
|
|
AdmReset(pADMFile->dwAdm, szInfFile, pADMFile->pData, pADMCategory->pData);
|
|
else
|
|
AdmReset(pADMFile->dwAdm, szInfFile, pADMFile->pData, NULL);
|
|
}
|
|
else
|
|
{
|
|
if (pADMCategory != NULL)
|
|
AdmReset(pADMFile->dwAdm, NULL, pADMFile->pData, pADMCategory->pData);
|
|
else
|
|
AdmReset(pADMFile->dwAdm, NULL, pADMFile->pData, NULL);
|
|
}
|
|
|
|
hItem = hNextItem;
|
|
}
|
|
|
|
if(hSelectedItem != NULL && isPolicyTree(hTreeView, hSelectedItem) && hSelectedItem != g_hPolicyRootItem &&
|
|
TreeView_GetParent(hTreeView, hSelectedItem) != g_hPolicyRootItem)
|
|
{
|
|
tvitem.mask = TVIF_PARAM;
|
|
tvitem.hItem = hSelectedItem;
|
|
TreeView_GetItem(hTreeView, &tvitem);
|
|
|
|
pADMCategory = (ADMCategory*)tvitem.lParam;
|
|
|
|
EnableWindow(pADMCategory->hWnd, TRUE);
|
|
}
|
|
}
|
|
|
|
static void saveAdmFilesHelper(HWND hTreeView, LPCTSTR pcszWorkDir, LPCTSTR pcszInsFile)
|
|
{
|
|
HTREEITEM hItem = TreeView_GetChild(hTreeView, g_hPolicyRootItem); // get first policy item
|
|
HTREEITEM hNextItem = NULL;
|
|
TV_ITEM tvitem;
|
|
TCHAR szInfFile[MAX_PATH];
|
|
TCHAR szRegistryData[MAX_PATH + 15];
|
|
TCHAR szBaseFileName[_MAX_FNAME];
|
|
LPTSTR pExt = NULL;
|
|
ADMFile* pADMFile;
|
|
|
|
if(!IsAdmDirty() || g_hPolicyRootItem == NULL) // no elements under policy item
|
|
return;
|
|
|
|
while(hItem != NULL) // if items in the tree view
|
|
{
|
|
hNextItem = TreeView_GetNextSibling(hTreeView, hItem); // get next item
|
|
|
|
tvitem.mask = TVIF_PARAM;
|
|
tvitem.hItem = hItem;
|
|
TreeView_GetItem(hTreeView, &tvitem);
|
|
|
|
pADMFile = (ADMFile*)tvitem.lParam;
|
|
|
|
ZeroMemory(szInfFile, sizeof(szInfFile));
|
|
getInfFileName(pADMFile->szFileName, szInfFile,
|
|
ARRAYSIZE(szInfFile), pcszWorkDir);
|
|
StrCpy(szBaseFileName, PathFindFileName(szInfFile));
|
|
PathRemoveExtension(szBaseFileName);
|
|
|
|
AdmFinished(pADMFile->dwAdm, szInfFile, pADMFile->pData);
|
|
if (PathFileExists(szInfFile))
|
|
{
|
|
pExt = PathFindExtension(szInfFile);
|
|
wnsprintf(szRegistryData, ARRAYSIZE(szRegistryData),
|
|
TEXT("*,%s,DefaultInstall"), PathFindFileName(szInfFile));
|
|
InsWriteString(IS_EXTREGINF, szBaseFileName, szRegistryData, pcszInsFile);
|
|
|
|
if (!InsIsSectionEmpty(TEXT("AddRegSection.HKLM"), szInfFile))
|
|
{
|
|
wnsprintf(szRegistryData, ARRAYSIZE(szRegistryData),
|
|
TEXT("%s,IEAKInstall.HKLM"), PathFindFileName(szInfFile));
|
|
InsWriteString(IS_EXTREGINF_HKLM, szBaseFileName, szRegistryData, pcszInsFile);
|
|
}
|
|
if (!InsIsSectionEmpty(TEXT("AddRegSection.HKCU"), szInfFile))
|
|
{
|
|
wnsprintf(szRegistryData, ARRAYSIZE(szRegistryData),
|
|
TEXT("%s,IEAKInstall.HKCU"), PathFindFileName(szInfFile));
|
|
InsWriteString(IS_EXTREGINF_HKCU, szBaseFileName, szRegistryData, pcszInsFile);
|
|
}
|
|
}
|
|
hItem = hNextItem;
|
|
}
|
|
WritePrivateProfileString(NULL, NULL, NULL, pcszInsFile);
|
|
}
|
|
|
|
//*********
|
|
|
|
// CDscrWnd
|
|
// This window is used to display the description title and text for the top level item selected in the treeview.
|
|
|
|
CDscrWnd::CDscrWnd()
|
|
{
|
|
hWndMain = NULL;
|
|
hWndDscrTitle = NULL;
|
|
hWndDscrText = NULL;
|
|
hFontDscrTitle = NULL;
|
|
}
|
|
|
|
CDscrWnd::~CDscrWnd()
|
|
{
|
|
if (hFontDscrTitle != NULL)
|
|
{
|
|
DeleteObject(hFontDscrTitle);
|
|
hFontDscrTitle = NULL;
|
|
}
|
|
|
|
if (hWndMain != NULL) //destroying the main window destroys its child windows
|
|
DestroyWindow(hWndMain);
|
|
}
|
|
|
|
static WNDPROC g_lpfnDscrTextWndProc = NULL;
|
|
|
|
LRESULT CALLBACK DscrTextWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (uMsg == WM_GETDLGCODE)
|
|
return (DLGC_WANTARROWS | DLGC_WANTCHARS);
|
|
return (CallWindowProc(g_lpfnDscrTextWndProc, hWnd, uMsg, wParam, lParam));
|
|
}
|
|
|
|
void CDscrWnd::Create(HWND hWndParent, HWND hWndInsertAfter, int nXPos, int nYPos, int nWidth,
|
|
int nHeight)
|
|
{
|
|
if (hWndMain != NULL) // already created
|
|
return;
|
|
|
|
// create the main window
|
|
hWndMain = CreateWindowEx(WS_EX_CONTROLPARENT, TEXT("STATIC"), TEXT(""), WS_VISIBLE | WS_CHILD | WS_GROUP,
|
|
nXPos, nYPos, nWidth, nHeight, hWndParent, NULL, g_hInst, NULL);
|
|
if (hWndMain == NULL)
|
|
return;
|
|
|
|
if (hWndInsertAfter != NULL)
|
|
SetWindowPos(hWndMain, hWndInsertAfter, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
|
|
|
|
// create the description title window
|
|
hWndDscrTitle = CreateWindowEx(0, TEXT("STATIC"), TEXT(""), WS_VISIBLE | WS_CHILD | SS_LEFT | SS_NOPREFIX,
|
|
0, 0, nWidth, 0, hWndMain, NULL, g_hInst, NULL );
|
|
if (hWndDscrTitle == NULL)
|
|
return;
|
|
|
|
// change the font of the title to make it bold
|
|
HDC hDC = GetDC(hWndDscrTitle);
|
|
|
|
if (hFontDscrTitle == NULL)
|
|
hFontDscrTitle = getBoldFont(hWndDscrTitle);
|
|
|
|
if (hFontDscrTitle)
|
|
SelectObject(hDC, hFontDscrTitle);
|
|
|
|
ReleaseDC(hWndDscrTitle, hDC);
|
|
|
|
// create the description text window
|
|
hWndDscrText = CreateWindowEx(0, TEXT("EDIT"), TEXT(""), WS_VISIBLE | WS_CHILD | WS_TABSTOP | WS_VSCROLL |
|
|
ES_LEFT | ES_MULTILINE | ES_READONLY,
|
|
0, 25, nWidth, 0, hWndMain, NULL, g_hInst, NULL );
|
|
if (hWndDscrText == NULL)
|
|
return;
|
|
|
|
// change the font of the text to default gui font
|
|
HFONT hFont = (HFONT) GetStockObject(DEFAULT_GUI_FONT);
|
|
SendMessage(hWndDscrText, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
|
|
|
|
g_lpfnDscrTextWndProc = (WNDPROC) GetWindowLongPtr(hWndDscrText, GWLP_WNDPROC);
|
|
SetWindowLongPtr(hWndDscrText, GWLP_WNDPROC, (LONG_PTR) DscrTextWndProc);
|
|
}
|
|
|
|
void CDscrWnd::ShowWindow(BOOL fShow)
|
|
{
|
|
if (hWndMain != NULL)
|
|
{
|
|
if (fShow)
|
|
::ShowWindow(hWndMain, SW_SHOWNORMAL);
|
|
else
|
|
::ShowWindow(hWndMain, SW_HIDE);
|
|
}
|
|
}
|
|
|
|
void CDscrWnd::SetText(LPCTSTR pcszTitle, LPCTSTR pcszText, BOOL fUpdateWindowState)
|
|
{
|
|
int nYPos = 0;
|
|
HDC hDC = NULL;
|
|
int nHeight = 0;
|
|
int nWidth = 0;
|
|
RECT rect;
|
|
|
|
if (hWndMain == NULL)
|
|
return;
|
|
|
|
if (fUpdateWindowState)
|
|
::ShowWindow(hWndMain, SW_SHOWNORMAL);
|
|
if (hWndDscrTitle != NULL)
|
|
{
|
|
if(pcszTitle == NULL || *pcszTitle == TEXT('\0'))
|
|
{
|
|
if (fUpdateWindowState)
|
|
::ShowWindow(hWndDscrTitle, SW_HIDE);
|
|
}
|
|
else
|
|
{
|
|
GetClientRect(GetParent(hWndDscrTitle), &rect);
|
|
nWidth = rect.right;
|
|
hDC = GetDC(hWndDscrTitle);
|
|
nHeight = DrawText(hDC, pcszTitle, -1, &rect, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
|
|
ReleaseDC(hWndDscrTitle, hDC);
|
|
SetWindowPos(hWndDscrTitle, NULL, 0, 0, nWidth, nHeight, SWP_NOMOVE | SWP_NOZORDER);
|
|
|
|
SetWindowText(hWndDscrTitle, pcszTitle);
|
|
nYPos = nHeight + 5;
|
|
if (fUpdateWindowState)
|
|
::ShowWindow(hWndDscrTitle, SW_SHOWNORMAL);
|
|
}
|
|
}
|
|
|
|
if (hWndDscrText != NULL)
|
|
{
|
|
if (pcszText == NULL || *pcszText == TEXT('\0'))
|
|
{
|
|
if (fUpdateWindowState)
|
|
::ShowWindow(hWndDscrText, SW_HIDE);
|
|
}
|
|
else
|
|
{
|
|
GetClientRect(GetParent(hWndDscrText), &rect);
|
|
SetWindowPos(hWndDscrText, NULL, 0, nYPos, rect.right, rect.bottom - nYPos, SWP_NOZORDER);
|
|
|
|
SetWindowText(hWndDscrText, pcszText);
|
|
if (fUpdateWindowState)
|
|
::ShowWindow(hWndDscrText, SW_SHOWNORMAL);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDscrWnd::GetRect(RECT* lpRect)
|
|
{
|
|
ZeroMemory(lpRect, sizeof(RECT));
|
|
if (hWndMain != NULL)
|
|
GetWindowRect(hWndMain, lpRect);
|
|
}
|
|
|
|
void CDscrWnd::MoveWindow(int nXPos, int nYPos, int nWidth, int nHeight)
|
|
{
|
|
TCHAR szDscrTitle[ADM_TITLELEN];
|
|
TCHAR szDscr[ADM_DSCRLEN];
|
|
|
|
if (hWndMain == NULL)
|
|
return;
|
|
|
|
::MoveWindow(hWndMain, nXPos, nYPos, nWidth, nHeight, TRUE);
|
|
|
|
ZeroMemory(szDscrTitle, ADM_TITLELEN);
|
|
if (hWndDscrTitle != NULL)
|
|
GetWindowText(hWndDscrTitle, szDscrTitle, ADM_TITLELEN);
|
|
|
|
ZeroMemory(szDscr, ADM_DSCRLEN);
|
|
if (hWndDscrText != NULL)
|
|
GetWindowText(hWndDscrText, szDscr, ADM_DSCRLEN);
|
|
|
|
SetText(szDscrTitle, szDscr, FALSE);
|
|
}
|
|
|
|
static HFONT getBoldFont(HWND hWnd)
|
|
{
|
|
static HFONT hFont = NULL;
|
|
LOGFONT lf;
|
|
TEXTMETRIC tm;
|
|
HDC hDC;
|
|
int nFontSize = 0;
|
|
|
|
ZeroMemory(&lf, sizeof(lf));
|
|
|
|
if (hFont == NULL)
|
|
{
|
|
if (GetFontInfo != NULL)
|
|
GetFontInfo(lf.lfFaceName, &nFontSize);
|
|
|
|
if (*(lf.lfFaceName) == TEXT('\0'))
|
|
{
|
|
StrCpy(lf.lfFaceName, TEXT("MS Sans Serif"));
|
|
nFontSize = 10;
|
|
}
|
|
|
|
hDC = GetDC(hWnd);
|
|
|
|
lf.lfHeight = -((nFontSize * GetDeviceCaps(hDC, LOGPIXELSY)) / 72);
|
|
lf.lfWeight = FW_BOLD;
|
|
|
|
GetTextMetrics(hDC, &tm);
|
|
lf.lfCharSet = tm.tmCharSet;
|
|
|
|
ReleaseDC(hWnd, hDC);
|
|
|
|
hFont = CreateFontIndirect(&lf);
|
|
}
|
|
|
|
return hFont;
|
|
}
|
|
|
|
static BOOL getAdmFileListHelper(LPRESULTITEM* pResultItems, int* pnResultItems, int nRole)
|
|
{
|
|
WIN32_FIND_DATA FindFileData;
|
|
TCHAR szFileName[MAX_PATH];
|
|
TCHAR szADMFilePath[MAX_PATH];
|
|
int nAdmFiles = 0;
|
|
int nAllocatedBuffer = 10;
|
|
|
|
*pResultItems = (LPRESULTITEM) CoTaskMemAlloc(sizeof(RESULTITEM) * nAllocatedBuffer);
|
|
if (*pResultItems == NULL)
|
|
{
|
|
ErrorMessageBox(NULL, IDS_MEMORY_ERROR, MB_ICONEXCLAMATION | MB_OK);
|
|
return FALSE;
|
|
}
|
|
|
|
// BUGBUG: for now assume the admfilepath
|
|
GetWindowsDirectory(szADMFilePath, countof(szADMFilePath));
|
|
PathAppend(szADMFilePath, TEXT("INF"));
|
|
PathCombine(szFileName, szADMFilePath, TEXT("*.adm"));
|
|
|
|
HANDLE hFind = FindFirstFile(szFileName, &FindFileData);
|
|
if(hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
TCHAR szBuffer[MAX_PATH];
|
|
LPRESULTITEM lpResultItem;
|
|
|
|
PathCombine(szFileName, szADMFilePath, FindFileData.cFileName);
|
|
|
|
if (InsIsSectionEmpty(TEXT("IEAK"), szFileName) ||
|
|
!isADMFileVisibleHelper(szFileName, nRole, g_dwPlatformId))
|
|
continue;
|
|
|
|
if (nAdmFiles >= nAllocatedBuffer)
|
|
{
|
|
LPVOID lpTemp;
|
|
|
|
nAllocatedBuffer += 5;
|
|
lpTemp = CoTaskMemRealloc(*pResultItems, sizeof(RESULTITEM) * nAllocatedBuffer);
|
|
if (lpTemp == NULL)
|
|
{
|
|
ErrorMessageBox(NULL, IDS_MEMORY_ERROR, MB_ICONINFORMATION | MB_OK);
|
|
CoTaskMemFree(*pResultItems);
|
|
*pResultItems = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
*pResultItems = (LPRESULTITEM) lpTemp;
|
|
}
|
|
|
|
ZeroMemory(&((*pResultItems)[nAdmFiles]), sizeof((*pResultItems)[nAdmFiles]));
|
|
|
|
GetPrivateProfileString(IS_STRINGS, TEXT("IEAK_Title"), szFileName,
|
|
szBuffer, countof(szBuffer), szFileName);
|
|
|
|
lpResultItem = &((*pResultItems)[nAdmFiles]);
|
|
|
|
if ((lpResultItem->pszName = (LPTSTR)CoTaskMemAlloc(StrCbFromSz(szBuffer))) != NULL)
|
|
StrCpy(lpResultItem->pszName, szBuffer);
|
|
|
|
if ((lpResultItem->pszDesc = (LPTSTR)CoTaskMemAlloc(StrCbFromSz(szFileName))) != NULL)
|
|
StrCpy(lpResultItem->pszDesc, szFileName);
|
|
|
|
nAdmFiles++;
|
|
|
|
}while(FindNextFile(hFind, &FindFileData));
|
|
FindClose(hFind);
|
|
}
|
|
|
|
*pnResultItems = nAdmFiles;
|
|
|
|
return TRUE;
|
|
}
|