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.
2248 lines
64 KiB
2248 lines
64 KiB
/*++
|
|
|
|
Copyright (c) 1989-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
customlayer.cpp
|
|
|
|
Abstract:
|
|
|
|
Code for creating, removing and editing custom layers
|
|
|
|
Author:
|
|
|
|
kinshu created July 2, 2001
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
|
|
//////////////////////// Extern variables /////////////////////////////////////
|
|
|
|
extern HWND g_hDlg;
|
|
extern HINSTANCE g_hInstance;
|
|
extern HIMAGELIST g_hImageList;
|
|
extern DatabaseTree DBTree;
|
|
extern struct DataBase GlobalDataBase;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////// Global Variables /////////////////////////////////////
|
|
|
|
// Pointer to the instance of CCustomLayer
|
|
CCustomLayer* g_pCustomLayer;
|
|
|
|
//
|
|
// The layer that was passed to us through the lParam when we created the dialog.
|
|
// If we are editing a layer, this will point to the layer being modified. If we want to
|
|
// create a new layer, the caller of the dialog box, creates a new layer and passes the pointer
|
|
// to that while calling the dialog box. If user presses cancel when creating a new layer, caller
|
|
// must free the new layer.
|
|
static PLAYER_FIX s_pLayerParam = NULL;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////// Function Declarations ///////////////////////////////
|
|
|
|
|
|
void
|
|
ResizeControls(
|
|
HWND hdlg
|
|
);
|
|
|
|
void
|
|
RemoveAll(
|
|
HWND hDlg
|
|
);
|
|
|
|
void
|
|
SetOkParamsStatus(
|
|
HWND hdlg
|
|
);
|
|
|
|
BOOL
|
|
HandleNotifyShimList(
|
|
HWND hDlg,
|
|
LPARAM lParam
|
|
);
|
|
|
|
BOOL
|
|
HandleNotifyLayerList(
|
|
HWND hDlg,
|
|
LPARAM lParam
|
|
);
|
|
|
|
void
|
|
ShowParams(
|
|
HWND hDlg,
|
|
HWND hwndList
|
|
);
|
|
|
|
void
|
|
RemoveSingleItem(
|
|
HWND hdlg,
|
|
INT iIndex,
|
|
BOOL bOnlySelected
|
|
);
|
|
|
|
void
|
|
OnCopy(
|
|
HWND hdlg
|
|
);
|
|
|
|
void
|
|
LoadCombo(
|
|
HWND hdlg
|
|
);
|
|
|
|
INT_PTR
|
|
CALLBACK
|
|
CustomLayerProc(
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
);
|
|
|
|
INT_PTR
|
|
CALLBACK
|
|
ChooseLayersProc(
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
);
|
|
|
|
void
|
|
OnDone(
|
|
HWND hDlg,
|
|
PLAYER_FIX pLayerParam
|
|
);
|
|
|
|
void
|
|
PopulateLists(
|
|
HWND hdlg,
|
|
PLAYER_FIX pLayerParam,
|
|
BOOL bSelChange
|
|
);
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL
|
|
CheckLayerInUse(
|
|
IN PLAYER_FIX_LIST plfl,
|
|
IN PLAYER_FIX plfArg
|
|
)
|
|
/*++
|
|
|
|
CheckLayerInUse
|
|
|
|
Desc: Checks if the layer plfArg is pointed to by plfl. This is used when we want to
|
|
check if some layer list contains a particular layer
|
|
|
|
Params:
|
|
IN PLAYER_FIX_LIST plfl: The layer list in which to check
|
|
IN PLAYER_FIX plfArg: The layer to check
|
|
|
|
Return:
|
|
TRUE: If the layer exists in the layer list
|
|
FALSE: Otherwise
|
|
--*/
|
|
{
|
|
if (plfl == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// For all the layer fix lists in the list headed by plfl, check if any one of
|
|
// is for plfArg
|
|
//
|
|
while (plfl) {
|
|
|
|
assert(plfl->pLayerFix);
|
|
|
|
if (plfl->pLayerFix == plfArg) {
|
|
return TRUE;
|
|
}
|
|
|
|
plfl = plfl->pNext;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
OnRemove(
|
|
IN HWND hDlg
|
|
)
|
|
/*++
|
|
OnRemove
|
|
|
|
Desc: Moves a selected list item from the layer list (RHS) to the shim list (LHS)
|
|
|
|
Params:
|
|
IN HWND hDlg: The handle to the customlayer dialog
|
|
|
|
Return:
|
|
void
|
|
--*/
|
|
{
|
|
HWND hwndLayerList = GetDlgItem(hDlg, IDC_LAYERLIST);
|
|
HWND hwndShimList = GetDlgItem(hDlg, IDC_SHIMLIST);
|
|
LVITEM lvi;
|
|
INT nCount;
|
|
INT nTotal;
|
|
PSHIM_FIX_LIST psflInLayerList = NULL;
|
|
PFLAG_FIX_LIST pfflInLayerList = NULL;
|
|
|
|
ZeroMemory(&lvi, sizeof(lvi));
|
|
|
|
SendMessage(hwndLayerList, WM_SETREDRAW, FALSE, 0);
|
|
SendMessage(hwndShimList, WM_SETREDRAW, FALSE, 0);
|
|
|
|
//
|
|
// Enumerate all the selected items and add them to the shim list
|
|
//
|
|
nTotal = ListView_GetItemCount(hwndLayerList);
|
|
|
|
for (nCount= nTotal - 1; nCount >= 0; --nCount) {
|
|
RemoveSingleItem(hDlg, nCount, TRUE); // Remove only if selected
|
|
}
|
|
|
|
SendMessage(hwndLayerList, WM_SETREDRAW, TRUE, 0);
|
|
SendMessage(hwndShimList, WM_SETREDRAW, TRUE, 0);
|
|
|
|
InvalidateRect(hwndShimList, NULL, TRUE);
|
|
InvalidateRect(hwndLayerList, NULL, TRUE);
|
|
|
|
UpdateWindow(hwndShimList);
|
|
UpdateWindow(hwndLayerList);
|
|
}
|
|
|
|
void
|
|
OnAdd(
|
|
IN HWND hDlg
|
|
)
|
|
/*++
|
|
OnAdd
|
|
|
|
Desc: Moves a selected list item from the shim list (LHS) to the layer list (RHS)
|
|
|
|
Params:
|
|
IN HWND hDlg: The handle to the customlayer dialog
|
|
|
|
Return:
|
|
void
|
|
--*/
|
|
|
|
{
|
|
HWND hwndShimList = GetDlgItem(hDlg, IDC_SHIMLIST);
|
|
HWND hwndLayerList = GetDlgItem(hDlg, IDC_LAYERLIST);
|
|
PSHIM_FIX_LIST psflInShimList = NULL;
|
|
PFLAG_FIX_LIST pfflInShimList = NULL;
|
|
LVITEM lvi;
|
|
INT nCount;
|
|
INT nTotal;
|
|
|
|
ZeroMemory(&lvi, sizeof(lvi));
|
|
|
|
SendMessage(hwndShimList, WM_SETREDRAW, FALSE, 0);
|
|
SendMessage(hwndLayerList, WM_SETREDRAW, FALSE, 0);
|
|
|
|
nTotal = ListView_GetItemCount(hwndShimList);
|
|
|
|
//
|
|
// Enumerate all the selected items and add them to the layer list
|
|
//
|
|
for (nCount= nTotal - 1; nCount >= 0; --nCount) {
|
|
|
|
lvi.mask = LVIF_PARAM | LVIF_STATE ;
|
|
lvi.stateMask = LVIS_SELECTED;
|
|
lvi.iItem = nCount;
|
|
lvi.iSubItem = 0;
|
|
|
|
if (!ListView_GetItem(hwndShimList, &lvi)) {
|
|
assert(FALSE);
|
|
continue;
|
|
}
|
|
|
|
if (lvi.state & LVIS_SELECTED) {
|
|
|
|
TYPE type = ConvertLparam2Type(lvi.lParam);
|
|
|
|
if (type == FIX_LIST_SHIM) {
|
|
//
|
|
// This is a shim
|
|
//
|
|
psflInShimList = (PSHIM_FIX_LIST)lvi.lParam;
|
|
|
|
if (psflInShimList->pShimFix == NULL) {
|
|
assert(FALSE);
|
|
continue;
|
|
}
|
|
|
|
lvi.mask = LVIF_PARAM | LVIF_TEXT;
|
|
lvi.pszText = psflInShimList->pShimFix->strName.pszString;
|
|
lvi.iImage = IMAGE_SHIM;
|
|
lvi.iItem = 0;
|
|
lvi.iSubItem = 0;
|
|
lvi.lParam = (LPARAM)psflInShimList;
|
|
|
|
INT iIndex = ListView_InsertItem(hwndLayerList, &lvi);
|
|
|
|
//
|
|
// Add the command line and the params in the expert mode
|
|
//
|
|
if (g_bExpert) {
|
|
|
|
//
|
|
// We need to set the commandline in the list view, if we are in
|
|
// expert mode. Unlike flags, shims can have include-exclude params
|
|
// in addition to command line parameter
|
|
//
|
|
ListView_SetItemText(hwndLayerList,
|
|
iIndex,
|
|
1,
|
|
psflInShimList->strCommandLine);
|
|
|
|
ListView_SetItemText(hwndLayerList,
|
|
iIndex,
|
|
2,
|
|
psflInShimList->strlInExclude.IsEmpty() ?
|
|
GetString(IDS_NO) : GetString(IDS_YES));
|
|
}
|
|
|
|
} else if (type == FIX_LIST_FLAG) {
|
|
//
|
|
// This is a flag
|
|
//
|
|
pfflInShimList = (PFLAG_FIX_LIST)lvi.lParam;
|
|
|
|
if (pfflInShimList->pFlagFix == NULL) {
|
|
assert(FALSE);
|
|
continue;
|
|
}
|
|
|
|
lvi.mask = LVIF_PARAM | LVIF_TEXT;
|
|
lvi.pszText = pfflInShimList->pFlagFix->strName.pszString;
|
|
lvi.iImage = IMAGE_SHIM;
|
|
lvi.iItem = 0;
|
|
lvi.iSubItem = 0;
|
|
lvi.lParam = (LPARAM)pfflInShimList;
|
|
INT iIndex = ListView_InsertItem(hwndLayerList, &lvi);
|
|
|
|
if (g_bExpert) {
|
|
//
|
|
// We need to set the commandline in the list view, if we are in
|
|
// expert mode. Unlike shims flags can only have command lines, they
|
|
// do not have any include-exclude params
|
|
//
|
|
ListView_SetItemText(hwndLayerList,
|
|
iIndex,
|
|
1,
|
|
pfflInShimList->strCommandLine);
|
|
|
|
ListView_SetItemText(hwndLayerList, iIndex, 2, GetString(IDS_NO));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Remove the shim or flag from the shim list (LHS)
|
|
//
|
|
ListView_DeleteItem(hwndShimList, nCount);
|
|
}
|
|
}
|
|
|
|
SendMessage(hwndShimList, WM_SETREDRAW, TRUE, 0);
|
|
SendMessage(hwndLayerList, WM_SETREDRAW, TRUE, 0);
|
|
|
|
InvalidateRect(hwndLayerList, NULL, TRUE);
|
|
InvalidateRect(hwndShimList, NULL, TRUE);
|
|
|
|
UpdateWindow(hwndLayerList);
|
|
UpdateWindow(hwndShimList);
|
|
|
|
}
|
|
|
|
BOOL
|
|
CCustomLayer::AddCustomLayer(
|
|
OUT PLAYER_FIX pLayer,
|
|
IN PDATABASE pDatabase
|
|
)
|
|
/*++
|
|
|
|
CCustomLayer::AddCustomLayer
|
|
|
|
Desc: Sets the shims and/or flags for a new layer
|
|
|
|
Params:
|
|
OUT PLAYER_FIX pLayer: The pointer to the layer for which we have to
|
|
set the shims and/or flags. If we return FALSE, the caller should delete
|
|
it.
|
|
|
|
IN PDATABASE pDatabase: The presently selected database
|
|
|
|
|
|
Return:
|
|
TRUE: If the shims and/or flags have been properly set, the user pressed OK on the
|
|
custom layer dialog
|
|
|
|
FALSE: Otherwise
|
|
--*/
|
|
{
|
|
g_pCustomLayer = this;
|
|
m_uMode = LAYERMODE_ADD;
|
|
m_pCurrentSelectedDB = pDatabase;
|
|
|
|
return DialogBoxParam(g_hInstance,
|
|
MAKEINTRESOURCE(IDD_CUSTOMLAYER),
|
|
g_hDlg,
|
|
CustomLayerProc,
|
|
(LPARAM)pLayer);
|
|
}
|
|
|
|
BOOL
|
|
CCustomLayer::EditCustomLayer(
|
|
IN OUT PLAYER_FIX pLayer,
|
|
IN PDATABASE pDatabase
|
|
)
|
|
/*++
|
|
|
|
CCustomLayer::EditCustomLayer
|
|
|
|
Desc: Modifies the shims and/or flags for an existing layer
|
|
|
|
Params:
|
|
IN OUT PLAYER_FIX pLayer: The pointer to the layer for which we have to
|
|
set the shims and/or flags. If we return FALSE this means that the layer
|
|
was not modified
|
|
|
|
IN PDATABASE pDatabase: The presnntly selected database
|
|
|
|
Return:
|
|
TRUE: If the shims and/or flags have been modified, the user pressed OK on the
|
|
custom layer dialog
|
|
|
|
FALSE: Otherwise
|
|
--*/
|
|
{
|
|
g_pCustomLayer = this;
|
|
m_uMode = LAYERMODE_EDIT;
|
|
m_pCurrentSelectedDB = pDatabase;
|
|
|
|
return DialogBoxParam(g_hInstance,
|
|
MAKEINTRESOURCE(IDD_CUSTOMLAYER),
|
|
g_hDlg,
|
|
CustomLayerProc,
|
|
(LPARAM)pLayer);
|
|
}
|
|
|
|
void
|
|
OnCustomLayerInitDialog(
|
|
IN HWND hDlg,
|
|
IN LPARAM lParam
|
|
)
|
|
/*++
|
|
DoInitDialog
|
|
|
|
Desc: Handles the WM_INITDIALOG message for the custom layer dialog box
|
|
If we are in non-expert mode, calls ResizeControls() so that the sizes
|
|
of both the list views is same
|
|
|
|
Params:
|
|
IN HWND hdlg: The custom layer dialog.
|
|
IN LPARAM lParam: This will contain the pointer to a LAYER_FIX
|
|
This is the layer that was passed to us through the lParam when we created the
|
|
dialog. If we are editing a layer, this will point to the layer being
|
|
modified. If we want to create a new layer, the caller of the dialog box,
|
|
creates a new layer and passes the pointer to that while calling the
|
|
dialog box. If user presses cancel when creating a new layer, caller
|
|
must free the new layer.
|
|
|
|
Return:
|
|
void
|
|
--*/
|
|
{
|
|
if (lParam == NULL) {
|
|
assert(FALSE);
|
|
return;
|
|
}
|
|
|
|
HWND hwndLayerList = GetDlgItem(hDlg, IDC_LAYERLIST);
|
|
HWND hwndShimList = GetDlgItem(hDlg, IDC_SHIMLIST);
|
|
|
|
//
|
|
// Add the columns for the list views and set the image lists. The layer list
|
|
// will have columns for the commandline and the include-exclude params only
|
|
// in expert mode
|
|
//
|
|
ListView_SetImageList(hwndLayerList, g_hImageList, LVSIL_SMALL);
|
|
ListView_SetImageList(hwndShimList, g_hImageList, LVSIL_SMALL);
|
|
|
|
InsertColumnIntoListView(hwndShimList,
|
|
CSTRING(IDS_COL_FIXNAME),
|
|
0,
|
|
100);
|
|
|
|
InsertColumnIntoListView(hwndLayerList,
|
|
CSTRING(IDS_COL_FIXNAME),
|
|
0,
|
|
g_bExpert ? 50 : 100);
|
|
|
|
if (g_bExpert) {
|
|
|
|
InsertColumnIntoListView(hwndLayerList, CSTRING(IDS_COL_CMDLINE), 1, 30);
|
|
InsertColumnIntoListView(hwndLayerList, CSTRING(IDS_COL_MODULE), 2, 20);
|
|
|
|
ListView_SetColumnWidth(hwndLayerList, 2, LVSCW_AUTOSIZE_USEHEADER);
|
|
|
|
} else {
|
|
//
|
|
// We do not allow to configure parameters in non-expert mode
|
|
//
|
|
ShowWindow(GetDlgItem(hDlg, IDC_PARAMS), SW_HIDE);
|
|
ListView_SetColumnWidth(hwndLayerList, 0, LVSCW_AUTOSIZE_USEHEADER);
|
|
}
|
|
|
|
ListView_SetExtendedListViewStyleEx(hwndShimList,
|
|
0,
|
|
LVS_EX_LABELTIP | LVS_EX_FULLROWSELECT);
|
|
|
|
ListView_SetExtendedListViewStyleEx(hwndLayerList,
|
|
0,
|
|
LVS_EX_LABELTIP | LVS_EX_FULLROWSELECT);
|
|
//
|
|
// When this dialog is called, it is passed a PLAYER_FIX. This will be either a
|
|
// new PLAYER_FIX if want to create a new layer or an existing one in case
|
|
// we are trying to modify an existing one
|
|
//
|
|
s_pLayerParam = (PLAYER_FIX)lParam;
|
|
|
|
if (g_pCustomLayer->m_uMode == LAYERMODE_ADD) {
|
|
//
|
|
// We are creating a new layer
|
|
//
|
|
ENABLEWINDOW(GetDlgItem(hDlg, IDC_NAME), TRUE);
|
|
|
|
ShowWindow(GetDlgItem(hDlg, IDC_NAME), SW_SHOW);
|
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_NAME),
|
|
EM_LIMITTEXT,
|
|
(WPARAM)
|
|
LIMIT_LAYER_NAME,
|
|
(LPARAM)0);
|
|
|
|
ENABLEWINDOW(GetDlgItem(hDlg, IDOK), FALSE);
|
|
|
|
SetFocus(GetDlgItem(hDlg, IDC_NAME));
|
|
|
|
} else {
|
|
//
|
|
// We want to edit an existing layer
|
|
//
|
|
int iPos = -1;
|
|
|
|
ENABLEWINDOW(GetDlgItem(hDlg, IDC_COMBO), TRUE);
|
|
|
|
ShowWindow (GetDlgItem(hDlg, IDC_COMBO), SW_SHOW);
|
|
|
|
//
|
|
// Load the combo box with the names of the existing layers
|
|
// for the present database.
|
|
//
|
|
LoadCombo(hDlg);
|
|
|
|
//
|
|
// Set the selection in the combo box to the layer that was passed to us
|
|
//
|
|
if (s_pLayerParam) {
|
|
|
|
iPos = SendMessage(GetDlgItem(hDlg, IDC_COMBO),
|
|
CB_SELECTSTRING,
|
|
(WPARAM)0,
|
|
(LPARAM)(s_pLayerParam->strName.pszString));
|
|
|
|
assert(iPos != CB_ERR);
|
|
}
|
|
|
|
SetFocus(GetDlgItem(hDlg, IDC_COMBO));
|
|
SetWindowText (hDlg, GetString(IDS_EDITCUSTOMCOMPATDLG));
|
|
}
|
|
|
|
//
|
|
// Populate both the shim list and the layer lust. Since we are
|
|
// editing a layer here, the layer list will contain the fixes for
|
|
// the layer being edited
|
|
//
|
|
PopulateLists(hDlg, s_pLayerParam, FALSE);
|
|
|
|
if (g_bExpert == FALSE) {
|
|
//
|
|
// We are in non-expert mode, so we must make the sizes of both the list view
|
|
// controls equal as we will now not show the command lines and the params of
|
|
// the shims in the layer list view(RHS). We will also need to move the buttons
|
|
//
|
|
ResizeControls(hDlg);
|
|
}
|
|
|
|
SetFocus(GetDlgItem(hDlg, IDC_SHIMLIST));
|
|
}
|
|
|
|
BOOL
|
|
CALLBACK
|
|
CustomLayerProc(
|
|
IN HWND hDlg,
|
|
IN UINT uMsg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
/*++
|
|
|
|
CustomLayerProc
|
|
|
|
Desc: The dialog proc for the custom layer
|
|
|
|
Params: Standard dialog handler parameters
|
|
|
|
IN HWND hDlg
|
|
IN UINT uMsg
|
|
IN WPARAM wParam
|
|
IN LPARAM lParam: This will contain the pointer to a LAYER_FIX
|
|
This is the layer that was passed to us thorugh the lParam when we created the
|
|
dialog. If we are editing a layer, this will point to the layer being
|
|
modified. If we want to create a new layer, the caller of the dialog box,
|
|
creates a new layer and passes the pointer to that while calling the
|
|
dialog box. If user presses cancel when creating a new layer, caller
|
|
must free the new layer.
|
|
|
|
Return: Standard dialog handler return
|
|
|
|
--*/
|
|
{
|
|
switch (uMsg) {
|
|
case WM_INITDIALOG:
|
|
|
|
OnCustomLayerInitDialog(hDlg, lParam);
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
{
|
|
LPNMHDR lpnmhdr = (LPNMHDR)lParam;
|
|
|
|
if (lpnmhdr == NULL) {
|
|
break;
|
|
}
|
|
|
|
if (lpnmhdr->idFrom == IDC_SHIMLIST) {
|
|
return HandleNotifyShimList(hDlg, lParam);
|
|
|
|
} else if (lpnmhdr->idFrom == IDC_LAYERLIST) {
|
|
return HandleNotifyLayerList(hDlg, lParam);
|
|
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case WM_DESTROY:
|
|
{
|
|
HWND hwndLayerList = GetDlgItem(hDlg, IDC_SHIMLIST);
|
|
int nTotal = ListView_GetItemCount(hwndLayerList);
|
|
LVITEM lvi;
|
|
|
|
ZeroMemory(&lvi, sizeof(lvi));
|
|
|
|
lvi.mask = LVIF_PARAM;
|
|
lvi.iSubItem = 0;
|
|
|
|
//
|
|
// Enumerate all the shims/flags listed on the shim side and delete
|
|
// their corresponding PSHIM_FIX_LIST
|
|
// or PFLAG_FIX_LIST
|
|
//
|
|
for (int nCount = 0; nCount < nTotal; ++nCount) {
|
|
|
|
lvi.iItem = nCount;
|
|
|
|
if (!ListView_GetItem(hwndLayerList, &lvi)) {
|
|
assert(FALSE);
|
|
continue;
|
|
}
|
|
|
|
TYPE type = ConvertLparam2Type(lvi.lParam);
|
|
|
|
if (type == FIX_LIST_SHIM) {
|
|
DeleteShimFixList((PSHIM_FIX_LIST)lvi.lParam);
|
|
|
|
} else if (type == FIX_LIST_FLAG) {
|
|
DeleteFlagFixList((PFLAG_FIX_LIST)lvi.lParam);
|
|
|
|
} else {
|
|
//
|
|
// Invalid type for this operation
|
|
//
|
|
assert(FALSE);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case WM_COMMAND:
|
|
|
|
switch (LOWORD(wParam)) {
|
|
case IDC_NAME:
|
|
{
|
|
//
|
|
// The Ok button will be enabled only if the IDC_NAME, text box is non-empty and the
|
|
// the number of elements in the IDC_LAYERLIST is > 0
|
|
//
|
|
if (EN_UPDATE == HIWORD(wParam)) {
|
|
|
|
TCHAR szText[MAX_PATH_BUFFSIZE];
|
|
UINT uTotal = ListView_GetItemCount(GetDlgItem(hDlg,
|
|
IDC_LAYERLIST));
|
|
BOOL bEnable = TRUE;
|
|
|
|
*szText = 0;
|
|
|
|
GetDlgItemText(hDlg,
|
|
IDC_NAME,
|
|
szText,
|
|
ARRAYSIZE(szText));
|
|
|
|
bEnable = (uTotal > 0) && CSTRING::Trim(szText);
|
|
|
|
ENABLEWINDOW(GetDlgItem(hDlg, IDOK), bEnable);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case IDC_REMOVEALL:
|
|
|
|
RemoveAll(hDlg);
|
|
break;
|
|
|
|
case IDC_COPY:
|
|
|
|
OnCopy(hDlg);
|
|
SetOkParamsStatus(hDlg);
|
|
break;
|
|
|
|
case IDC_ADD:
|
|
|
|
OnAdd(hDlg);
|
|
SetOkParamsStatus(hDlg);
|
|
break;
|
|
|
|
case IDC_REMOVE:
|
|
|
|
OnRemove(hDlg);
|
|
SetOkParamsStatus(hDlg);
|
|
break;
|
|
|
|
case IDOK://DONE Button
|
|
|
|
OnDone(hDlg, s_pLayerParam);
|
|
break;
|
|
|
|
case IDC_PARAMS:
|
|
|
|
ShowParams(hDlg, GetDlgItem(hDlg, IDC_LAYERLIST));
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
case IDC_CANCEL:
|
|
{
|
|
//
|
|
// Note: We only free the items for the layer list here.
|
|
// The items for the shim list will be freed up in destroy
|
|
//
|
|
HWND hwndLayerList = GetDlgItem(hDlg, IDC_LAYERLIST);
|
|
int nTotal = ListView_GetItemCount(hwndLayerList);
|
|
LVITEM lvi;
|
|
|
|
ZeroMemory(&lvi, sizeof(lvi));
|
|
|
|
lvi.mask = LVIF_PARAM;
|
|
lvi.iSubItem = 0;
|
|
|
|
//
|
|
// Enumerate all the shims/flags listed on the layer side and delete
|
|
// their corresponding PSHIM_FIX_LIST
|
|
// or PFLAG_FIX_LIST
|
|
//
|
|
for (int nCount = 0; nCount < nTotal; ++nCount) {
|
|
|
|
lvi.iItem = nCount;
|
|
|
|
if (!ListView_GetItem(hwndLayerList, &lvi)) {
|
|
assert(FALSE);
|
|
continue;
|
|
}
|
|
|
|
TYPE type = ConvertLparam2Type(lvi.lParam);
|
|
|
|
if (type == FIX_LIST_SHIM) {
|
|
DeleteShimFixList((PSHIM_FIX_LIST)lvi.lParam);
|
|
|
|
} else if (type == FIX_LIST_FLAG) {
|
|
DeleteFlagFixList((PFLAG_FIX_LIST)lvi.lParam);
|
|
|
|
} else {
|
|
//
|
|
// Invalid type for this operation
|
|
//
|
|
assert(FALSE);
|
|
}
|
|
}
|
|
|
|
EndDialog(hDlg, FALSE);
|
|
}
|
|
|
|
break;
|
|
|
|
case IDC_COMBO:
|
|
{
|
|
HWND hwndCombo = GetDlgItem(hDlg, IDC_COMBO);
|
|
|
|
if (HIWORD(wParam) == CBN_SELCHANGE) {
|
|
|
|
int iPos = SendMessage(hwndCombo,
|
|
CB_GETCURSEL,
|
|
0,
|
|
0);
|
|
|
|
if (iPos == CB_ERR) {
|
|
break;
|
|
}
|
|
|
|
s_pLayerParam = (PLAYER_FIX)SendMessage(hwndCombo,
|
|
CB_GETITEMDATA,
|
|
iPos,
|
|
0);
|
|
//
|
|
// We need to repopulate the lists with the new layer that was selected
|
|
//
|
|
PopulateLists(hDlg, s_pLayerParam, TRUE);
|
|
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return FALSE;
|
|
break;
|
|
}
|
|
|
|
default:return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
INT_PTR
|
|
CALLBACK
|
|
ChooseLayersProc(
|
|
IN HWND hDlg,
|
|
IN UINT uMsg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
/*++
|
|
|
|
ChooseLayersProc
|
|
|
|
Desc: The dialog proc for the dialog that allows us to choose a layer, when we do a Copy
|
|
layer operation from the custom layer dialog
|
|
|
|
Params: Standard dialog handler parameters
|
|
|
|
IN HWND hDlg
|
|
IN UINT uMsg
|
|
IN WPARAM wParam
|
|
IN LPARAM lParam
|
|
|
|
Return:
|
|
PLAYER_FIX of selected layer, if OK is pressed
|
|
NULL, otherwise
|
|
--*/
|
|
{
|
|
switch (uMsg) {
|
|
case WM_INITDIALOG:
|
|
{
|
|
PLAYER_FIX pLayerFix = NULL;
|
|
//
|
|
// Add the global layers
|
|
//
|
|
pLayerFix = GlobalDataBase.pLayerFixes;
|
|
|
|
while (NULL != pLayerFix) {
|
|
|
|
int nIndex = SendDlgItemMessage(hDlg,
|
|
IDC_LIST,
|
|
LB_ADDSTRING,
|
|
0,
|
|
(LPARAM)(LPCTSTR)pLayerFix->strName);
|
|
|
|
if (LB_ERR != nIndex) {
|
|
|
|
SendDlgItemMessage(hDlg,
|
|
IDC_LIST,
|
|
LB_SETITEMDATA,
|
|
nIndex,
|
|
(LPARAM)pLayerFix);
|
|
}
|
|
|
|
pLayerFix = pLayerFix->pNext;
|
|
}
|
|
//
|
|
// Add the custom layers
|
|
//
|
|
pLayerFix = g_pCustomLayer->m_pCurrentSelectedDB->pLayerFixes;
|
|
|
|
while (NULL != pLayerFix) {
|
|
|
|
int nIndex = SendDlgItemMessage(hDlg,
|
|
IDC_LIST,
|
|
LB_ADDSTRING,
|
|
0,
|
|
(LPARAM)(LPCTSTR)pLayerFix->strName);
|
|
|
|
if (LB_ERR != nIndex) {
|
|
|
|
SendDlgItemMessage(hDlg,
|
|
IDC_LIST,
|
|
LB_SETITEMDATA,
|
|
nIndex,
|
|
(LPARAM)pLayerFix);
|
|
}
|
|
|
|
pLayerFix = pLayerFix->pNext;
|
|
}
|
|
|
|
SendMessage(GetDlgItem(hDlg, IDC_LIST), LB_SETCURSEL, (WPARAM)0, (LPARAM)0);
|
|
|
|
SetFocus(GetDlgItem (hDlg, IDC_LIST));
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
{
|
|
switch (LOWORD(wParam)) {
|
|
case IDC_LIST:
|
|
|
|
if (LB_ERR == SendMessage(GetDlgItem(hDlg, IDC_LIST), LB_GETCURSEL, 0, 0)) {
|
|
ENABLEWINDOW(GetDlgItem(hDlg, IDOK), FALSE);
|
|
|
|
} else {
|
|
ENABLEWINDOW(GetDlgItem(hDlg, IDOK), TRUE);
|
|
}
|
|
|
|
break;
|
|
|
|
case IDOK:
|
|
{
|
|
int nIndex = SendMessage(GetDlgItem(hDlg, IDC_LIST), LB_GETCURSEL, 0, 0);
|
|
|
|
|
|
PLAYER_FIX pLayerTemp = (PLAYER_FIX) SendDlgItemMessage(hDlg,
|
|
IDC_LIST,
|
|
LB_GETITEMDATA,
|
|
nIndex,
|
|
0);
|
|
|
|
if (pLayerTemp == NULL) {
|
|
assert(FALSE);
|
|
break;
|
|
}
|
|
|
|
EndDialog(hDlg, (INT_PTR)pLayerTemp);
|
|
}
|
|
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
|
|
EndDialog(hDlg, NULL);
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
RemoveLayer(
|
|
IN PDATABASE pDataBase,
|
|
IN PLAYER_FIX pLayerToRemove,
|
|
OUT HTREEITEM* pHItem
|
|
)
|
|
/*++
|
|
|
|
RemoveLayer
|
|
|
|
Desc: Removes a layer from a database
|
|
|
|
Params:
|
|
IN PDATABASE pDataBase: The database in which the layer resides
|
|
IN PLAYER_FIX pLayerToRemove: The layer to remove
|
|
OUT HTREEITEM* pHItem: If this not null, then we can save the hitem
|
|
for the layer in the db tree in this variable
|
|
|
|
Warn: Before removing a layer we must make sure that this layer is not in use
|
|
|
|
Return:
|
|
TRUE: We managed to remove the layer
|
|
FALSE: Otherwise
|
|
|
|
--*/
|
|
{
|
|
HTREEITEM hItem;
|
|
LPARAM lParam;
|
|
PDBENTRY pEntry = NULL, pApp = NULL;
|
|
PLAYER_FIX plfTemp = NULL;
|
|
PLAYER_FIX plfPrev = NULL;
|
|
CSTRING strMessage;
|
|
|
|
if (pDataBase == NULL || pLayerToRemove == NULL) {
|
|
assert(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
pApp = pEntry = pDataBase->pEntries;
|
|
|
|
//
|
|
// Check if the layer is in use by any entry
|
|
//
|
|
while (NULL != pEntry) {
|
|
|
|
if (CheckLayerInUse(pEntry->pFirstLayer, pLayerToRemove)) {
|
|
//
|
|
// This layer is applied to some app and cannot be removed
|
|
//
|
|
|
|
strMessage.Sprintf(GetString(IDS_UNABLETOREMOVE_MODE),
|
|
(LPCTSTR)pLayerToRemove->strName,
|
|
(LPCTSTR)pEntry->strExeName,
|
|
(LPCTSTR)pEntry->strAppName);
|
|
|
|
MessageBox(g_hDlg,
|
|
(LPCTSTR)strMessage,
|
|
g_szAppName,
|
|
MB_ICONWARNING);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if (pEntry->pSameAppExe) {
|
|
pEntry = pEntry->pSameAppExe;
|
|
} else {
|
|
pEntry = pApp->pNext;
|
|
pApp = pApp->pNext;
|
|
}
|
|
}
|
|
|
|
plfTemp = pDataBase->pLayerFixes, plfPrev = NULL;
|
|
|
|
while (plfTemp) {
|
|
|
|
if (plfTemp == pLayerToRemove) {
|
|
break;
|
|
}
|
|
|
|
plfPrev = plfTemp;
|
|
plfTemp = plfTemp->pNext;
|
|
}
|
|
|
|
if (plfTemp) {
|
|
//
|
|
// The layer was found
|
|
//
|
|
if (plfPrev) {
|
|
plfPrev->pNext = plfTemp->pNext;
|
|
} else {
|
|
//
|
|
// This was the first layer of the database
|
|
//
|
|
pDataBase->pLayerFixes = plfTemp->pNext;
|
|
}
|
|
}
|
|
|
|
hItem = pDataBase->hItemAllLayers;
|
|
|
|
//
|
|
// Set the phItem properly if asked to. This is the hItem of the layer in the Lib Tree. This can be used to
|
|
// remove the item directly.
|
|
//
|
|
if (pHItem) {
|
|
|
|
*pHItem = NULL;
|
|
|
|
while (hItem) {
|
|
|
|
DBTree.GetLParam(hItem, &lParam);
|
|
|
|
if ((PLAYER_FIX)lParam == pLayerToRemove) {
|
|
*pHItem = hItem;
|
|
break;
|
|
}
|
|
|
|
hItem = TreeView_GetNextSibling(DBTree.m_hLibraryTree, hItem);
|
|
}
|
|
}
|
|
|
|
ValidateClipBoard(NULL, (LPVOID)plfTemp);
|
|
|
|
if (plfTemp) {
|
|
delete plfTemp;
|
|
plfTemp = NULL;
|
|
}
|
|
|
|
pDataBase->uLayerCount--;
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
PopulateLists(
|
|
IN HWND hdlg,
|
|
IN PLAYER_FIX pLayerParam,
|
|
IN BOOL bSelChange
|
|
)
|
|
/*++
|
|
|
|
PopulateLists
|
|
|
|
Desc: Populates both the shim list (LHS) and the layer list (RHS)
|
|
|
|
Params:
|
|
IN HWND hdlg: The custom layer dialog proc
|
|
IN PLAYER_FIX pLayerParam: The layer that has to be shown in the layer list
|
|
IN BOOL bSelChange: Is this because of a selchange in the combo box
|
|
|
|
Return:
|
|
void
|
|
--*/
|
|
{
|
|
HWND hwndShimList = GetDlgItem(hdlg, IDC_SHIMLIST);
|
|
HWND hwndLayerList = GetDlgItem(hdlg, IDC_LAYERLIST);
|
|
PSHIM_FIX psf = GlobalDataBase.pShimFixes;
|
|
PFLAG_FIX pff = GlobalDataBase.pFlagFixes;
|
|
INT iIndex = 0;
|
|
LVITEM lvi;
|
|
|
|
ZeroMemory(&lvi, sizeof (lvi));
|
|
|
|
//
|
|
// Turn off repaints
|
|
//
|
|
SendDlgItemMessage(hdlg, IDC_SHIMLIST, WM_SETREDRAW, FALSE, 0);
|
|
SendDlgItemMessage(hdlg, IDC_LAYERLIST, WM_SETREDRAW, FALSE, 0);
|
|
|
|
//
|
|
// This is because of a selchange in the combo box. So we must
|
|
// remove all the shims that are shown in the layer list. This means that we
|
|
// will move the entries from the layer list to the shim list
|
|
//
|
|
if (bSelChange) {
|
|
RemoveAll(hdlg);
|
|
}
|
|
|
|
lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
|
|
|
|
if (!bSelChange) {
|
|
|
|
//
|
|
// The function has been called because of the initialization of the dialog box
|
|
// If we are editing a layer, pLayerParam will be the pointer to the layer
|
|
// being edited
|
|
//
|
|
|
|
//
|
|
// Add the shims first
|
|
//
|
|
while (psf != NULL) {
|
|
|
|
if ((psf->bGeneral || g_bExpert) &&
|
|
!ShimFlagExistsInLayer(psf, pLayerParam, FIX_SHIM)) {
|
|
|
|
//
|
|
// Add a new shim item to the shim list view
|
|
//
|
|
PSHIM_FIX_LIST psfl = new SHIM_FIX_LIST;
|
|
|
|
if (psfl == NULL) {
|
|
MEM_ERR;
|
|
return;
|
|
}
|
|
|
|
psfl->pShimFix = psf;
|
|
|
|
lvi.pszText = psf->strName;
|
|
lvi.iSubItem = 0;
|
|
lvi.lParam = (LPARAM)psfl;
|
|
lvi.iImage = IMAGE_SHIM;
|
|
lvi.iItem = 0;
|
|
|
|
ListView_InsertItem(hwndShimList, &lvi);
|
|
}
|
|
|
|
psf = psf->pNext;
|
|
}
|
|
|
|
//
|
|
// Add the flags next
|
|
//
|
|
while (pff != NULL) {
|
|
|
|
if ((pff->bGeneral || g_bExpert) &&
|
|
!ShimFlagExistsInLayer(pff, pLayerParam, FIX_FLAG)) {
|
|
|
|
//
|
|
// Add a new flag item to the shim list view
|
|
//
|
|
PFLAG_FIX_LIST pffl = new FLAG_FIX_LIST;
|
|
|
|
if (pffl == NULL) {
|
|
MEM_ERR;
|
|
return;
|
|
}
|
|
|
|
pffl->pFlagFix = pff;
|
|
|
|
lvi.pszText = pff->strName;
|
|
lvi.iSubItem = 0;
|
|
lvi.lParam = (LPARAM)pffl;
|
|
lvi.iItem = 0;
|
|
lvi.iImage = IMAGE_SHIM;
|
|
|
|
ListView_InsertItem(hwndShimList, &lvi);
|
|
}
|
|
|
|
pff = pff->pNext;
|
|
}
|
|
}
|
|
|
|
if (NULL != pLayerParam) {
|
|
|
|
PSHIM_FIX_LIST psflInLayer = pLayerParam->pShimFixList;
|
|
PFLAG_FIX_LIST pfflInLayer = pLayerParam->pFlagFixList;
|
|
|
|
//
|
|
// Copy the shims to the layer list
|
|
//
|
|
while (psflInLayer) {
|
|
|
|
if (psflInLayer->pShimFix == NULL) {
|
|
assert(FALSE);
|
|
goto Next_Shim;
|
|
}
|
|
|
|
//
|
|
// Add a new shim item to the layer list view
|
|
//
|
|
PSHIM_FIX_LIST psfl = new SHIM_FIX_LIST;
|
|
|
|
if (psfl == NULL) {
|
|
MEM_ERR;
|
|
break;
|
|
}
|
|
|
|
psfl->pShimFix = psflInLayer->pShimFix;
|
|
|
|
//
|
|
// Add the command lines for this shim
|
|
//
|
|
psfl->strCommandLine = psflInLayer->strCommandLine;
|
|
|
|
//
|
|
// Add the inclusion-exclusion list for this shim
|
|
//
|
|
psfl->strlInExclude = psflInLayer->strlInExclude;
|
|
|
|
//
|
|
// Copy the LUA data
|
|
//
|
|
if (psflInLayer->pLuaData) {
|
|
psfl->pLuaData = new LUADATA;
|
|
|
|
if (psfl->pLuaData == NULL) {
|
|
MEM_ERR;
|
|
return;
|
|
}
|
|
|
|
psfl->pLuaData->Copy(psflInLayer->pLuaData);
|
|
}
|
|
|
|
lvi.pszText = psflInLayer->pShimFix->strName;
|
|
lvi.iSubItem = 0;
|
|
lvi.lParam = (LPARAM)psfl;
|
|
lvi.iItem = 0;
|
|
lvi.iImage = IMAGE_SHIM;
|
|
|
|
iIndex = ListView_InsertItem(hwndLayerList, &lvi);
|
|
|
|
if (g_bExpert) {
|
|
ListView_SetItemText(hwndLayerList,
|
|
iIndex,
|
|
1,
|
|
psfl->strCommandLine);
|
|
|
|
ListView_SetItemText(hwndLayerList,
|
|
iIndex,
|
|
2,
|
|
psfl->strlInExclude.IsEmpty() ? GetString(IDS_NO) : GetString(IDS_YES));
|
|
}
|
|
|
|
Next_Shim:
|
|
|
|
psflInLayer = psflInLayer->pNext;
|
|
}
|
|
|
|
//
|
|
// Copy the flags to the layer list
|
|
//
|
|
while (pfflInLayer) {
|
|
|
|
if (pfflInLayer->pFlagFix == NULL) {
|
|
assert(FALSE);
|
|
goto Next_Flag;
|
|
}
|
|
|
|
//
|
|
// Add a new flag item to the layer list view
|
|
//
|
|
PFLAG_FIX_LIST pffl = new FLAG_FIX_LIST;
|
|
|
|
if (pffl == NULL) {
|
|
MEM_ERR;
|
|
return;
|
|
}
|
|
|
|
pffl->pFlagFix = pfflInLayer->pFlagFix;
|
|
|
|
//
|
|
// Add the command lines for this flag
|
|
//
|
|
pffl->strCommandLine = pfflInLayer->strCommandLine;
|
|
|
|
lvi.pszText = pfflInLayer->pFlagFix->strName;
|
|
lvi.iSubItem = 0;
|
|
lvi.lParam = (LPARAM)pffl;
|
|
lvi.iItem = 0;
|
|
lvi.iImage = IMAGE_SHIM;
|
|
|
|
INT iIndexFlag = ListView_InsertItem(hwndLayerList, &lvi);
|
|
|
|
if (g_bExpert) {
|
|
ListView_SetItemText(hwndLayerList,
|
|
iIndexFlag,
|
|
1,
|
|
pffl->strCommandLine);
|
|
}
|
|
|
|
Next_Flag:
|
|
|
|
pfflInLayer = pfflInLayer->pNext;
|
|
}
|
|
|
|
SendDlgItemMessage(hdlg, IDC_SHIMLIST, WM_SETREDRAW, TRUE, 0);
|
|
InvalidateRect(GetDlgItem(hdlg, IDC_SHIMLIST), NULL, TRUE);
|
|
UpdateWindow(GetDlgItem(hdlg, IDC_SHIMLIST));
|
|
|
|
SendDlgItemMessage(hdlg, IDC_LAYERLIST, WM_SETREDRAW, TRUE, 0);
|
|
InvalidateRect(GetDlgItem(hdlg, IDC_LAYERLIST), NULL, TRUE);
|
|
UpdateWindow(GetDlgItem(hdlg, IDC_LAYERLIST));
|
|
|
|
} else {
|
|
assert(FALSE);
|
|
}
|
|
}
|
|
|
|
void
|
|
LoadCombo(
|
|
IN HWND hdlg
|
|
)
|
|
/*++
|
|
|
|
LoadCombo
|
|
|
|
Desc: Loads the combo box with the names of the existing layers for the present database.
|
|
Sets the lParam to the PLAYER_FIX for the layer
|
|
Should be called when editing layers only
|
|
|
|
Params:
|
|
IN HWND hdlg: The custom layer dialog proc
|
|
--*/
|
|
{
|
|
|
|
PLAYER_FIX plf = g_pCustomLayer->m_pCurrentSelectedDB->pLayerFixes;
|
|
int iPos = -1;
|
|
HWND hwndCombo = GetDlgItem(hdlg, IDC_COMBO);
|
|
|
|
//
|
|
// Add all the layers for the database to the combo-box
|
|
//
|
|
while (plf) {
|
|
|
|
iPos = SendMessage(hwndCombo, CB_ADDSTRING, 0,(LPARAM)plf->strName.pszString);
|
|
|
|
if (iPos != CB_ERR) {
|
|
SendMessage(hwndCombo, CB_SETITEMDATA, (WPARAM)iPos, (LPARAM)plf);
|
|
}
|
|
|
|
plf = plf->pNext;
|
|
}
|
|
}
|
|
|
|
void
|
|
OnCopy(
|
|
IN HWND hDlg
|
|
)
|
|
/*++
|
|
|
|
OnCopy
|
|
|
|
Desc: Handles the case when the user presses "Copy" button in the dialog box
|
|
|
|
This routine allows us to make shim combinations based on existing layers
|
|
The commandline and the in-ex list of the shims in the layers are also copied
|
|
|
|
Params:
|
|
IN HWND hdlg: The custom layer dialog proc
|
|
--*/
|
|
{
|
|
LVITEM lvi;
|
|
INT iIndex;
|
|
HWND hwndShimList = GetDlgItem(hDlg, IDC_SHIMLIST);
|
|
HWND hwndLayerList = GetDlgItem(hDlg, IDC_LAYERLIST);
|
|
|
|
ZeroMemory(&lvi, sizeof(lvi));
|
|
|
|
HWND hwndFocus = GetFocus();
|
|
|
|
//
|
|
// Get the layer whose shims/flags we want to copy
|
|
//
|
|
PLAYER_FIX plfSelected = (PLAYER_FIX)DialogBox(g_hInstance,
|
|
MAKEINTRESOURCE(IDD_SELECTLAYER),
|
|
hDlg,
|
|
ChooseLayersProc);
|
|
|
|
if (plfSelected) {
|
|
|
|
PSHIM_FIX_LIST psfl = plfSelected->pShimFixList;
|
|
PFLAG_FIX_LIST pffl = plfSelected->pFlagFixList;
|
|
|
|
PSHIM_FIX_LIST psflInShimList = NULL;
|
|
PFLAG_FIX_LIST pfflInShimList = NULL;
|
|
LVFINDINFO lvfind;
|
|
|
|
SendDlgItemMessage(hDlg, IDC_SHIMLIST, WM_SETREDRAW, FALSE, 0);
|
|
SendDlgItemMessage(hDlg, IDC_LAYERLIST, WM_SETREDRAW, FALSE, 0);
|
|
|
|
lvfind.flags = LVFI_STRING;
|
|
|
|
//
|
|
// Add over all the shims for this layer that we want to copy
|
|
//
|
|
while (psfl) {
|
|
|
|
if (psfl->pShimFix == NULL) {
|
|
assert(FALSE);
|
|
goto Next_Shim;
|
|
}
|
|
|
|
lvfind.psz = psfl->pShimFix->strName.pszString;
|
|
iIndex = ListView_FindItem(hwndShimList, -1, &lvfind);
|
|
|
|
if (iIndex != -1) {
|
|
//
|
|
// This was a general shim, we have to add this to the layer list
|
|
//
|
|
lvi.mask = LVIF_PARAM;
|
|
lvi.iItem = iIndex;
|
|
lvi.iSubItem = 0;
|
|
|
|
if (!ListView_GetItem(hwndShimList, &lvi)) {
|
|
assert(FALSE);
|
|
goto Next_Shim;
|
|
}
|
|
|
|
psflInShimList = (PSHIM_FIX_LIST)lvi.lParam;
|
|
|
|
psflInShimList->strCommandLine = psfl->strCommandLine;
|
|
psflInShimList->strlInExclude = psfl->strlInExclude;
|
|
|
|
//
|
|
// LUA data. This will be not required but just in case ...
|
|
//
|
|
if (psflInShimList->pLuaData) {
|
|
delete psflInShimList->pLuaData;
|
|
psflInShimList->pLuaData = NULL;
|
|
}
|
|
|
|
if (psfl->pLuaData) {
|
|
psflInShimList->pLuaData = new LUADATA;
|
|
|
|
if (psflInShimList->pLuaData == NULL) {
|
|
MEM_ERR;
|
|
return;
|
|
}
|
|
|
|
psflInShimList->pLuaData->Copy(psfl->pLuaData);
|
|
}
|
|
|
|
//
|
|
// Remove the item from the shim list and add it to the layer list
|
|
//
|
|
ListView_DeleteItem(hwndShimList, iIndex);
|
|
|
|
} else {
|
|
//
|
|
// The shim may be present in the layer list, if yes we can remove it now
|
|
//
|
|
assert(psfl->pShimFix);
|
|
lvfind.psz = psfl->pShimFix->strName.pszString;
|
|
iIndex = ListView_FindItem(hwndLayerList, -1, &lvfind);
|
|
|
|
if (iIndex != -1) {
|
|
|
|
lvi.mask = LVIF_PARAM;
|
|
lvi.iItem = iIndex;
|
|
lvi.iSubItem = 0;
|
|
|
|
if (!ListView_GetItem(hwndLayerList, &lvi)) {
|
|
assert(FALSE);
|
|
goto Next_Shim;
|
|
}
|
|
|
|
//
|
|
// This is the PSHIM_FIX_LIST that was present in the
|
|
// layer list view
|
|
//
|
|
psflInShimList = (PSHIM_FIX_LIST)lvi.lParam;
|
|
|
|
psflInShimList->strCommandLine = psfl->strCommandLine;
|
|
psflInShimList->strlInExclude = psfl->strlInExclude;
|
|
|
|
//
|
|
// LUA data. This will be not required but just in case ...
|
|
//
|
|
if (psflInShimList->pLuaData) {
|
|
delete psflInShimList->pLuaData;
|
|
psflInShimList->pLuaData = NULL;
|
|
}
|
|
|
|
if (psfl->pLuaData) {
|
|
psflInShimList->pLuaData = new LUADATA;
|
|
|
|
if (psflInShimList->pLuaData) {
|
|
psflInShimList->pLuaData->Copy(psfl->pLuaData);
|
|
} else {
|
|
MEM_ERR;
|
|
return;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Remove the item from the layer list view. We will add it again soon.
|
|
//
|
|
ListView_DeleteItem(hwndLayerList, iIndex);
|
|
|
|
} else {
|
|
|
|
//
|
|
// We have to create new as this is a non-general shim
|
|
//
|
|
psflInShimList = new SHIM_FIX_LIST;
|
|
|
|
if (psflInShimList == NULL) {
|
|
MEM_ERR;
|
|
return;
|
|
}
|
|
|
|
psflInShimList->pShimFix = psfl->pShimFix;
|
|
psflInShimList->strCommandLine = psfl->strCommandLine;
|
|
psflInShimList->strlInExclude = psfl->strlInExclude;
|
|
|
|
if (psfl->pLuaData) {
|
|
|
|
psflInShimList->pLuaData = new LUADATA;
|
|
|
|
if (psflInShimList->pLuaData) {
|
|
MEM_ERR;
|
|
return;
|
|
}
|
|
|
|
psflInShimList->pLuaData->Copy(psfl->pLuaData);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Add this psflInshimList to the layer list now
|
|
//
|
|
lvi.mask = LVIF_PARAM | LVIF_TEXT | LVIF_IMAGE;
|
|
lvi.pszText = psflInShimList->pShimFix->strName;
|
|
lvi.iSubItem = 0;
|
|
lvi.lParam = (LPARAM)psflInShimList;
|
|
lvi.iImage = IMAGE_SHIM;
|
|
lvi.iItem = 0;
|
|
|
|
iIndex = ListView_InsertItem(hwndLayerList, &lvi);
|
|
|
|
if (g_bExpert) {
|
|
|
|
ListView_SetItemText(hwndLayerList,
|
|
iIndex,
|
|
1,
|
|
psflInShimList->strCommandLine);
|
|
|
|
ListView_SetItemText(hwndLayerList,
|
|
iIndex,
|
|
2,
|
|
psflInShimList->strlInExclude.IsEmpty() ?
|
|
GetString(IDS_NO) : GetString(IDS_YES));
|
|
}
|
|
Next_Shim:
|
|
psfl = psfl->pNext;
|
|
}
|
|
|
|
//
|
|
// Now add the flags for the layer
|
|
//
|
|
while (pffl) {
|
|
|
|
if (pffl->pFlagFix == NULL) {
|
|
assert(FALSE);
|
|
goto Next_Flag;
|
|
}
|
|
|
|
lvfind.psz = pffl->pFlagFix->strName.pszString;
|
|
iIndex = ListView_FindItem(hwndShimList, -1, &lvfind);
|
|
|
|
if (iIndex != -1) {
|
|
//
|
|
// This was a general flag, we have to add this to the layer lit
|
|
//
|
|
lvi.mask = LVIF_PARAM;
|
|
lvi.iItem = iIndex;
|
|
lvi.iSubItem = 0;
|
|
|
|
if (!ListView_GetItem(hwndShimList, &lvi)) {
|
|
assert(FALSE);
|
|
goto Next_Flag;
|
|
}
|
|
|
|
pfflInShimList = (PFLAG_FIX_LIST)lvi.lParam;
|
|
//
|
|
// Add the command lines for this shim
|
|
//
|
|
pfflInShimList->strCommandLine = pffl->strCommandLine;
|
|
|
|
//
|
|
// Remove the item from the flag list and add it to the layer list
|
|
//
|
|
ListView_DeleteItem(hwndShimList, iIndex);
|
|
|
|
} else {
|
|
//
|
|
// The flag may be present in the layer list, if yes we can remove it now
|
|
//
|
|
if (pffl->pFlagFix == NULL) {
|
|
assert(FALSE);
|
|
goto Next_Flag;
|
|
}
|
|
|
|
lvfind.psz = pffl->pFlagFix->strName.pszString;
|
|
iIndex = ListView_FindItem(hwndLayerList, -1, &lvfind);
|
|
|
|
if (iIndex != -1) {
|
|
|
|
lvi.mask = LVIF_PARAM;
|
|
lvi.iItem = iIndex;
|
|
lvi.iSubItem = 0;
|
|
|
|
if (!ListView_GetItem(hwndLayerList, &lvi)) {
|
|
assert(FALSE);
|
|
goto Next_Flag;
|
|
}
|
|
|
|
//
|
|
// This is the PFLAG_FIX_LIST that was present in the
|
|
// layer list view
|
|
//
|
|
pfflInShimList = (PFLAG_FIX_LIST)lvi.lParam;
|
|
|
|
pfflInShimList->strCommandLine = pffl->strCommandLine;
|
|
|
|
//
|
|
// Remove the item from the layer list. We will add it again soon.
|
|
//
|
|
ListView_DeleteItem(hwndLayerList, iIndex);
|
|
|
|
} else {
|
|
|
|
//
|
|
// We have to create new
|
|
//
|
|
pfflInShimList = new FLAG_FIX_LIST;
|
|
|
|
if (pfflInShimList == NULL) {
|
|
MEM_ERR;
|
|
return;
|
|
}
|
|
|
|
pfflInShimList->pFlagFix = pffl->pFlagFix;
|
|
pfflInShimList->strCommandLine = pffl->strCommandLine;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Add this pfflInflagList to the layer list now
|
|
//
|
|
lvi.mask = LVIF_PARAM | LVIF_TEXT;
|
|
lvi.pszText = pfflInShimList->pFlagFix->strName;
|
|
lvi.iSubItem = 0;
|
|
lvi.lParam = (LPARAM)pfflInShimList;
|
|
lvi.iImage = IMAGE_SHIM;
|
|
lvi.iItem = 0;
|
|
|
|
iIndex = ListView_InsertItem(hwndLayerList, &lvi);
|
|
|
|
if (g_bExpert) {
|
|
|
|
ListView_SetItemText(hwndLayerList,
|
|
iIndex,
|
|
1,
|
|
pfflInShimList->strCommandLine);
|
|
|
|
ListView_SetItemText(hwndLayerList,
|
|
iIndex,
|
|
2,
|
|
GetString(IDS_NO));
|
|
}
|
|
Next_Flag:
|
|
pffl = pffl->pNext;
|
|
}
|
|
|
|
SendDlgItemMessage(hDlg, IDC_SHIMLIST, WM_SETREDRAW, TRUE, 0);
|
|
SendDlgItemMessage(hDlg, IDC_LAYERLIST, WM_SETREDRAW, TRUE, 0);
|
|
|
|
InvalidateRect(GetDlgItem(hDlg, IDC_SHIMLIST), NULL, TRUE);
|
|
UpdateWindow(GetDlgItem(hDlg, IDC_SHIMLIST));
|
|
|
|
InvalidateRect(GetDlgItem(hDlg, IDC_LAYERLIST), NULL, TRUE);
|
|
UpdateWindow(GetDlgItem(hDlg, IDC_LAYERLIST));
|
|
}
|
|
|
|
SetFocus(hwndFocus);
|
|
}
|
|
|
|
void
|
|
OnDone(
|
|
IN HWND hDlg,
|
|
IN OUT PLAYER_FIX pLayerParam
|
|
)
|
|
/*++
|
|
OnDone
|
|
|
|
Desc: Removes all the existing shims and flags from pLayerParam and then
|
|
adds the selected shims and flags (those in the layerlist (RHS)) to pLayerParam
|
|
|
|
Params:
|
|
IN HWND hDlg: The custom layer dialog proc
|
|
IN OUT PLAYER_FIX pLayerParam: The layer that has to be populated with the
|
|
selected shims and flags
|
|
--*/
|
|
{
|
|
|
|
TCHAR szText[MAX_PATH_BUFFSIZE];
|
|
LVITEM lvi;
|
|
HWND hwndLayerList;
|
|
|
|
ZeroMemory(&lvi, sizeof(lvi));
|
|
|
|
*szText = 0;
|
|
|
|
hwndLayerList = GetDlgItem(hDlg, IDC_LAYERLIST);
|
|
|
|
if (g_pCustomLayer->m_uMode == LAYERMODE_EDIT) {
|
|
GetDlgItemText(hDlg, IDC_COMBO, szText, ARRAYSIZE(szText));
|
|
} else {
|
|
GetDlgItemText(hDlg, IDC_NAME, szText, ARRAYSIZE(szText));
|
|
}
|
|
|
|
if (CSTRING::Trim(szText) == 0) {
|
|
|
|
MessageBox(hDlg,
|
|
GetString(IDS_INVALID_LAYER_NAME),
|
|
g_szAppName,
|
|
MB_ICONWARNING);
|
|
|
|
return;
|
|
}
|
|
|
|
CSTRING strLayerName = szText;
|
|
|
|
//
|
|
// Check if the new name already exists, if yes give error.
|
|
//
|
|
if (g_pCustomLayer->m_uMode == LAYERMODE_ADD
|
|
&& FindFix((LPCTSTR)strLayerName, FIX_LAYER, g_pCustomLayer->m_pCurrentSelectedDB)) {
|
|
|
|
//
|
|
// Since we have a read only combo box when we are editing a fix, the user
|
|
// cannot change the name, so we only check for whether we have an existing layer of the
|
|
// same name when we are creating a new layer
|
|
//
|
|
MessageBox(hDlg, GetString(IDS_LAYEREXISTS), g_szAppName, MB_ICONWARNING);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Remove all the shims.
|
|
//
|
|
DeleteShimFixList(pLayerParam->pShimFixList);
|
|
pLayerParam->pShimFixList = NULL;
|
|
|
|
//
|
|
// Remove all the Flags.
|
|
//
|
|
DeleteFlagFixList (pLayerParam->pFlagFixList);
|
|
pLayerParam->pFlagFixList = NULL;
|
|
|
|
pLayerParam->uShimCount = 0;
|
|
|
|
int nCount;
|
|
int nTotal;
|
|
|
|
pLayerParam->strName = szText;
|
|
|
|
nTotal = ListView_GetItemCount(hwndLayerList);
|
|
|
|
//
|
|
// Enumerate all the shims listed and add to the layer.
|
|
//
|
|
for (nCount=0; nCount < nTotal; ++nCount) {
|
|
|
|
lvi.mask = LVIF_PARAM;
|
|
lvi.iItem = nCount;
|
|
lvi.iSubItem = 0;
|
|
|
|
if (!ListView_GetItem(hwndLayerList, &lvi)) {
|
|
assert(FALSE);
|
|
continue;
|
|
}
|
|
|
|
TYPE type = ConvertLparam2Type(lvi.lParam);
|
|
|
|
if (type == FIX_LIST_SHIM) {
|
|
|
|
//
|
|
// Add this shim to the layer
|
|
//
|
|
PSHIM_FIX_LIST pShimFixList = (PSHIM_FIX_LIST)lvi.lParam;
|
|
|
|
assert(pShimFixList);
|
|
|
|
if (pLayerParam->pShimFixList == NULL) {
|
|
pLayerParam->pShimFixList = pShimFixList;
|
|
pLayerParam->pShimFixList->pNext = NULL;
|
|
} else {
|
|
pShimFixList->pNext = pLayerParam->pShimFixList->pNext;
|
|
pLayerParam->pShimFixList->pNext = pShimFixList;
|
|
}
|
|
|
|
} else if (FIX_LIST_FLAG) {
|
|
|
|
//
|
|
// Add this flag to the layer
|
|
//
|
|
PFLAG_FIX_LIST pFlagFixList = (PFLAG_FIX_LIST) lvi.lParam;
|
|
|
|
assert(pFlagFixList);
|
|
|
|
if (pLayerParam->pFlagFixList == NULL) {
|
|
pLayerParam->pFlagFixList = pFlagFixList;
|
|
pLayerParam->pFlagFixList->pNext = NULL;
|
|
} else {
|
|
pFlagFixList->pNext = pLayerParam->pFlagFixList->pNext;
|
|
pLayerParam->pFlagFixList->pNext = pFlagFixList;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Count of both shims and flags, we do not use this variable now
|
|
// BUBUG: remove this variable from the structure
|
|
//
|
|
pLayerParam->uShimCount++;
|
|
}
|
|
|
|
EndDialog(hDlg, TRUE);
|
|
}
|
|
|
|
void
|
|
RemoveSingleItem(
|
|
IN HWND hdlg,
|
|
IN INT iIndex,
|
|
IN BOOL bOnlySelected
|
|
)
|
|
/*++
|
|
RemoveSingleItem
|
|
|
|
Desc: Moves a single item from the layer list to the shim list
|
|
|
|
Params:
|
|
IN HWND hdlg: The custom layer dialog
|
|
IN INT iIndex: The index of the item that has to be removed
|
|
IN BOOL bOnlySelected: We should remove the item only if it selected
|
|
--*/
|
|
{
|
|
LVITEM lvi;
|
|
HWND hwndLayerList = GetDlgItem(hdlg, IDC_LAYERLIST);
|
|
HWND hwndShimList = GetDlgItem(hdlg, IDC_SHIMLIST);
|
|
|
|
PSHIM_FIX_LIST psflInLayerList = NULL;
|
|
PFLAG_FIX_LIST pfflInLayerList = NULL;
|
|
|
|
ZeroMemory(&lvi, sizeof(lvi));
|
|
|
|
lvi.mask = LVIF_PARAM | LVIF_STATE ;
|
|
lvi.stateMask = LVIS_SELECTED;
|
|
lvi.iItem = iIndex;
|
|
lvi.iSubItem = 0;
|
|
|
|
if (!ListView_GetItem(hwndLayerList, &lvi)) {
|
|
assert(FALSE);
|
|
return;
|
|
}
|
|
|
|
if (!bOnlySelected ||(lvi.state & LVIS_SELECTED)) {
|
|
|
|
TYPE type = ConvertLparam2Type(lvi.lParam);
|
|
|
|
if (type == FIX_LIST_SHIM) {
|
|
|
|
psflInLayerList = (PSHIM_FIX_LIST)lvi.lParam;
|
|
assert(psflInLayerList->pShimFix);
|
|
|
|
lvi.mask = LVIF_PARAM | LVIF_TEXT;
|
|
lvi.pszText = psflInLayerList->pShimFix->strName;
|
|
lvi.iImage = IMAGE_SHIM;
|
|
lvi.iItem = 0;
|
|
lvi.iSubItem = 0;
|
|
lvi.lParam = (LPARAM)psflInLayerList;
|
|
|
|
} else if (type == FIX_LIST_FLAG) {
|
|
|
|
pfflInLayerList = (PFLAG_FIX_LIST)lvi.lParam;
|
|
assert(pfflInLayerList->pFlagFix);
|
|
|
|
lvi.mask = LVIF_PARAM | LVIF_STATE | LVIF_TEXT;
|
|
lvi.pszText = pfflInLayerList->pFlagFix->strName;
|
|
lvi.iImage = IMAGE_SHIM;
|
|
lvi.iItem = 0;
|
|
lvi.iSubItem = 0;
|
|
lvi.lParam = (LPARAM)pfflInLayerList;
|
|
}
|
|
|
|
ListView_InsertItem(hwndShimList, &lvi);
|
|
ListView_DeleteItem(hwndLayerList, iIndex);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
HandleNotifyLayerList(
|
|
IN HWND hDlg,
|
|
IN LPARAM lParam
|
|
)
|
|
/*++
|
|
|
|
HandleNotifyLayerList
|
|
|
|
Desc: Handles the notification messages for the layer list. This is the RHS list view
|
|
|
|
Params:
|
|
IN HWND hDlg: The custom layer dialog proc
|
|
IN LPARAM lParam: The lParam with WM_NOTIFY
|
|
|
|
--*/
|
|
|
|
{
|
|
NMHDR * pHdr = (NMHDR*)lParam;
|
|
|
|
switch (pHdr->code) {
|
|
case NM_DBLCLK:
|
|
|
|
OnRemove(hDlg);
|
|
SetOkParamsStatus(hDlg);
|
|
break;
|
|
|
|
case NM_CLICK:
|
|
|
|
if (ListView_GetSelectedCount(GetDlgItem(hDlg, IDC_LAYERLIST)) == 0) {
|
|
ENABLEWINDOW(GetDlgItem(hDlg, IDC_PARAMS), FALSE);
|
|
} else {
|
|
ENABLEWINDOW(GetDlgItem(hDlg, IDC_PARAMS), TRUE);
|
|
}
|
|
|
|
break;
|
|
|
|
case LVN_ITEMCHANGED:
|
|
{
|
|
LPNMLISTVIEW lpnmlv;
|
|
|
|
lpnmlv = (LPNMLISTVIEW)lParam;
|
|
|
|
if (lpnmlv && (lpnmlv->uChanged & LVIF_STATE)) {
|
|
|
|
if (lpnmlv->uNewState & LVIS_SELECTED) {
|
|
ENABLEWINDOW(GetDlgItem(hDlg, IDC_PARAMS), TRUE);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default: return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
HandleNotifyShimList(
|
|
IN HWND hDlg,
|
|
IN LPARAM lParam
|
|
)
|
|
/*++
|
|
|
|
HandleNotifyShimList
|
|
|
|
Desc: Handles the notification messages for the ShimList. This is the LHS list view
|
|
|
|
Params:
|
|
IN HWND hDlg: The custom layer dialog proc
|
|
IN LPARAM lParam: The lParam with WM_NOTIFY
|
|
--*/
|
|
{
|
|
NMHDR* pHdr = (NMHDR*)lParam;
|
|
|
|
switch (pHdr->code) {
|
|
case NM_DBLCLK:
|
|
|
|
OnAdd(hDlg);
|
|
SetOkParamsStatus(hDlg);
|
|
break;
|
|
|
|
default: return FALSE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
SetOkParamsStatus(
|
|
IN HWND hdlg
|
|
)
|
|
/*++
|
|
|
|
SetOkParamsStatus
|
|
|
|
Desc: Sets the status of the ok button and the params button
|
|
|
|
Params:
|
|
IN HWND hDlg: The custom layer dialog proc
|
|
--*/
|
|
{
|
|
INT iTotalCount = ListView_GetItemCount(GetDlgItem(hdlg, IDC_LAYERLIST));
|
|
|
|
if (g_pCustomLayer->m_uMode == LAYERMODE_ADD) {
|
|
SendMessage(hdlg, WM_COMMAND, MAKELONG(IDC_NAME, EN_UPDATE), 0);
|
|
} else {
|
|
ENABLEWINDOW(GetDlgItem(hdlg, IDOK), iTotalCount > 0);
|
|
}
|
|
|
|
//
|
|
// Enable the params button only if we have some selection in the layer list view(RHS)
|
|
//
|
|
ENABLEWINDOW(GetDlgItem(hdlg, IDC_PARAMS),
|
|
ListView_GetNextItem(GetDlgItem(hdlg, IDC_LAYERLIST), -1, LVNI_SELECTED) != -1);
|
|
}
|
|
|
|
void
|
|
RemoveAll(
|
|
IN HWND hDlg
|
|
)
|
|
/*++
|
|
|
|
RemoveAll
|
|
|
|
Desc: Removes all the shims/flags from the layer list and adds them
|
|
to the shim list
|
|
|
|
Params:
|
|
IN HWND hDlg: The custom layer dialog
|
|
|
|
Return:
|
|
--*/
|
|
{
|
|
SendDlgItemMessage(hDlg, IDC_SHIMLIST, WM_SETREDRAW, FALSE, 0);
|
|
SendDlgItemMessage(hDlg, IDC_LAYERLIST, WM_SETREDRAW, FALSE, 0);
|
|
|
|
int nCount;
|
|
|
|
nCount = ListView_GetItemCount(GetDlgItem(hDlg, IDC_LAYERLIST)) - 1;
|
|
|
|
for (;nCount >= 0; --nCount) {
|
|
|
|
//
|
|
// Remove all either selected or not
|
|
//
|
|
RemoveSingleItem(hDlg, nCount, FALSE);
|
|
}
|
|
|
|
|
|
SendDlgItemMessage(hDlg, IDC_SHIMLIST, WM_SETREDRAW, TRUE, 0);
|
|
SendDlgItemMessage(hDlg, IDC_LAYERLIST, WM_SETREDRAW, TRUE, 0);
|
|
|
|
InvalidateRect(GetDlgItem(hDlg, IDC_SHIMLIST), NULL, TRUE);
|
|
UpdateWindow(GetDlgItem(hDlg, IDC_SHIMLIST));
|
|
InvalidateRect(GetDlgItem(hDlg, IDC_LAYERLIST), NULL, TRUE);
|
|
UpdateWindow(GetDlgItem(hDlg, IDC_LAYERLIST));
|
|
|
|
SetOkParamsStatus(hDlg);
|
|
}
|
|
|
|
void
|
|
ResizeControls(
|
|
IN HWND hdlg
|
|
)
|
|
/*++
|
|
|
|
ResizeControls
|
|
|
|
Desc: Make the sizes of both the list view controls equal as we will now
|
|
not show the command lines and the params of the shims in the layer
|
|
list view(RHS) in non-expert mode. We will also need to move the buttons
|
|
|
|
Params:
|
|
IN HWND hdlg: The custom layer dialog box
|
|
|
|
Return:
|
|
void
|
|
--*/
|
|
{
|
|
HWND hwndTemp;
|
|
RECT rcTemp;
|
|
INT iWidthShimList;
|
|
INT iWidthLayerList;
|
|
INT iWidthDiff;
|
|
|
|
HDWP hdwp = BeginDeferWindowPos(3);
|
|
|
|
//
|
|
// Note: DeferWindowPos: All windows in a multiple-window position structure must
|
|
// have the same parent.
|
|
//
|
|
hwndTemp = GetDlgItem(hdlg, IDC_SHIMLIST);
|
|
|
|
GetWindowRect(hwndTemp, &rcTemp);
|
|
MapWindowPoints(NULL, hdlg, (LPPOINT)&rcTemp, 2);
|
|
|
|
iWidthShimList = rcTemp.right - rcTemp.left;
|
|
|
|
hwndTemp = GetDlgItem(hdlg, IDC_LAYERLIST);
|
|
|
|
GetWindowRect(hwndTemp, &rcTemp);
|
|
MapWindowPoints(NULL, hdlg, (LPPOINT)&rcTemp, 2);
|
|
|
|
iWidthLayerList = rcTemp.right - rcTemp.left;
|
|
|
|
iWidthDiff = iWidthLayerList - iWidthShimList;
|
|
|
|
//
|
|
// Make the width of the layer list equal to the width of the shim list
|
|
//
|
|
DeferWindowPos(hdwp,
|
|
hwndTemp,
|
|
NULL,
|
|
0,
|
|
0,
|
|
iWidthShimList,
|
|
rcTemp.bottom - rcTemp.top,
|
|
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
//
|
|
// Move the OK button to the left
|
|
//
|
|
hwndTemp = GetDlgItem(hdlg, IDOK);
|
|
|
|
GetWindowRect(hwndTemp, &rcTemp);
|
|
MapWindowPoints(NULL, hdlg, (LPPOINT)&rcTemp, 2);
|
|
|
|
DeferWindowPos(hdwp,
|
|
hwndTemp,
|
|
NULL,
|
|
rcTemp.left - iWidthDiff,
|
|
rcTemp.top,
|
|
0,
|
|
0,
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
//
|
|
// Move the Cancel button to the left
|
|
//
|
|
hwndTemp = GetDlgItem(hdlg, IDC_CANCEL);
|
|
|
|
GetWindowRect(hwndTemp, &rcTemp);
|
|
MapWindowPoints(NULL, hdlg, (LPPOINT)&rcTemp, 2);
|
|
|
|
DeferWindowPos(hdwp,
|
|
hwndTemp,
|
|
NULL,
|
|
rcTemp.left - iWidthDiff,
|
|
rcTemp.top,
|
|
0,
|
|
0,
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
EndDeferWindowPos(hdwp);
|
|
|
|
//
|
|
// Now we must reduce the size of the main dialog as well
|
|
//
|
|
GetWindowRect(hdlg, &rcTemp);
|
|
|
|
MoveWindow(hdlg,
|
|
rcTemp.left,
|
|
rcTemp.top,
|
|
rcTemp.right - rcTemp.left - iWidthDiff,
|
|
rcTemp.bottom - rcTemp.top,
|
|
TRUE);
|
|
|
|
//
|
|
// Make the last column fit in the list view
|
|
//
|
|
hwndTemp = GetDlgItem(hdlg, IDC_LAYERLIST);
|
|
ListView_SetColumnWidth(hwndTemp, 0, LVSCW_AUTOSIZE_USEHEADER);
|
|
}
|