1427 lines
45 KiB
C++
1427 lines
45 KiB
C++
// FormAdv.cpp : implementation file
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "pwsform.h"
|
|
#include <inetcom.h>
|
|
#include "mbobjs.h"
|
|
|
|
#include "Title.h"
|
|
#include "Sink.h"
|
|
#include "pwsdoc.h"
|
|
#include "EdDir.h"
|
|
#include "FormAdv.h"
|
|
#include "resource.h"
|
|
|
|
#include <iwamreg.h>
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
// the key type string for the virtual directories
|
|
#define MDSZ_W3_VDIR_TYPE _T("IIsWebVirtualDir")
|
|
|
|
#define WIDE_MAX_PATH ( MAX_PATH * sizeof(WCHAR) )
|
|
|
|
// tree view icons
|
|
enum {
|
|
IMAGE_GOOD_FOLDER = 0,
|
|
IMAGE_SERVER,
|
|
IAMGE_BAD_FOLDER
|
|
};
|
|
|
|
#define WM_UPDATE_VITRUAL_TREE WM_USER
|
|
|
|
|
|
CFormAdvanced* g_FormAdv = NULL;
|
|
extern CPwsDoc* g_p_Doc;
|
|
extern CPWSForm* g_pCurrentForm;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CFormAdvanced
|
|
|
|
IMPLEMENT_DYNCREATE(CFormAdvanced, CFormView)
|
|
|
|
//------------------------------------------------------------------------
|
|
CFormAdvanced::CFormAdvanced()
|
|
: CPWSForm(CFormAdvanced::IDD),
|
|
m_hRoot( NULL ),
|
|
m_DirHelpID( 0 )
|
|
{
|
|
//{{AFX_DATA_INIT(CFormAdvanced)
|
|
m_sz_default_doc = _T("");
|
|
m_bool_allow_browsing = FALSE;
|
|
m_bool_enable_default = FALSE;
|
|
m_bool_save_log = FALSE;
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
CFormAdvanced::~CFormAdvanced()
|
|
{
|
|
g_FormAdv = NULL;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CFormView::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CFormAdvanced)
|
|
DDX_Control(pDX, IDC_REMOVE, m_cbtn_remove);
|
|
DDX_Control(pDX, IDC_TITLE_BAR, m_ctitle_title);
|
|
DDX_Control(pDX, IDC_TREE, m_ctreectrl_tree);
|
|
DDX_Control(pDX, IDC_DEFAULT_TITLE, m_csz_default_doc_title);
|
|
DDX_Control(pDX, IDC_DEFAULT_DOC, m_csz_default_doc);
|
|
DDX_Text(pDX, IDC_DEFAULT_DOC, m_sz_default_doc);
|
|
DDX_Check(pDX, IDC_DIR_BROWSE, m_bool_allow_browsing);
|
|
DDX_Check(pDX, IDC_ENABLE_DEFAULT, m_bool_enable_default);
|
|
DDX_Check(pDX, IDC_SAVE_LOG, m_bool_save_log);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
BEGIN_MESSAGE_MAP(CFormAdvanced, CFormView)
|
|
ON_WM_CONTEXTMENU()
|
|
//{{AFX_MSG_MAP(CFormAdvanced)
|
|
ON_EN_KILLFOCUS(IDC_DEFAULT_DOC, OnKillfocusDefaultDoc)
|
|
ON_BN_CLICKED(IDC_ENABLE_DEFAULT, OnEnableDefault)
|
|
ON_BN_CLICKED(IDC_DIR_BROWSE, OnDirBrowse)
|
|
ON_BN_CLICKED(IDC_EDIT, OnEdit)
|
|
ON_NOTIFY(NM_DBLCLK, IDC_TREE, OnDblclkTree)
|
|
ON_BN_CLICKED(IDC_SAVE_LOG, OnSaveLog)
|
|
ON_BN_CLICKED(IDC_ADD, OnAdd)
|
|
ON_BN_CLICKED(IDC_REMOVE, OnRemove)
|
|
ON_COMMAND(ID_ADD_VIRT, OnAddVirt)
|
|
ON_UPDATE_COMMAND_UI(ID_ADD_VIRT, OnUpdateAddVirt)
|
|
ON_COMMAND(ID_PROPERTIES_VIRT, OnPropertiesVirt)
|
|
ON_UPDATE_COMMAND_UI(ID_PROPERTIES_VIRT, OnUpdatePropertiesVirt)
|
|
ON_UPDATE_COMMAND_UI(ID_DELETE_VIRT, OnUpdateDeleteVirt)
|
|
ON_COMMAND(ID_DELETE_VIRT, OnDeleteVirt)
|
|
ON_UPDATE_COMMAND_UI(ID_BROWSE_VIRT, OnUpdateBrowseVirt)
|
|
ON_COMMAND(ID_BROWSE_VIRT, OnBrowseVirt)
|
|
ON_UPDATE_COMMAND_UI(ID_EXPLORE_VIRT, OnUpdateExploreVirt)
|
|
ON_COMMAND(ID_EXPLORE_VIRT, OnExploreVirt)
|
|
ON_UPDATE_COMMAND_UI(ID_OPEN_VIRT, OnUpdateOpenVirt)
|
|
ON_COMMAND(ID_OPEN_VIRT, OnOpenVirt)
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateEditCut)
|
|
ON_COMMAND(ID_EDIT_CUT, OnEditCut)
|
|
ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
|
|
ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
|
|
ON_NOTIFY(TVN_SELCHANGED, IDC_TREE, OnSelchangedTree)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CFormAdvanced diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CFormAdvanced::AssertValid() const
|
|
{
|
|
CFormView::AssertValid();
|
|
}
|
|
|
|
void CFormAdvanced::Dump(CDumpContext& dc) const
|
|
{
|
|
CFormView::Dump(dc);
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
// initialize the trees - done once
|
|
void CFormAdvanced::InitTree()
|
|
{
|
|
// prepare the list's image list
|
|
if ( m_imageList.Create( IDB_LIST_IMAGES, 17, 5, 0x00FF00FF ) )
|
|
// set the image list into the list control
|
|
m_ctreectrl_tree.SetImageList( &m_imageList, TVSIL_NORMAL );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// empty all the items out of the tree
|
|
void CFormAdvanced::EmptyTree()
|
|
{
|
|
m_ctreectrl_tree.DeleteAllItems();
|
|
m_hRoot = NULL;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// given an item in the tree, build its relative metabase path
|
|
void CFormAdvanced::BuildMetaPath( HTREEITEM hItem, CString &sz )
|
|
{
|
|
// clear the path to start with
|
|
sz.Empty();
|
|
// keep building as long as this is not the root node
|
|
while( hItem != m_hRoot )
|
|
{
|
|
// since we are working backwards, add the nodes to the front of the string
|
|
sz = m_ctreectrl_tree.GetItemText( hItem ) + sz;
|
|
|
|
// move up a level to the parent
|
|
hItem = m_ctreectrl_tree.GetParentItem( hItem );
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
BOOL CFormAdvanced::FIsVirtualDirectoryValid( CWrapMetaBase *pmb, CString szRelPath )
|
|
{
|
|
CString sz;
|
|
BOOL fAnswer = FALSE;
|
|
|
|
// we need to load the virtual directory path and see if it really exists
|
|
// and thus show the appropriate image
|
|
fAnswer = pmb->GetString(
|
|
szRelPath,
|
|
MD_VR_PATH,
|
|
IIS_MD_UT_FILE,
|
|
sz.GetBuffer(WIDE_MAX_PATH),
|
|
WIDE_MAX_PATH,
|
|
METADATA_INHERIT
|
|
);
|
|
|
|
sz.ReleaseBuffer();
|
|
|
|
if ( fAnswer )
|
|
{
|
|
fAnswer = FALSE;
|
|
DWORD dwAttrib = GetFileAttributes( sz );
|
|
// it can't be an error and the directory flag must be set
|
|
if ( (dwAttrib != 0xFFFFFFFF) &&
|
|
((dwAttrib & FILE_ATTRIBUTE_DIRECTORY) != 0) )
|
|
fAnswer = TRUE;
|
|
}
|
|
|
|
// return the answer
|
|
return fAnswer;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// set the appropriate tree image for a given item
|
|
void CFormAdvanced::SetTreeImage( CWrapMetaBase *pmb, CString szRelPath, HTREEITEM hItem )
|
|
{
|
|
BOOL f;
|
|
int iTreeImage;
|
|
|
|
// we need to load the virtual directory path and see if it really exists
|
|
// and thus show the appropriate image
|
|
if ( FIsVirtualDirectoryValid( pmb, szRelPath ) )
|
|
iTreeImage = IMAGE_GOOD_FOLDER;
|
|
else
|
|
iTreeImage = IAMGE_BAD_FOLDER;
|
|
|
|
// set the image
|
|
f = m_ctreectrl_tree.SetItemImage( hItem, iTreeImage, iTreeImage );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// write out item data
|
|
void CFormAdvanced::WriteItemData( CWrapMetaBase *pmb, CString szRelPath, CEditDirectory *pdlg )
|
|
{
|
|
DWORD dword;
|
|
BOOL f;
|
|
|
|
// set the path into place
|
|
f = pmb->SetString( szRelPath, MD_VR_PATH, IIS_MD_UT_FILE, (LPCTSTR)pdlg->m_sz_path );
|
|
|
|
// put the access flags into place. There are other flags than the ones that are manupulated
|
|
// here, so be careful to read the value first, then flip the flags, then write it back
|
|
dword = 0;
|
|
pmb->GetDword( szRelPath, MD_ACCESS_PERM, IIS_MD_UT_FILE, &dword, METADATA_INHERIT );
|
|
|
|
// read permissions
|
|
if ( pdlg->m_bool_read )
|
|
dword |= MD_ACCESS_READ; // set the flag
|
|
else
|
|
dword &= ~MD_ACCESS_READ; // clear the flag
|
|
|
|
// write permissions
|
|
if ( pdlg->m_bool_write )
|
|
dword |= MD_ACCESS_WRITE; // set the flag
|
|
else
|
|
dword &= ~MD_ACCESS_WRITE; // clear the flag
|
|
|
|
// read source permissions
|
|
if ( pdlg->m_bool_source )
|
|
dword |= MD_ACCESS_SOURCE; // set the flag
|
|
else
|
|
dword &= ~MD_ACCESS_SOURCE; // clear the flag
|
|
|
|
// since the app permissions are now a set of radio buttons, use a case to discern
|
|
switch ( pdlg->m_int_AppPerms )
|
|
{
|
|
case CEditDirectory::APPPERM_NONE:
|
|
dword &= ~MD_ACCESS_SCRIPT; // clear the flag
|
|
dword &= ~MD_ACCESS_EXECUTE; // clear the flag
|
|
break;
|
|
case CEditDirectory::APPPERM_SCRIPTS:
|
|
dword |= MD_ACCESS_SCRIPT; // set the flag
|
|
dword &= ~MD_ACCESS_EXECUTE; // clear the flag
|
|
break;
|
|
case CEditDirectory::APPPERM_EXECUTE:
|
|
dword |= MD_ACCESS_SCRIPT; // set the flag
|
|
dword |= MD_ACCESS_EXECUTE; // set the flag
|
|
break;
|
|
};
|
|
|
|
// write the dword back into the metabase
|
|
f = pmb->SetDword( szRelPath, MD_ACCESS_PERM, IIS_MD_UT_FILE, dword );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// edit the selected item in the tree (calls EditTreeItem)
|
|
void CFormAdvanced::EditSelectedItem()
|
|
{
|
|
CString szRelativePath;
|
|
CString szOrigAlias;
|
|
BOOL f;
|
|
DWORD err;
|
|
DWORD dword;
|
|
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
|
|
// start by building the relative path name from the root node
|
|
HTREEITEM hItemEdit = m_ctreectrl_tree.GetSelectedItem();
|
|
|
|
// build the path
|
|
BuildMetaPath( hItemEdit, szRelativePath );
|
|
|
|
// prepare the edit dialog
|
|
CEditDirectory dlg;
|
|
|
|
// if this is the home directory - let it know
|
|
if ( hItemEdit == m_hRoot )
|
|
{
|
|
dlg.m_fHome = TRUE;
|
|
dlg.m_sz_alias.LoadString( IDS_HOME_DIRECTORY );
|
|
}
|
|
else
|
|
{
|
|
dlg.m_fHome = FALSE;
|
|
szOrigAlias = m_ctreectrl_tree.GetItemText( hItemEdit );
|
|
// get rid of the preceding '/' character
|
|
szOrigAlias = szOrigAlias.Right( szOrigAlias.GetLength() - 1 );
|
|
dlg.m_sz_alias = szOrigAlias;
|
|
}
|
|
|
|
// tell the edit dialog where this alias goes
|
|
dlg.m_szMetaPath = szRelativePath;
|
|
|
|
// now load in the directory path from the metabase
|
|
// go for the root directory first
|
|
if ( mb.Open(SZ_MB_ROOT) )
|
|
{
|
|
CString sz;
|
|
f = mb.GetString(
|
|
szRelativePath,
|
|
MD_VR_PATH,
|
|
IIS_MD_UT_FILE,
|
|
sz.GetBuffer(WIDE_MAX_PATH),
|
|
WIDE_MAX_PATH,
|
|
METADATA_INHERIT
|
|
);
|
|
|
|
sz.ReleaseBuffer();
|
|
if ( f )
|
|
{
|
|
dlg.m_sz_path = sz;
|
|
}
|
|
|
|
// now prep the access permisions
|
|
if ( mb.GetDword( szRelativePath, MD_ACCESS_PERM, IIS_MD_UT_FILE, &dword, METADATA_INHERIT ) )
|
|
{
|
|
// break the flags out into the dialog items
|
|
dlg.m_bool_read = (dword & MD_ACCESS_READ) > 0;
|
|
dlg.m_bool_write = (dword & MD_ACCESS_WRITE) > 0;
|
|
dlg.m_bool_source = (dword & MD_ACCESS_SOURCE) > 0;
|
|
|
|
// application permissions are a set of radio buttons, so break it out that way
|
|
dlg.m_int_AppPerms = CEditDirectory::APPPERM_NONE;
|
|
if ( dword & MD_ACCESS_EXECUTE )
|
|
{
|
|
dlg.m_int_AppPerms = CEditDirectory::APPPERM_EXECUTE;
|
|
}
|
|
else if ( dword & MD_ACCESS_SCRIPT )
|
|
{
|
|
dlg.m_int_AppPerms = CEditDirectory::APPPERM_SCRIPTS;
|
|
}
|
|
}
|
|
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
|
|
// now edit the item
|
|
if ( dlg.DoModal() == IDOK )
|
|
{
|
|
// remove the WAM application - recoverable
|
|
CString szWAMLocation;
|
|
szWAMLocation = SZ_MB_ROOT;
|
|
szWAMLocation += szRelativePath;
|
|
BOOL fWAM = MakeWAMApplication( szWAMLocation, FALSE, TRUE, FALSE );
|
|
|
|
// write out the directory information
|
|
if ( mb.Open(SZ_MB_ROOT, METADATA_PERMISSION_READ|METADATA_PERMISSION_WRITE) )
|
|
{
|
|
// write out the data
|
|
WriteItemData( &mb, szRelativePath, &dlg );
|
|
|
|
// update the tree image
|
|
SetTreeImage( &mb, szRelativePath, hItemEdit );
|
|
|
|
// if this is not the root - AND the alias has changed, rename the object in the metabase
|
|
// DO THIS LAST!! becuase it actually changes the metabase path
|
|
if ( (hItemEdit != m_hRoot) && (dlg.m_sz_alias != szOrigAlias) )
|
|
{
|
|
CString szNew = szRelativePath;
|
|
|
|
// truncate off the last part of the name
|
|
szNew = szNew.Left( szNew.ReverseFind(_T('/')) + 1 );
|
|
// add on the new name
|
|
szNew += dlg.m_sz_alias;
|
|
|
|
// rename the key in the metabase
|
|
f = mb.RenameObject( szRelativePath, dlg.m_sz_alias );
|
|
|
|
if ( !f )
|
|
err = GetLastError();
|
|
|
|
// build the display name
|
|
CString szName = '/';
|
|
szName += dlg.m_sz_alias;
|
|
|
|
// rename the item in the tree view with the display name
|
|
m_ctreectrl_tree.SetItemText( hItemEdit, szName );
|
|
}
|
|
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
|
|
// recover the WAM application
|
|
if ( fWAM )
|
|
{
|
|
// build the path
|
|
BuildMetaPath( hItemEdit, szRelativePath );
|
|
// set the WAM app
|
|
szWAMLocation = SZ_MB_ROOT;
|
|
szWAMLocation += szRelativePath;
|
|
MakeWAMApplication( szWAMLocation, TRUE, TRUE, FALSE );
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Update info from the metabase
|
|
|
|
//------------------------------------------------------------------------
|
|
// recursively add all the items to the tree
|
|
void CFormAdvanced::RecurseAddVDItems( CWrapMetaBase* pmb, LPCTSTR szMB, HTREEITEM hParent )
|
|
{
|
|
CString szEnum;
|
|
CString szMBPath;
|
|
HTREEITEM hItem;
|
|
DWORD index = 0;
|
|
|
|
// enumerate the sub-directories of the open directory and add them
|
|
// to the tree. Recurse each to add its children as well
|
|
// enumerate the directories, adding each to the list
|
|
while ( pmb->EnumObjects(szMB, szEnum.GetBuffer(WIDE_MAX_PATH), WIDE_MAX_PATH, index) )
|
|
{
|
|
szEnum.ReleaseBuffer();
|
|
|
|
// build the display name for this item
|
|
szMBPath = _T('/');
|
|
szMBPath += szEnum;
|
|
|
|
// add the item to the tree
|
|
hItem = m_ctreectrl_tree.InsertItem( szMBPath, hParent, TVI_SORT );
|
|
|
|
// build the metabase path for this item
|
|
szMBPath = szMB;
|
|
szMBPath += _T('/');
|
|
szMBPath += szEnum;
|
|
|
|
// we need to load the virtual directory path and see if it really exists
|
|
// and thus show the appropriate image
|
|
SetTreeImage( pmb, szMBPath, hItem );
|
|
|
|
// recurse the item
|
|
RecurseAddVDItems( pmb, szMBPath, hItem );
|
|
|
|
// advance the index
|
|
index++;
|
|
}
|
|
szEnum.ReleaseBuffer();
|
|
|
|
// expand the parent
|
|
m_ctreectrl_tree.Expand( hParent, TVE_EXPAND );
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
// to rebuild the tree, first we add the homedirectory and open the metabase
|
|
// at that location. Then we recursively add all the subdirectories
|
|
void CFormAdvanced::UpdateVirtualTree()
|
|
{
|
|
BOOL f;
|
|
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
|
|
// go for the root directory first
|
|
if ( mb.Open(SZ_MB_ROOT) )
|
|
{
|
|
// prep the home directory name
|
|
CString szHome;
|
|
szHome.LoadString( IDS_HOME_DIRECTORY );
|
|
|
|
// insert the root item into the tree
|
|
m_hRoot = m_ctreectrl_tree.InsertItem( szHome );
|
|
f = m_ctreectrl_tree.SetItemImage( m_hRoot, IMAGE_SERVER, IMAGE_SERVER );
|
|
|
|
// do the recursive adding thing
|
|
RecurseAddVDItems( &mb, _T(""), m_hRoot );
|
|
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// update the default document info from the metabase
|
|
void CFormAdvanced::UpdateBrowseInfo()
|
|
{
|
|
DWORD dword;
|
|
PWCHAR pBuff;
|
|
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
|
|
// get ready
|
|
UpdateData( TRUE );
|
|
|
|
// go for the root directory first
|
|
if ( mb.Open(SZ_MB_ROOT) )
|
|
{
|
|
// first, the default directory string. Because this is a comma-list, it could get rather long.
|
|
// thus, instead of reading it into a static buffer, we should get it into a allocated one, read
|
|
// the string, and clean up
|
|
pBuff = (PWCHAR)mb.GetData(
|
|
_T(""),
|
|
MD_DEFAULT_LOAD_FILE,
|
|
IIS_MD_UT_FILE,
|
|
STRING_METADATA,
|
|
&dword
|
|
);
|
|
|
|
if ( !pBuff )
|
|
{
|
|
DWORD err = GetLastError( );
|
|
if ( err == RPC_E_SERVERCALL_RETRYLATER )
|
|
{
|
|
// we should try again later
|
|
PostMessage( WM_UPDATE_BROWSEINFO );
|
|
mb.Close();
|
|
return;
|
|
}
|
|
}
|
|
if ( pBuff )
|
|
{
|
|
m_sz_default_doc = pBuff;
|
|
// clean up
|
|
mb.FreeWrapData(pBuff);
|
|
}
|
|
else
|
|
{
|
|
m_sz_default_doc.Empty();
|
|
}
|
|
|
|
// now the dword representing the boolean flags
|
|
if ( mb.GetDword(
|
|
_T(""),
|
|
MD_DIRECTORY_BROWSING,
|
|
IIS_MD_UT_FILE,
|
|
&dword,
|
|
METADATA_INHERIT
|
|
))
|
|
{
|
|
m_bool_allow_browsing = (dword & MD_DIRBROW_ENABLED) > 0;
|
|
m_bool_enable_default = (dword & MD_DIRBROW_LOADDEFAULT) > 0;
|
|
}
|
|
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
|
|
// put the answers back
|
|
UpdateData( FALSE );
|
|
|
|
// enable the default doc items as appropriate
|
|
EnableItems();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// update the save log info from the metabase
|
|
void CFormAdvanced::UpdateSaveLog()
|
|
{
|
|
DWORD dword;
|
|
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
|
|
// get ready
|
|
UpdateData( TRUE );
|
|
|
|
// open for the root key
|
|
if ( mb.Open(MB_SERVER_KEY_UPDATE) )
|
|
{
|
|
// get the dword representing log type
|
|
if ( mb.GetDword( _T(""), MD_LOG_TYPE, IIS_MD_UT_SERVER, &dword, METADATA_INHERIT ) )
|
|
{
|
|
m_bool_save_log = (dword == INET_LOG_TO_FILE) || (dword == INET_LOG_TO_SQL);
|
|
}
|
|
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
|
|
// put the data into place
|
|
UpdateData( FALSE );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::EnableItems()
|
|
{
|
|
UpdateData(TRUE);
|
|
|
|
// enable the default document windows as necessary
|
|
m_csz_default_doc_title.EnableWindow( m_bool_enable_default );
|
|
m_csz_default_doc.EnableWindow( m_bool_enable_default );
|
|
|
|
// if the root is selected, disable the remove button
|
|
// get the handle of the selected item in the tree
|
|
HTREEITEM hItem = m_ctreectrl_tree.GetSelectedItem();
|
|
m_cbtn_remove.EnableWindow( (hItem != m_hRoot) );
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Write info to the metabase
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
// Write the default document & browsing info to the metabase
|
|
void CFormAdvanced::SaveBrowseInfo()
|
|
{
|
|
DWORD dword;
|
|
BOOL f;
|
|
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
|
|
// write out the correct data
|
|
UpdateData( TRUE );
|
|
|
|
// go for the root directory first
|
|
if ( mb.Open(SZ_MB_ROOT, METADATA_PERMISSION_READ | METADATA_PERMISSION_WRITE) )
|
|
{
|
|
// first, write out the boolean flags
|
|
// to prepare the browsing flag for saving - we must get the current value
|
|
if ( mb.GetDword( _T(""), MD_DIRECTORY_BROWSING, IIS_MD_UT_FILE, &dword ) )
|
|
{
|
|
// start by setting or clearing the browsing allowed flag
|
|
if ( m_bool_allow_browsing )
|
|
dword |= MD_DIRBROW_ENABLED; // set the flag
|
|
else
|
|
dword &= ~MD_DIRBROW_ENABLED; // clear the flag
|
|
|
|
// next, set or clear the enable default flag
|
|
if ( m_bool_enable_default )
|
|
dword |= MD_DIRBROW_LOADDEFAULT; // set the flag
|
|
else
|
|
dword &= ~MD_DIRBROW_LOADDEFAULT; // clear the flag
|
|
|
|
// save the browsing flag
|
|
f = mb.SetDword( _T(""), MD_DIRECTORY_BROWSING, IIS_MD_UT_FILE, dword );
|
|
}
|
|
|
|
// if the default file is enabled, then write it out too
|
|
if ( m_bool_enable_default )
|
|
f = mb.SetString( _T(""), MD_DEFAULT_LOAD_FILE, IIS_MD_UT_FILE, (LPCTSTR)m_sz_default_doc );
|
|
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// Write the save log info to the metabase
|
|
void CFormAdvanced::SaveSaveLog()
|
|
{
|
|
DWORD dword;
|
|
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
|
|
// get ready
|
|
UpdateData( TRUE );
|
|
|
|
// open for the root key
|
|
if ( mb.Open(MB_SERVER_KEY_UPDATE, METADATA_PERMISSION_WRITE) )
|
|
{
|
|
if ( m_bool_save_log )
|
|
dword = INET_LOG_TO_FILE;
|
|
else
|
|
dword = INET_LOG_DISABLED;
|
|
|
|
// write out the flag
|
|
mb.SetDword( _T(""), MD_LOG_TYPE, IIS_MD_UT_SERVER, dword );
|
|
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
|
|
// put the data into place
|
|
UpdateData( FALSE );
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CFormAdvanced message handlers
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnInitialUpdate()
|
|
{
|
|
CFormView::OnInitialUpdate();
|
|
|
|
// initialize the VD tree
|
|
InitTree();
|
|
|
|
// update the virtural directory tree
|
|
UpdateVirtualTree();
|
|
|
|
// update the directory browsing related information
|
|
UpdateBrowseInfo();
|
|
|
|
// update the logging information
|
|
UpdateSaveLog();
|
|
|
|
// let the sink object know we are here
|
|
g_FormAdv = this;
|
|
g_pCurrentForm = this;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::SinkNotify(
|
|
/* [in] */ DWORD dwMDNumElements,
|
|
/* [size_is][in] */ MD_CHANGE_OBJECT __RPC_FAR pcoChangeList[ ])
|
|
{
|
|
// do the appropriate action based on the type of change
|
|
if ( (pcoChangeList->dwMDChangeType & MD_CHANGE_TYPE_DELETE_OBJECT) ||
|
|
(pcoChangeList->dwMDChangeType & MD_CHANGE_TYPE_ADD_OBJECT) ||
|
|
(pcoChangeList->dwMDChangeType & MD_CHANGE_TYPE_RENAME_OBJECT) )
|
|
{
|
|
PostMessage( WM_UPDATE_TREEINFO );
|
|
}
|
|
else if ( pcoChangeList->dwMDChangeType & MD_CHANGE_TYPE_SET_DATA )
|
|
{
|
|
// we are only concerned with changes in the state of the server here
|
|
// thus, we can just look for the MD_SERVER_STATE id
|
|
for ( DWORD iElement = 0; iElement < dwMDNumElements; iElement++ )
|
|
{
|
|
// each change has a list of IDs...
|
|
for ( DWORD iID = 0; iID < pcoChangeList[iElement].dwMDNumDataIDs; iID++ )
|
|
{
|
|
// look for the ids that we are interested in
|
|
switch( pcoChangeList[iElement].pdwMDDataIDs[iID] )
|
|
{
|
|
case MD_DIRECTORY_BROWSING:
|
|
case MD_DEFAULT_LOAD_FILE:
|
|
PostMessage( WM_UPDATE_BROWSEINFO );
|
|
break;
|
|
|
|
case MD_LOG_TYPE:
|
|
PostMessage( WM_UPDATE_LOGINFO );
|
|
break;
|
|
default:
|
|
// do nothing
|
|
break;
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
LRESULT CFormAdvanced::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
// process the update message
|
|
switch( message )
|
|
{
|
|
case WM_UPDATE_BROWSEINFO:
|
|
UpdateBrowseInfo();
|
|
break;
|
|
case WM_UPDATE_LOGINFO:
|
|
break;
|
|
case WM_UPDATE_TREEINFO:
|
|
EmptyTree();
|
|
UpdateVirtualTree();
|
|
break;
|
|
};
|
|
|
|
// do the normal thing
|
|
return CFormView::WindowProc(message, wParam, lParam);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnKillfocusDefaultDoc()
|
|
{
|
|
// write out the change to the metabase
|
|
SaveBrowseInfo();
|
|
// also, make sure we are showing the latest info
|
|
UpdateBrowseInfo();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnEnableDefault()
|
|
{
|
|
// write out the change to the metabase
|
|
SaveBrowseInfo();
|
|
// also, make sure we are showing the latest info
|
|
UpdateBrowseInfo();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnDirBrowse()
|
|
{
|
|
// write out the change to the metabase
|
|
SaveBrowseInfo();
|
|
// also, make sure we are showing the latest info
|
|
UpdateBrowseInfo();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnSaveLog()
|
|
{
|
|
// write out the change to the metabase
|
|
SaveSaveLog();
|
|
// also, make sure we are showing the latest info
|
|
UpdateSaveLog();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnEdit()
|
|
{
|
|
// prep the help
|
|
m_DirHelpID = IDD_DIRECTORY;
|
|
EditSelectedItem();
|
|
m_DirHelpID = 0;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnDblclkTree(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
m_DirHelpID = IDD_DIRECTORY;
|
|
EditSelectedItem();
|
|
m_DirHelpID = 0;
|
|
*pResult = 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnAdd()
|
|
{
|
|
HTREEITEM hItem;
|
|
BOOL fSuccess = FALSE;
|
|
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
|
|
// get the parent of the item
|
|
HTREEITEM hParent = m_ctreectrl_tree.GetSelectedItem();
|
|
|
|
// build a path going to the parent - then add on one more /
|
|
CString szRelativePath;
|
|
BuildMetaPath( hParent, szRelativePath );
|
|
szRelativePath += _T('/');
|
|
|
|
// start by editing a set of default values
|
|
CEditDirectory dlg;
|
|
dlg.m_sz_alias.LoadString( IDS_DEF_ALIAS );
|
|
dlg.m_bool_read = TRUE;
|
|
dlg.m_bool_write = FALSE;
|
|
dlg.m_bool_source = FALSE;
|
|
dlg.m_int_AppPerms = CEditDirectory::APPPERM_SCRIPTS;
|
|
dlg.m_szMetaPath = szRelativePath;
|
|
dlg.m_fNewItem = TRUE;
|
|
|
|
// tell the dialog to use the add directory title
|
|
dlg.m_idsTitle = IDS_ADD_DIRECTORY;
|
|
|
|
// prep the help
|
|
m_DirHelpID = 0x0504;
|
|
|
|
// if the user edits and says OK, then make the item and add it in and all that
|
|
if ( dlg.DoModal() == IDOK )
|
|
{
|
|
// the WAM stuff can take a few seconds so...
|
|
CWaitCursor waitcursor;
|
|
|
|
// where to put this new item in the tree??
|
|
// if there is no selected item, default to the root
|
|
if ( !hParent )
|
|
hParent = m_hRoot;
|
|
|
|
// add on the new child to the relative path
|
|
szRelativePath += dlg.m_sz_alias;
|
|
|
|
// open the metabase
|
|
if ( mb.Open(SZ_MB_ROOT, METADATA_PERMISSION_READ|METADATA_PERMISSION_WRITE) )
|
|
{
|
|
// add the object to the metabase
|
|
if ( mb.AddObject( szRelativePath ) )
|
|
{
|
|
// so far, so good
|
|
fSuccess = TRUE;
|
|
|
|
// set the key type
|
|
mb.SetString( szRelativePath, MD_KEY_TYPE, IIS_MD_UT_SERVER, MDSZ_W3_VDIR_TYPE, 0 );
|
|
|
|
// write out the object's data
|
|
WriteItemData( &mb, szRelativePath, &dlg );
|
|
|
|
// build the display name
|
|
CString szName = _T('/');
|
|
szName += dlg.m_sz_alias;
|
|
|
|
// add the item to the tree
|
|
hItem = m_ctreectrl_tree.InsertItem( szName, hParent, TVI_SORT );
|
|
SetTreeImage( &mb, szRelativePath, hItem );
|
|
}
|
|
|
|
// close the metabase object
|
|
mb.Close();
|
|
|
|
// create the WAM application at the new virtual directory location
|
|
if ( fSuccess )
|
|
{
|
|
CString szWAMLocation;
|
|
szWAMLocation = SZ_MB_ROOT;
|
|
szWAMLocation += szRelativePath;
|
|
if ( !MakeWAMApplication( szWAMLocation, TRUE ) )
|
|
{
|
|
// it failed to create the WAM application, but we require it.
|
|
fSuccess = FALSE;
|
|
|
|
// remove the virtual directory
|
|
// open the metabase
|
|
if ( mb.Open(SZ_MB_ROOT, METADATA_PERMISSION_WRITE) )
|
|
{
|
|
// remove the object from the metabase
|
|
mb.DeleteObject( szRelativePath );
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// make sure the parent is expanded
|
|
m_ctreectrl_tree.Expand( hParent, TVE_EXPAND );
|
|
|
|
// if it failed, put up an alert to that affect
|
|
if ( !fSuccess )
|
|
AfxMessageBox( IDS_ERR_ADD_VIRT );
|
|
}
|
|
|
|
// unprep the help
|
|
m_DirHelpID = 0;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// This routine takes a path to a virutal directory in the metabase and creates
|
|
// a WAM application there. Most of the code is actually obtaining and maintaining
|
|
// the interface to the WAM ole object
|
|
// szPath The path to the metabase
|
|
// fCreate True if creating an application, FALSE if deleting an existing app
|
|
BOOL CFormAdvanced::MakeWAMApplication( IN CString &szPath, IN BOOL fCreate, IN BOOL fRecover, IN BOOL fRecurse )
|
|
{
|
|
IClassFactory* pcsfFactory = NULL;
|
|
IWamAdmin2* pWAM;
|
|
HRESULT hresError;
|
|
BOOL fAnswer = FALSE;
|
|
|
|
hresError = CoGetClassObject( CLSID_WamAdmin, CLSCTX_SERVER, NULL,
|
|
IID_IClassFactory, (void**) &pcsfFactory);
|
|
if (FAILED(hresError))
|
|
return FALSE;
|
|
|
|
// create the instance of the interface
|
|
hresError = pcsfFactory->CreateInstance(NULL, IID_IWamAdmin2, (void **)&pWAM);
|
|
if (FAILED(hresError))
|
|
return FALSE;
|
|
|
|
// release the factory
|
|
pcsfFactory->Release();
|
|
|
|
// this part will be nicer after it is converted to unicode
|
|
WCHAR* pwch;
|
|
// allocate the name buffer
|
|
pwch = new WCHAR[szPath.GetLength() + 2];
|
|
if ( !pwch )
|
|
{
|
|
pWAM->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
// unicodize the name into the buffer
|
|
if ( pwch )
|
|
{
|
|
|
|
#ifdef _UNICODE
|
|
lstrcpy(pwch, szPath);
|
|
#else
|
|
MultiByteToWideChar(
|
|
CP_ACP,
|
|
MB_PRECOMPOSED,
|
|
szPath,
|
|
-1,
|
|
pwch,
|
|
szPath.GetLength() + 1
|
|
);
|
|
|
|
#endif // _UNICODE
|
|
|
|
|
|
// create the in-proc application, if requested
|
|
if ( fCreate )
|
|
{
|
|
if ( fRecover )
|
|
hresError = pWAM->AppRecover( pwch, fRecurse );
|
|
else
|
|
hresError = pWAM->AppCreate2( pwch, eAppRunOutProcInDefaultPool );
|
|
}
|
|
else
|
|
{
|
|
// delete the application. Because the whole virtual dir is going away,
|
|
// delete any applications lower down in the tree as well
|
|
if ( fRecover )
|
|
hresError = pWAM->AppDeleteRecoverable( pwch, fRecurse );
|
|
else
|
|
hresError = pWAM->AppDelete( pwch, fRecurse );
|
|
}
|
|
|
|
// check the error code
|
|
fAnswer = SUCCEEDED( hresError );
|
|
|
|
// clean up
|
|
delete pwch;
|
|
}
|
|
|
|
// release the logging ui
|
|
pWAM->Release();
|
|
|
|
// return the answer
|
|
return fAnswer;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnRemove()
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
|
|
// get the handle of the selected item in the tree
|
|
HTREEITEM hItem = m_ctreectrl_tree.GetSelectedItem();
|
|
// make sure its not the root
|
|
if ( hItem == m_hRoot ) return;
|
|
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
|
|
// get the name of the item
|
|
CString sz;
|
|
CString szItem = m_ctreectrl_tree.GetItemText( hItem );
|
|
|
|
// munge the name into the confirm string
|
|
AfxFormatString1( sz, IDS_CONFIRM_REMOVE, szItem );
|
|
|
|
// ask the user if the really want to do this
|
|
if ( AfxMessageBox( sz, MB_YESNO ) == IDYES )
|
|
{
|
|
CString szRelativePath;
|
|
|
|
// the WAM stuff can take a few seconds so...
|
|
CWaitCursor waitcursor;
|
|
|
|
// build the item's relative path in the metabase
|
|
BuildMetaPath( hItem, szRelativePath );
|
|
|
|
// delete the WAM application at the virtual directory location
|
|
CString szWAMLocation;
|
|
szWAMLocation = SZ_MB_ROOT;
|
|
szWAMLocation += szRelativePath;
|
|
fSuccess = MakeWAMApplication( szWAMLocation, FALSE );
|
|
|
|
// open the metabase
|
|
if ( fSuccess && mb.Open(SZ_MB_ROOT, METADATA_PERMISSION_READ|METADATA_PERMISSION_WRITE) )
|
|
{
|
|
// remove the item from the metabase
|
|
HRESULT hresError = mb.DeleteObject( szRelativePath );
|
|
// check the error code
|
|
fSuccess = SUCCEEDED( hresError );
|
|
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
|
|
// remove the item from the tree
|
|
m_ctreectrl_tree.DeleteItem( hItem );
|
|
|
|
// if we did not succeed, tell the user
|
|
if ( !fSuccess )
|
|
AfxMessageBox( IDS_ERR_REMOVE_VIRT );
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnContextMenu(CWnd* pWnd, CPoint point)
|
|
{
|
|
UINT idMenu;
|
|
UINT flags;
|
|
|
|
|
|
// first, we need to convert the point from form coordinates, to tree coordinates
|
|
CPoint ptTree = point;
|
|
::ScreenToClient( m_ctreectrl_tree.m_hWnd, &ptTree );
|
|
|
|
// get the tree item that has been right-clicked on
|
|
HTREEITEM hHitItem = m_ctreectrl_tree.HitTest( ptTree, &flags );
|
|
|
|
// if we didn't hit an item, leave
|
|
if ( !hHitItem )
|
|
return;
|
|
|
|
// quick, make sure it is selected - if it isn't - select it
|
|
if ( m_ctreectrl_tree.GetSelectedItem() != hHitItem )
|
|
{
|
|
m_ctreectrl_tree.Select( hHitItem, TVGN_CARET );
|
|
}
|
|
|
|
// show the appropriate menu based on the selection
|
|
if ( hHitItem == m_hRoot )
|
|
idMenu = CG_IDR_POPUP_ADV_ROOT;
|
|
else
|
|
idMenu = CG_IDR_POPUP_ADV_VIRT;
|
|
|
|
CMenu menu;
|
|
VERIFY(menu.LoadMenu(idMenu));
|
|
|
|
CMenu* pPopup = menu.GetSubMenu(0);
|
|
ASSERT(pPopup != NULL);
|
|
|
|
CWnd* pWndPopupOwner = this;
|
|
while (pWndPopupOwner->GetStyle() & WS_CHILD)
|
|
pWndPopupOwner = pWndPopupOwner->GetParent();
|
|
|
|
pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, pWndPopupOwner);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
BOOL CFormAdvanced::PreTranslateMessage(MSG* pMsg)
|
|
{
|
|
// CG: This block was added by the Pop-up Menu component
|
|
{
|
|
// Shift+F10: show pop-up menu.
|
|
if ((((pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN) && // If we hit a key and
|
|
(pMsg->wParam == VK_F10) && (GetKeyState(VK_SHIFT) & ~1)) != 0) || // it's Shift+F10 OR
|
|
(pMsg->message == WM_CONTEXTMENU)) // Natural keyboard key
|
|
{
|
|
CRect rect;
|
|
GetClientRect(rect);
|
|
ClientToScreen(rect);
|
|
|
|
CPoint point = rect.TopLeft();
|
|
point.Offset(5, 5);
|
|
OnContextMenu(NULL, point);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return CFormView::PreTranslateMessage(pMsg);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnUpdateAddVirt(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( TRUE );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnAddVirt()
|
|
{
|
|
OnAdd();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnUpdatePropertiesVirt(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( TRUE );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnPropertiesVirt()
|
|
{
|
|
OnEdit();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnUpdateDeleteVirt(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( TRUE );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnDeleteVirt()
|
|
{
|
|
OnRemove();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnUpdateBrowseVirt(CCmdUI* pCmdUI)
|
|
{
|
|
CString szURL;
|
|
pCmdUI->Enable( g_p_Doc && g_p_Doc->BuildHomePageString(szURL) &&
|
|
m_ctreectrl_tree.GetSelectedItem() );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnBrowseVirt()
|
|
{
|
|
CString szURL;
|
|
CString szRelative;
|
|
|
|
// get the beginning part of the url
|
|
if ( !g_p_Doc ) return;
|
|
if ( !g_p_Doc->BuildHomePageString( szURL ) )
|
|
return;
|
|
|
|
// get the selected item's relative URL path
|
|
BuildMetaPath( m_ctreectrl_tree.GetSelectedItem(), szRelative );
|
|
|
|
// put it all together...
|
|
szURL += szRelative;
|
|
|
|
// and do it to it!
|
|
ShellExecute(
|
|
NULL, // handle to parent window
|
|
NULL, // pointer to string that specifies operation to perform
|
|
szURL, // pointer to filename or folder name string
|
|
NULL, // pointer to string that specifies executable-file parameters
|
|
NULL, // pointer to string that specifies default directory
|
|
SW_SHOW // whether file is shown when opened
|
|
);
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
BOOL CFormAdvanced::FIsVirtualDirectoryValid( HTREEITEM hItem )
|
|
{
|
|
BOOL fValid = FALSE;
|
|
if ( !hItem )
|
|
return FALSE;
|
|
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return FALSE;
|
|
|
|
// build the metabase path
|
|
CString szMB;
|
|
BuildMetaPath( m_ctreectrl_tree.GetSelectedItem(), szMB );
|
|
|
|
// open the metabase
|
|
if ( mb.Open(SZ_MB_ROOT) )
|
|
{
|
|
// do the test
|
|
fValid = FIsVirtualDirectoryValid( &mb, szMB );
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
|
|
// finally, return the answer
|
|
return fValid;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnUpdateExploreVirt(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( FIsVirtualDirectoryValid(m_ctreectrl_tree.GetSelectedItem()) );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnExploreVirt()
|
|
{
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
|
|
// build the metabase path
|
|
CString szMB;
|
|
BuildMetaPath( m_ctreectrl_tree.GetSelectedItem(), szMB );
|
|
|
|
// open the metabase
|
|
if ( mb.Open(SZ_MB_ROOT) )
|
|
{
|
|
CString sz;
|
|
BOOL f = mb.GetString( szMB, MD_VR_PATH, IIS_MD_UT_FILE,
|
|
sz.GetBuffer( WIDE_MAX_PATH ), WIDE_MAX_PATH, METADATA_INHERIT);
|
|
sz.ReleaseBuffer();
|
|
if ( f )
|
|
{
|
|
// explore it!
|
|
ShellExecute(
|
|
NULL, // handle to parent window
|
|
_T("explore"), // pointer to string that specifies operation to perform
|
|
sz, // pointer to filename or folder name string
|
|
NULL, // pointer to string that specifies executable-file parameters
|
|
NULL, // pointer to string that specifies default directory
|
|
SW_SHOW // whether file is shown when opened
|
|
);
|
|
}
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnUpdateOpenVirt(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( FIsVirtualDirectoryValid(m_ctreectrl_tree.GetSelectedItem()) );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnOpenVirt()
|
|
{
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
|
|
// build the metabase path
|
|
CString szMB;
|
|
BuildMetaPath( m_ctreectrl_tree.GetSelectedItem(), szMB );
|
|
|
|
// open the metabase
|
|
if ( mb.Open(SZ_MB_ROOT) )
|
|
{
|
|
CString sz;
|
|
BOOL f = mb.GetString( szMB, MD_VR_PATH, IIS_MD_UT_FILE,
|
|
sz.GetBuffer(WIDE_MAX_PATH), WIDE_MAX_PATH, METADATA_INHERIT);
|
|
sz.ReleaseBuffer();
|
|
if ( f )
|
|
{
|
|
// explore it!
|
|
ShellExecute(
|
|
NULL, // handle to parent window
|
|
_T("open"), // pointer to string that specifies operation to perform
|
|
sz, // pointer to filename or folder name string
|
|
NULL, // pointer to string that specifies executable-file parameters
|
|
NULL, // pointer to string that specifies default directory
|
|
SW_SHOW // whether file is shown when opened
|
|
);
|
|
}
|
|
// close the metabase object
|
|
mb.Close();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnFinalRelease()
|
|
{
|
|
// create the metabase wrapper
|
|
CWrapMetaBase mb;
|
|
if ( !mb.FInit() )
|
|
return;
|
|
// make sure the metabase saves the chagnes
|
|
mb.Save();
|
|
CFormView::OnFinalRelease();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
WORD CFormAdvanced::GetContextHelpID()
|
|
{
|
|
if ( m_DirHelpID )
|
|
return m_DirHelpID;
|
|
return CFormAdvanced::IDD;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnUpdateEditCopy(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( m_csz_default_doc.IsWindowEnabled() );
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnUpdateEditPaste(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( m_csz_default_doc.IsWindowEnabled() );
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnUpdateEditCut(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( m_csz_default_doc.IsWindowEnabled() );
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnEditCut()
|
|
{
|
|
m_csz_default_doc.Cut();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnEditCopy()
|
|
{
|
|
m_csz_default_doc.Copy();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnEditPaste()
|
|
{
|
|
m_csz_default_doc.Paste();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
void CFormAdvanced::OnSelchangedTree(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
|
|
// check the remove button
|
|
EnableItems();
|
|
*pResult = 0;
|
|
}
|