able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/cluster/admin/cluadmin/barfdlg.cpp

940 lines
24 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 1996-2000 Microsoft Corporation
//
// Module Name:
// BarfDlg.cpp
//
// Abstract:
// Implementation of the Basic Artifical Resource Failure dialog classes.
//
// Author:
// David Potter (davidp) April 11, 1997
//
// Revision History:
//
// Notes:
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "resource.h"
#define _RESOURCE_H_
#define _NO_BARF_DEFINITIONS_
#include "Barf.h"
#include "BarfDlg.h"
#include "TraceTag.h"
#include "ExcOper.h"
#ifdef _USING_BARF_
#error BARF failures should be disabled!
#endif
#ifdef _DEBUG // The entire file!
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
/////////////////////////////////////////////////////////////////////////////
// Global Variables
/////////////////////////////////////////////////////////////////////////////
CTraceTag g_tagBarfDialog(_T("Debug"), _T("BARF Dialog"), 0);
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CBarfDialog
/////////////////////////////////////////////////////////////////////////////
CBarfDialog * CBarfDialog::s_pdlg = NULL;
HICON CBarfDialog::s_hicon = NULL;
/////////////////////////////////////////////////////////////////////////////
// Message Maps
BEGIN_MESSAGE_MAP(CBarfDialog, CDialog)
//{{AFX_MSG_MAP(CBarfDialog)
ON_BN_CLICKED(IDC_BS_RESET_CURRENT_COUNT, OnResetCurrentCount)
ON_BN_CLICKED(IDC_BS_RESET_ALL_COUNTS, OnResetAllCounts)
ON_BN_CLICKED(IDC_BS_GLOBAL_ENABLE, OnGlobalEnable)
ON_NOTIFY(LVN_ITEMCHANGED, IDC_BS_CATEGORIES_LIST, OnItemChanged)
ON_BN_CLICKED(IDC_BS_CONTINUOUS, OnStatusChange)
ON_BN_CLICKED(IDC_BS_DISABLE, OnStatusChange)
ON_EN_CHANGE(IDC_BS_FAIL_AT, OnStatusChange)
ON_WM_CLOSE()
//}}AFX_MSG_MAP
ON_COMMAND(IDCANCEL, OnCancel)
ON_MESSAGE(WM_USER+5, OnBarfUpdate)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::CBarfDialog
//
// Routine Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CBarfDialog::CBarfDialog(void)
{
//{{AFX_DATA_INIT(CBarfDialog)
m_nFailAt = 0;
m_bContinuous = FALSE;
m_bDisable = FALSE;
m_bGlobalEnable = FALSE;
//}}AFX_DATA_INIT
Trace(g_tagBarfDialog, _T("CBarfDialog::CBarfDialog"));
m_pbarfSelected = NULL;
} //*** CBarfDialog::CBarfDialog()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::Create
//
// Routine Description:
// Modeless dialog creation method.
//
// Arguments:
// pParentWnd [IN OUT] Parent window for the dialog.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CBarfDialog::Create(
IN OUT CWnd * pParentWnd //=NULL
)
{
Trace(g_tagBarfDialog, _T("CBarfDialog::Create"));
return CDialog::Create(IDD, pParentWnd);
} //*** CBarfDialog::Create()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::DoDataExchange
//
// Routine Description:
// Do data exchange between the dialog and the class.
//
// Arguments:
// pDX [IN OUT] Data exchange object
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::DoDataExchange(CDataExchange * pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CBarfDialog)
DDX_Control(pDX, IDC_BS_GLOBAL_ENABLE, m_ckbGlobalEnable);
DDX_Control(pDX, IDC_BS_DISABLE, m_ckbDisable);
DDX_Control(pDX, IDC_BS_CONTINUOUS, m_ckbContinuous);
DDX_Control(pDX, IDC_BS_CATEGORIES_LIST, m_lcCategories);
DDX_Text(pDX, IDC_BS_FAIL_AT, m_nFailAt);
DDX_Check(pDX, IDC_BS_CONTINUOUS, m_bContinuous);
DDX_Check(pDX, IDC_BS_DISABLE, m_bDisable);
DDX_Check(pDX, IDC_BS_GLOBAL_ENABLE, m_bGlobalEnable);
//}}AFX_DATA_MAP
if (pDX->m_bSaveAndValidate)
{
} // if: saving data from the dialog
else
{
int ili;
CBarf * pbarf;
CString str;
ili = m_lcCategories.GetNextItem(-1, LVNI_SELECTED);
if (ili == -1)
ili = m_lcCategories.GetNextItem(-1, LVNI_FOCUSED);
if (ili != -1)
{
pbarf = (CBarf *) m_lcCategories.GetItemData(ili);
// Set the current count.
str.Format(_T("%d"), pbarf->NCurrent());
VERIFY(m_lcCategories.SetItemText(ili, 1, str));
// Set the failure point.
str.Format(_T("%d"), pbarf->NFail());
VERIFY(m_lcCategories.SetItemText(ili, 2, str));
} // if: there is an item with focus
} // else: setting data to the dialog
} //*** CBarfDialog::DoDataExchange()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::OnInitDialog
//
// Routine Description:
// Handler for the WM_INITDIALOG message.
//
// Arguments:
// None.
//
// Return Value:
// TRUE Focus needs to be set.
// FALSE Focus already set.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CBarfDialog::OnInitDialog(void)
{
// Call the base class.
CDialog::OnInitDialog();
ASSERT(Pdlg() == NULL);
s_pdlg = this;
// Set the post update function to point to our static function.
CBarf::SetPostUpdateFn(&PostUpdate);
CBarf::SetSpecialMem(Pdlg());
// Add the columns to the list control.
{
m_lcCategories.InsertColumn(0, _T("Category"), LVCFMT_LEFT, 100);
m_lcCategories.InsertColumn(1, _T("Count"), LVCFMT_LEFT, 50);
m_lcCategories.InsertColumn(2, _T("Fail At"), LVCFMT_LEFT, 50);
} // Add the columns to the list control
// Set-up the dialog based on the real values...
FillList();
OnUpdate();
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
} //*** CBarfDialog::OnInitDialog()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::OnClose
//
// Routine Description:
// Handler method for the WM_CLOSE message.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::OnClose(void)
{
CDialog::OnClose();
DestroyWindow();
} //*** CBarfDialog::OnClose()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::OnCancel
//
// Routine Description:
// Handler method for the WM_COMMAND message when IDCANCEL is sent.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::OnCancel(void)
{
CDialog::OnCancel();
DestroyWindow();
} //*** CBarfDialog::OnCancel()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::PostNcDestroy
//
// Routine Description:
// Processing after non-client has been destroyed.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::PostNcDestroy(void)
{
CDialog::PostNcDestroy();
delete this;
CBarf::ClearPostUpdateFn();
s_pdlg = NULL;
} //*** CBarfDialog::PostNcDestroy()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::FillList
//
// Routine Description:
// Loads the list of failure categories.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::FillList(void)
{
int ili;
int iliReturn;
CString str;
CBarf * pbarf = CBarf::s_pbarfFirst;
CBarfSuspend bs;
m_lcCategories.DeleteAllItems();
for (ili = 0 ; pbarf != NULL ; ili++)
{
// Insert the item.
iliReturn = m_lcCategories.InsertItem(ili, pbarf->PszName());
ASSERT(iliReturn != -1);
// Set the current count.
str.Format(_T("%d"), pbarf->NCurrent());
VERIFY(m_lcCategories.SetItemText(iliReturn, 1, str));
// Set the failure point.
str.Format(_T("%d"), pbarf->NFail());
VERIFY(m_lcCategories.SetItemText(iliReturn, 2, str));
// Set the pointer in the entry so we can retrieve it later.
VERIFY(m_lcCategories.SetItemData(iliReturn, (DWORD) pbarf));
// Advance to the next entry
pbarf = pbarf->m_pbarfNext;
} // while: more BARF entries
// If no known selection yet, get the current selection.
if (m_pbarfSelected == NULL)
{
ili = m_lcCategories.GetNextItem(-1, LVNI_SELECTED);
if (ili == -1)
ili = 0;
m_pbarfSelected = (CBarf *) m_lcCategories.GetItemData(ili);
if (m_pbarfSelected != NULL)
OnUpdate();
} // if: no know selection
// Select the proper item.
{
LV_FINDINFO lvfi = { LVFI_PARAM, NULL, (DWORD) m_pbarfSelected };
ili = m_lcCategories.FindItem(&lvfi);
if (ili != -1)
m_lcCategories.SetItemState(ili, LVIS_SELECTED, LVIS_SELECTED);
} // Select the proper item
} //*** CBarfDialog::FillList()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::OnUpdate
//
// Routine Description:
// Updates the displayed counts to their TRUE values.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::OnUpdate(void)
{
Trace(g_tagBarfDialog, _T("Updating the counts."));
ASSERT(m_pbarfSelected != NULL);
m_bContinuous = m_pbarfSelected->BContinuous();
m_bDisable = m_pbarfSelected->BDisabled();
m_nFailAt = m_pbarfSelected->NFail();
m_bGlobalEnable = CBarf::s_bGlobalEnable;
UpdateData(FALSE /*bSaveAndValidate*/);
} //*** CBarfDialog::OnUpdate()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::OnGlobalEnable
//
// Routine Description:
// Handler function for the BN_CLICKED message on the Global Enable
// checkbox.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::OnGlobalEnable(void)
{
ASSERT(m_ckbGlobalEnable.m_hWnd != NULL);
CBarf::s_bGlobalEnable = m_ckbGlobalEnable.GetCheck() == BST_CHECKED;
} //*** CBarfDialog::OnGlobalEnable()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::OnResetCurrentCount
//
// Routine Description:
// Handler function for the BN_CLICKED message on the Reset Current
// Count button.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::OnResetCurrentCount(void)
{
int ili;
CBarf * pbarf;
ASSERT(m_lcCategories.m_hWnd != NULL);
// Get the selected item.
ili = m_lcCategories.GetNextItem(-1, LVIS_SELECTED);
ASSERT(ili != -1);
pbarf = (CBarf *) m_lcCategories.GetItemData(ili);
ASSERT(pbarf != NULL);
ASSERT(pbarf == m_pbarfSelected);
// Reset the count.
pbarf->m_nCurrent = 0;
OnStatusChange();
} //*** CBarfDialog::OnResetCurrentCount()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::OnResetAllCounts
//
// Routine Description:
// Handler function for the BN_CLICKED message on the Reset All
// Counts button.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::OnResetAllCounts(void)
{
CBarf * pbarf = CBarf::s_pbarfFirst;
Trace(g_tagBarfDialog, _T("Resetting ALL current counts."));
while (pbarf != NULL)
{
pbarf->m_nCurrent = 0;
pbarf = pbarf->m_pbarfNext;
} // while: more BARF entries
FillList();
} //*** CBarfDialog::OnResetAllCounts()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::OnResetAllCounts
//
// Routine Description:
// Handler function for the LVN_ITEMCHANGED message from the list control.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::OnItemChanged(NMHDR * pNMHDR, LRESULT * pResult)
{
NM_LISTVIEW * pNMListView = (NM_LISTVIEW *) pNMHDR;
// If the item just became unselected or selected, change the checkboxes to match.
if ((pNMListView->uChanged & LVIF_STATE)
&& ((pNMListView->uOldState & LVIS_SELECTED)
|| (pNMListView->uNewState & LVIS_SELECTED)))
{
// Handle a selection change.
m_pbarfSelected = (CBarf *) pNMListView->lParam;
OnStatusChange();
} // if: item received the focus
*pResult = 0;
} //*** CBarfDialog::OnItemChanged()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::OnStatusChange
//
// Routine Description:
// Adjusts the C== object when the status of the currently selected
// item changes.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::OnStatusChange(void)
{
ASSERT(m_pbarfSelected != NULL);
UpdateData(TRUE /*bSaveAndValidate*/);
m_pbarfSelected->m_bContinuous = m_bContinuous;
m_pbarfSelected->m_bDisabled = m_bDisable;
m_pbarfSelected->m_nFail = m_nFailAt;
UpdateData(FALSE /*bSaveAndValidate*/);
} //*** CBarfDialog::OnStatusChange()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::OnBarfUpdate
//
// Routine Description:
// Handler for the WM_USER message.
// Processes barf notifications.
//
// Arguments:
// wparam 1st parameter.
// lparam 2nd parameter.
//
// Return Value:
// Value returned from the application method.
//
//--
/////////////////////////////////////////////////////////////////////////////
LRESULT CBarfDialog::OnBarfUpdate(WPARAM wparam, LPARAM lparam)
{
OnUpdate();
return 0;
} //*** CBarfDialog::OnBarfUpdate()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfDialog::PostUpdate
//
// Routine Description:
// Static function so that CBarf::BFail can post updates to us.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfDialog::PostUpdate(void)
{
// If this function gets called, there should be BARF dialog.
ASSERT(Pdlg() != NULL);
if (Pdlg() != NULL)
::PostMessage(Pdlg()->m_hWnd, WM_USER+5, NULL, NULL);
} //*** CBarfDialog::PostUpdate()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CBarfAllDialog
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Message Maps
BEGIN_MESSAGE_MAP(CBarfAllDialog, CDialog)
//{{AFX_MSG_MAP(CBarfAllDialog)
ON_BN_CLICKED(IDC_BAS_MENU_ITEM, OnMenuItem)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfAllDialog::CBarfAllDialog
//
// Routine Description:
// Constructor.
//
// Arguments:
// pParentWnd [IN OUT] Parent window for the dialog.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CBarfAllDialog::CBarfAllDialog(
IN OUT CWnd * pParentWnd //=NULL
)
: CDialog(IDD, pParentWnd)
{
//{{AFX_DATA_INIT(CBarfAllDialog)
//}}AFX_DATA_INIT
m_hwndBarf = NULL;
m_wmBarf = 0;
m_wparamBarf = 0;
m_lparamBarf = 0;
} //*** CBarfAllDialog::CBarfAllDialog()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfAllDialog::DoDataExchange
//
// Routine Description:
// Do data exchange between the dialog and the class.
//
// Arguments:
// pDX [IN OUT] Data exchange object
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfAllDialog::DoDataExchange(CDataExchange * pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CBarfAllDialog)
DDX_Control(pDX, IDC_BAS_LPARAM, m_editLparam);
DDX_Control(pDX, IDC_BAS_WPARAM, m_editWparam);
DDX_Control(pDX, IDC_BAS_WM, m_editWm);
DDX_Control(pDX, IDC_BAS_HWND, m_editHwnd);
//}}AFX_DATA_MAP
DDX_Text(pDX, IDC_BAS_HWND, (DWORD &) m_hwndBarf);
DDX_Text(pDX, IDC_BAS_WM, m_wmBarf);
DDX_Text(pDX, IDC_BAS_WPARAM, m_wparamBarf);
DDX_Text(pDX, IDC_BAS_LPARAM, m_lparamBarf);
} //*** CBarfAllDialog::DoDataExchange()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfAllDialog::OnInitDialog
//
// Routine Description:
// Handler for the WM_INITDIALOG message.
//
// Arguments:
// None.
//
// Return Value:
// TRUE Focus needs to be set.
// FALSE Focus already set.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CBarfAllDialog::OnInitDialog(void)
{
// Call the base class.
CDialog::OnInitDialog();
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
} //*** CBarfAllDialog::OnInitDialog()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfAllDialog::OnOK
//
// Routine Description:
// Handler for the BN_CLICKED message on the OK button.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfAllDialog::OnOK(void)
{
if (m_hwndBarf == NULL)
m_hwndBarf = AfxGetMainWnd()->m_hWnd;
CDialog::OnOK();
} //*** CBarfAllDialog::OnDialog()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CBarfAllDialog::OnMenuItem
//
// Routine Description:
// Handler for the BN_CLICKED message on the Menu Item button.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBarfAllDialog::OnMenuItem(void)
{
m_editHwnd.SetWindowText(_T("0"));
m_editWm.SetWindowText(_T("273")); // WM_COMMAND
m_editLparam.SetWindowText(_T("0"));
m_editWparam.SetWindowText(_T("0"));
} //*** CBarfAllDialog::OnMenuItem()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// Global Functions
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// BarfAll
//
// Routine Description:
// Exercises all possible single failures.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void BarfAll(void)
{
CBarf * pbarf;
CBarfAllDialog dlg(AfxGetMainWnd());
ID id;
CString str;
// First, pick-up the message to test.
id = dlg.DoModal();
if (id != IDOK)
{
Trace(g_tagAlways, _T("BarfAll() - operation cancelled."));
return;
} // if: BarfAll cancelled
Trace(g_tagAlways,
_T("BarfAll with hwnd = %#08lX, wm = 0x%4x, wparam = %d, lparam = %d"),
dlg.HwndBarf(), dlg.WmBarf(), dlg.WparamBarf(), dlg.LparamBarf());
// Now, find out how many counts of each resource...
pbarf = CBarf::s_pbarfFirst;
while (pbarf != NULL)
{
pbarf->m_nCurrentSave = pbarf->m_nCurrent;
pbarf->m_nCurrent = 0;
pbarf->m_nFail = 0;
pbarf->m_bContinuous = FALSE;
pbarf->m_bDisabled = FALSE;
pbarf = pbarf->m_pbarfNext;
} // while: more BARF entries
if (CBarfDialog::Pdlg())
CBarfDialog::Pdlg()->OnUpdate();
str = _T("BarfAll Test pass.");
Trace(g_tagAlways, str);
SendMessage(dlg.HwndBarf(), dlg.WmBarf(),
dlg.WparamBarf(), dlg.LparamBarf());
pbarf = CBarf::s_pbarfFirst;
while (pbarf != NULL)
{
pbarf->m_nBarfAll = pbarf->m_nCurrentSave;
pbarf = pbarf->m_pbarfNext;
} // while: more entries in the list
MessageBox(dlg.HwndBarf(), str, _T("BARF Status"), MB_OK | MB_ICONEXCLAMATION);
// Finally, THE big loop...
pbarf = CBarf::s_pbarfFirst;
while (pbarf != NULL)
{
for (pbarf->m_nFail = 1
; pbarf->m_nFail <= pbarf->m_nBarfAll
; pbarf->m_nFail++)
{
// CBarfMemory::Mark();
pbarf->m_nCurrent = 0;
if (CBarfDialog::Pdlg())
CBarfDialog::Pdlg()->OnUpdate();
str.Format(_T("BarfAll on resource %s, call # %d of %d"),
pbarf->m_pszName, pbarf->m_nFail, pbarf->m_nBarfAll);
Trace(g_tagAlways, str);
SendMessage(dlg.HwndBarf(), dlg.WmBarf(),
dlg.WparamBarf(), dlg.LparamBarf());
// CBarfMemory::DumpMarked();
// ValidateMemory();
str += _T("\nContinue?");
if (MessageBox(dlg.HwndBarf(), str, _T("BARF: Pass Complete."), MB_YESNO | MB_ICONEXCLAMATION) != IDYES)
break;
} // for: while the failure count is less than the BARF All count
pbarf->m_nFail = 0;
pbarf->m_nCurrent = pbarf->m_nCurrentSave;
pbarf = pbarf->m_pbarfNext;
} // while: more BARF entries
if (CBarfDialog::Pdlg())
CBarfDialog::Pdlg()->OnUpdate();
} //*** BarfAll()
/////////////////////////////////////////////////////////////////////////////
//++
//
// DoBarfDialog
//
// Routine Description:
// Launches the Barf Settings dialog.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void DoBarfDialog( void )
{
if ( CBarf::s_pbarfFirst == NULL )
{
AfxMessageBox( _T("No BARF counters defined yet."), MB_OK );
} // if: no counters defined yet
else if ( CBarfDialog::Pdlg() )
{
BringWindowToTop( CBarfDialog::Pdlg()->m_hWnd );
if ( IsIconic( CBarfDialog::Pdlg()->m_hWnd ) )
{
SendMessage( CBarfDialog::Pdlg()->m_hWnd, WM_SYSCOMMAND, SC_RESTORE, NULL );
} // if: window is currently minimized
} // if: there is already a dialog up
else
{
CBarfDialog * pdlg = NULL;
try
{
pdlg = new CBarfDialog;
if ( pdlg == NULL )
{
AfxThrowMemoryException();
} // if: error allocating the dialog
pdlg->Create( AfxGetMainWnd() );
} // try
catch ( CException * pe )
{
pe->ReportError();
pe->Delete();
} // catch: CException
} // else: no dialog up yet
} //*** DoBarfDialog()
#endif // _DEBUG
Reference in a new issue Copy permalink