archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/admin/cys/servmgmt/snapins/manager/cmndlgs.cpp

1314 lines
38 KiB
Raw Blame History

// cmndlgs.cpp - Common Dialogs
#include "stdafx.h"
#include <adext.h>
#include <windowsx.h>
#include <algorithm>
#include "cmndlgs.h"
#include "query.h"
#include "rowitem.h"
#include "scopenode.h"
#include "namemap.h"
#include "menuCmd.h"
#include "util.h"
//////////////////////////////////////////////////////////////////////////////////
// CAddColumnDlg
LRESULT CAddColumnDlg::OnInitDialog( UINT mMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
ASSERT(!m_strClassName.empty());
DisplayNameMap* pNameMap = DisplayNames::GetMap(m_strClassName.c_str());
if (pNameMap == NULL)
return TRUE;
SetDlgItemText( IDC_OBJCLASS, pNameMap->GetClassDisplayName() );
pNameMap->GetFriendlyNames(&m_vstrAllColumns);
HWND hwndList = GetDlgItem(IDC_COLUMNLIST);
if( hwndList && ::IsWindow(hwndList) )
{
ConfigSingleColumnListView(hwndList);
if (!m_vstrAllColumns.empty())
{
LV_ITEM lvi;
lvi.mask = LVIF_TEXT | LVIF_PARAM;
lvi.iItem = 0;
lvi.iSubItem = 0;
string_vector::iterator itStr;
for (itStr = m_vstrAllColumns.begin(); itStr != m_vstrAllColumns.end(); itStr++)
{
lvi.pszText = const_cast<LPWSTR>(pNameMap->GetAttributeDisplayName(itStr->c_str()));
lvi.lParam = (LPARAM)itStr->c_str();
int iPos = ListView_InsertItem(hwndList, &lvi);
ASSERT(iPos >= 0);
}
}
}
EnableDlgItem( m_hWnd, IDOK, FALSE );
return TRUE;
}
LRESULT CAddColumnDlg::OnClose( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
if (wID == IDOK)
{
HWND hwndList = GetDlgItem(IDC_COLUMNLIST);
ASSERT(hwndList != NULL);
m_vstrColumns.clear();
// copy LDAP names of selected items to vector
int iIndex = -1;
while ((iIndex = ListView_GetNextItem(hwndList, iIndex, LVNI_SELECTED)) != -1)
{
LVITEM lvi;
lvi.mask = LVIF_PARAM;
lvi.iItem = iIndex;
lvi.iSubItem = 0;
BOOL bStat = ListView_GetItem(hwndList, &lvi);
ASSERT(bStat);
m_vstrColumns.push_back(reinterpret_cast<LPWSTR>(lvi.lParam));
}
}
EndDialog(wID);
return 0;
}
LRESULT CAddColumnDlg::OnColumnChanged(int idCtrl, LPNMHDR pNMHDR, BOOL& bHandled)
{
LPNMLISTVIEW pnmv = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
if( !pnmv ) return 0;
// if selection change, update OK button
if ((pnmv->uChanged & LVIF_STATE))
{
EnableDlgItem( m_hWnd, IDOK, (ListView_GetSelectedCount(GetDlgItem(idCtrl)) > 0) );
}
return 0;
}
LRESULT CAddColumnDlg::OnColumnActivate(int idCtrl, LPNMHDR pNMHDR, BOOL& bHandled)
{
SendDlgItemMessage( IDOK, BM_CLICK, (WPARAM)0, (LPARAM)0 );
return 0;
}
//////////////////////////////////////////////////////////////////////////////////
// CAddMenuDlg
CAddMenuDlg::~CAddMenuDlg()
{
m_MenuTypeCB.Detach();
DeleteObject(m_hbmArrow);
}
LRESULT CAddMenuDlg::OnInitDialog( UINT mMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
DisplayNameMap* pNameMap = DisplayNames::GetMap(m_ClassInfo.Name());
if (pNameMap == NULL)
return TRUE;
SetDlgItemText( IDC_OBJCLASS, pNameMap->GetClassDisplayName() );
HWND hwndMenuType = GetDlgItem(IDC_COMMANDTYPE);
if( hwndMenuType && ::IsWindow(hwndMenuType) )
{
m_MenuTypeCB.Attach( hwndMenuType );
}
// Set menu arrow bitmap in param menu button
m_hbmArrow = LoadBitmap(NULL, MAKEINTRESOURCE(OBM_MNARROW));
if( m_hbmArrow )
{
SendDlgItemMessage( IDC_PARAMS_MENU, BM_SETIMAGE, IMAGE_BITMAP, (LPARAM)m_hbmArrow );
}
COMBOBOXEXITEM cbi;
cbi.mask = CBEIF_TEXT|CBEIF_LPARAM;
cbi.iItem = -1;
tstring strMenuType = StrLoadString(IDS_ACTDIRCMD);
cbi.pszText = const_cast<LPWSTR>(strMenuType.c_str());
cbi.lParam = MENUTYPE_ACTDIR;
m_MenuTypeCB.InsertItem(&cbi);
strMenuType = StrLoadString(IDS_SHELLCMD);
cbi.pszText = const_cast<LPWSTR>(strMenuType.c_str());
cbi.lParam = MENUTYPE_SHELL;
m_MenuTypeCB.InsertItem(&cbi);
Edit_LimitText(GetDlgItem(IDC_NAME), 255);
Edit_LimitText(GetDlgItem(IDC_COMMAND), 255);
Edit_LimitText(GetDlgItem(IDC_STARTIN), 500);
LoadClassMenuCmds();
// If editing an existing menu
if (m_pMenuCmd != NULL)
{
// Set name modified so that it won't be changed to default
m_bUserModifiedName = TRUE;
// Display info for selected menu
LoadMenuInfo(m_pMenuCmd);
}
else
{
m_MenuTypeCB.SetCurSel(0);
SetMenuType(MENUTYPE_ACTDIR);
}
m_bCommandChg = FALSE;
m_bStartDirChg = FALSE;
EnableOKButton();
return TRUE;
}
void CAddMenuDlg::LoadMenuInfo(CMenuCmd* pMenuCmd)
{
if( !pMenuCmd ) return;
SetDlgItemText( IDC_NAME, pMenuCmd->Name() );
Button_SetCheck(GetDlgItem(IDC_REFRESH), pMenuCmd->IsAutoRefresh() ? BST_CHECKED : BST_UNCHECKED);
switch (pMenuCmd->MenuType())
{
case MENUTYPE_SHELL:
{
CShellMenuCmd* pShellCmd = static_cast<CShellMenuCmd*>(pMenuCmd);
SetDlgItemText( IDC_COMMAND, pShellCmd->m_strProgPath.c_str() );
SetDlgItemText( IDC_STARTIN, pShellCmd->m_strStartDir.c_str() );
// Convert parameters from LDAP names to display names
tstring strParams = pShellCmd->m_strCmdLine;
DisplayNameMap* pNameMap = DisplayNames::GetMap(m_ClassInfo.Name());
if (pNameMap != NULL)
{
// Create function object to do parameter translation
CLookupDisplayName lookup(m_ClassInfo.Columns(), pNameMap);
ReplaceParameters(strParams, lookup, TRUE);
}
SetDlgItemText( IDC_PARAMS, strParams.c_str() );
m_MenuTypeCB.SetCurSel(1);
SetMenuType(MENUTYPE_SHELL);
}
break;
case MENUTYPE_ACTDIR:
{
CActDirMenuCmd* pADCmd = static_cast<CActDirMenuCmd*>(pMenuCmd);
LVFINDINFO lvfi;
lvfi.flags = LVFI_STRING;
lvfi.psz = pADCmd->m_strADName.c_str();
HWND hwndLV = GetDlgItem(IDC_MENULIST);
int iItem = ListView_FindItem(hwndLV, -1, &lvfi);
if( iItem == -1 )
{
// Couldn't find the language dependant string, try the language independant string
int nItems = ListView_GetItemCount(hwndLV);
for( int i = 0; i < nItems; i++ )
{
LVITEM lvi;
ZeroMemory( &lvi, sizeof(lvi) );
lvi.mask = LVIF_PARAM;
lvi.iItem = i;
ListView_GetItem( hwndLV, &lvi );
if( lvi.lParam )
{
LPCWSTR pszMenuNoLoc = pADCmd->ADNoLocName();
// Compare the stored string with the menu string
if( pszMenuNoLoc && (wcscmp( (LPCWSTR)(lvi.lParam), pszMenuNoLoc ) == 0) )
{
iItem = i;
break;
}
}
}
}
// If we found the string, default the value
if (iItem != -1)
ListView_SetItemState(hwndLV, iItem, LVIS_SELECTED, LVIS_SELECTED);
m_MenuTypeCB.SetCurSel(0);
SetMenuType(MENUTYPE_ACTDIR);
}
break;
default:
ASSERT(FALSE);
}
}
void CAddMenuDlg::LoadClassMenuCmds()
{
// Use a directory extension proxy to query for menu items
// because this dialog may run on a secondary thread and some
// directory extensions (dsadmin.dll!!) can only run on the main thread.
CActDirExtProxy adext;
// Initialize it with selected class name
HRESULT hr = adext.Initialize(m_ClassInfo.Name());
if (FAILED(hr))
return;
// Get menu commands for the selected class
menu_vector vMenuNames;
hr = adext.GetMenuItems(vMenuNames);
if (FAILED(hr))
return;
HWND hwndLV = GetDlgItem(IDC_MENULIST);
ASSERT(::IsWindow(hwndLV));
ConfigSingleColumnListView(hwndLV);
LV_ITEM lvi;
lvi.mask = LVIF_TEXT | LVIF_PARAM;
lvi.iItem = 0;
lvi.iSubItem = 0;
menu_vector::iterator itstr;
for (itstr = vMenuNames.begin(); itstr < vMenuNames.end(); ++itstr)
{
TCHAR* szNoLoc = new TCHAR[itstr->strNoLoc.length() + 1];
if( szNoLoc )
{
_tcscpy(szNoLoc, itstr->strNoLoc.c_str());
}
lvi.pszText = const_cast<LPWSTR>(itstr->strPlain.c_str());
lvi.lParam = reinterpret_cast<LPARAM>(szNoLoc);
int iPos = ListView_InsertItem(hwndLV, &lvi);
ASSERT(iPos >= 0);
if( iPos == -1 )
{
// Error, need to clean up here
delete [] szNoLoc;
continue;
}
// After adding the first item, default the selection to the first item
if( iPos == 0 )
{
ListView_SetItemState(hwndLV, 0, LVIS_FOCUSED|LVIS_SELECTED, LVIS_FOCUSED|LVIS_SELECTED);
}
lvi.iItem++;
}
}
LRESULT CAddMenuDlg::OnTypeSelect( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
int iItem = m_MenuTypeCB.GetCurSel();
ASSERT(iItem >= 0);
if( iItem >= 0 )
{
MENUTYPE type = static_cast<MENUTYPE>(m_MenuTypeCB.GetItemData(iItem));
SetMenuType(type);
}
return 0;
}
LRESULT CAddMenuDlg::OnBrowseForCommand( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
tstring strCommand;
GetItemText( GetDlgItem(IDC_COMMAND), strCommand );
tstring strFilter = StrLoadString(IDS_EXEFILTER);
/*
* The file dialog expects embedded \0's in the string, but those
* don't load well. The string in the resource file has \\ where
* the \0 should be, so let's make the substitution now.
*/
LPTSTR pchTemp = (LPTSTR)strFilter.data();
for( LPTSTR pch = pchTemp; *pch != _T('\0'); pch = pchTemp )
{
pchTemp = CharNext(pch);
if (*pch == _T('\\'))
*pch = _T('\0');
}
// don't call ReleaseBuffer, since the string now contains \0 chars
CFileDialog dlg (true, NULL, strCommand.c_str(), OFN_FILEMUSTEXIST | OFN_HIDEREADONLY, strFilter.c_str(), m_hWnd);
if (dlg.DoModal() == IDOK)
{
SetDlgItemText (IDC_COMMAND, dlg.m_szFileName);
}
return (0);
}
// Define private CFolderDialog to handle the OnInitialized callback
class CFolderDialogPriv : public CFolderDialogImpl<CFolderDialogPriv>
{
public:
CFolderDialogPriv(HWND hWndParent, LPCWSTR pszTitle, UINT uFlags, LPCWSTR pszCurFolder )
: CFolderDialogImpl<CFolderDialogPriv>(hWndParent, pszTitle, uFlags), m_pszCurFolder(pszCurFolder) {}
void OnInitialized() { if (m_pszCurFolder) SetSelection(m_pszCurFolder); }
LPCWSTR m_pszCurFolder;
};
LRESULT CAddMenuDlg::OnBrowseForStartIn( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
tstring strCaption = StrLoadString(IDS_SELECT_STARTDIR);
tstring strDir;
GetItemText( GetDlgItem(IDC_STARTIN), strDir );
CFolderDialogPriv dlg( m_hWnd, strCaption.c_str(), BIF_RETURNONLYFSDIRS|BIF_NEWDIALOGSTYLE, strDir.c_str() );
if (dlg.DoModal() == IDOK)
SetDlgItemText (IDC_STARTIN, dlg.GetFolderPath());
return (0);
}
LRESULT CAddMenuDlg::OnNameChange( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
m_bUserModifiedName = TRUE;
EnableOKButton();
return 0;
}
LRESULT CAddMenuDlg::OnCommandChange( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
EnableOKButton();
m_bCommandChg = TRUE;
return 0;
}
LRESULT CAddMenuDlg::OnStartDirChange( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
m_bStartDirChg = TRUE;
return 0;
}
LRESULT CAddMenuDlg::OnMenuChanged(int idCtrl, LPNMHDR pNMHDR, BOOL& bHandled)
{
LPNMLISTVIEW pnmv = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
if( !pnmv ) return 0;
// if new item selected user hasn't entered a name, default name to the menu
if ((pnmv->uChanged & LVIF_STATE) && (pnmv->uNewState & LVIS_SELECTED))
{
// If user hasn't modified the name or the name is empty, default to the menu name
if (!m_bUserModifiedName || ::Edit_GetTextLength(GetDlgItem(IDC_NAME)) == 0)
{
WCHAR szName[256];
ListView_GetItemText(GetDlgItem(IDC_MENULIST), pnmv->iItem, 0, szName, lengthof(szName));
::Edit_SetText(GetDlgItem(IDC_NAME), szName);
// reset user modified flag becuase it will be set by the Edit_SetText call
m_bUserModifiedName = FALSE;
}
}
EnableOKButton();
return 0;
}
void CAddMenuDlg::EnableOKButton()
{
BOOL bEnable = TRUE;
if (::Edit_GetTextLength(GetDlgItem(IDC_NAME)) == 0)
{
bEnable = FALSE;
}
else
{
if (m_menutype == MENUTYPE_SHELL)
{
if (::Edit_GetTextLength(GetDlgItem(IDC_COMMAND)) == 0)
bEnable = FALSE;
}
else
{
if (ListView_GetSelectedCount(GetDlgItem(IDC_MENULIST)) == 0)
bEnable = FALSE;
}
}
EnableDlgItem( m_hWnd, IDOK, bEnable );
}
void CAddMenuDlg::SetMenuType(MENUTYPE type)
{
static int aiActDirItems[] = {IDC_OBJCLASS_LBL, IDC_OBJCLASS, IDC_MENULIST_LBL, IDC_MENULIST, 0};
static int aiShellItems[] = {IDC_COMMAND_LBL, IDC_COMMAND, IDC_COMMAND_BROWSE, IDC_PARAMS_LBL,
IDC_PARAMS, IDC_STARTIN_LBL, IDC_STARTIN, IDC_STARTIN_BROWSE,
IDC_PARAMS_MENU, 0};
int* piItem = (type == MENUTYPE_SHELL) ? aiActDirItems : aiShellItems;
while (*piItem)
{
EnableDlgItem( m_hWnd, *piItem, FALSE );
::ShowWindow(GetDlgItem(*piItem), SW_HIDE);
piItem++;
}
piItem = (type == MENUTYPE_SHELL) ? aiShellItems : aiActDirItems;
while (*piItem)
{
::ShowWindow(GetDlgItem(*piItem), SW_SHOW);
EnableDlgItem( m_hWnd, *piItem, TRUE );
piItem++;
}
m_menutype = type;
EnableOKButton();
}
LRESULT CAddMenuDlg::OnParameterMenu(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
// Construct parameter menu
CMenu menu;
menu.CreatePopupMenu();
// Add standard parameters first
UINT uID = 1;
for( int i = 0; i < lengthof(MenuParamTable); i++ )
{
if (MenuParamTable[i].ID == 0)
{
menu.AppendMenu(MF_SEPARATOR);
}
else
{
CString str;
str.LoadString(MenuParamTable[i].rsrcID);
menu.AppendMenu(MF_STRING, uID++, str);
}
}
// Then add class attributes
DisplayNameMap* pNameMap = DisplayNames::GetMap(m_ClassInfo.Name());
if (pNameMap != NULL)
{
string_vector& vColumns = m_ClassInfo.Columns();
string_vector::iterator itCol;
for (itCol = vColumns.begin(); itCol != vColumns.end(); itCol++)
{
menu.AppendMenu(MF_STRING, uID++, pNameMap->GetAttributeDisplayName(itCol->c_str()));
}
}
// Pop-up menu at menu button
RECT rc;
::GetWindowRect(GetDlgItem(IDC_PARAMS_MENU), &rc);
long cx = (rc.right + rc.left) / 2;
long cy = (rc.top + rc.bottom) / 2;
UINT uCmd = menu.TrackPopupMenu(TPM_LEFTALIGN|TPM_TOPALIGN|TPM_RETURNCMD|TPM_LEFTBUTTON,
cx, cy, m_hWnd);
if (uCmd != 0)
{
WCHAR szBuf[128] = {0};
// Convert menu name to parameter format: $<name>
wcscpy(szBuf, L"$<");
// BUGBUG - Don't depend on count returned by GetMenuString. For some locales
// it returns a byte count rather than a character count.
int iLen = menu.GetMenuString(uCmd, szBuf+2, lengthof(szBuf)-5, MF_BYCOMMAND);
ASSERT(iLen != 0);
// Add closing '>' and one trailing space so user can add multiple parameters
// without manually entering separating spaces
wcscat(szBuf, L"> ");
Edit_ReplaceSel(GetDlgItem(IDC_PARAMS), szBuf);
::SetFocus(GetDlgItem(IDC_PARAMS));
}
return 0;
}
LRESULT CAddMenuDlg::OnClose( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
if (wID == IDOK)
{
CMenuCmd* pMenu = NULL;
// Get menu name
tstring strName;
GetItemText( GetDlgItem(IDC_NAME), strName );
// Name without the hotkey
tstring strPlainName = strName;
// Validate hotkey selection
int posKey = strName.find(L"&", 0);
if (posKey != tstring::npos)
{
WCHAR chKey = posKey < strName.length() - 1 ? strName[posKey+1] : 0;
if (!( (chKey >= L'A' && chKey <= L'Z') ||
(chKey >= L'a' && chKey <= L'z') ||
(chKey >= L'0' && chKey <= L'9') ))
{
DisplayMessageBox(m_hWnd, IDS_ERRORTITLE_MENUNAME, IDS_ERROR_BADACCESSKEY);
return 0;
}
if (strName.find(L"&", posKey+1) != tstring::npos)
{
DisplayMessageBox(m_hWnd, IDS_ERRORTITLE_MENUNAME, IDS_ERROR_MULTIACCESSKEY);
return 0;
}
// remove '&'
strPlainName.erase(posKey, 1);
}
// Check for duplicated name
menucmd_vector::iterator itMenu;
for (itMenu = m_ClassInfo.Menus().begin(); itMenu != m_ClassInfo.Menus().end(); ++itMenu)
{
// if editing a an existing menu, don't compare to itself
if (*itMenu == m_pMenuCmd)
continue;
// Compare names, skipping '&'s
LPCWSTR pszName = (*itMenu)->Name();
LPCWSTR pszNewName = strPlainName.c_str();
if( pszName && pszNewName )
{
while (*pszName && *pszNewName)
{
if (*pszName == L'&')
++pszName;
if (*pszName != *pszNewName)
break;
++pszName;
++pszNewName;
}
// if duplicate name
if (*pszName == *pszNewName)
{
DisplayMessageBox(m_hWnd, IDS_ERRORTITLE_MENUNAME, IDS_ERROR_DUPMENUNAME, MB_OK|MB_ICONEXCLAMATION, strPlainName.c_str());
return 0;
}
}
}
switch (m_menutype)
{
case MENUTYPE_SHELL:
{
CShellMenuCmd* pShellMenu = new CShellMenuCmd();
if (pShellMenu != NULL)
{
GetItemText( GetDlgItem(IDC_COMMAND), pShellMenu->m_strProgPath );
if (m_bCommandChg && ValidateFile(pShellMenu->m_strProgPath) != S_OK)
{
int iRet = DisplayMessageBox(m_hWnd, IDS_ERRORTITLE_MENUCMD, IDS_ERROR_MENUCMD,
MB_ICONINFORMATION | MB_YESNO, pShellMenu->m_strProgPath.c_str());
if (iRet != IDYES)
{
delete pShellMenu;
return 0;
}
}
GetItemText( GetDlgItem(IDC_STARTIN), pShellMenu->m_strStartDir );
if (m_bStartDirChg && !pShellMenu->m_strStartDir.empty() &&
ValidateDirectory(pShellMenu->m_strStartDir) != S_OK)
{
int iRet = DisplayMessageBox(m_hWnd, IDS_ERRORTITLE_STARTDIR, IDS_ERROR_STARTDIR,
MB_ICONINFORMATION | MB_YESNO, pShellMenu->m_strStartDir.c_str());
if (iRet != IDYES)
{
delete pShellMenu;
return 0;
}
}
tstring strParams;
GetItemText( GetDlgItem(IDC_PARAMS), strParams );
// Convert parameters from display names to LDAP names
DisplayNameMap* pNameMap = DisplayNames::GetMap(m_ClassInfo.Name());
if (pNameMap != NULL)
{
// Create function object to do parameter translation
CLookupLDAPName lookup(m_ClassInfo.Columns(), pNameMap);
ReplaceParameters(strParams, lookup, TRUE);
}
pShellMenu->m_strCmdLine.erase();
pShellMenu->m_strCmdLine = strParams;
pMenu = pShellMenu;
}
}
break;
case MENUTYPE_ACTDIR:
{
CActDirMenuCmd* pADMenu = new CActDirMenuCmd();
if (pADMenu != NULL)
{
HWND hwndLV = GetDlgItem(IDC_MENULIST);
int iItem = ListView_GetNextItem(hwndLV, -1, LVNI_SELECTED);
ASSERT(iItem != -1);
LV_ITEM lvi;
lvi.mask = LVIF_TEXT | LVIF_PARAM;
lvi.iItem = iItem;
lvi.iSubItem = 0;
WCHAR szBuf[MAX_PATH];
szBuf[0] = 0;
lvi.pszText = szBuf;
lvi.cchTextMax = MAX_PATH;
ListView_GetItem(hwndLV, &lvi);
pADMenu->m_strADName = szBuf;
pADMenu->m_strADNoLocName = (TCHAR*)lvi.lParam;
pMenu = pADMenu;
}
}
break;
default:
ASSERT(FALSE);
}
if (pMenu != NULL)
{
pMenu->m_strName = strName;
m_pMenuCmd = pMenu;
pMenu->SetAutoRefresh(Button_GetCheck(GetDlgItem(IDC_REFRESH)) == BST_CHECKED);
}
}
//Iterate through list and delete lParams
HWND hwndLV = GetDlgItem(IDC_MENULIST);
int nItems = ListView_GetItemCount(hwndLV);
for( int i = 0; i < nItems; i++ )
{
LVITEM lvi;
ZeroMemory( &lvi, sizeof(lvi) );
lvi.mask = LVIF_PARAM;
lvi.iItem = i;
ListView_GetItem( hwndLV, &lvi );
if( lvi.lParam )
{
delete [] (TCHAR*)lvi.lParam;
lvi.lParam = NULL;
ListView_SetItem( hwndLV, &lvi );
}
}
EndDialog(wID);
return 0;
}
//////////////////////////////////////////////////////////////////////////////////
// CAddQNMenuDlg
LRESULT CAddQNMenuDlg::OnInitDialog( UINT mMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
// If editing an existing menu
if (m_pMenuCmd != NULL)
{
// Set name modified so that it won't be changed to default
m_bUserModifiedName = TRUE;
// Display info for selected menu
LoadMenuInfo(m_pMenuCmd);
}
m_bCommandChg = FALSE;
m_bStartDirChg = FALSE;
EnableOKButton();
return TRUE;
}
void CAddQNMenuDlg::LoadMenuInfo(CMenuCmd* pMenuCmd)
{
SetDlgItemText( IDC_NAME, pMenuCmd->Name() );
Button_SetCheck(GetDlgItem(IDC_REFRESH), pMenuCmd->IsAutoRefresh() ? BST_CHECKED : BST_UNCHECKED);
CShellMenuCmd* pShellCmd = static_cast<CShellMenuCmd*>(pMenuCmd);
SetDlgItemText( IDC_COMMAND, pShellCmd->m_strProgPath.c_str() );
SetDlgItemText( IDC_STARTIN, pShellCmd->m_strStartDir.c_str() );
SetDlgItemText( IDC_PARAMS, pShellCmd->m_strCmdLine.c_str() );
SetMenuType(MENUTYPE_SHELL);
}
LRESULT CAddQNMenuDlg::OnBrowseForCommand( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
tstring strCommand;
GetItemText( GetDlgItem(IDC_COMMAND), strCommand );
tstring strFilter = StrLoadString(IDS_EXEFILTER);
/*
* The file dialog expects embedded \0's in the string, but those
* don't load well. The string in the resource file has \\ where
* the \0 should be, so let's make the substitution now.
*/
LPTSTR pchTemp = (LPTSTR)strFilter.data();
for (LPTSTR pch = pchTemp; *pch != _T('\0'); pch = pchTemp )
{
pchTemp = CharNext(pch);
if (*pch == _T('\\'))
*pch = _T('\0');
}
// don't call ReleaseBuffer, since the string now contains \0 chars
CFileDialog dlg (true, NULL, strCommand.c_str(), OFN_FILEMUSTEXIST | OFN_HIDEREADONLY, strFilter.c_str(), m_hWnd);
if (dlg.DoModal() == IDOK)
{
SetDlgItemText (IDC_COMMAND, dlg.m_szFileName);
}
return (0);
}
LRESULT CAddQNMenuDlg::OnBrowseForStartIn( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
tstring strCaption = StrLoadString(IDS_SELECT_STARTDIR);
tstring strDir;
GetItemText( GetDlgItem(IDC_STARTIN), strDir );
CFolderDialogPriv dlg( m_hWnd, strCaption.c_str(), BIF_RETURNONLYFSDIRS|BIF_NEWDIALOGSTYLE, strDir.c_str() );
if (dlg.DoModal() == IDOK)
{
SetDlgItemText (IDC_STARTIN, dlg.GetFolderPath());
}
return (0);
}
LRESULT CAddQNMenuDlg::OnNameChange( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
m_bUserModifiedName = TRUE;
EnableOKButton();
return 0;
}
LRESULT CAddQNMenuDlg::OnCommandChange( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
EnableOKButton();
m_bCommandChg = TRUE;
return 0;
}
LRESULT CAddQNMenuDlg::OnStartDirChange( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
m_bStartDirChg = TRUE;
return 0;
}
void CAddQNMenuDlg::EnableOKButton()
{
BOOL bEnable = TRUE;
if (::Edit_GetTextLength(GetDlgItem(IDC_NAME)) == 0)
{
bEnable = FALSE;
}
else
{
if (::Edit_GetTextLength(GetDlgItem(IDC_COMMAND)) == 0)
bEnable = FALSE;
}
EnableDlgItem( m_hWnd, IDOK, bEnable );
}
void CAddQNMenuDlg::SetMenuType(MENUTYPE type)
{
m_menutype = type;
EnableOKButton();
}
LRESULT CAddQNMenuDlg::OnClose( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
if (wID == IDOK)
{
CMenuCmd* pMenu = NULL;
// Get menu name
tstring strName;
GetItemText( GetDlgItem(IDC_NAME), strName );
// Name without the hotkey
tstring strPlainName = strName;
// Validate hotkey selection
int posKey = strName.find(L"&", 0);
if (posKey != tstring::npos)
{
WCHAR chKey = posKey < strName.size() - 1 ? strName[posKey+1] : 0;
if (!( (chKey >= L'A' && chKey <= L'Z') ||
(chKey >= L'a' && chKey <= L'z') ||
(chKey >= L'0' && chKey <= L'9') ))
{
DisplayMessageBox(m_hWnd, IDS_ERRORTITLE_MENUNAME, IDS_ERROR_BADACCESSKEY);
return 0;
}
if (strName.find(L"&", posKey+1) != tstring::npos)
{
DisplayMessageBox(m_hWnd, IDS_ERRORTITLE_MENUNAME, IDS_ERROR_MULTIACCESSKEY);
return 0;
}
// remove '&'
strPlainName.erase(posKey, 1);
}
// Check for duplicated name
menucmd_vector::iterator itMenu;
for (itMenu = m_EditObject.Menus().begin(); itMenu != m_EditObject.Menus().end(); ++itMenu)
{
// if editing a an existing menu, don't compare to itself
if (*itMenu == m_pMenuCmd)
continue;
// Compare names, skipping '&'s
LPCWSTR pszName = (*itMenu)->Name();
LPCWSTR pszNewName = strPlainName.c_str();
while (*pszName && *pszNewName)
{
if (*pszName == L'&')
++pszName;
if (*pszName != *pszNewName)
break;
++pszName;
++pszNewName;
}
// if duplicate name
if (*pszName == *pszNewName)
{
DisplayMessageBox(m_hWnd, IDS_ERRORTITLE_MENUNAME, IDS_ERROR_DUPMENUNAME, MB_OK|MB_ICONEXCLAMATION, strPlainName.c_str());
return 0;
}
}
CShellMenuCmd* pShellMenu = new CShellMenuCmd();
if (pShellMenu != NULL)
{
GetItemText( GetDlgItem(IDC_COMMAND), pShellMenu->m_strProgPath );
if (m_bCommandChg && ValidateFile(pShellMenu->m_strProgPath) != S_OK)
{
int iRet = DisplayMessageBox(m_hWnd, IDS_ERRORTITLE_MENUCMD, IDS_ERROR_MENUCMD,
MB_ICONINFORMATION | MB_YESNO, pShellMenu->m_strProgPath.c_str());
if (iRet != IDYES)
{
delete pShellMenu;
return 0;
}
}
GetItemText( GetDlgItem(IDC_STARTIN), pShellMenu->m_strStartDir );
if (m_bStartDirChg && !pShellMenu->m_strStartDir.empty() &&
ValidateDirectory(pShellMenu->m_strStartDir) != S_OK)
{
int iRet = DisplayMessageBox(m_hWnd, IDS_ERRORTITLE_STARTDIR, IDS_ERROR_STARTDIR,
MB_ICONINFORMATION | MB_YESNO, pShellMenu->m_strStartDir.c_str());
if (iRet != IDYES)
{
delete pShellMenu;
return 0;
}
}
tstring strParams;
GetItemText( GetDlgItem(IDC_PARAMS), strParams );
pShellMenu->m_strCmdLine.erase();
pShellMenu->m_strCmdLine = strParams;
pMenu = pShellMenu;
}
if (pMenu != NULL)
{
pMenu->m_strName = strName;
m_pMenuCmd = pMenu;
pMenu->SetAutoRefresh(Button_GetCheck(GetDlgItem(IDC_REFRESH)) == BST_CHECKED);
}
}
EndDialog(wID);
return 0;
}
//////////////////////////////////////////////////////////////////////////////////////////////
// Add Group Node Dialog
LRESULT CAddGroupNodeDlg::OnInitDialog( UINT mMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
EnableDlgItem( m_hWnd, IDC_SCOPE_LBL, FALSE );
EnableDlgItem( m_hWnd, IDC_SCOPE, FALSE );
EnableDlgItem( m_hWnd, IDC_SCOPE_BROWSE, FALSE );
EnableDlgItem( m_hWnd, IDC_FILTER_LBL, FALSE );
EnableDlgItem( m_hWnd, IDC_FILTER, FALSE );
EnableDlgItem( m_hWnd, IDOK, FALSE );
SendDlgItemMessage( IDC_NAME, EM_LIMITTEXT, 255, 0);
return TRUE;
}
LRESULT CAddGroupNodeDlg::OnApplyScopeClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
BOOL bEnable = Button_GetCheck(GetDlgItem(IDC_APPLYSCOPE)) == BST_CHECKED;
EnableDlgItem( m_hWnd, IDC_SCOPE_LBL, bEnable );
EnableDlgItem( m_hWnd, IDC_SCOPE, bEnable );
EnableDlgItem( m_hWnd, IDC_SCOPE_BROWSE, bEnable );
EnableOKButton();
return 0;
}
LRESULT CAddGroupNodeDlg::OnApplyFilterClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
BOOL bEnable = Button_GetCheck(GetDlgItem(IDC_APPLYFILTER)) == BST_CHECKED;
EnableDlgItem( m_hWnd, IDC_FILTER_LBL, bEnable );
EnableDlgItem( m_hWnd, IDC_FILTER, bEnable );
EnableOKButton();
return 0;
}
LRESULT CAddGroupNodeDlg::OnScopeBrowse(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = GetQueryScope(m_hWnd, m_strScope);
if (hr == S_OK)
{
tstring strDisplay;
GetScopeDisplayString(m_strScope, strDisplay);
SetDlgItemText( IDC_SCOPE, strDisplay.c_str() );
}
EnableOKButton();
return 0;
}
LRESULT CAddGroupNodeDlg::OnEditChange( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
EnableOKButton();
return 0;
}
void CAddGroupNodeDlg::EnableOKButton()
{
BOOL bEnable;
if ( (::Edit_GetTextLength(GetDlgItem(IDC_NAME)) == 0) ||
(Button_GetCheck(GetDlgItem(IDC_APPLYFILTER)) == BST_CHECKED &&
::Edit_GetTextLength(GetDlgItem(IDC_FILTER)) == 0) ||
(Button_GetCheck(GetDlgItem(IDC_APPLYSCOPE)) == BST_CHECKED &&
m_strScope.size() == 0) )
{
bEnable = FALSE;
}
else
{
bEnable = TRUE;
}
EnableDlgItem( m_hWnd, IDOK, bEnable );
}
LRESULT CAddGroupNodeDlg::OnClose( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
if (wID == IDOK)
{
if( !m_pnode ) return 0;
bool bScope = Button_GetCheck(GetDlgItem(IDC_APPLYSCOPE)) == BST_CHECKED;
m_pnode->SetApplyScope(bScope);
m_pnode->SetScope(m_strScope.c_str());
bool bFilter = Button_GetCheck(GetDlgItem(IDC_APPLYFILTER)) == BST_CHECKED;
m_pnode->SetApplyFilter(bFilter);
tstring strFilter;
GetItemText( GetDlgItem(IDC_FILTER), strFilter );
m_pnode->SetFilter(strFilter.c_str());
GetItemText( GetDlgItem(IDC_NAME), m_strName );
}
EndDialog(wID);
return 0;
}
//////////////////////////////////////////////////////////////////////////////////
// CMoveQueryDlg
LRESULT CMoveQueryDlg::OnInitDialog( UINT mMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{
if( !m_pnodeCurFolder ) return 0;
CRootNode* pRootNode = m_pnodeCurFolder->GetRootNode();
if( !pRootNode ) return 0;
HWND hwndTree = GetDlgItem(IDC_FOLDERTREE);
// Create a node image list and assign to folder tree
CImageList images;
if (images.Create(IDB_QUERY16, 16, 100, RGB(255,0,255)))
TreeView_SetImageList(hwndTree, images.Detach(), TVSIL_NORMAL);
// Set snap-in root node as root of tree
TV_INSERTSTRUCT tvi;
tvi.hParent = TVI_ROOT;
tvi.hInsertAfter = TVI_ROOT;
tvi.item.mask = TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_PARAM;
tvi.item.pszText = const_cast<LPWSTR>(pRootNode->GetName());
tvi.item.iImage = pRootNode->GetImage();
tvi.item.iSelectedImage = tvi.item.iImage;
tvi.item.lParam = reinterpret_cast<LPARAM>(pRootNode);
HTREEITEM hti = TreeView_InsertItem(hwndTree, &tvi);
if( !hti ) return 0;
// Insert all group nodes as children of root
tvi.hParent = hti;
tvi.hInsertAfter = TVI_LAST;
CScopeNode* pnode = pRootNode->FirstChild();
while (pnode != NULL)
{
if (pnode->NodeType() == GROUP_NODETYPE)
{
tvi.item.pszText = const_cast<LPWSTR>(pnode->GetName());
tvi.item.iImage = pnode->GetImage();
tvi.item.iSelectedImage = tvi.item.iImage;
tvi.item.lParam = reinterpret_cast<LPARAM>(pnode);
HTREEITEM hti2 = TreeView_InsertItem(hwndTree, &tvi);
ASSERT(hti2 != NULL);
}
pnode = pnode->Next();
}
// Show the group nodes
TreeView_Expand(hwndTree, hti, TVE_EXPAND);
return TRUE;
}
LRESULT CMoveQueryDlg::OnClose( WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled )
{
if( (wID == IDOK) && m_ppnodeDestFolder )
{
HWND hwndTree = GetDlgItem(IDC_FOLDERTREE);
// Get the node pointer (lparam) of the selected tree item
HTREEITEM hti = TreeView_GetSelection(hwndTree);
if( !hti ) return 0;
TVITEM tvi;
tvi.hItem = hti;
tvi.mask = TVIF_PARAM;
tvi.lParam = NULL;
BOOL bStat = TreeView_GetItem(hwndTree, &tvi);
ASSERT(bStat && tvi.lParam != NULL);
*m_ppnodeDestFolder = reinterpret_cast<CScopeNode*>(tvi.lParam);
}
EndDialog(wID);
return 0;
}
////////////////////////////////////////////////////////////////////////////////////
// Parameter translation classes
//
// LDAP to Display translator
BOOL CLookupDisplayName::operator() (tstring& strParam, tstring& strValue)
{
// Check for special parameter ID value
if (strParam.size() == 1 && strParam[0] <= MENU_PARAM_LAST)
{
// Find entry in param table and return display string
for (int i = 0; i<lengthof(MenuParamTable); i++)
{
if (MenuParamTable[i].ID == strParam[0])
{
CString str;
str.LoadString(MenuParamTable[i].rsrcID);
strValue = str;
return TRUE;
}
}
}
// check for class attribute name
string_vector::iterator itstr = std::find(m_vstrParam.begin(), m_vstrParam.end(), strParam);
if (itstr == m_vstrParam.end())
return FALSE;
strValue = m_pNameMap->GetAttributeDisplayName(itstr->c_str());
return TRUE;
}
// Display to LDAP translator
BOOL CLookupLDAPName::operator() (tstring& strParam, tstring& strValue)
{
// Check for standard parameter name
for (int i=0; i<lengthof(MenuParamTable); i++)
{
CString str;
str.LoadString(MenuParamTable[i].rsrcID);
// if match, return single wchar equal to param ID
if (_wcsicmp(strParam.c_str(), str) == 0)
{
strValue = (WCHAR)MenuParamTable[i].ID;
return TRUE;
}
}
// Check for class attribute display name
string_vector::iterator itstr;
for (itstr = m_vstrParam.begin(); itstr != m_vstrParam.end(); ++itstr)
{
if (_wcsicmp(strParam.c_str(), m_pNameMap->GetAttributeDisplayName(itstr->c_str())) == 0)
{
strValue = (*itstr);
return TRUE;
}
}
return FALSE;
}