able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/osshell/lmui/ntshrui/shrpage.cxx

2585 lines
67 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1995 - 1995.
//
// File: shrpage.cxx
//
// Contents: "Sharing" shell property page extension
//
// History: 6-Apr-95 BruceFo Created
// 12-Jul-00 JonN fixed 140878, MSG_MULTIDEL debounce
// 06-Oct-00 jeffreys Split CShareBase out of CSharingPropertyPage
//
//--------------------------------------------------------------------------
#include "headers.hxx"
#pragma hdrstop
#include "resource.h"
#include "helpids.h"
#include "dlgnew.hxx"
#include "cache.hxx"
#include "share.hxx"
#include "acl.hxx"
#include "shrinfo.hxx"
#include "shrpage.hxx"
#include "util.hxx"
void _MyShow( HWND hwndParent, INT idControl, BOOL fShow )
{
HWND hwndChild = GetDlgItem( hwndParent, idControl );
appAssert( NULL != hwndChild );
ShowWindow( hwndChild, (fShow) ? SW_SHOW : SW_HIDE );
EnableWindow( hwndChild, fShow );
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CShareBase::QueryInterface(REFIID riid, void **ppvObj)
{
static const QITAB qit[] = {
QITABENT(CShareBase, IOleWindow), // IID_IOleWindow
{ 0 }
};
return QISearch(this, qit, riid, ppvObj);
}
STDMETHODIMP_(ULONG) CShareBase::AddRef()
{
return InterlockedIncrement(&_cRef);
}
STDMETHODIMP_(ULONG) CShareBase::Release()
{
if (InterlockedDecrement(&_cRef))
return _cRef;
delete this;
return 0;
}
STDMETHODIMP CShareBase::GetWindow(HWND *phwnd)
{
*phwnd = _GetFrameWindow();
return S_OK;
}
STDMETHODIMP CShareBase::ContextSensitiveHelp(BOOL /*fEnterMode*/)
{
return E_NOTIMPL;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::PageCallback, static public
//
// Synopsis:
//
//--------------------------------------------------------------------------
UINT CALLBACK
CShareBase::PageCallback(
IN HWND hwnd,
IN UINT uMsg,
IN LPPROPSHEETPAGE ppsp
)
{
switch (uMsg)
{
case PSPCB_CREATE:
return 1; // allow creation
case PSPCB_RELEASE:
{
CShareBase* pThis = (CShareBase*)ppsp->lParam;
pThis->Release(); // do this LAST!
return 0; // ignored
}
case PSPCB_ADDREF:
// Should probably implement some refcounting, but we only get
// addref'd once and released once.
return 0;
default:
appDebugOut((DEB_ERROR, "CShareBase::PageCallback, unknown page callback message %d\n", uMsg));
return 0;
} // end switch
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::DlgProcPage, static public
//
// Synopsis: Dialog Procedure for all sharing dialogs/pages
//
//--------------------------------------------------------------------------
INT_PTR CALLBACK
CShareBase::DlgProcPage(
IN HWND hwnd,
IN UINT msg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
CShareBase* pThis = NULL;
if (msg==WM_INITDIALOG)
{
PROPSHEETPAGE* psp = (PROPSHEETPAGE*)lParam;
pThis = (CShareBase*)psp->lParam;
SetWindowLongPtr(hwnd,GWLP_USERDATA,(LPARAM)pThis);
}
else
{
pThis = (CShareBase*) GetWindowLongPtr(hwnd,GWLP_USERDATA);
}
if (pThis != NULL)
{
return pThis->_PageProc(hwnd,msg,wParam,lParam);
}
else
{
return FALSE;
}
}
//+--------------------------------------------------------------------------
//
// Method: CShareBase::CShareBase, public
//
// Synopsis: Constructor
//
//---------------------------------------------------------------------------
CShareBase::CShareBase(
IN PWSTR pszPath,
IN BOOL bDialog // called as a dialog, not a property page?
)
:
_cRef(1),
_pszPath(pszPath), // take ownership!
_hwndPage(NULL),
_fInitializingPage(0), // JonN 7/11/00 140878
_bDirty(FALSE),
_pInfoList(NULL),
_pReplaceList(NULL),
_pCurInfo(NULL),
_cShares(0),
_bNewShare(TRUE),
_bDialog(bDialog)
{
INIT_SIG(CShareBase);
appAssert(NULL != _pszPath);
}
//+--------------------------------------------------------------------------
//
// Method: CShareBase::~CShareBase, public
//
// Synopsis: Destructor
//
//---------------------------------------------------------------------------
CShareBase::~CShareBase()
{
CHECK_SIG(CShareBase);
// delete the the list of shares
appAssert(NULL != _pInfoList);
DeleteShareInfoList(_pInfoList, TRUE);
_pInfoList = NULL;
_pCurInfo = NULL;
// delete the "replacement" list
appAssert(NULL != _pReplaceList);
DeleteShareInfoList(_pReplaceList, TRUE);
_pReplaceList = NULL;
delete[] _pszPath;
_pszPath = NULL;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::InitInstance, public
//
// Synopsis: Part II of the constuctor process
//
// Notes: We don't want to handle any errors in constuctor, so this
// method is necessary for the second phase error detection.
//
//--------------------------------------------------------------------------
HRESULT
CShareBase::InitInstance(
VOID
)
{
CHECK_SIG(CShareBase);
appDebugOut((DEB_ITRACE, "CShareBase::InitInstance\n"));
_pInfoList = new CShareInfo(); // dummy head node
if (NULL == _pInfoList)
{
return E_OUTOFMEMORY;
}
_pReplaceList = new CShareInfo(); // dummy head node
if (NULL == _pReplaceList)
{
return E_OUTOFMEMORY;
}
return S_OK;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_PageProc, private
//
// Synopsis: Dialog Procedure for this object
//
//--------------------------------------------------------------------------
BOOL
CShareBase::_PageProc(
IN HWND hwnd,
IN UINT msg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
CHECK_SIG(CShareBase);
switch (msg)
{
case WM_INITDIALOG:
_hwndPage = hwnd;
//
// We know this drive is allowed to be shared. However, someone may
// have changed the number or characteristics of the share using the
// command line or winfile or server manager or the new file server
// tool, and the cache may not have been refreshed. Force a refresh
// now, to pick up any new shares for this path.
//
// Note that for the SharingDialog() API, this is the first time the
// cache gets loaded. If the server is not running, we nuke the dialog
// and return an error code.
//
g_ShareCache.Refresh();
if (_bDialog && !g_fSharingEnabled)
{
EndDialog(hwnd, -1);
}
_ConstructShareList();
return _OnInitDialog(hwnd, (HWND)wParam, lParam);
case WM_COMMAND:
return _OnCommand(hwnd, HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
case WM_NOTIFY:
return _OnNotify(hwnd, (int)wParam, (LPNMHDR)lParam);
case WM_HELP:
return _OnHelp(hwnd, (LPHELPINFO)lParam);
case WM_CONTEXTMENU:
return _OnContextMenu(hwnd, (HWND)wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
} // end switch (msg)
return FALSE;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_OnCommand, private
//
// Synopsis: WM_COMMAND handler
//
//--------------------------------------------------------------------------
BOOL
CShareBase::_OnCommand(
IN HWND hwnd,
IN WORD wNotifyCode,
IN WORD wID,
IN HWND hwndCtl
)
{
CHECK_SIG(CShareBase);
//
// Commands only used when this page is invoked as a dialog box, via the
// SharingDialog() API:
//
if (_bDialog)
{
switch (wID)
{
case IDCANCEL:
if (!_DoCancel(hwnd))
{
// We might consider not going away. But instead, go away anyway.
}
EndDialog(hwnd, FALSE);
return TRUE;
case IDOK:
if (!_ValidatePage(hwnd))
{
// don't go away
return TRUE;
}
if (!_DoApply(hwnd, TRUE))
{
// don't go away
return TRUE;
}
EndDialog(hwnd, TRUE);
return TRUE;
default:
break;
}
}
return FALSE;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_OnNotify, private
//
// Synopsis: WM_NOTIFY handler
//
//--------------------------------------------------------------------------
BOOL
CShareBase::_OnNotify(
IN HWND hwnd,
IN int idCtrl,
IN LPNMHDR phdr
)
{
CHECK_SIG(CShareBase);
// assume a property sheet notification
return _OnPropertySheetNotify(hwnd, phdr);
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_OnPropertySheetNotify, private
//
// Synopsis: WM_NOTIFY handler for the property sheet notification
//
//--------------------------------------------------------------------------
BOOL
CShareBase::_OnPropertySheetNotify(
IN HWND hwnd,
IN LPNMHDR phdr
)
{
CHECK_SIG(CShareBase);
switch (phdr->code)
{
case PSN_RESET: // cancel
if (_DoCancel(hwnd))
{
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_NOERROR); // go away
}
else
{
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID);
}
return TRUE;
case PSN_KILLACTIVE: // change to another page
if (_ValidatePage(hwnd))
{
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_NOERROR);
return FALSE;
}
else
{
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
case PSN_APPLY:
if (_DoApply(hwnd, !!(((LPPSHNOTIFY)phdr)->lParam)))
{
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_NOERROR); // go away
}
else
{
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID);
}
return TRUE;
} // end switch (phdr->code)
return FALSE;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_DoApply, public
//
// Synopsis: If anything has changed, apply the data
//
//--------------------------------------------------------------------------
BOOL
CShareBase::_DoApply(
IN HWND hwnd,
IN BOOL /*bClose*/
)
{
CHECK_SIG(CShareBase);
if (_bDirty)
{
_bDirty = FALSE;
PropSheet_UnChanged(_GetFrameWindow(),_hwndPage);
}
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_DoCancel, public
//
// Synopsis: Do whatever is necessary to cancel the changes
//
//--------------------------------------------------------------------------
BOOL
CShareBase::_DoCancel(
IN HWND hwnd
)
{
CHECK_SIG(CShareBase);
if (_bDirty)
{
_bDirty = FALSE;
PropSheet_UnChanged(_GetFrameWindow(),_hwndPage);
}
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_MarkPageDirty, private
//
// Synopsis: A change has made such that the page is now dirty
//
//--------------------------------------------------------------------------
VOID
CShareBase::_MarkPageDirty(
VOID
)
{
CHECK_SIG(CShareBase);
if (!_fInitializingPage)
{
if (!_bDirty)
{
appDebugOut((DEB_ITRACE, "Marking Sharing page dirty\n"));
_bDirty = TRUE;
PropSheet_Changed(_GetFrameWindow(),_hwndPage);
}
}
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_ConnstructShareList, private
//
// Synopsis: Construct the list of shares for the current path by
// iterating through the entire cache of shares and adding an
// element for every path that matches.
//
//--------------------------------------------------------------------------
HRESULT
CShareBase::_ConstructShareList(
VOID
)
{
CHECK_SIG(CShareBase);
appDebugOut((DEB_ITRACE, "_ConstructShareList\n"));
// This routine sets _cShares, and _bNewShare, and adds to
// the _pInfoList list
HRESULT hr;
DeleteShareInfoList(_pInfoList);
_pCurInfo = NULL;
_bNewShare = FALSE;
appAssert(_pInfoList->IsSingle());
appAssert(_pCurInfo == NULL);
appAssert(_pszPath != NULL);
hr = g_ShareCache.ConstructList(_pszPath, _pInfoList, &_cShares);
if (SUCCEEDED(hr) && _cShares == 0)
{
// There are no existing shares. Construct an element to be used
// by the UI to stash the new share's data
hr = _ConstructNewShareInfo();
}
return hr;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_ConstructNewShareInfo, private
//
// Synopsis: Construct an element to be used by the UI to stash the new
// share's data
//
//--------------------------------------------------------------------------
HRESULT
CShareBase::_ConstructNewShareInfo(
VOID
)
{
CHECK_SIG(CShareBase);
HRESULT hr;
CShareInfo* pNewInfo = new CShareInfo();
if (NULL == pNewInfo)
{
return E_OUTOFMEMORY;
}
hr = pNewInfo->InitInstance();
CHECK_HRESULT(hr);
if (FAILED(hr))
{
delete pNewInfo;
return hr;
}
hr = pNewInfo->SetPath(_pszPath);
CHECK_HRESULT(hr);
if (FAILED(hr))
{
delete pNewInfo;
return hr;
}
NET_API_STATUS ret = pNewInfo->ReadCacheFlags ();
if ( NERR_Success != ret )
{
delete pNewInfo;
return HRESULT_FROM_WIN32 (ret);
}
_bNewShare = TRUE;
pNewInfo->SetDirtyFlag(SHARE_FLAG_ADDED);
pNewInfo->InsertBefore(_pInfoList);
//NOTE: leave the count of shares to be zero. The count of shares only
// reflects the number of committed shares (?)
// Get the shell's name for the folder to use as the share name. This
// gives us localized names for things like "Shared Documents".
//
// Sometimes the shell's name contains invalid characters, such
// as when we're looking at the root of the drive. In that case
// SHGetFileInfo returns "label (X:)" and IsValidShareName fails
// on the colon. For those, try calling shell32's PathCleanupSpec
// to make the name valid.
//
// If SHGetFileInfo and PathCleanupSpec fail to give us a good name,
// fall back on the old method, which is...
//
// Give the share a default name. For paths like "X:\", use the default
// "X", for paths like "X:\foo\bar\baz", use the default "baz".
// For everything else, juse leave it blank. Also, check that the
// computed default is not already a share name. If it is, leave it
// blank.
appAssert(NULL != _pszPath);
WCHAR szDefault[2] = L"";
PWSTR pszDefault = NULL;
SHFILEINFOW sfi = {0};
if (SHGetFileInfoW(_pszPath, 0, &sfi, sizeof(sfi), SHGFI_DISPLAYNAME))
{
if (IsValidShareName(sfi.szDisplayName, &hr))
{
pszDefault = sfi.szDisplayName;
}
else
{
int iResult = PathCleanupSpec(NULL, sfi.szDisplayName);
if (0 == (iResult & (PCS_TRUNCATED|PCS_PATHTOOLONG|PCS_FATAL))
&& IsValidShareName(sfi.szDisplayName, &hr))
{
pszDefault = sfi.szDisplayName;
}
}
//
// NTRAID#NTBUG9-225755-2000/12/19-jeffreys
//
// Win9x boxes can't see the share if the name is long
//
if (NULL != pszDefault && wcslen(pszDefault) > LM20_NNLEN)
{
// Go back to the old way below
pszDefault = NULL;
}
}
if (NULL == pszDefault)
{
pszDefault = szDefault;
int len = wcslen(_pszPath);
if (len == 3 && _pszPath[1] == L':' && _pszPath[2] == L'\\')
{
szDefault[0] = _pszPath[0];
}
else
{
PWSTR pszTmp = wcsrchr(_pszPath, L'\\');
if (pszTmp != NULL)
{
pszDefault = pszTmp + 1;
}
}
}
if (g_ShareCache.IsShareNameUsed(pszDefault))
{
pszDefault = szDefault;
szDefault[0] = L'\0';
}
hr = pNewInfo->SetNetname(pszDefault);
CHECK_HRESULT(hr);
if (FAILED(hr))
{
// FEATURE: error handling?
_bNewShare = FALSE;
pNewInfo->Unlink();
delete pNewInfo;
return hr;
}
return hr;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_ValidateNewShareName, protected
//
// Synopsis: Return TRUE if the sharename is valid, performing
// confirmations if necessary
//
//--------------------------------------------------------------------------
BOOL
CShareBase::_ValidateNewShareName(
VOID
)
{
CHECK_SIG(CShareBase);
if (!_bNewShare)
{
// nothing to do
return TRUE;
}
appAssert(NULL != _pCurInfo);
if (NULL == _pCurInfo) // JonN 5/2/01 384155
return FALSE;
PWSTR pszShareName = _pCurInfo->GetNetname();
appAssert(NULL != pszShareName);
if ((NULL == pszShareName) || (0 == wcslen(pszShareName))) // PREFIX 240253
{
MyErrorDialog(_hwndPage, IERR_BlankShareName);
return FALSE;
}
HRESULT uTemp;
if (!IsValidShareName(pszShareName, &uTemp))
{
MyErrorDialog(_hwndPage, uTemp);
return FALSE;
}
// Trying to create a reserved share?
if (0 == _wcsicmp(g_szIpcShare, pszShareName))
{
MyErrorDialog(_hwndPage, IERR_SpecialShare);
return FALSE;
}
if (0 == _wcsicmp(g_szAdminShare, pszShareName))
{
// We will let the admin create the admin$ share if they create
// it in the directory specified by GetWindowsDirectory().
WCHAR szWindowsDir[MAX_PATH];
UINT err = GetWindowsDirectory(szWindowsDir, ARRAYLEN(szWindowsDir));
if (err == 0)
{
// oh well, give them this error
MyErrorDialog(_hwndPage, IERR_SpecialShare);
return FALSE;
}
if (0 != _wcsicmp(_pCurInfo->GetPath(), szWindowsDir))
{
MyErrorDialog(_hwndPage, IERR_SpecialShare);
return FALSE;
}
// otherwise, it is the right directory. Let them create it.
}
/* removed JonN 10/5/98
// Check for downlevel accessibility
// we should really get rid of this at some point -- JonN 7/18/97
ULONG nType;
if (NERR_Success != NetpPathType(NULL, pszShareName, &nType, INPT_FLAGS_OLDPATHS))
{
DWORD id = MyConfirmationDialog(
_hwndPage,
IERR_InaccessibleByDos,
MB_YESNO | MB_ICONEXCLAMATION,
pszShareName);
if (id == IDNO)
{
return FALSE;
}
}
*/
WCHAR szOldPath[PATHLEN+1];
if (g_ShareCache.IsExistingShare(pszShareName, _pCurInfo->GetPath(), szOldPath))
{
DWORD id = ConfirmReplaceShare(_hwndPage, pszShareName, szOldPath, _pCurInfo->GetPath());
if (id != IDYES)
{
return FALSE;
}
// User said to replace the old share. We need to add
// a "delete" record for the old share.
HRESULT hr;
CShareInfo* pNewInfo = new CShareInfo();
if (NULL == pNewInfo)
{
return FALSE;
}
hr = pNewInfo->InitInstance();
CHECK_HRESULT(hr);
if (FAILED(hr))
{
delete pNewInfo;
return FALSE;
}
// only need net name for delete; ignore other fields
hr = pNewInfo->SetNetname(pszShareName);
CHECK_HRESULT(hr);
if (FAILED(hr))
{
delete pNewInfo;
return FALSE;
}
hr = pNewInfo->SetPath(szOldPath);
CHECK_HRESULT(hr);
if (FAILED(hr))
{
delete pNewInfo;
return FALSE;
}
NET_API_STATUS ret = pNewInfo->ReadCacheFlags ();
if ( NERR_Success != ret )
{
delete pNewInfo;
return HRESULT_FROM_WIN32 (ret);
}
pNewInfo->SetDirtyFlag(SHARE_FLAG_REMOVE);
pNewInfo->InsertBefore(_pReplaceList); // add to end of replace list
}
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CShareBase::_CommitShares, protected
//
// Synopsis: Commit outstanding share edits. Note that this method does
// not reset _bDirty.
//
//--------------------------------------------------------------------------
VOID
CShareBase::_CommitShares(
IN BOOL bNotShared
)
{
CHECK_SIG(CShareBase);
if (!_bDirty)
{
// nothing to do
return;
}
if (bNotShared)
{
// When the user hits "Not Shared" after having had "Shared As"
// selected, we don't actually delete anything (or even mark it
// for deletion). This is so the user can hit "Shared As" again
// and they haven't lost anything. However, if they subsequently
// apply changes, we must go through and actually delete anything
// that they wanted to delete. So, fix up our list to do this.
// Delete SHARE_FLAG_ADDED nodes, and mark all others as
// SHARE_FLAG_REMOVE.
for (CShareInfo* p = (CShareInfo*) _pInfoList->Next();
p != _pInfoList;
)
{
CShareInfo* pNext = (CShareInfo*)p->Next();
if (p->GetFlag() == SHARE_FLAG_ADDED)
{
// get rid of p
p->Unlink();
delete p;
}
else
{
p->SetDirtyFlag(SHARE_FLAG_REMOVE);
}
p = pNext;
}
}
//
// Commit the changes!
//
HRESULT hr;
CShareInfo* p;
// Delete all "replace" shares first. These are all the shares whos
// names are being reused to share a different directory.
// These replace deletes have already been confirmed.
for (p = (CShareInfo*) _pReplaceList->Next();
p != _pReplaceList;
p = (CShareInfo*) p->Next())
{
appAssert(p->GetFlag() == SHARE_FLAG_REMOVE);
NET_API_STATUS ret = p->Commit(NULL);
if (ret != NERR_Success)
{
DisplayError(_hwndPage, IERR_CANT_DEL_SHARE, ret, p->GetNetname());
// We've got a problem here because we couldn't delete a
// share that will be added subsequently. Oh well...
}
// Note that we don't delete this list because we need to notify
// the shell (*after* all changes) that all these guys have
// changed (and get rid of those little hands)...
}
// Now, do all add/delete/modify of the current
for (p = (CShareInfo*) _pInfoList->Next();
p != _pInfoList;
)
{
CShareInfo* pNext = (CShareInfo*)p->Next();
if (0 != p->GetFlag())
{
if (SHARE_FLAG_REMOVE == p->GetFlag())
{
// confirm the delete, if there are connections
DWORD id = ConfirmStopShare(_hwndPage, MB_YESNO, p->GetNetname());
if (id != IDYES)
{
p->SetDirtyFlag(0); // don't do anything to it
}
}
NET_API_STATUS ret = p->Commit(NULL);
if (ret != NERR_Success)
{
HRESULT hrMsg = 0;
switch (p->GetFlag())
{
case SHARE_FLAG_ADDED: hrMsg = IERR_CANT_ADD_SHARE; break;
case SHARE_FLAG_MODIFY: hrMsg = IERR_CANT_MODIFY_SHARE; break;
case SHARE_FLAG_REMOVE: hrMsg = IERR_CANT_DEL_SHARE; break;
default:
appAssert(!"Illegal flag for a failed commit!");
}
DisplayError(_hwndPage, hrMsg, ret, p->GetNetname());
}
else
{
if (p->GetFlag() == SHARE_FLAG_REMOVE)
{
// nuke it!
p->Unlink();
delete p;
}
else
{
p->SetDirtyFlag(0); // clear flag on success
}
}
}
p = pNext;
}
if (_bNewShare)
{
_bNewShare = FALSE;
_cShares = 1;
}
// I refresh the cache, even though the shell comes back and asks
// for a refresh after every SHChangeNotify. However, SHChangeNotify
// is asynchronous, and I need the cache refreshed immediately so I
// can display the new share information, if the "apply" button was
// hit and the page didn't go away.
g_ShareCache.Refresh();
appDebugOut((DEB_TRACE,
"Changed share for path %ws, notifying shell\n",
_pszPath));
SHChangeNotify(SHCNE_NETSHARE, SHCNF_PATH, _pszPath, NULL);
// FEATURE: might want to use SHCNE_NETUNSHARE, but the shell doesn't
// distinguish them
// Now, notify the shell about all the paths we got rid of to be able
// to use their share names ...
for (p = (CShareInfo*) _pReplaceList->Next();
p != _pReplaceList;
)
{
appAssert(p->GetFlag() == SHARE_FLAG_REMOVE);
appDebugOut((DEB_TRACE,
"Got rid of share on path %ws, notifying shell\n",
p->GetPath()));
// We're going to be asked by the shell to refresh the cache once
// for every notify. But, seeing as how the average case is zero
// of these notifies, don't worry about it.
SHChangeNotify(SHCNE_NETSHARE, SHCNF_PATH, p->GetPath(), NULL);
CShareInfo* pNext = (CShareInfo*) p->Next();
p->Unlink();
delete p;
p = pNext;
}
_ConstructShareList();
}
//+-------------------------------------------------------------------------
//
// Member: CSharingPropertyPage::SizeWndProc, public
//
// Synopsis: "allow" edit window subclass proc to disallow non-numeric
// characters.
//
// History: 5-Apr-95 BruceFo Created
//
//--------------------------------------------------------------------------
LRESULT CALLBACK
CSharingPropertyPage::SizeWndProc(
IN HWND hwnd,
IN UINT wMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
switch (wMsg)
{
case WM_CHAR:
{
WCHAR chCharCode = (WCHAR)wParam;
if ( (chCharCode == TEXT('\t'))
|| (chCharCode == TEXT('\b'))
|| (chCharCode == TEXT('\n'))
// || (chCharCode == TEXT('\x1b')) // ESCAPE key
)
{
break;
}
if (chCharCode < TEXT('0') || chCharCode > TEXT('9'))
{
// bad key: ignore it
MessageBeep(0xffffffff); // let user know it's an illegal char
return FALSE;
}
break;
}
} // end of switch
CSharingPropertyPage* pThis = (CSharingPropertyPage*)GetWindowLongPtr(GetParent(hwnd),GWLP_USERDATA);
appAssert(NULL != pThis);
appAssert(NULL != pThis->_pfnAllowProc);
return CallWindowProc(pThis->_pfnAllowProc, hwnd, wMsg, wParam, lParam);
}
//+--------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::CSharingPropertyPage, public
//
// Synopsis: Constructor
//
//---------------------------------------------------------------------------
CSharingPropertyPage::CSharingPropertyPage(
IN PWSTR pszPath,
IN BOOL bDialog // called as a dialog, not a property page?
)
:
CShareBase(pszPath, bDialog),
_wIDSelected(0), // JonN 7/12/00 140878
_bItemDirty(FALSE),
_bShareNameChanged(FALSE),
_bCommentChanged(FALSE),
_bUserLimitChanged(FALSE),
_wMaxUsers(DEFAULT_MAX_USERS),
_pfnAllowProc(NULL),
_bIsCachingSupported (false)
{
INIT_SIG(CSharingPropertyPage);
}
//+--------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::~CSharingPropertyPage, public
//
// Synopsis: Destructor
//
//---------------------------------------------------------------------------
CSharingPropertyPage::~CSharingPropertyPage()
{
CHECK_SIG(CSharingPropertyPage);
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_PageProc, private
//
// Synopsis: Dialog Procedure for this object
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_PageProc(
IN HWND hwnd,
IN UINT msg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
CHECK_SIG(CSharingPropertyPage);
switch (msg)
{
case WM_VSCROLL:
// The up/down control changed the edit control: select it again
SendDlgItemMessage(hwnd, IDC_SHARE_ALLOW_VALUE, EM_SETSEL, 0, (LPARAM)-1);
return TRUE;
case WM_CLOSE:
// NOTE: There is a bug where hitting "ESCAPE" with the focus on the
// MLE for the "allow" text doesn't kill the property sheet unless we
// forward the WM_CLOSE message on to the property sheet root dialog.
return (BOOL)SendMessage(_GetFrameWindow(), msg, wParam, lParam);
case WM_DESTROY:
// restore original subclass to window.
appAssert(NULL != GetDlgItem(hwnd,IDC_SHARE_ALLOW_VALUE));
SetWindowLongPtr(GetDlgItem(hwnd,IDC_SHARE_ALLOW_VALUE), GWLP_WNDPROC, (LONG_PTR)_pfnAllowProc);
break;
} // end switch (msg)
return CShareBase::_PageProc(hwnd, msg, wParam, lParam);
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_OnInitDialog, private
//
// Synopsis: WM_INITDIALOG handler
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_OnInitDialog(
IN HWND hwnd,
IN HWND hwndFocus,
IN LPARAM lInitParam
)
{
CHECK_SIG(CSharingPropertyPage);
appDebugOut((DEB_ITRACE, "_OnInitDialog\n"));
// Subclass allow edit control to disallow non-positive numbers
_pfnAllowProc = (WNDPROC)SetWindowLongPtr(
GetDlgItem(hwnd, IDC_SHARE_ALLOW_VALUE),
GWLP_WNDPROC,
(LONG_PTR)&SizeWndProc);
// use LanMan API constants to set maximum share name & comment lengths
SendDlgItemMessage(hwnd, IDC_SHARE_SHARENAME, EM_LIMITTEXT, NNLEN, 0L);
SendDlgItemMessage(hwnd, IDC_SHARE_COMMENT, EM_LIMITTEXT, MAXCOMMENTSZ, 0L);
if (_bDialog)
{
SetWindowText(hwnd, _pszPath);
}
else
{
_MyShow( hwnd, IDOK, FALSE );
_MyShow( hwnd, IDCANCEL, FALSE );
}
_InitializeControls(hwnd);
// #if DBG == 1
// Dump(L"_OnInitDialog finished");
// #endif // DBG == 1
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_OnCommand, private
//
// Synopsis: WM_COMMAND handler
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_OnCommand(
IN HWND hwnd,
IN WORD wNotifyCode,
IN WORD wID,
IN HWND hwndCtl
)
{
CHECK_SIG(CSharingPropertyPage);
switch (wID)
{
//
// Notifications
//
case IDC_SHARE_NOTSHARED:
{
if (BN_CLICKED == wNotifyCode)
{
if ( (!_fInitializingPage)
&& (IDC_SHARE_NOTSHARED != _wIDSelected) // JonN 7/11/00 140878
// JonN 7/11/00 140878
// sometimes you get BN_CLICKED even before the
// button is selected according to IsDlgButtonChecked
&& (1 == IsDlgButtonChecked(hwnd, IDC_SHARE_NOTSHARED))
)
{
_wIDSelected = IDC_SHARE_NOTSHARED;
_ReadControls(hwnd);
// Delete all shares from the combo box; convert the combo box
// to the edit control (default state), and then disable
// all the controls. Cache whatever shares we had, so if
// the user hits "Shared As", we can put them back.
if (_cShares > 1)
{
// JonN 7/11/00 140878
// Additional BN_CLICKED notifications are coming in while
// the MSG_MULTIDEL dialog is still onscreen, resulting
// in multiple copies of the dialog.
_fInitializingPage++; // JonN 7/11/00 140878
DWORD id = MyConfirmationDialog(
hwnd,
MSG_MULTIDEL,
MB_YESNO | MB_ICONQUESTION);
if (IDNO == id)
{
CheckRadioButton(
hwnd,
IDC_SHARE_NOTSHARED,
IDC_SHARE_SHAREDAS,
IDC_SHARE_SHAREDAS);
//
// JonN 3/8/01 140878 part 2 (unit-test 3/9/01)
// At this point, IDC_SHARE_SHAREDAS is selected,
// but focus is still on IDC_SHARE_NOTSHARED and
// _wIDSelected == IDC_SHARE_NOTSHARED.
// Correct this, but stay in the _fInitializingPage
// block so that the page will not be marked dirty.
//
SendMessage(hwnd, WM_NEXTDLGCTL,
(WPARAM)GetDlgItem(hwnd,IDC_SHARE_SHAREDAS),
(LPARAM)TRUE);
_wIDSelected = IDC_SHARE_SHAREDAS;
_fInitializingPage--; // JonN 7/11/00 140878
return TRUE;
}
_fInitializingPage--; // JonN 7/11/00 140878
}
//
// Next, regenerate the UI
//
_SetControlsFromData(hwnd, NULL);
_MarkPageDirty();
}
}
return TRUE;
}
case IDC_SHARE_SHAREDAS:
{
if (BN_CLICKED == wNotifyCode)
{
if ( (!_fInitializingPage)
&& (IDC_SHARE_SHAREDAS != _wIDSelected) // JonN 7/11/00 140878
// JonN 7/11/00 140878
// Sometimes you get BN_CLICKED even before the
// button is selected according to IsDlgButtonChecked
&& (1 == IsDlgButtonChecked(hwnd, IDC_SHARE_SHAREDAS))
)
{
_wIDSelected = IDC_SHARE_SHAREDAS;
// if there were shares there that we just hid when the user
// pressed "Not Shared", then put them back.
//
// Regenerate the UI
//
_SetControlsFromData(hwnd, NULL);
_MarkPageDirty();
}
}
return TRUE;
}
case IDC_SHARE_SHARENAME:
{
if (EN_CHANGE == wNotifyCode)
{
if (!_fInitializingPage)
{
_bShareNameChanged = TRUE;
_MarkItemDirty();
}
EnableWindow (GetDlgItem(hwnd, IDC_SHARE_CACHING),
IsCachingSupported ());
}
return TRUE;
}
case IDC_SHARE_COMMENT:
{
if (EN_CHANGE == wNotifyCode)
{
if (!_fInitializingPage)
{
_bCommentChanged = TRUE;
_MarkItemDirty();
}
}
return TRUE;
}
case IDC_SHARE_SHARENAME_COMBO:
{
if (CBN_SELCHANGE == wNotifyCode)
{
_ReadControls(hwnd);
HWND hwndCombo = GetDlgItem(hwnd, IDC_SHARE_SHARENAME_COMBO);
int item = ComboBox_GetCurSel(hwndCombo);
LRESULT itemData = ComboBox_GetItemData(hwndCombo, item);
_pCurInfo = (CB_ERR == itemData) ? NULL : (CShareInfo *)itemData;
appAssert(NULL != _pCurInfo);
_SetFieldsFromCurrent(hwnd);
}
return TRUE;
}
case IDC_SHARE_MAXIMUM:
if (BN_CLICKED == wNotifyCode)
{
// Take away WS_TABSTOP from the "allow users" edit control
HWND hwndEdit = GetDlgItem(hwnd, IDC_SHARE_ALLOW_VALUE);
SetWindowLong(hwndEdit, GWL_STYLE, GetWindowLong(hwndEdit, GWL_STYLE) & ~WS_TABSTOP);
_CacheMaxUses(hwnd);
SetDlgItemText(hwnd, IDC_SHARE_ALLOW_VALUE, L"");
_bUserLimitChanged = TRUE;
_MarkItemDirty();
}
return TRUE;
case IDC_SHARE_ALLOW:
if (BN_CLICKED == wNotifyCode)
{
// Give WS_TABSTOP to the "allow users" edit control
HWND hwndEdit = GetDlgItem(hwnd, IDC_SHARE_ALLOW_VALUE);
SetWindowLong(hwndEdit, GWL_STYLE, GetWindowLong(hwndEdit, GWL_STYLE) | WS_TABSTOP);
// let the spin control set the edit control
SendDlgItemMessage(hwnd, IDC_SHARE_ALLOW_SPIN, UDM_SETPOS, 0, MAKELONG(_wMaxUsers, 0));
SendDlgItemMessage(hwnd, IDC_SHARE_ALLOW_VALUE, EM_SETSEL, 0, (LPARAM)-1);
_bUserLimitChanged = TRUE;
_MarkItemDirty();
}
return TRUE;
case IDC_SHARE_ALLOW_VALUE:
{
if (EN_CHANGE == wNotifyCode)
{
_bUserLimitChanged = TRUE;
_MarkItemDirty();
}
if (EN_SETFOCUS == wNotifyCode)
{
if (1 != IsDlgButtonChecked(hwnd, IDC_SHARE_ALLOW))
{
CheckRadioButton(
hwnd,
IDC_SHARE_MAXIMUM,
IDC_SHARE_ALLOW,
IDC_SHARE_ALLOW);
}
// let the spin control set the edit control
SendDlgItemMessage(hwnd, IDC_SHARE_ALLOW_SPIN, UDM_SETPOS, 0, MAKELONG(_wMaxUsers, 0));
SendDlgItemMessage(hwnd, IDC_SHARE_ALLOW_VALUE, EM_SETSEL, 0, (LPARAM)-1);
_bUserLimitChanged = TRUE;
_MarkItemDirty();
}
if (EN_KILLFOCUS == wNotifyCode)
{
_CacheMaxUses(hwnd);
}
return TRUE;
}
case IDC_SHARE_ALLOW_SPIN:
if (UDN_DELTAPOS == wNotifyCode)
{
if (1 != IsDlgButtonChecked(hwnd, IDC_SHARE_ALLOW))
{
CheckRadioButton(
hwnd,
IDC_SHARE_MAXIMUM,
IDC_SHARE_ALLOW,
IDC_SHARE_ALLOW);
}
_bUserLimitChanged = TRUE;
_MarkItemDirty();
}
return TRUE;
//
// Commands
//
case IDC_SHARE_PERMISSIONS:
return _OnPermissions(hwnd);
case IDC_SHARE_REMOVE:
return _OnRemove(hwnd);
case IDC_SHARE_NEWSHARE:
return _OnNewShare(hwnd);
case IDC_SHARE_CACHING:
return _OnCaching(hwnd);
default:
break;
}
return CShareBase::_OnCommand(hwnd, wNotifyCode, wID, hwndCtl);
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_OnHelp, private
//
// Synopsis: WM_HELP handler
//
//--------------------------------------------------------------------------
static const DWORD aHelpIds[] =
{
IDOK, HC_OK,
IDCANCEL, HC_CANCEL,
IDC_SHARE_SHARENAME, HC_SHARE_SHARENAME,
IDC_SHARE_SHARENAME_TEXT, HC_SHARE_SHARENAME,
IDC_SHARE_COMMENT, HC_SHARE_COMMENT,
IDC_SHARE_COMMENT_TEXT, HC_SHARE_COMMENT,
IDC_SHARE_MAXIMUM, HC_SHARE_MAXIMUM,
IDC_SHARE_ALLOW, HC_SHARE_ALLOW,
IDC_SHARE_ALLOW_VALUE, HC_SHARE_ALLOW_VALUE,
IDC_SHARE_ALLOW_SPIN, -1L, // 257807 by request of JillZ
IDC_SHARE_PERMISSIONS, HC_SHARE_PERMISSIONS,
IDC_SHARE_LIMIT, HC_SHARE_LIMIT,
IDC_SHARE_NOTSHARED, HC_SHARE_NOTSHARED,
IDC_SHARE_SHAREDAS, HC_SHARE_SHAREDAS,
IDC_SHARE_SHARENAME_COMBO, HC_SHARE_SHARENAME_COMBO,
IDC_SHARE_REMOVE, HC_SHARE_REMOVE,
IDC_SHARE_NEWSHARE, HC_SHARE_NEWSHARE,
IDC_SHARE_ICON, -1L, // 311328 JillZ
IDC_SHARE_TOPTEXT, -1L, // 311328 JillZ
0,0
};
static const DWORD aCSCUIHelpIds[] =
{
IDC_SHARE_CACHING, IDH_SHARE_CACHING_BTN,
IDC_SHARE_CACHING_TEXT, IDH_SHARE_CACHING_BTN,
0,0
};
BOOL
CSharingPropertyPage::_OnHelp(
IN HWND hwnd,
IN LPHELPINFO lphi
)
{
if (lphi->iContextType == HELPINFO_WINDOW) // a control
{
WCHAR szHelp[50];
if ( IDC_SHARE_CACHING == lphi->iCtrlId || IDC_SHARE_CACHING_TEXT == lphi->iCtrlId )
{
LoadString(g_hInstance, IDS_CSCUI_HELPFILENAME, szHelp, ARRAYLEN(szHelp));
WinHelp(
(HWND)lphi->hItemHandle,
szHelp,
HELP_WM_HELP,
(DWORD_PTR)aCSCUIHelpIds);
}
else
{
LoadString(g_hInstance, IDS_HELPFILENAME, szHelp, ARRAYLEN(szHelp));
WinHelp(
(HWND)lphi->hItemHandle,
szHelp,
HELP_WM_HELP,
(DWORD_PTR)aHelpIds);
}
}
return TRUE;
}
#define _AfxGetDlgCtrlID(hWnd) ((UINT)(WORD)::GetDlgCtrlID(hWnd))
HWND MyChildWindowFromPoint(HWND hWnd, POINT pt)
{
appAssert(hWnd != NULL);
// check child windows
::ClientToScreen(hWnd, &pt);
HWND hWndChild = ::GetWindow(hWnd, GW_CHILD);
for (; hWndChild != NULL; hWndChild = ::GetWindow(hWndChild, GW_HWNDNEXT))
{
if (_AfxGetDlgCtrlID(hWndChild) != (WORD)-1 &&
(::GetWindowLong(hWndChild, GWL_STYLE) & WS_VISIBLE))
{
// see if point hits the child window
RECT rect;
::GetWindowRect(hWndChild, &rect);
if (PtInRect(&rect, pt))
return hWndChild;
}
}
return NULL; // not found
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_OnContextMenu, private
//
// Synopsis: WM_CONTEXTMENU handler
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_OnContextMenu(
IN HWND hwnd,
IN HWND hCtrlWnd,
IN int xPos,
IN int yPos
)
{
WCHAR szHelp[50];
int ctrlID = 0;
if ( hwnd == hCtrlWnd )
{
POINT point;
point.x = xPos;
point.y = yPos;
if ( ScreenToClient (hwnd, &point) )
{
hCtrlWnd = MyChildWindowFromPoint (hwnd, point); // takes client coords
if ( !hCtrlWnd )
hCtrlWnd = hwnd;
}
}
ctrlID = GetDlgCtrlID (hCtrlWnd);
if ( IDC_SHARE_CACHING == ctrlID || IDC_SHARE_CACHING_TEXT == ctrlID )
{
LoadString(g_hInstance, IDS_CSCUI_HELPFILENAME, szHelp, ARRAYLEN(szHelp));
WinHelp(
hCtrlWnd,
szHelp,
HELP_CONTEXTMENU,
(DWORD_PTR)aCSCUIHelpIds);
}
else
{
LoadString(g_hInstance, IDS_HELPFILENAME, szHelp, ARRAYLEN(szHelp));
WinHelp(
hCtrlWnd,
szHelp,
HELP_CONTEXTMENU,
(DWORD_PTR)aHelpIds);
}
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_OnPermissions, private
//
// Synopsis: WM_COMMAND handler: the permissions button
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_OnPermissions(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
appAssert(NULL != _pCurInfo);
if (NULL == _pCurInfo) // JonN 5/2/01 384155
return TRUE;
if (STYPE_SPECIAL & _pCurInfo->GetType())
{
MyErrorDialog(hwnd, IERR_AdminShare);
return TRUE;
}
WCHAR szShareName[NNLEN + 1];
if (_cShares > 0)
{
wcscpy(szShareName, _pCurInfo->GetNetname());
}
else
{
GetDlgItemText(hwnd, IDC_SHARE_SHARENAME, szShareName, ARRAYLEN(szShareName));
// don't trim spaces, this might be an existing share with spaces in its name
}
PSECURITY_DESCRIPTOR pNewSecDesc = NULL;
PSECURITY_DESCRIPTOR pSecDesc = _pCurInfo->GetSecurityDescriptor();
appAssert(NULL == pSecDesc || IsValidSecurityDescriptor(pSecDesc));
BOOL bSecDescChanged;
LONG err = EditShareAcl(
hwnd,
NULL,
szShareName,
pSecDesc,
&bSecDescChanged,
&pNewSecDesc);
if (bSecDescChanged)
{
appAssert(IsValidSecurityDescriptor(pNewSecDesc));
_pCurInfo->TransferSecurityDescriptor(pNewSecDesc);
_MarkPageDirty();
}
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_OnRemove, private
//
// Synopsis: WM_COMMAND handler: the Remove button
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_OnRemove(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
appAssert(_cShares > 1);
appAssert(_pCurInfo != NULL);
if (NULL == _pCurInfo) // JonN 5/2/01 384155
return TRUE;
//
// Alter the data structures
//
if (_pCurInfo->GetFlag() == SHARE_FLAG_ADDED)
{
// Something that was added this session is being removed: get rid of
// it from our list.
_pCurInfo->Unlink();
delete _pCurInfo;
_pCurInfo = NULL;
// the _SetControlsFromData call resets the _pCurInfo pointer
}
else
{
// if the state was MODIFY or no state, then set it to REMOVE
_pCurInfo->SetDirtyFlag(SHARE_FLAG_REMOVE);
}
--_cShares;
//
// Next, regenerate the UI
//
_SetControlsFromData(hwnd, NULL);
_MarkPageDirty();
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_OnNewShare, private
//
// Synopsis: WM_COMMAND handler: the New Share button
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_OnNewShare(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
//
// First, create an object to put the new share into.
// FEATURE: for out of memory errors, should we pop up an error box?
//
HRESULT hr;
CShareInfo* pNewInfo = new CShareInfo();
if (NULL == pNewInfo)
{
return FALSE;
}
hr = pNewInfo->InitInstance();
CHECK_HRESULT(hr);
if (FAILED(hr))
{
delete pNewInfo;
return FALSE;
}
hr = pNewInfo->SetPath(_pszPath);
CHECK_HRESULT(hr);
if (FAILED(hr))
{
delete pNewInfo;
return FALSE;
}
NET_API_STATUS ret = pNewInfo->ReadCacheFlags ();
if ( NERR_Success != ret )
{
delete pNewInfo;
return HRESULT_FROM_WIN32 (ret);
}
pNewInfo->SetDirtyFlag(SHARE_FLAG_ADDED);
CDlgNewShare dlg(hwnd);
dlg.m_pInfoList = _pInfoList;
dlg.m_pReplaceList = _pReplaceList;
dlg.m_pShareInfo = pNewInfo;
if (dlg.DoModal())
{
_ReadControls(hwnd); // read current stuff
//
// Add the new one to the list
//
pNewInfo->InsertBefore(_pInfoList); // add to end of list
++_cShares; // one more share in the list...
//
// Next, regenerate the UI
//
_SetControlsFromData(hwnd, pNewInfo->GetNetname());
_MarkPageDirty();
}
else
{
// user hit "cancel"
delete pNewInfo;
}
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_OnCaching, private
//
// Synopsis: WM_COMMAND handler: the Caching button
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_OnCaching(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
// show wait cursor ??
HINSTANCE hInstance = ::LoadLibrary (L"FileMgmt.dll");
if ( hInstance )
{
typedef HRESULT (*PfnCacheSettingsDlg)(HWND hwndParent, DWORD & dwFlags);
PfnCacheSettingsDlg pfn = (PfnCacheSettingsDlg) ::GetProcAddress (
hInstance, "CacheSettingsDlg");
appAssert( NULL != _pCurInfo );
if ( pfn && NULL != _pCurInfo) // JonN 5/2/01 384155
{
DWORD dwFlags = _pCurInfo->GetCacheFlags ();
HRESULT hResult = pfn (hwnd, dwFlags);
if ( S_OK == hResult )
{
_pCurInfo->SetCacheFlags (dwFlags);
_MarkPageDirty();
}
}
::FreeLibrary (hInstance);
return FALSE;
}
else
return FALSE;
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_InitializeControls, private
//
// Synopsis: Initialize the controls from scratch
//
//--------------------------------------------------------------------------
VOID
CSharingPropertyPage::_InitializeControls(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
//
// Set defaults first
//
_SetControlsToDefaults(hwnd);
_fInitializingPage++; // JonN 7/11/00 140878
CheckRadioButton(
hwnd,
IDC_SHARE_NOTSHARED,
IDC_SHARE_SHAREDAS,
(_cShares > 0) ? IDC_SHARE_SHAREDAS : IDC_SHARE_NOTSHARED);
_fInitializingPage--; // JonN 7/11/00 140878
_SetControlsFromData(hwnd, NULL);
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_SetControlsToDefaults, private
//
// Synopsis: Set all the controls on the page to their default values
//
//--------------------------------------------------------------------------
VOID
CSharingPropertyPage::_SetControlsToDefaults(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
_fInitializingPage++; // JonN 7/11/00 140878
// Make "Maximum" the default number of users, and clear the value field
// (which the spin button set on creation?).
CheckRadioButton(
hwnd,
IDC_SHARE_MAXIMUM,
IDC_SHARE_ALLOW,
IDC_SHARE_MAXIMUM);
SetDlgItemText(hwnd, IDC_SHARE_ALLOW_VALUE, L"");
// set the spin control range: 1 <--> large number
SendDlgItemMessage(
hwnd,
IDC_SHARE_ALLOW_SPIN,
UDM_SETRANGE,
0,
MAKELONG(g_uiMaxUsers, 1));
_HideControls(hwnd, 0);
HWND hwndCombo = GetDlgItem(hwnd, IDC_SHARE_SHARENAME_COMBO);
ComboBox_ResetContent(hwndCombo);
SetDlgItemText(hwnd, IDC_SHARE_SHARENAME, L"");
SetDlgItemText(hwnd, IDC_SHARE_COMMENT, L"");
SetDlgItemText(hwnd, IDC_SHARE_ALLOW_VALUE, L"");
_fInitializingPage--; // JonN 7/11/00 140878
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::SetControlsFromData, private
//
// Synopsis: From the class variables and current state of the radio
// buttons, set the enabled/disabled state of the buttons, as
// well as filling the controls with the appropriate values.
//
//--------------------------------------------------------------------------
VOID
CSharingPropertyPage::_SetControlsFromData(
IN HWND hwnd,
IN PWSTR pszPreferredSelection
)
{
CHECK_SIG(CSharingPropertyPage);
BOOL bIsShared = (1 == IsDlgButtonChecked(hwnd, IDC_SHARE_SHAREDAS));
_EnableControls(hwnd, bIsShared);
if (bIsShared)
{
appDebugOut((DEB_ITRACE, "_SetControlsFromData: path is shared\n"));
_HideControls(hwnd, _cShares);
//
// Now, set controls based on actual data
//
_fInitializingPage++; // JonN 7/11/00 140878
// if there is a new share, we only show the edit control for the
// share name, not the combo box.
if (_cShares == 0)
{
_pCurInfo = (CShareInfo*)_pInfoList->Next();
appAssert(NULL != _pCurInfo);
if (NULL != _pCurInfo) // JonN 5/2/01 384155
SetDlgItemText(hwnd, IDC_SHARE_SHARENAME, _pCurInfo->GetNetname());
}
else // (_cShares > 0)
{
// in the combo box, the "item data" is the CShareInfo pointer of
// the item.
// fill the combo.
HWND hwndCombo = GetDlgItem(hwnd, IDC_SHARE_SHARENAME_COMBO);
ComboBox_ResetContent(hwndCombo);
for (CShareInfo* p = (CShareInfo*) _pInfoList->Next();
p != _pInfoList;
p = (CShareInfo*) p->Next())
{
if (p->GetFlag() != SHARE_FLAG_REMOVE)
{
int item = ComboBox_AddString(hwndCombo, p->GetNetname());
if (CB_ERR == item || CB_ERRSPACE == item)
{
// FEATURE: how to recover here?
break;
}
if (CB_ERR == ComboBox_SetItemData(hwndCombo, item, p))
{
// FEATURE: how to recover here?
}
}
}
int sel = 0;
if (NULL != pszPreferredSelection)
{
sel = ComboBox_FindStringExact(hwndCombo, -1, pszPreferredSelection);
if (CB_ERR == sel)
{
sel = 0;
}
}
ComboBox_SetCurSel(hwndCombo, sel);
_pCurInfo = (CShareInfo*)ComboBox_GetItemData(hwndCombo, sel);
appAssert(NULL != _pCurInfo);
}
_fInitializingPage--; // JonN 7/11/00 140878
// From the current item, set the rest of the fields
_SetFieldsFromCurrent(hwnd);
// This must be called after the share name field is initialized.
EnableWindow(GetDlgItem(hwnd, IDC_SHARE_CACHING), IsCachingSupported ());
}
else
{
appDebugOut((DEB_ITRACE, "_SetControlsFromData: path is not shared\n"));
_pCurInfo = NULL;
}
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_EnableControls, private
//
// Synopsis: Enable/disable controls
//
//--------------------------------------------------------------------------
VOID
CSharingPropertyPage::_EnableControls(
IN HWND hwnd,
IN BOOL bEnable
)
{
CHECK_SIG(CSharingPropertyPage);
int idControls[] =
{
IDC_SHARE_SHARENAME_TEXT,
IDC_SHARE_SHARENAME,
IDC_SHARE_SHARENAME_COMBO,
IDC_SHARE_COMMENT_TEXT,
IDC_SHARE_COMMENT,
IDC_SHARE_LIMIT,
IDC_SHARE_MAXIMUM,
IDC_SHARE_ALLOW,
IDC_SHARE_ALLOW_SPIN,
IDC_SHARE_ALLOW_VALUE,
IDC_SHARE_REMOVE,
IDC_SHARE_NEWSHARE,
IDC_SHARE_PERMISSIONS
};
for (int i = 0; i < ARRAYLEN(idControls); i++)
{
EnableWindow(GetDlgItem(hwnd, idControls[i]), bEnable);
}
EnableWindow(GetDlgItem(hwnd, IDC_SHARE_CACHING),
bEnable && IsCachingSupported ());
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_HideControls, private
//
// Synopsis: Hide or show the controls based on the current number
// of shares.
//
//--------------------------------------------------------------------------
VOID
CSharingPropertyPage::_HideControls(
IN HWND hwnd,
IN int cShares
)
{
CHECK_SIG(CSharingPropertyPage);
_MyShow( hwnd, IDC_SHARE_REMOVE, !!(cShares > 1) );
_MyShow( hwnd, IDC_SHARE_NEWSHARE, !!(cShares >= 1) );
_MyShow( hwnd, IDC_SHARE_SHARENAME, !!(cShares < 1) );
_MyShow( hwnd, IDC_SHARE_SHARENAME_COMBO, !!(cShares >= 1) );
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_SetFieldsFromCurrent, private
//
// Synopsis: From the currently selected share, set the property page
// controls.
//
//--------------------------------------------------------------------------
VOID
CSharingPropertyPage::_SetFieldsFromCurrent(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
appAssert(NULL != _pCurInfo);
_fInitializingPage++; // JonN 7/11/00 140878
SetDlgItemText(hwnd, IDC_SHARE_COMMENT,
(NULL == _pCurInfo) ? L'\0' : _pCurInfo->GetRemark());
DWORD dwLimit = (NULL == _pCurInfo) // JonN 5/2/01 384155
? SHI_USES_UNLIMITED : _pCurInfo->GetMaxUses();
if (dwLimit == SHI_USES_UNLIMITED)
{
_wMaxUsers = DEFAULT_MAX_USERS;
appDebugOut((DEB_ITRACE, "_SetFieldsFromCurrent: unlimited users\n"));
CheckRadioButton(
hwnd,
IDC_SHARE_MAXIMUM,
IDC_SHARE_ALLOW,
IDC_SHARE_MAXIMUM);
SetDlgItemText(hwnd, IDC_SHARE_ALLOW_VALUE, L"");
}
else
{
_wMaxUsers = (WORD)dwLimit;
appDebugOut((DEB_ITRACE,
"_SetFieldsFromCurrent: max users = %d\n",
_wMaxUsers));
CheckRadioButton(
hwnd,
IDC_SHARE_MAXIMUM,
IDC_SHARE_ALLOW,
IDC_SHARE_ALLOW);
// let the spin control set the edit control
SendDlgItemMessage(hwnd, IDC_SHARE_ALLOW_SPIN, UDM_SETPOS, 0, MAKELONG(_wMaxUsers, 0));
SendDlgItemMessage(hwnd, IDC_SHARE_ALLOW_VALUE, EM_SETSEL, 0, (LPARAM)-1);
}
_fInitializingPage--; // JonN 7/11/00 140878
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_ReadControls, private
//
// Synopsis: Load the data in the controls into internal data structures.
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_ReadControls(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
if (!_bItemDirty)
{
// nothing to read
appDebugOut((DEB_ITRACE, "_ReadControls: item not dirty\n"));
return TRUE;
}
appDebugOut((DEB_ITRACE, "_ReadControls: item dirty\n"));
appAssert(NULL != _pCurInfo);
if (NULL == _pCurInfo) // JonN 5/2/01 384155
return TRUE;
if (_bShareNameChanged)
{
appDebugOut((DEB_ITRACE, "_ReadControls: share name changed\n"));
WCHAR szShareName[NNLEN + 1];
GetDlgItemText(hwnd, IDC_SHARE_SHARENAME, szShareName, ARRAYLEN(szShareName));
TrimLeadingAndTrailingSpaces(szShareName);
_pCurInfo->SetNetname(szShareName);
_bShareNameChanged = FALSE;
}
if (_bCommentChanged)
{
appDebugOut((DEB_ITRACE, "_ReadControls: comment changed\n"));
WCHAR szComment[MAXCOMMENTSZ + 1];
GetDlgItemText(hwnd, IDC_SHARE_COMMENT, szComment, ARRAYLEN(szComment));
_pCurInfo->SetRemark(szComment);
_bCommentChanged = FALSE;
}
if (_bUserLimitChanged)
{
appDebugOut((DEB_ITRACE, "_ReadControls: user limit changed\n"));
if (1 == IsDlgButtonChecked(hwnd, IDC_SHARE_MAXIMUM))
{
_pCurInfo->SetMaxUses(SHI_USES_UNLIMITED);
}
else if (1 == IsDlgButtonChecked(hwnd, IDC_SHARE_ALLOW))
{
_CacheMaxUses(hwnd);
_pCurInfo->SetMaxUses(_wMaxUsers);
}
_bUserLimitChanged = FALSE;
}
_bItemDirty = FALSE;
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_MarkItemDirty, private
//
// Synopsis: A change has made such that the current item (and page)
// is now dirty
//
//--------------------------------------------------------------------------
VOID
CSharingPropertyPage::_MarkItemDirty(
VOID
)
{
CHECK_SIG(CSharingPropertyPage);
if (!_fInitializingPage)
{
if (!_bItemDirty)
{
appDebugOut((DEB_ITRACE, "Marking Sharing page---current item---dirty\n"));
_bItemDirty = TRUE;
}
_MarkPageDirty();
}
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_ValidatePage, private
//
// Synopsis: Return TRUE if the current page is valid
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_ValidatePage(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
_ReadControls(hwnd); // read current stuff
if (1 == IsDlgButtonChecked(hwnd, IDC_SHARE_SHAREDAS))
{
// If the user is creating a share on the property sheet (as
// opposed to using the "new share" dialog), we must validate the
// share.... Note that _bNewShare is still TRUE if the the user has
// clicked on "Not Shared", so we must check that too.
// Validate the share
if (!_ValidateNewShareName())
{
SetErrorFocus(hwnd, IDC_SHARE_SHARENAME);
return FALSE;
}
}
#if DBG == 1
Dump(L"_ValidatePage finished");
#endif // DBG == 1
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_DoApply, public
//
// Synopsis: If anything has changed, apply the data
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_DoApply(
IN HWND hwnd,
IN BOOL bClose
)
{
CHECK_SIG(CSharingPropertyPage);
if (_bDirty)
{
BOOL bNotShared = (1 == IsDlgButtonChecked(hwnd, IDC_SHARE_NOTSHARED));
if (!bNotShared)
{
_ReadControls(hwnd);
}
_CommitShares(bNotShared);
CShareBase::_DoApply(hwnd, bClose);
if (!bClose)
{
_InitializeControls(hwnd);
}
}
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_DoCancel, public
//
// Synopsis: Do whatever is necessary to cancel the changes
//
//--------------------------------------------------------------------------
BOOL
CSharingPropertyPage::_DoCancel(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
if (_bDirty)
{
_bItemDirty = FALSE;
_bShareNameChanged = FALSE;
_bCommentChanged = FALSE;
_bUserLimitChanged = FALSE;
}
return CShareBase::_DoCancel(hwnd);
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::_CacheMaxUses, private
//
// Synopsis:
//
//--------------------------------------------------------------------------
VOID
CSharingPropertyPage::_CacheMaxUses(
IN HWND hwnd
)
{
CHECK_SIG(CSharingPropertyPage);
DWORD dwRet = (DWORD)SendDlgItemMessage(hwnd, IDC_SHARE_ALLOW_SPIN, UDM_GETPOS, 0, 0);
if (HIWORD(dwRet) != 0)
{
_wMaxUsers = DEFAULT_MAX_USERS;
// Reset the edit control to the new value
SendDlgItemMessage(hwnd, IDC_SHARE_ALLOW_SPIN, UDM_SETPOS, 0, MAKELONG(_wMaxUsers, 0));
SendDlgItemMessage(hwnd, IDC_SHARE_ALLOW_VALUE, EM_SETSEL, 0, (LPARAM)-1);
}
else
{
_wMaxUsers = LOWORD(dwRet);
}
}
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::IsCachingSupported
//
// Synopsis: Does the operating system support caching on this share?
// This method initializes _bIsCachingSupported, if it is not already true
//
//--------------------------------------------------------------------------
bool CSharingPropertyPage::IsCachingSupported()
{
if (!_bIsCachingSupported)
{
LPWSTR pszShareName = 0;
WCHAR szShareName[NNLEN + 1];
UINT nRet = GetDlgItemText (_hwndPage, IDC_SHARE_SHARENAME, szShareName,
ARRAYLEN(szShareName));
if ( nRet > 0 )
pszShareName = szShareName;
else if ( _pCurInfo )
pszShareName = _pCurInfo->GetNetname ();
if ( pszShareName )
{
SHARE_INFO_501* pshi501 = NULL;
//
// On pre-NT5 systems (per IsaacHe), NetShareGetInfo will return
// ERROR_INVALID_LEVEL for info level 501 regardless of the share
// name provided. This is because the net code validates the
// requested level *before* validating the share name.
// Therefore, passing a blank share name works for our purposes
// here. If NetShareGetInfo returns ERROR_INVALID_LEVEL, this
// means level 501 is not supported which means the system
// isn't NT5 which means caching is not supported. No need to
// query the contents of *pshi501 because we're not interested in
// the level of caching at this point. [brianau - 8/11/98]
//
NET_API_STATUS retval = ::NetShareGetInfo(
L"", // machine name
L"", // share name
501,
(LPBYTE*)&pshi501);
if (ERROR_INVALID_LEVEL != retval)
{
_bIsCachingSupported = true;
}
if ( pshi501 )
{
::NetApiBufferFree (pshi501);
}
}
}
return _bIsCachingSupported;
}
#if DBG == 1
//+-------------------------------------------------------------------------
//
// Method: CSharingPropertyPage::Dump, private
//
// Synopsis:
//
//--------------------------------------------------------------------------
VOID
CSharingPropertyPage::Dump(
IN PWSTR pszCaption
)
{
CHECK_SIG(CSharingPropertyPage);
appDebugOut((DEB_TRACE,
"CSharingPropertyPage::Dump, %ws\n",
pszCaption));
appDebugOut((DEB_TRACE | DEB_NOCOMPNAME,
"\t This: 0x%08lx\n"
"\t Path: %ws\n"
"\t Page: 0x%08lx\n"
"\t Initializing?: %ws\n"
"\t Dirty?: %ws\n"
"\t Item dirty?: %ws\n"
"\t Share changed?: %ws\n"
"\tComment changed?: %ws\n"
"\tUsr Lim changed?: %ws\n"
"\t Max uses: %d\n"
"\t _pInfoList: 0x%08lx\n"
"\t _pCurInfo: 0x%08lx\n"
"\t Shares: %d\n"
,
this,
_pszPath,
_hwndPage,
_fInitializingPage ? L"yes" : L"no",
_bDirty ? L"yes" : L"no",
_bItemDirty ? L"yes" : L"no",
_bShareNameChanged ? L"yes" : L"no",
_bCommentChanged ? L"yes" : L"no",
_bUserLimitChanged ? L"yes" : L"no",
_wMaxUsers,
_pInfoList,
_pCurInfo,
_cShares
));
CShareInfo* p;
for (p = (CShareInfo*) _pInfoList->Next();
p != _pInfoList;
p = (CShareInfo*) p->Next())
{
p->Dump(L"Prop page list");
}
for (p = (CShareInfo*) _pReplaceList->Next();
p != _pReplaceList;
p = (CShareInfo*) p->Next())
{
p->Dump(L"Replace list");
}
}
#endif // DBG == 1
Reference in a new issue Copy permalink