1850 lines
44 KiB
C++
1850 lines
44 KiB
C++
//+-------------------------------------------------------------------------
|
||
//
|
||
// Microsoft Windows
|
||
//
|
||
// Copyright (C) Microsoft Corporation, 1998 - 1999
|
||
//
|
||
// File: pgpolicy.cpp
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
|
||
// pgpolicy.cpp : implementation file
|
||
//
|
||
|
||
#include "stdafx.h"
|
||
#include <objsel.h>
|
||
#include "helper.h"
|
||
#include "acsadmin.h"
|
||
#include "acsdata.h"
|
||
#include "acshand.h"
|
||
#include "pgpolicy.h"
|
||
|
||
#ifdef _DEBUG
|
||
#define new DEBUG_NEW
|
||
#undef THIS_FILE
|
||
static char THIS_FILE[] = __FILE__;
|
||
#endif
|
||
|
||
void CACSPolicyPageManager::SetPolicyData(CACSPolicyElement* pPolicy, CACSPolicyHandle* pHandle)
|
||
{
|
||
ASSERT(pPolicy && pHandle);
|
||
m_spPolicy = pPolicy;
|
||
m_pHandle = pHandle;
|
||
if(pHandle)
|
||
pHandle->AddRef();
|
||
}
|
||
CACSPolicyPageManager::~CACSPolicyPageManager()
|
||
{
|
||
m_spPolicy.Release();
|
||
if(m_pHandle)
|
||
m_pHandle->Release();
|
||
}
|
||
|
||
BOOL CACSPolicyPageManager::OnApply()
|
||
{
|
||
if(CPageManager::OnApply())
|
||
{
|
||
HRESULT hr = S_OK;
|
||
ASSERT((CACSPolicyElement*)m_spPolicy);
|
||
|
||
// check if data is valid ... // to verify cross page data
|
||
UserPolicyType PolicyType = UNDEFINED;
|
||
|
||
if ((m_nBranchFlag & BRANCH_FLAG_GLOBAL) != 0) // may need to alter the text
|
||
{
|
||
ASSERT(m_pGeneralPage);
|
||
|
||
if(m_pGeneralPage->IfAnyAuth())
|
||
{
|
||
PolicyType = GLOBAL_ANY_AUTHENTICATED;
|
||
}
|
||
else if (m_pGeneralPage->IfAnyUnauth())
|
||
{
|
||
PolicyType = GLOBAL_ANY_UNAUTHENTICATED;
|
||
}
|
||
}
|
||
|
||
|
||
UINT ErrorId = m_spPolicy->PreSaveVerifyData(GetFlags(), PolicyType);
|
||
|
||
if(ErrorId != 0) // not valid
|
||
{
|
||
// Display error message,
|
||
AfxMessageBox(ErrorId);
|
||
|
||
// Return FALSE
|
||
return FALSE;
|
||
}
|
||
|
||
// persist the data into DS
|
||
|
||
hr = m_spPolicy->Save(GetFlags());
|
||
|
||
{
|
||
CWaitCursor wc;
|
||
|
||
Sleep(1000);
|
||
}
|
||
|
||
// modifies the state info on UI ( may change states of other conflicted ones
|
||
m_spPolicy->InvalidateConflictState();
|
||
|
||
// inform container to check conflict
|
||
|
||
if FAILED(hr)
|
||
ReportError(hr, IDS_ERR_SAVESUBNETCONFIG, NULL);
|
||
else
|
||
{
|
||
AfxMessageBox(IDS_WRN_POLICY_EFFECTIVE_FROM_NEXT_RSVP);
|
||
m_pHandle->UpdateStrings();
|
||
m_pHandle->OnPropertyPageApply();
|
||
// Advise super class that the apply button has been activated.
|
||
CPageManager::OnApply();
|
||
}
|
||
ClearFlags();
|
||
|
||
MMCNotify();
|
||
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CPgPolicyGeneral property page
|
||
|
||
IMPLEMENT_DYNCREATE(CPgPolicyGeneral, CACSPage)
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CPgTraffic message handlers
|
||
enum DirectionIndex
|
||
{
|
||
DIRECTION_SEND,
|
||
DIRECTION_RECEIVE,
|
||
DIRECTION_SENDRECEIVE
|
||
};
|
||
|
||
enum ServiceTypeIndex
|
||
{
|
||
SERVICETYPE_ALL,
|
||
SERVICETYPE_CONTROLLEDLOAD,
|
||
SERVICETYPE_GUARANTEEDSERVICE,
|
||
SERVICETYPE_DISABLED
|
||
};
|
||
|
||
enum IdentityTypeIndex
|
||
{
|
||
IDENTITYTYPE_DEFAULT,
|
||
IDENTITYTYPE_UNKNOWN,
|
||
IDENTITYTYPE_USER,
|
||
IDENTITYTYPE_OU
|
||
};
|
||
|
||
CPgPolicyGeneral::CPgPolicyGeneral() : CACSPage(CPgPolicyGeneral::IDD)
|
||
{
|
||
DataInit();
|
||
}
|
||
|
||
CPgPolicyGeneral::CPgPolicyGeneral(CACSPolicyElement* pData) : CACSPage(CPgPolicyGeneral::IDD)
|
||
{
|
||
ASSERT(pData);
|
||
m_spData = pData;
|
||
DataInit();
|
||
}
|
||
|
||
|
||
void CPgPolicyGeneral::DataInit()
|
||
{
|
||
//{{AFX_DATA_INIT(CPgPolicyGeneral)
|
||
m_strOU = _T("");
|
||
m_strUser = _T("");
|
||
m_nIdentityChoice = -1;
|
||
//}}AFX_DATA_INIT
|
||
}
|
||
|
||
CPgPolicyGeneral::~CPgPolicyGeneral()
|
||
{
|
||
delete m_pDirection;
|
||
delete m_pServiceType;
|
||
m_aServiceTypes.DeleteAll();
|
||
m_aDirections.DeleteAll();
|
||
}
|
||
|
||
void CPgPolicyGeneral::DoDataExchange(CDataExchange* pDX)
|
||
{
|
||
CACSPage::DoDataExchange(pDX);
|
||
//{{AFX_DATA_MAP(CPgPolicyGeneral)
|
||
DDX_Control(pDX, IDC_POLICY_GEN_BROWSEUSER, m_buttonUser);
|
||
DDX_Control(pDX, IDC_POLICY_GEN_BROWSEOU, m_buttonOU);
|
||
DDX_Control(pDX, IDC_POLICY_GEN_EDIT_USER, m_editUser);
|
||
DDX_Control(pDX, IDC_POLICY_GEN_EDIT_OU, m_editOU);
|
||
DDX_Text(pDX, IDC_POLICY_GEN_EDIT_OU, m_strOU);
|
||
DDX_Text(pDX, IDC_POLICY_GEN_EDIT_USER, m_strUser);
|
||
DDX_Radio(pDX, IDC_POLICY_GEN_DEFAULTUSER, m_nIdentityChoice);
|
||
//}}AFX_DATA_MAP
|
||
}
|
||
|
||
|
||
BEGIN_MESSAGE_MAP(CPgPolicyGeneral, CACSPage)
|
||
//{{AFX_MSG_MAP(CPgPolicyGeneral)
|
||
ON_BN_CLICKED(IDC_POLICY_GEN_BROWSEOU, OnBrowseOU)
|
||
ON_BN_CLICKED(IDC_POLICY_GEN_BROWSEUSER, OnBrowseUser)
|
||
ON_BN_CLICKED(IDC_POLICY_GEN_UNKNOWNUSER, OnUnknownuser)
|
||
ON_BN_CLICKED(IDC_POLICY_GEN_DEFAULTUSER, OnDefaultuser)
|
||
ON_BN_CLICKED(IDC_POLICY_GEN_RADIO_OU, OnRadioOu)
|
||
ON_BN_CLICKED(IDC_POLICY_GEN_RADIO_USER, OnRadioUser)
|
||
ON_EN_CHANGE(IDC_POLICY_GEN_EDIT_OU, OnChangeEditOu)
|
||
ON_EN_CHANGE(IDC_POLICY_GEN_EDIT_USER, OnChangeEditUser)
|
||
ON_CBN_SELCHANGE(IDC_POLICY_GEN_SERVICELEVEL, OnSelchangeServicelevel)
|
||
ON_CBN_SELCHANGE(IDC_POLICY_GEN_DIRECTION, OnSelchangeDirection)
|
||
//}}AFX_MSG_MAP
|
||
END_MESSAGE_MAP()
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CPgPolicyGeneral message handlers
|
||
void CPgPolicyGeneral::OnBrowseOU()
|
||
{
|
||
TCHAR szRoot[MAX_PATH] = TEXT("");
|
||
TCHAR szBuffer[MAX_PATH] = TEXT("");;
|
||
DSBROWSEINFO dsbi = { 0 };
|
||
CString strTemp;
|
||
|
||
strTemp.LoadString(IDS_BROWSEOU_TITLE);
|
||
// initialize the structure (its already NULL)
|
||
|
||
dsbi.cbStruct = sizeof(dsbi);
|
||
dsbi.hwndOwner = GetSafeHwnd();
|
||
dsbi.pszTitle = strTemp;
|
||
dsbi.pszRoot = NULL;
|
||
dsbi.pszPath = szBuffer;
|
||
dsbi.cchPath = sizeof(szBuffer) / sizeof(TCHAR);
|
||
dsbi.dwFlags = 0;
|
||
dsbi.pfnCallback = NULL;
|
||
dsbi.lParam = (LPARAM)0;
|
||
|
||
dsbi.dwFlags |= DSBI_ENTIREDIRECTORY;
|
||
|
||
|
||
UINT idResult = DsBrowseForContainer(&dsbi);
|
||
|
||
if ( idResult != IDOK )
|
||
return;
|
||
|
||
m_strOU = szBuffer;
|
||
IADs* pADs = NULL;
|
||
VARIANT v;
|
||
VariantInit(&v);
|
||
if(m_strOU.GetLength())
|
||
{
|
||
m_strOU = _T("");
|
||
CHECK_HR(ADsOpenObject(szBuffer, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_USE_SIGNING | ADS_USE_SEALING, IID_IADs, (void**)&pADs));
|
||
ASSERT(pADs);
|
||
CHECK_HR(pADs->Get(L"distinguishedName", &v));
|
||
m_strOU = V_BSTR(&v);
|
||
m_editOU.SetWindowText(m_strOU);
|
||
}
|
||
|
||
L_ERR:
|
||
VariantClear(&v);
|
||
if(pADs)
|
||
{
|
||
pADs->Release();
|
||
pADs = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
//+--------------------------------------------------------------------------
|
||
//
|
||
// Function: InitObjectPickerForGroups
|
||
//
|
||
// Synopsis: Call IDsObjectPicker::Initialize with arguments that will
|
||
// set it to allow the user to pick one or more groups.
|
||
//
|
||
// Arguments: [pDsObjectPicker] - object picker interface instance
|
||
//
|
||
// Returns: Result of calling IDsObjectPicker::Initialize.
|
||
//
|
||
// History: 10-14-1998 DavidMun Created
|
||
//
|
||
//---------------------------------------------------------------------------
|
||
|
||
HRESULT
|
||
InitObjectPickerForGroups(IDsObjectPicker *pDsObjectPicker, BOOL fMultiselect)
|
||
{
|
||
//
|
||
// Prepare to initialize the object picker.
|
||
// Set up the array of scope initializer structures.
|
||
//
|
||
|
||
static const int SCOPE_INIT_COUNT = 1;
|
||
DSOP_SCOPE_INIT_INFO aScopeInit[SCOPE_INIT_COUNT];
|
||
|
||
ZeroMemory(aScopeInit, sizeof(DSOP_SCOPE_INIT_INFO) * SCOPE_INIT_COUNT);
|
||
|
||
//
|
||
// Target computer scope. This adds a "Look In" entry for the
|
||
// target computer. Computer scopes are always treated as
|
||
// downlevel (i.e., they use the WinNT provider).
|
||
//
|
||
|
||
aScopeInit[0].cbSize = sizeof(DSOP_SCOPE_INIT_INFO);
|
||
aScopeInit[0].flType = DSOP_SCOPE_TYPE_ENTERPRISE_DOMAIN | DSOP_SCOPE_TYPE_GLOBAL_CATALOG;
|
||
aScopeInit[0].flScope = DSOP_SCOPE_FLAG_STARTING_SCOPE;
|
||
aScopeInit[0].FilterFlags.flDownlevel = DSOP_DOWNLEVEL_FILTER_USERS;
|
||
aScopeInit[0].FilterFlags.Uplevel.flBothModes = DSOP_FILTER_USERS;
|
||
|
||
DSOP_INIT_INFO InitInfo;
|
||
ZeroMemory(&InitInfo, sizeof(InitInfo));
|
||
|
||
InitInfo.cbSize = sizeof(InitInfo);
|
||
|
||
//
|
||
// The pwzTargetComputer member allows the object picker to be
|
||
// retargetted to a different computer. It will behave as if it
|
||
// were being run ON THAT COMPUTER.
|
||
//
|
||
|
||
InitInfo.pwzTargetComputer = NULL; // NULL == local machine
|
||
InitInfo.cDsScopeInfos = SCOPE_INIT_COUNT;
|
||
InitInfo.aDsScopeInfos = aScopeInit;
|
||
InitInfo.flOptions = (fMultiselect) ? DSOP_FLAG_MULTISELECT : 0;
|
||
|
||
LPCTSTR attrs[] = {_T("distinguishedName")};
|
||
|
||
InitInfo.cAttributesToFetch = 1;
|
||
InitInfo.apwzAttributeNames = attrs;
|
||
|
||
|
||
//
|
||
// Note object picker makes its own copy of InitInfo. Also note
|
||
// that Initialize may be called multiple times, last call wins.
|
||
//
|
||
|
||
HRESULT hr = pDsObjectPicker->Initialize(&InitInfo);
|
||
|
||
if (FAILED(hr))
|
||
{
|
||
ULONG i;
|
||
|
||
for (i = 0; i < SCOPE_INIT_COUNT; i++)
|
||
{
|
||
if (FAILED(InitInfo.aDsScopeInfos[i].hr))
|
||
{
|
||
printf("Initialization failed because of scope %u\n", i);
|
||
}
|
||
}
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
#define BREAK_ON_FAIL_HRESULT(hr) \
|
||
if (FAILED(hr)) { printf("line %u err 0x%x\n", __LINE__, hr); break; }
|
||
|
||
|
||
void CPgPolicyGeneral::OnBrowseUser()
|
||
{
|
||
HRESULT hr = S_OK;
|
||
IDsObjectPicker * pDsObjectPicker = NULL;
|
||
IDataObject * pdo = NULL;
|
||
BOOL fSuccess = TRUE;
|
||
|
||
hr = CoInitialize(NULL);
|
||
if(FAILED(hr))
|
||
return ;
|
||
|
||
do
|
||
{
|
||
//
|
||
// Create an instance of the object picker. The implementation in
|
||
// objsel.dll is apartment model.
|
||
//
|
||
hr = CoCreateInstance(CLSID_DsObjectPicker,
|
||
NULL,
|
||
CLSCTX_INPROC_SERVER,
|
||
IID_IDsObjectPicker,
|
||
(void **) &pDsObjectPicker);
|
||
BREAK_ON_FAIL_HRESULT(hr);
|
||
|
||
hr = InitObjectPickerForGroups(pDsObjectPicker, FALSE);
|
||
|
||
//
|
||
// Invoke the modal dialog.
|
||
//
|
||
hr = pDsObjectPicker->InvokeDialog(this->GetSafeHwnd(), &pdo);
|
||
BREAK_ON_FAIL_HRESULT(hr);
|
||
|
||
//
|
||
// If the user hit Cancel, hr == S_FALSE
|
||
//
|
||
if (hr == S_FALSE)
|
||
{
|
||
Trace0("User canceled object picker dialog\n");
|
||
fSuccess = FALSE;
|
||
break;
|
||
}
|
||
|
||
//
|
||
// Process the user's selections
|
||
//
|
||
Assert(pdo);
|
||
// ProcessSelectedObjects(pdo);
|
||
{
|
||
UINT g_cfDsObjectPicker = RegisterClipboardFormat(CFSTR_DSOP_DS_SELECTION_LIST);
|
||
|
||
|
||
STGMEDIUM stgmedium =
|
||
{
|
||
TYMED_HGLOBAL,
|
||
NULL,
|
||
NULL
|
||
};
|
||
|
||
FORMATETC formatetc =
|
||
{
|
||
(unsigned short)g_cfDsObjectPicker,
|
||
NULL,
|
||
DVASPECT_CONTENT,
|
||
-1,
|
||
TYMED_HGLOBAL
|
||
};
|
||
|
||
bool fGotStgMedium = false;
|
||
|
||
do
|
||
{
|
||
hr = pdo->GetData(&formatetc, &stgmedium);
|
||
BREAK_ON_FAIL_HRESULT(hr);
|
||
|
||
fGotStgMedium = true;
|
||
|
||
PDS_SELECTION_LIST pDsSelList =
|
||
(PDS_SELECTION_LIST) GlobalLock(stgmedium.hGlobal);
|
||
|
||
// inteprete the selection
|
||
ASSERT(pDsSelList->cItems == 1);
|
||
|
||
ASSERT(pDsSelList->aDsSelection[0].pvarFetchedAttributes[0].vt == VT_BSTR);
|
||
|
||
if(pDsSelList->aDsSelection[0].pvarFetchedAttributes[0].vt == VT_BSTR)
|
||
{
|
||
m_strUser = V_BSTR(&(pDsSelList->aDsSelection[0].pvarFetchedAttributes[0]));
|
||
// update the edit field of the property page
|
||
|
||
m_editUser.SetWindowText(m_strUser);
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
CString str;
|
||
str.LoadString(IDS_ERR_DN);
|
||
str.Format(str, pDsSelList->aDsSelection[0].pwzName);
|
||
AfxMessageBox(str, MB_OK);
|
||
}
|
||
GlobalUnlock(stgmedium.hGlobal);
|
||
} while (0);
|
||
|
||
if (fGotStgMedium)
|
||
{
|
||
ReleaseStgMedium(&stgmedium);
|
||
}
|
||
}
|
||
|
||
pdo->Release();
|
||
pdo = NULL;
|
||
|
||
} while (0);
|
||
|
||
if (pDsObjectPicker)
|
||
{
|
||
pDsObjectPicker->Release();
|
||
}
|
||
|
||
CoUninitialize();
|
||
|
||
if (FAILED(hr))
|
||
fSuccess = FALSE;
|
||
|
||
return;
|
||
}
|
||
|
||
void CPgPolicyGeneral::OnUnknownuser()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
EnableIdentityCtrls(1);
|
||
|
||
}
|
||
|
||
void CPgPolicyGeneral::OnDefaultuser()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
EnableIdentityCtrls(0);
|
||
|
||
}
|
||
|
||
void CPgPolicyGeneral::OnRadioOu()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
EnableIdentityCtrls(3);
|
||
|
||
}
|
||
|
||
void CPgPolicyGeneral::OnRadioUser()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
EnableIdentityCtrls(2);
|
||
|
||
}
|
||
|
||
void CPgPolicyGeneral::OnChangeEditOu()
|
||
{
|
||
// TODO: If this is a RICHEDIT control, the control will not
|
||
// send this notification unless you override the CPropertyPage::OnInitDialog()
|
||
// function to send the EM_SETEVENTMASK message to the control
|
||
// with the ENM_CHANGE flag ORed into the lParam mask.
|
||
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
|
||
}
|
||
|
||
void CPgPolicyGeneral::OnChangeEditUser()
|
||
{
|
||
// TODO: If this is a RICHEDIT control, the control will not
|
||
// send this notification unless you override the CPropertyPage::OnInitDialog()
|
||
// function to send the EM_SETEVENTMASK message to the control
|
||
// with the ENM_CHANGE flag ORed into the lParam mask.
|
||
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
}
|
||
|
||
void CPgPolicyGeneral::OnSelchangeServicelevel()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
}
|
||
|
||
void CPgPolicyGeneral::OnSelchangeDirection()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
|
||
}
|
||
|
||
BOOL CPgPolicyGeneral::OnKillActive( )
|
||
{
|
||
// GURANTEEDSERVICE and SEND can not be a policy
|
||
if(m_pServiceType->GetSelected() == SERVICETYPE_GUARANTEEDSERVICE && m_pDirection->GetSelected() == DIRECTION_SEND)
|
||
{
|
||
AfxMessageBox(IDS_NO_POLICY_FOR_SEND_AND_GUARANTEE, MB_OK, 0);
|
||
return FALSE;
|
||
}
|
||
|
||
return CACSPage::OnKillActive();
|
||
}
|
||
|
||
BOOL CPgPolicyGeneral::OnApply()
|
||
{
|
||
if(!GetModified()) return TRUE;
|
||
|
||
// direction
|
||
if(m_pDirection)
|
||
{
|
||
switch(m_pDirection->GetSelected())
|
||
{
|
||
case DIRECTION_SEND:
|
||
m_spData->m_dwDirection = ACS_DIRECTION_SEND;
|
||
break;
|
||
case DIRECTION_RECEIVE:
|
||
m_spData->m_dwDirection = ACS_DIRECTION_RECEIVE;
|
||
break;
|
||
case DIRECTION_SENDRECEIVE:
|
||
m_spData->m_dwDirection = ACS_DIRECTION_BOTH;
|
||
break;
|
||
default:
|
||
// no valid value should come here
|
||
ASSERT(0);
|
||
}
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_DIRECTION, true);
|
||
}
|
||
else // save what ever is loaded
|
||
{
|
||
if(m_spData->GetFlags(ATTR_FLAG_LOAD, ACS_PAF_DIRECTION))
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_DIRECTION, true);
|
||
else
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_DIRECTION, false);
|
||
}
|
||
|
||
// service type
|
||
if(m_pServiceType)
|
||
{
|
||
switch(m_pServiceType->GetSelected())
|
||
{
|
||
case SERVICETYPE_DISABLED:
|
||
m_spData->m_dwServiceType = ACS_SERVICETYPE_DISABLED;
|
||
break;
|
||
case SERVICETYPE_CONTROLLEDLOAD:
|
||
m_spData->m_dwServiceType = ACS_SERVICETYPE_CONTROLLEDLOAD;
|
||
break;
|
||
case SERVICETYPE_GUARANTEEDSERVICE:
|
||
m_spData->m_dwServiceType = ACS_SERVICETYPE_GUARANTEEDSERVICE;
|
||
break;
|
||
case SERVICETYPE_ALL:
|
||
m_spData->m_dwServiceType = ACS_SERVICETYPE_ALL;
|
||
break;
|
||
default:
|
||
// no valid value should come here
|
||
ASSERT(0);
|
||
}
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_SERVICETYPE, true);
|
||
}
|
||
else // save what ever is loaded
|
||
{
|
||
if(m_spData->GetFlags(ATTR_FLAG_LOAD, ACS_PAF_SERVICETYPE))
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_SERVICETYPE, true);
|
||
else
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_SERVICETYPE, false);
|
||
}
|
||
|
||
// GURANTEEDSERVICE and SEND can not be a policy
|
||
if(m_spData->m_dwServiceType == ACS_SERVICETYPE_GUARANTEEDSERVICE && m_spData->m_dwDirection == ACS_DIRECTION_SEND)
|
||
{
|
||
AfxMessageBox(IDS_NO_POLICY_FOR_SEND_AND_GUARANTEE, MB_OK, 0);
|
||
return FALSE;
|
||
|
||
}
|
||
|
||
// ACS_SERVICETYPE_CONTROLLEDLOAD and SEND can not be a policy
|
||
if(m_spData->m_dwServiceType == ACS_SERVICETYPE_CONTROLLEDLOAD && m_spData->m_dwDirection == ACS_DIRECTION_SEND)
|
||
{
|
||
AfxMessageBox(IDS_NO_POLICY_FOR_SEND_AND_CONTROLLEDLOAD, MB_OK, 0);
|
||
return FALSE;
|
||
|
||
}
|
||
|
||
// code for identity
|
||
|
||
CString* pIdentity;
|
||
if(m_spData->m_strArrayIdentityName.GetSize())
|
||
{
|
||
pIdentity = m_spData->m_strArrayIdentityName[(INT_PTR)0];
|
||
}
|
||
else
|
||
{
|
||
pIdentity = new CString();
|
||
m_spData->m_strArrayIdentityName.Add(pIdentity);
|
||
}
|
||
|
||
switch(m_nIdentityChoice)
|
||
{
|
||
case 0: // default user
|
||
*pIdentity = ACS_IDENTITY_DEFAULT;
|
||
break;
|
||
case 1: // unknown user
|
||
*pIdentity = ACS_IDENTITY_UNKNOWN;
|
||
break;
|
||
case 2: // user
|
||
*pIdentity = ACS_IDENTITY_USER;
|
||
if(m_strUser.GetLength() == 0)
|
||
{
|
||
GotoDlgCtrl(&m_editUser);
|
||
AfxMessageBox(IDS_ERR_USER_DN);
|
||
return FALSE;
|
||
}
|
||
|
||
*pIdentity += m_strUser;
|
||
break;
|
||
case 3: // OU
|
||
*pIdentity = ACS_IDENTITY_OU;
|
||
if(m_strOU.GetLength() == 0)
|
||
{
|
||
GotoDlgCtrl(&m_editOU);
|
||
AfxMessageBox(IDS_ERR_OU_DN);
|
||
return FALSE;
|
||
}
|
||
|
||
*pIdentity+= m_strOU;
|
||
break;
|
||
|
||
default:
|
||
return FALSE;
|
||
|
||
}
|
||
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_IDENTITYNAME, true);
|
||
|
||
// check if conflict with other policies in the folder
|
||
if(m_spData->IsConflictInContainer())
|
||
{
|
||
if(AfxMessageBox(IDS_CONFLICTPOLICY, MB_OKCANCEL, 0) != IDOK)
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
DWORD dwAttrFlags = 0;
|
||
dwAttrFlags |= (ACS_PAF_IDENTITYNAME | ACS_PAF_SERVICETYPE | ACS_PAF_DIRECTION);
|
||
|
||
AddFlags(dwAttrFlags); // prepare flags for saving
|
||
|
||
|
||
|
||
return CACSPage::OnApply();
|
||
}
|
||
|
||
BOOL CPgPolicyGeneral::OnInitDialog()
|
||
{
|
||
CString* pStr = NULL;
|
||
bool bModified = false;
|
||
// direction
|
||
// fillin the list box
|
||
try{
|
||
|
||
pStr = new CString();
|
||
pStr->LoadString(IDS_SEND);
|
||
m_aDirections.Add(pStr);
|
||
|
||
pStr = new CString();
|
||
pStr->LoadString(IDS_RECEIVE);
|
||
m_aDirections.Add(pStr);
|
||
|
||
pStr = new CString();
|
||
pStr->LoadString(IDS_SENDRECEIVE);
|
||
m_aDirections.Add(pStr);
|
||
|
||
m_pDirection = new CStrBox<CComboBox>(this, IDC_POLICY_GEN_DIRECTION, m_aDirections);
|
||
m_pDirection->Fill();
|
||
|
||
// decide which one to select
|
||
if(m_spData->GetFlags(ATTR_FLAG_LOAD, ACS_PAF_DIRECTION))
|
||
{
|
||
int current = -1;
|
||
switch(m_spData->m_dwDirection)
|
||
{
|
||
case ACS_DIRECTION_SEND:
|
||
current = DIRECTION_SEND;
|
||
break;
|
||
case ACS_DIRECTION_RECEIVE:
|
||
current = DIRECTION_RECEIVE;
|
||
break;
|
||
case ACS_DIRECTION_BOTH:
|
||
current = DIRECTION_SENDRECEIVE;
|
||
break;
|
||
default:
|
||
// invalid value
|
||
ASSERT(0);
|
||
// message box
|
||
}
|
||
|
||
m_pDirection->Select(current);
|
||
}
|
||
else
|
||
{
|
||
m_pDirection->Select(DIRECTION_SENDRECEIVE); // default
|
||
}
|
||
}catch(CMemoryException&){};
|
||
|
||
// service type
|
||
try{
|
||
pStr = new CString();
|
||
pStr->LoadString(IDS_ALL);
|
||
m_aServiceTypes.Add(pStr);
|
||
|
||
pStr = new CString();
|
||
pStr->LoadString(IDS_CONTROLLEDLOAD);
|
||
m_aServiceTypes.Add(pStr);
|
||
|
||
pStr = new CString();
|
||
pStr->LoadString(IDS_GUARANTEEDSERVICE);
|
||
m_aServiceTypes.Add(pStr);
|
||
|
||
pStr = new CString();
|
||
pStr->LoadString(IDS_SERVICETYPE_DISABLED);
|
||
m_aServiceTypes.Add(pStr);
|
||
|
||
m_pServiceType = new CStrBox<CComboBox>(this, IDC_POLICY_GEN_SERVICELEVEL, m_aServiceTypes);
|
||
m_pServiceType->Fill();
|
||
|
||
// decide which one to select
|
||
if(m_spData->GetFlags(ATTR_FLAG_LOAD, ACS_PAF_SERVICETYPE))
|
||
{
|
||
int current = -1;
|
||
switch(m_spData->m_dwServiceType)
|
||
{
|
||
case ACS_SERVICETYPE_DISABLED:
|
||
current = SERVICETYPE_DISABLED;
|
||
break;
|
||
case ACS_SERVICETYPE_CONTROLLEDLOAD:
|
||
current = SERVICETYPE_CONTROLLEDLOAD;
|
||
break;
|
||
case ACS_SERVICETYPE_GUARANTEEDSERVICE:
|
||
current = SERVICETYPE_GUARANTEEDSERVICE;
|
||
break;
|
||
case ACS_SERVICETYPE_ALL:
|
||
current = SERVICETYPE_ALL;
|
||
break;
|
||
default:
|
||
// invalid value
|
||
ASSERT(0);
|
||
// message box
|
||
}
|
||
|
||
m_pServiceType->Select(current);
|
||
}
|
||
else
|
||
{
|
||
m_pServiceType->Select(SERVICETYPE_ALL); // default
|
||
}
|
||
}catch(CMemoryException&){};
|
||
|
||
// Identity -- user / ou
|
||
CString strIdentity;
|
||
m_nIdentityChoice = m_spData->GetIdentityType(strIdentity);
|
||
|
||
switch(m_nIdentityChoice){
|
||
case 0: // default
|
||
case 1: // unknown
|
||
break;
|
||
case 2: // user
|
||
m_strUser = strIdentity;
|
||
break;
|
||
case 3: // OU
|
||
m_strOU = strIdentity;
|
||
break;
|
||
default:
|
||
ASSERT(0);
|
||
break;
|
||
}
|
||
|
||
|
||
CACSPage::OnInitDialog();
|
||
|
||
if(bModified)
|
||
SetModified();
|
||
|
||
EnableIdentityCtrls(m_nIdentityChoice);
|
||
|
||
return TRUE; // return TRUE unless you set the focus to a control
|
||
// EXCEPTION: OCX Property Pages should return FALSE
|
||
}
|
||
|
||
void CPgPolicyGeneral::EnableIdentityCtrls(int nChoice)
|
||
{
|
||
|
||
switch(nChoice){
|
||
case 0: // default
|
||
case 1: // unknown
|
||
m_editUser.EnableWindow(FALSE);
|
||
m_editOU.EnableWindow(FALSE);
|
||
m_buttonUser.EnableWindow(FALSE);
|
||
m_buttonOU.EnableWindow(FALSE);
|
||
break;
|
||
case 2: // user
|
||
m_editUser.EnableWindow(TRUE);
|
||
m_buttonUser.EnableWindow(TRUE);
|
||
m_editOU.EnableWindow(FALSE);
|
||
m_buttonOU.EnableWindow(FALSE);
|
||
break;
|
||
case 3: // OU
|
||
m_editUser.EnableWindow(FALSE);
|
||
m_buttonUser.EnableWindow(FALSE);
|
||
m_editOU.EnableWindow(TRUE);
|
||
m_buttonOU.EnableWindow(TRUE);
|
||
break;
|
||
default:
|
||
m_editUser.EnableWindow(FALSE);
|
||
m_buttonUser.EnableWindow(FALSE);
|
||
m_editOU.EnableWindow(FALSE);
|
||
m_buttonOU.EnableWindow(FALSE);
|
||
}
|
||
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CPgPolicyFlow property page
|
||
|
||
IMPLEMENT_DYNCREATE(CPgPolicyFlow, CACSPage)
|
||
|
||
CPgPolicyFlow::CPgPolicyFlow(CACSPolicyElement* pData) : CACSPage(CPgPolicyFlow::IDD)
|
||
{
|
||
ASSERT(pData);
|
||
m_spData = pData;
|
||
DataInit();
|
||
}
|
||
|
||
CPgPolicyFlow::CPgPolicyFlow() : CACSPage(CPgPolicyFlow::IDD)
|
||
{
|
||
}
|
||
|
||
void CPgPolicyFlow::DataInit()
|
||
{
|
||
//{{AFX_DATA_INIT(CPgPolicyFlow)
|
||
m_uDuration = 0;
|
||
m_uPeakRate = 0;
|
||
m_nDataRateChoice = -1;
|
||
m_nDurationChoice = -1;
|
||
m_nPeakRateChoice = -1;
|
||
m_uDataRate = 0;
|
||
//}}AFX_DATA_INIT
|
||
|
||
m_nBranchFlag = 0;
|
||
m_pGeneralPage = NULL;
|
||
}
|
||
|
||
CPgPolicyFlow::~CPgPolicyFlow()
|
||
{
|
||
m_nBranchFlag = 0;
|
||
m_pGeneralPage = NULL;
|
||
}
|
||
|
||
void CPgPolicyFlow::DoDataExchange(CDataExchange* pDX)
|
||
{
|
||
CACSPage::DoDataExchange(pDX);
|
||
//{{AFX_DATA_MAP(CPgPolicyFlow)
|
||
|
||
DDX_Control(pDX, IDC_POLICY_FLOW_PEAKDATARATE_EDIT_LIMIT, m_editPeakRate);
|
||
DDX_Control(pDX, IDC_POLICY_FLOW_DURATION_EDIT_LIMIT, m_editDuration);
|
||
DDX_Control(pDX, IDC_POLICY_FLOW_DATARATE_EDIT_LIMIT, m_editDataRate);
|
||
|
||
DDX_Radio(pDX, IDC_POLICY_FLOW_DATARATE_RES, m_nDataRateChoice);
|
||
DDX_Radio(pDX, IDC_POLICY_FLOW_DURATION_RES, m_nDurationChoice);
|
||
DDX_Radio(pDX, IDC_POLICY_FLOW_PEAKDATARATE_RES, m_nPeakRateChoice);
|
||
|
||
DDX_Text(pDX, IDC_POLICY_FLOW_DURATION_EDIT_LIMIT, m_uDuration);
|
||
if (m_nDurationChoice == 2)
|
||
DDV_MinMaxUInt(pDX, m_uDuration, 0, 71582780);
|
||
|
||
DDX_Text(pDX, IDC_POLICY_FLOW_PEAKDATARATE_EDIT_LIMIT, m_uPeakRate);
|
||
if (m_nPeakRateChoice ==2 )
|
||
DDV_MinMaxUInt(pDX, m_uPeakRate, 0, 4194300);
|
||
|
||
DDX_Text(pDX, IDC_POLICY_FLOW_DATARATE_EDIT_LIMIT, m_uDataRate);
|
||
if (m_nDataRateChoice == 2)
|
||
DDV_MinMaxUInt(pDX, m_uDataRate, 0, 4194300);
|
||
//}}AFX_DATA_MAP
|
||
}
|
||
|
||
|
||
BEGIN_MESSAGE_MAP(CPgPolicyFlow, CACSPage)
|
||
//{{AFX_MSG_MAP(CPgPolicyFlow)
|
||
ON_BN_CLICKED(IDC_POLICY_FLOW_DATARATE_DEF, OnPolicyFlowDatarateDef)
|
||
ON_EN_CHANGE(IDC_POLICY_FLOW_DATARATE_EDIT_LIMIT, OnChangePolicyFlowDatarateEditLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_FLOW_DATARATE_RADIO_LIMIT, OnPolicyFlowDatarateRadioLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_FLOW_DATARATE_RES, OnPolicyFlowDatarateRes)
|
||
ON_BN_CLICKED(IDC_POLICY_FLOW_DURATION_DEF, OnPolicyFlowDurationDef)
|
||
ON_EN_CHANGE(IDC_POLICY_FLOW_DURATION_EDIT_LIMIT, OnChangePolicyFlowDurationEditLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_FLOW_DURATION_RADIO_LIMIT, OnPolicyFlowDurationRadioLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_FLOW_DURATION_RES, OnPolicyFlowDurationRes)
|
||
ON_BN_CLICKED(IDC_POLICY_FLOW_PEAKDATARATE_DEF, OnPolicyFlowPeakdatarateDef)
|
||
ON_EN_CHANGE(IDC_POLICY_FLOW_PEAKDATARATE_EDIT_LIMIT, OnChangePolicyFlowPeakdatarateEditLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_FLOW_PEAKDATARATE_RADIO_LIMIT, OnPolicyFlowPeakdatarateRadioLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_FLOW_PEAKDATARATE_RES, OnPolicyFlowPeakdatarateRes)
|
||
ON_WM_KILLFOCUS()
|
||
//}}AFX_MSG_MAP
|
||
END_MESSAGE_MAP()
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CPgPolicyFlow message handlers
|
||
|
||
BOOL CPgPolicyFlow::OnInitDialog()
|
||
{
|
||
//------------------
|
||
// per flow
|
||
|
||
// data rate
|
||
if(m_spData->GetFlags(ATTR_FLAG_LOAD, ACS_PAF_PF_TOKENRATE))
|
||
{
|
||
if IS_LARGE_UNLIMIT(m_spData->m_ddPFTokenRate)
|
||
m_nDataRateChoice = 0;
|
||
else
|
||
{
|
||
m_nDataRateChoice = 2; // numbered limit
|
||
m_uDataRate = TOKBS(m_spData->m_ddPFTokenRate.LowPart);
|
||
}
|
||
}
|
||
else
|
||
m_nDataRateChoice = 1; // default
|
||
|
||
// Peak data rate
|
||
if(m_spData->GetFlags(ATTR_FLAG_LOAD, ACS_PAF_PF_PEAKBANDWIDTH))
|
||
{
|
||
if IS_LARGE_UNLIMIT(m_spData->m_ddPFPeakBandWidth)
|
||
m_nPeakRateChoice = 0;
|
||
else
|
||
{
|
||
m_nPeakRateChoice = 2; // numbered limit
|
||
m_uPeakRate = TOKBS(m_spData->m_ddPFPeakBandWidth.LowPart);
|
||
}
|
||
}
|
||
else
|
||
m_nPeakRateChoice = 1; // default
|
||
|
||
// duration
|
||
if(m_spData->GetFlags(ATTR_FLAG_LOAD, ACS_PAF_PF_DURATION))
|
||
{
|
||
if(m_spData->m_dwPFDuration == UNLIMIT)
|
||
m_nDurationChoice = 0;
|
||
else
|
||
{
|
||
m_nDurationChoice = 2;
|
||
m_uDuration = SEC2MIN(m_spData->m_dwPFDuration);
|
||
}
|
||
}
|
||
else
|
||
m_nDurationChoice = 1;
|
||
|
||
// ==== data exchange is done within here
|
||
CACSPage::OnInitDialog();
|
||
|
||
if(m_nDataRateChoice != 2)
|
||
m_editDataRate.EnableWindow(FALSE);
|
||
|
||
if(m_nPeakRateChoice != 2)
|
||
m_editPeakRate.EnableWindow(FALSE);
|
||
|
||
if(m_nDurationChoice != 2)
|
||
m_editDuration.EnableWindow(FALSE);
|
||
|
||
GetDlgItem(IDC_POLICY_FLOW_DATARATE_DEF)->GetWindowText(m_strDataRateDefault);
|
||
GetDlgItem(IDC_POLICY_FLOW_PEAKDATARATE_DEF)->GetWindowText(m_strPeakRateDefault);
|
||
GetDlgItem(IDC_POLICY_FLOW_DURATION_DEF)->GetWindowText(m_strDurationDefault);
|
||
|
||
return TRUE; // return TRUE unless you set the focus to a control
|
||
// EXCEPTION: OCX Property Pages should return FALSE
|
||
}
|
||
|
||
BOOL CPgPolicyFlow::OnSetActive( )
|
||
{
|
||
// change default button strings based on choice of user
|
||
CString datarateStr = m_strDataRateDefault;
|
||
CString peakrateStr = m_strPeakRateDefault;
|
||
CString durationStr = m_strDurationDefault;
|
||
|
||
if ((m_nBranchFlag & BRANCH_FLAG_GLOBAL) != 0) // may need to alter the text
|
||
{
|
||
CString tmp;
|
||
|
||
ASSERT(m_pGeneralPage);
|
||
|
||
if(m_pGeneralPage->IfAnyAuth())
|
||
{
|
||
tmp.LoadString(IDS_A_DEF_DATARATE_SUF);
|
||
datarateStr += tmp;
|
||
tmp.LoadString(IDS_A_DEF_PEAKRATE_SUF);
|
||
peakrateStr += tmp;
|
||
tmp.LoadString(IDS_A_DEF_DURATION_SUF);
|
||
durationStr += tmp;
|
||
}
|
||
else if (m_pGeneralPage->IfAnyUnauth())
|
||
{
|
||
tmp.LoadString(IDS_U_DEF_DATARATE_SUF);
|
||
datarateStr += tmp;
|
||
tmp.LoadString(IDS_U_DEF_PEAKRATE_SUF);
|
||
peakrateStr += tmp;
|
||
tmp.LoadString(IDS_U_DEF_DURATION_SUF);
|
||
durationStr += tmp;
|
||
}
|
||
}
|
||
|
||
// test if the policy is for any authentication/unauthenticaion policy in enterprise level
|
||
GetDlgItem(IDC_POLICY_FLOW_DATARATE_DEF)->SetWindowText(datarateStr);
|
||
GetDlgItem(IDC_POLICY_FLOW_PEAKDATARATE_DEF)->SetWindowText(peakrateStr);
|
||
GetDlgItem(IDC_POLICY_FLOW_DURATION_DEF)->SetWindowText(durationStr);
|
||
|
||
return CACSPage::OnSetActive();
|
||
}
|
||
|
||
|
||
BOOL CPgPolicyFlow::OnKillActive( )
|
||
{
|
||
UINT cId = 0;
|
||
UINT mId = 0;
|
||
|
||
if(!UpdateData())
|
||
return FALSE;
|
||
|
||
// Peak Rate should be >= data rate
|
||
if(m_nPeakRateChoice ==2 && m_nDataRateChoice == 2 && m_uDataRate > m_uPeakRate)
|
||
{
|
||
cId = IDC_POLICY_FLOW_PEAKDATARATE_EDIT_LIMIT;
|
||
mId = IDS_ERR_PEAKRATE_LESS_RATE;
|
||
}
|
||
|
||
if ((m_nBranchFlag & BRANCH_FLAG_GLOBAL) != 0) // need to check again default value
|
||
{
|
||
CString tmp;
|
||
|
||
ASSERT(m_pGeneralPage);
|
||
|
||
if(m_pGeneralPage->IfAnyAuth())
|
||
{
|
||
// Peak Rate should be >= data rate
|
||
if(m_nPeakRateChoice ==2 && m_nDataRateChoice == 1 && DEFAULT_AA_DATARATE > FROMKBS(m_uPeakRate))
|
||
{
|
||
cId = IDC_POLICY_FLOW_PEAKDATARATE_EDIT_LIMIT;
|
||
mId = IDS_ERR_PEAKRATE_LESS_RATE;
|
||
}
|
||
}
|
||
else if (m_pGeneralPage->IfAnyUnauth())
|
||
{
|
||
// Peak Rate should be >= data rate
|
||
if(m_nPeakRateChoice ==2 && m_nDataRateChoice == 1 && DEFAULT_AU_DATARATE > FROMKBS(m_uPeakRate))
|
||
{
|
||
cId = IDC_POLICY_FLOW_PEAKDATARATE_EDIT_LIMIT;
|
||
mId = IDS_ERR_PEAKRATE_LESS_RATE;
|
||
}
|
||
}
|
||
}
|
||
// if there is anything wrong
|
||
if(cId)
|
||
{
|
||
CWnd* pWnd = GetDlgItem(cId);
|
||
|
||
ASSERT(pWnd);
|
||
GotoDlgCtrl( pWnd );
|
||
|
||
AfxMessageBox(mId);
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
// check if any is set to Zero
|
||
if(m_nDataRateChoice == 2 && m_uDataRate == 0) // date rate
|
||
{
|
||
cId = IDC_POLICY_FLOW_DATARATE_EDIT_LIMIT;
|
||
mId = IDS_WRN_ZERO_POLICY_DATA;
|
||
}
|
||
else if(m_nPeakRateChoice ==2 && m_uPeakRate == 0) // peak data rate
|
||
{
|
||
cId = IDC_POLICY_FLOW_PEAKDATARATE_EDIT_LIMIT;
|
||
mId = IDS_WRN_ZERO_POLICY_DATA;
|
||
}
|
||
else if(m_nDurationChoice == 2 && m_uDuration == 0) // duration
|
||
{
|
||
cId = IDC_POLICY_FLOW_DURATION_EDIT_LIMIT;
|
||
mId = IDS_WRN_ZERO_POLICY_DATA;
|
||
}
|
||
|
||
if(cId)
|
||
{
|
||
|
||
if(IDNO == AfxMessageBox(mId, MB_YESNO))
|
||
{
|
||
CWnd* pWnd = GetDlgItem(cId);
|
||
|
||
ASSERT(pWnd);
|
||
GotoDlgCtrl( pWnd );
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
return CACSPage::OnKillActive();
|
||
|
||
}
|
||
|
||
// radio buttons here, 0 -- no limit (resouce limit ) , 1 -- default to general level, 2 -- user limit
|
||
//
|
||
BOOL CPgPolicyFlow::OnApply()
|
||
{
|
||
CString* pStr = NULL;
|
||
// check if the values input on the page is valid
|
||
UINT cId = 0;
|
||
UINT mId = 0;
|
||
|
||
if(!GetModified()) return TRUE;
|
||
|
||
// Peak Rate should be >= data rate
|
||
if(m_nPeakRateChoice ==2 && m_nDataRateChoice == 2 && m_uDataRate > m_uPeakRate)
|
||
{
|
||
cId = IDC_POLICY_FLOW_PEAKDATARATE_EDIT_LIMIT;
|
||
mId = IDS_ERR_PEAKRATE_LESS_RATE;
|
||
}
|
||
|
||
// if there is anything wrong
|
||
if(cId)
|
||
{
|
||
CWnd* pWnd = GetDlgItem(cId);
|
||
|
||
ASSERT(pWnd);
|
||
GotoDlgCtrl( pWnd );
|
||
|
||
AfxMessageBox(mId);
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
//------------------
|
||
// per flow
|
||
|
||
// data rate
|
||
switch(m_nDataRateChoice){
|
||
case 2: // limit
|
||
m_spData->m_ddPFTokenRate.LowPart = FROMKBS(m_uDataRate);
|
||
m_spData->m_ddPFTokenRate.HighPart = 0;
|
||
break;
|
||
case 1: // default
|
||
break;
|
||
case 0: // unlimit
|
||
SET_LARGE_UNLIMIT(m_spData->m_ddPFTokenRate);
|
||
break;
|
||
default:
|
||
ASSERT(0);
|
||
};
|
||
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_PF_TOKENRATE, (m_nDataRateChoice != 1));
|
||
|
||
// Peak data rate
|
||
switch(m_nPeakRateChoice){
|
||
case 2: // limit
|
||
m_spData->m_ddPFPeakBandWidth.LowPart = FROMKBS(m_uPeakRate);
|
||
m_spData->m_ddPFPeakBandWidth.HighPart = 0;
|
||
break;
|
||
case 1: // default
|
||
break;
|
||
case 0: // unlimit
|
||
SET_LARGE_UNLIMIT(m_spData->m_ddPFPeakBandWidth);
|
||
break;
|
||
default:
|
||
ASSERT(0);
|
||
};
|
||
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_PF_PEAKBANDWIDTH, (m_nPeakRateChoice != 1));
|
||
|
||
// duration
|
||
switch(m_nDurationChoice){
|
||
case 2: // limit
|
||
m_spData->m_dwPFDuration = MIN2SEC(m_uDuration);
|
||
break;
|
||
case 1: // default
|
||
break;
|
||
case 0: // unlimit
|
||
m_spData->m_dwPFDuration = UNLIMIT;
|
||
break;
|
||
default:
|
||
ASSERT(0);
|
||
};
|
||
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_PF_DURATION, (m_nDurationChoice != 1));
|
||
|
||
DWORD dwAttrFlags = 0;
|
||
dwAttrFlags |= (ACS_PAF_PF_TOKENRATE | ACS_PAF_PF_PEAKBANDWIDTH | ACS_PAF_PF_DURATION);
|
||
|
||
AddFlags(dwAttrFlags); // prepare flags for saving
|
||
|
||
return CACSPage::OnApply();
|
||
}
|
||
|
||
void CPgPolicyFlow::OnPolicyFlowDatarateDef()
|
||
{
|
||
SetModified();
|
||
m_editDataRate.EnableWindow(FALSE);
|
||
}
|
||
|
||
void CPgPolicyFlow::OnChangePolicyFlowDatarateEditLimit()
|
||
{
|
||
// TODO: If this is a RICHEDIT control, the control will not
|
||
// send this notification unless you override the CACSPage::OnInitDialog()
|
||
// function to send the EM_SETEVENTMASK message to the control
|
||
// with the ENM_CHANGE flag ORed into the lParam mask.
|
||
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
|
||
}
|
||
|
||
void CPgPolicyFlow::OnPolicyFlowDatarateRadioLimit()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
m_editDataRate.EnableWindow(TRUE);
|
||
}
|
||
|
||
void CPgPolicyFlow::OnPolicyFlowDatarateRes()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
m_editDataRate.EnableWindow(FALSE);
|
||
}
|
||
|
||
void CPgPolicyFlow::OnPolicyFlowDurationDef()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
m_editDuration.EnableWindow(FALSE);
|
||
|
||
SetModified();
|
||
|
||
}
|
||
|
||
void CPgPolicyFlow::OnChangePolicyFlowDurationEditLimit()
|
||
{
|
||
// TODO: If this is a RICHEDIT control, the control will not
|
||
// send this notification unless you override the CACSPage::OnInitDialog()
|
||
// function to send the EM_SETEVENTMASK message to the control
|
||
// with the ENM_CHANGE flag ORed into the lParam mask.
|
||
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
|
||
}
|
||
|
||
void CPgPolicyFlow::OnPolicyFlowDurationRadioLimit()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
m_editDuration.EnableWindow(TRUE);
|
||
SetModified();
|
||
|
||
}
|
||
|
||
void CPgPolicyFlow::OnPolicyFlowDurationRes()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
m_editDuration.EnableWindow(FALSE);
|
||
|
||
SetModified();
|
||
}
|
||
|
||
void CPgPolicyFlow::OnPolicyFlowPeakdatarateDef()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
m_editPeakRate.EnableWindow(FALSE);
|
||
|
||
SetModified();
|
||
}
|
||
|
||
void CPgPolicyFlow::OnChangePolicyFlowPeakdatarateEditLimit()
|
||
{
|
||
// TODO: If this is a RICHEDIT control, the control will not
|
||
// send this notification unless you override the CACSPage::OnInitDialog()
|
||
// function to send the EM_SETEVENTMASK message to the control
|
||
// with the ENM_CHANGE flag ORed into the lParam mask.
|
||
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
|
||
}
|
||
|
||
void CPgPolicyFlow::OnPolicyFlowPeakdatarateRadioLimit()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
m_editPeakRate.EnableWindow(TRUE);
|
||
|
||
SetModified();
|
||
}
|
||
|
||
void CPgPolicyFlow::OnPolicyFlowPeakdatarateRes()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
|
||
m_editPeakRate.EnableWindow(FALSE);
|
||
SetModified();
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CPgPolicyAggregate dialog
|
||
|
||
CPgPolicyAggregate::CPgPolicyAggregate(CACSPolicyElement* pData) : CACSPage(CPgPolicyAggregate::IDD)
|
||
{
|
||
ASSERT(pData);
|
||
m_spData = pData;
|
||
DataInit();
|
||
}
|
||
|
||
|
||
CPgPolicyAggregate::CPgPolicyAggregate()
|
||
: CACSPage(CPgPolicyAggregate::IDD)
|
||
{
|
||
DataInit();
|
||
}
|
||
|
||
void CPgPolicyAggregate::DataInit()
|
||
{
|
||
//{{AFX_DATA_INIT(CPgPolicyAggregate)
|
||
m_nDataRateChoice = -1;
|
||
m_nFlowsChoice = -1;
|
||
m_nPeakRateChoice = -1;
|
||
m_uDataRate = 0;
|
||
m_uFlows = 0;
|
||
m_uPeakRate = 0;
|
||
//}}AFX_DATA_INIT
|
||
|
||
|
||
m_nBranchFlag = 0;
|
||
m_pGeneralPage = NULL;
|
||
|
||
}
|
||
|
||
|
||
void CPgPolicyAggregate::DoDataExchange(CDataExchange* pDX)
|
||
{
|
||
CACSPage::DoDataExchange(pDX);
|
||
//{{AFX_DATA_MAP(CPgPolicyAggregate)
|
||
DDX_Control(pDX, IDC_POLICY_AGGR_PEAKDATARATE_EDIT_LIMIT, m_editPeakRate);
|
||
DDX_Control(pDX, IDC_POLICY_AGGR_FLOWS_EDIT_LIMIT, m_editFlows);
|
||
DDX_Control(pDX, IDC_POLICY_AGGR_DATARATE_EDIT_LIMIT, m_editDataRate);
|
||
DDX_Radio(pDX, IDC_POLICY_AGGR_DATARATE_RES, m_nDataRateChoice);
|
||
DDX_Radio(pDX, IDC_POLICY_AGGR_FLOWS_RES, m_nFlowsChoice);
|
||
DDX_Radio(pDX, IDC_POLICY_AGGR_PEAKDATARATE_RES, m_nPeakRateChoice);
|
||
|
||
DDX_Text(pDX, IDC_POLICY_AGGR_DATARATE_EDIT_LIMIT, m_uDataRate);
|
||
if(m_nDataRateChoice == 2)
|
||
DDV_MinMaxUInt(pDX, m_uDataRate, 0, DWORD_LIMIT/1024);
|
||
|
||
|
||
DDX_Text(pDX, IDC_POLICY_AGGR_FLOWS_EDIT_LIMIT, m_uFlows);
|
||
if(m_nFlowsChoice == 2)
|
||
DDV_MinMaxUInt(pDX, m_uFlows, 0, DWORD_LIMIT);
|
||
|
||
DDX_Text(pDX, IDC_POLICY_AGGR_PEAKDATARATE_EDIT_LIMIT, m_uPeakRate);
|
||
if(m_nPeakRateChoice == 2)
|
||
DDV_MinMaxUInt(pDX, m_uPeakRate, 0, DWORD_LIMIT/1024);
|
||
//}}AFX_DATA_MAP
|
||
}
|
||
|
||
|
||
BEGIN_MESSAGE_MAP(CPgPolicyAggregate, CACSPage)
|
||
//{{AFX_MSG_MAP(CPgPolicyAggregate)
|
||
ON_BN_CLICKED(IDC_POLICY_AGGR_DATARATE_DEF, OnPolicyAggrDatarateDef)
|
||
ON_EN_CHANGE(IDC_POLICY_AGGR_DATARATE_EDIT_LIMIT, OnChangePolicyAggrDatarateEditLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_AGGR_DATARATE_RADIO_LIMIT, OnPolicyAggrDatarateRadioLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_AGGR_DATARATE_RES, OnPolicyAggrDatarateRes)
|
||
ON_BN_CLICKED(IDC_POLICY_AGGR_FLOWS_DEF, OnPolicyAggrFlowsDef)
|
||
ON_EN_CHANGE(IDC_POLICY_AGGR_FLOWS_EDIT_LIMIT, OnChangePolicyAggrFlowsEditLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_AGGR_FLOWS_RES, OnPolicyAggrFlowsRes)
|
||
ON_BN_CLICKED(IDC_POLICY_AGGR_PEAKDATARATE_DEF, OnPolicyAggrPeakdatarateDef)
|
||
ON_EN_CHANGE(IDC_POLICY_AGGR_PEAKDATARATE_EDIT_LIMIT, OnChangePolicyAggrPeakdatarateEditLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_AGGR_PEAKDATARATE_RADIO_LIMIT, OnPolicyAggrPeakdatarateRadioLimit)
|
||
ON_BN_CLICKED(IDC_POLICY_AGGR_PEAKDATARATE_RES, OnPolicyAggrPeakdatarateRes)
|
||
ON_BN_CLICKED(IDC_POLICY_AGGR_FLOWS_RADIO_LIMIT, OnPolicyAggrFlowsRadioLimit)
|
||
//}}AFX_MSG_MAP
|
||
END_MESSAGE_MAP()
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CPgPolicyAggregate message handlers
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CPgPolicyFlow message handlers
|
||
|
||
BOOL CPgPolicyAggregate::OnInitDialog()
|
||
{
|
||
//------------------
|
||
// Total
|
||
|
||
// data rate
|
||
if(m_spData->GetFlags(ATTR_FLAG_LOAD, ACS_PAF_TT_TOKENRATE))
|
||
{
|
||
if IS_LARGE_UNLIMIT(m_spData->m_ddTTTokenRate)
|
||
m_nDataRateChoice = 0;
|
||
else
|
||
{
|
||
m_nDataRateChoice = 2; // numbered limit
|
||
m_uDataRate = TOKBS(m_spData->m_ddTTTokenRate.LowPart);
|
||
}
|
||
}
|
||
else
|
||
m_nDataRateChoice = 1; // default
|
||
|
||
// Peak data rate
|
||
if(m_spData->GetFlags(ATTR_FLAG_LOAD, ACS_PAF_TT_PEAKBANDWIDTH))
|
||
{
|
||
if IS_LARGE_UNLIMIT(m_spData->m_ddTTPeakBandWidth)
|
||
m_nPeakRateChoice = 0;
|
||
else
|
||
{
|
||
m_nPeakRateChoice = 2; // numbered limit
|
||
m_uPeakRate = TOKBS(m_spData->m_ddTTPeakBandWidth.LowPart);
|
||
}
|
||
}
|
||
else
|
||
m_nPeakRateChoice = 1; // default
|
||
|
||
// flows
|
||
if(m_spData->GetFlags(ATTR_FLAG_LOAD, ACS_PAF_TT_FLOWS))
|
||
{
|
||
if(m_spData->m_dwTTFlows == UNLIMIT)
|
||
m_nFlowsChoice = 0;
|
||
else
|
||
{
|
||
m_nFlowsChoice = 2;
|
||
m_uFlows = m_spData->m_dwTTFlows;
|
||
}
|
||
}
|
||
else
|
||
m_nFlowsChoice = 1;
|
||
|
||
CACSPage::OnInitDialog();
|
||
|
||
|
||
if(m_nDataRateChoice != 2)
|
||
m_editDataRate.EnableWindow(FALSE);
|
||
|
||
if(m_nPeakRateChoice != 2)
|
||
m_editPeakRate.EnableWindow(FALSE);
|
||
|
||
if(m_nFlowsChoice != 2)
|
||
m_editFlows.EnableWindow(FALSE);
|
||
|
||
GetDlgItem(IDC_POLICY_AGGR_DATARATE_DEF)->GetWindowText(m_strDataRateDefault);
|
||
GetDlgItem(IDC_POLICY_AGGR_PEAKDATARATE_DEF)->GetWindowText(m_strPeakRateDefault);
|
||
GetDlgItem(IDC_POLICY_AGGR_FLOWS_DEF)->GetWindowText(m_strFlowsDefault);
|
||
|
||
return TRUE; // return TRUE unless you set the focus to a control
|
||
// EXCEPTION: OCX Property Pages should return FALSE
|
||
}
|
||
|
||
BOOL CPgPolicyAggregate::OnSetActive( )
|
||
{
|
||
// change default button strings based on choice of user
|
||
CString datarateStr = m_strDataRateDefault;
|
||
CString peakrateStr = m_strPeakRateDefault;
|
||
CString flowsStr = m_strFlowsDefault;
|
||
|
||
if ((m_nBranchFlag & BRANCH_FLAG_GLOBAL) != 0) // may need to alter the text
|
||
{
|
||
CString tmp;
|
||
ASSERT(m_pGeneralPage);
|
||
|
||
if(m_pGeneralPage->IfAnyAuth())
|
||
{
|
||
tmp.LoadString(IDS_A_DEF_DATARATE_SUF);
|
||
datarateStr += tmp;
|
||
tmp.LoadString(IDS_A_DEF_PEAKRATE_SUF);
|
||
peakrateStr += tmp;
|
||
tmp.LoadString(IDS_A_DEF_FLOWS_SUF);
|
||
flowsStr += tmp;
|
||
}
|
||
else if (m_pGeneralPage->IfAnyUnauth())
|
||
{
|
||
tmp.LoadString(IDS_U_DEF_DATARATE_SUF);
|
||
datarateStr += tmp;
|
||
tmp.LoadString(IDS_U_DEF_PEAKRATE_SUF);
|
||
peakrateStr += tmp;
|
||
tmp.LoadString(IDS_U_DEF_FLOWS_SUF);
|
||
flowsStr += tmp;
|
||
}
|
||
}
|
||
|
||
// test if the policy is for any authentication/unauthenticaion policy in enterprise level
|
||
GetDlgItem(IDC_POLICY_AGGR_DATARATE_DEF)->SetWindowText(datarateStr);
|
||
GetDlgItem(IDC_POLICY_AGGR_PEAKDATARATE_DEF)->SetWindowText(peakrateStr);
|
||
GetDlgItem(IDC_POLICY_AGGR_FLOWS_DEF)->SetWindowText(flowsStr);
|
||
|
||
|
||
return CACSPage::OnSetActive();
|
||
}
|
||
|
||
|
||
|
||
BOOL CPgPolicyAggregate::OnKillActive( )
|
||
{
|
||
// check if the values input on the page is valid
|
||
UINT cId = 0;
|
||
UINT mId = 0;
|
||
|
||
if(!UpdateData(TRUE)) return FALSE;
|
||
if(!GetModified()) return TRUE;
|
||
|
||
// Peak Rate should be >= data rate
|
||
if(m_nPeakRateChoice ==2 && m_nDataRateChoice == 2 && m_uDataRate > m_uPeakRate)
|
||
{
|
||
cId = IDC_POLICY_AGGR_PEAKDATARATE_EDIT_LIMIT;
|
||
mId = IDS_ERR_TOTALPEAK_LESS_TOTALRATE;
|
||
}
|
||
|
||
if ((m_nBranchFlag & BRANCH_FLAG_GLOBAL) != 0) // need to check again default value
|
||
{
|
||
CString tmp;
|
||
|
||
ASSERT(m_pGeneralPage);
|
||
|
||
if(m_pGeneralPage->IfAnyAuth())
|
||
{
|
||
// Peak Rate should be >= data rate
|
||
if(m_nPeakRateChoice ==2 && m_nDataRateChoice == 1 && DEFAULT_AA_DATARATE > FROMKBS(m_uPeakRate))
|
||
{
|
||
cId = IDC_POLICY_AGGR_PEAKDATARATE_EDIT_LIMIT;
|
||
mId = IDS_ERR_TOTALPEAK_LESS_TOTALRATE;
|
||
}
|
||
}
|
||
else if (m_pGeneralPage->IfAnyUnauth())
|
||
{
|
||
// Peak Rate should be >= data rate
|
||
if(m_nPeakRateChoice ==2 && m_nDataRateChoice == 1 && DEFAULT_AU_DATARATE > FROMKBS(m_uPeakRate))
|
||
{
|
||
cId = IDC_POLICY_AGGR_PEAKDATARATE_EDIT_LIMIT;
|
||
mId = IDS_ERR_TOTALPEAK_LESS_TOTALRATE;
|
||
}
|
||
}
|
||
}
|
||
// if there is anything wrong
|
||
if(cId)
|
||
{
|
||
CWnd* pWnd = GetDlgItem(cId);
|
||
|
||
ASSERT(pWnd);
|
||
GotoDlgCtrl( pWnd );
|
||
|
||
AfxMessageBox(mId);
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
// check if any is set to Zero
|
||
if(m_nDataRateChoice == 2 && m_uDataRate == 0) // date rate
|
||
{
|
||
cId = IDC_POLICY_AGGR_DATARATE_EDIT_LIMIT;
|
||
mId = IDS_WRN_ZERO_POLICY_DATA;
|
||
}
|
||
else if(m_nPeakRateChoice ==2 && m_uPeakRate == 0) // peak data rate
|
||
{
|
||
cId = IDC_POLICY_AGGR_PEAKDATARATE_EDIT_LIMIT;
|
||
mId = IDS_WRN_ZERO_POLICY_DATA;
|
||
}
|
||
else if(m_nFlowsChoice == 2 && m_uFlows == 0) // duration
|
||
{
|
||
cId = IDC_POLICY_AGGR_FLOWS_EDIT_LIMIT;
|
||
mId = IDS_WRN_ZERO_POLICY_DATA;
|
||
}
|
||
|
||
if(cId)
|
||
{
|
||
|
||
if(IDNO == AfxMessageBox(mId, MB_YESNO))
|
||
{
|
||
CWnd* pWnd = GetDlgItem(cId);
|
||
|
||
ASSERT(pWnd);
|
||
GotoDlgCtrl( pWnd );
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
|
||
return CACSPage::OnKillActive();
|
||
|
||
}
|
||
|
||
// radio buttons here, 0 -- no limit (resouce limit ) , 1 -- default to general level, 2 -- user limit
|
||
//
|
||
BOOL CPgPolicyAggregate::OnApply()
|
||
{
|
||
CString* pStr = NULL;
|
||
// check if the values input on the page is valid
|
||
UINT cId = 0;
|
||
UINT mId = 0;
|
||
|
||
if(!GetModified()) return TRUE;
|
||
|
||
// Peak Rate should be >= data rate
|
||
if(m_nPeakRateChoice ==2 && m_nDataRateChoice == 2 && m_uDataRate > m_uPeakRate)
|
||
{
|
||
cId = IDC_POLICY_AGGR_PEAKDATARATE_EDIT_LIMIT;
|
||
mId = IDS_ERR_TOTALPEAK_LESS_TOTALRATE;
|
||
}
|
||
|
||
// if there is anything wrong
|
||
if(cId)
|
||
{
|
||
CWnd* pWnd = GetDlgItem(cId);
|
||
|
||
ASSERT(pWnd);
|
||
GotoDlgCtrl( pWnd );
|
||
|
||
AfxMessageBox(mId);
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
//------------------
|
||
// per flow
|
||
|
||
// data rate
|
||
switch(m_nDataRateChoice){
|
||
case 2: // limit
|
||
m_spData->m_ddTTTokenRate.LowPart = FROMKBS(m_uDataRate);
|
||
m_spData->m_ddTTTokenRate.HighPart = 0;
|
||
break;
|
||
case 1: // default
|
||
break;
|
||
case 0: // unlimit
|
||
SET_LARGE_UNLIMIT(m_spData->m_ddTTTokenRate);
|
||
break;
|
||
default:
|
||
ASSERT(0);
|
||
};
|
||
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_TT_TOKENRATE, (m_nDataRateChoice != 1));
|
||
|
||
// Peak data rate
|
||
switch(m_nPeakRateChoice){
|
||
case 2: // limit
|
||
m_spData->m_ddTTPeakBandWidth.LowPart = FROMKBS(m_uPeakRate);
|
||
m_spData->m_ddTTPeakBandWidth.HighPart = 0;
|
||
break;
|
||
case 1: // default
|
||
break;
|
||
case 0: // unlimit
|
||
SET_LARGE_UNLIMIT(m_spData->m_ddTTPeakBandWidth);
|
||
break;
|
||
default:
|
||
ASSERT(0);
|
||
};
|
||
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_TT_PEAKBANDWIDTH, (m_nPeakRateChoice != 1));
|
||
|
||
// duration
|
||
switch(m_nFlowsChoice){
|
||
case 2: // limit
|
||
m_spData->m_dwTTFlows = m_uFlows;
|
||
break;
|
||
case 1: // default
|
||
break;
|
||
case 0: // unlimit
|
||
m_spData->m_dwTTFlows = UNLIMIT;
|
||
break;
|
||
default:
|
||
ASSERT(0);
|
||
};
|
||
|
||
m_spData->SetFlags(ATTR_FLAG_SAVE, ACS_PAF_TT_FLOWS, (m_nFlowsChoice != 1));
|
||
|
||
DWORD dwAttrFlags = 0;
|
||
dwAttrFlags |= (ACS_PAF_TT_TOKENRATE | ACS_PAF_TT_PEAKBANDWIDTH | ACS_PAF_TT_FLOWS);
|
||
|
||
AddFlags(dwAttrFlags); // prepare flags for saving
|
||
|
||
|
||
return CACSPage::OnApply();
|
||
}
|
||
|
||
|
||
|
||
void CPgPolicyAggregate::OnPolicyAggrDatarateDef()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
m_editDataRate.EnableWindow(FALSE);
|
||
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnChangePolicyAggrDatarateEditLimit()
|
||
{
|
||
// TODO: If this is a RICHEDIT control, the control will not
|
||
// send this notification unless you override the CACSPage::OnInitDialog()
|
||
// function to send the EM_SETEVENTMASK message to the control
|
||
// with the ENM_CHANGE flag ORed into the lParam mask.
|
||
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnPolicyAggrDatarateRadioLimit()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
|
||
SetModified();
|
||
m_editDataRate.EnableWindow(TRUE);
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnPolicyAggrDatarateRes()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
m_editDataRate.EnableWindow(FALSE);
|
||
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnPolicyAggrFlowsDef()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
m_editFlows.EnableWindow(FALSE);
|
||
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnChangePolicyAggrFlowsEditLimit()
|
||
{
|
||
// TODO: If this is a RICHEDIT control, the control will not
|
||
// send this notification unless you override the CACSPage::OnInitDialog()
|
||
// function to send the EM_SETEVENTMASK message to the control
|
||
// with the ENM_CHANGE flag ORed into the lParam mask.
|
||
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnPolicyAggrFlowsRes()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
m_editFlows.EnableWindow(FALSE);
|
||
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnPolicyAggrFlowsRadioLimit()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
m_editFlows.EnableWindow(TRUE);
|
||
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnPolicyAggrPeakdatarateDef()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
m_editPeakRate.EnableWindow(FALSE);
|
||
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnChangePolicyAggrPeakdatarateEditLimit()
|
||
{
|
||
// TODO: If this is a RICHEDIT control, the control will not
|
||
// send this notification unless you override the CACSPage::OnInitDialog()
|
||
// function to send the EM_SETEVENTMASK message to the control
|
||
// with the ENM_CHANGE flag ORed into the lParam mask.
|
||
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnPolicyAggrPeakdatarateRadioLimit()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
m_editPeakRate.EnableWindow(TRUE);
|
||
|
||
}
|
||
|
||
void CPgPolicyAggregate::OnPolicyAggrPeakdatarateRes()
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
SetModified();
|
||
m_editPeakRate.EnableWindow(FALSE);
|
||
|
||
}
|
||
|
||
|
||
void CPgPolicyFlow::OnKillFocus(CWnd* pNewWnd)
|
||
{
|
||
CACSPage::OnKillFocus(pNewWnd);
|
||
|
||
// TODO: Add your message handler code here
|
||
|
||
}
|
||
|