//+---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1998-2001
//
//  File:       SchedDlg.cpp
//
//  Contents:   Implementation of CConnectionScheduleDlg
//
//----------------------------------------------------------------------------

#include "stdafx.h"
#include "SchedDlg.h"
#include "log_gmt.h"
#include "loghrapi.h"

#ifdef _DEBUG
//#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

//
// The schedule block has been redefined to have 1 byte for every hour.
// CODEWORK These should be defined in SCHEDULE.H.  JonN 2/9/98
//
#define INTERVAL_MASK       0x0F
#define RESERVED            0xF0
#define FIRST_15_MINUTES    0x01
#define SECOND_15_MINUTES   0x02
#define THIRD_15_MINUTES    0x04
#define FOURTH_15_MINUTES   0x08

const int NONE_PER_HOUR = 0;
const int ONE_PER_HOUR	= 33;
const int TWO_PER_HOUR	= 67;
const int FOUR_PER_HOUR	= 100;
/////////////////////////////////////////////////////////////////////
//	ConnectionScheduleDialog ()
//
//	Invoke a dialog to set/modify a schedule, for example
//      -- the logon hours for a particular user
//      -- the schedule for a connection
//
//	RETURNS
//	Return S_OK if the user clicked on the OK button.
//	Return S_FALSE if the user clicked on the Cancel button.
//	Return E_OUTOFMEMORY if there is not enough memory.
///	Return E_UNEXPECTED if an expected error occured (eg: bad parameter)
//
//	INTERFACE NOTES
//	Each bit in the array represents one hour.  As a result, the
//	expected length of the array should be (24 / 8) * 7 = 21 bytes.
//	For convenience, the first day of the week is Sunday and
//	the last day is Saturday.
//	Consequently, the first bit of the array represents the schedule
//	for Sunday during period 12 AM to 1 AM.
//	- If *pprgbData is NULL, then the routine will allocate
//	  an array of 21 bytes using LocalAlloc ().  The caller
//	  is responsible of releasing the memory using LocalFree ().
//  - If *pprgbData is not NULL, the routine re-use the array as its
//	  output parameter.
//
//	HISTORY
//	17-Jul-97	t-danm		Creation.
//	16-Sep-97	jonn		Changed to UiScheduleDialog
//

HRESULT
ConnectionScheduleDialog (
	HWND hwndParent,		// IN: Parent's window handle
	BYTE ** pprgbData,	    // INOUT: Pointer to pointer to array of 21 bytes (one bit per hour)
	LPCTSTR pszTitle)		// IN: Dialog title
{
    return ConnectionScheduleDialogEx (hwndParent, pprgbData, pszTitle, 0);
}

HRESULT
ConnectionScheduleDialogEx (
	HWND hwndParent,		// IN: Parent's window handle
	BYTE ** pprgbData,	    // INOUT: Pointer to pointer to array of 21 bytes (one bit per hour)
	LPCTSTR pszTitle,		// IN: Dialog title
    DWORD   dwFlags)
{
	AFX_MANAGE_STATE (AfxGetStaticModuleState ());
	ASSERT (::IsWindow (hwndParent));
	ASSERT (pprgbData);
	ASSERT (pszTitle);
	ENDORSE (NULL == *pprgbData);	// TRUE => Use default logon hours (7x24)

	if (*pprgbData == NULL)
	{
		BYTE * pargbData;	// Pointer to allocated array of bytes
		pargbData = (BYTE *)LocalAlloc (0, 7*24);	// Allocate 168 bytes
		if ( !pargbData )
			return E_OUTOFMEMORY;
		// Set the logon hours to be valid 24 hours a day and 7 days a week.
		memset (OUT pargbData, -1, 7*24);
		*pprgbData = pargbData;
	}

    // If hwndParent passed in, create a CWnd to pass as the parent window
    CWnd* pWnd = 0;
    if ( ::IsWindow (hwndParent) )
    {
        pWnd = new CWnd;
        if ( pWnd )
        {
            pWnd->Attach (hwndParent);
        }
        else
            return E_OUTOFMEMORY;
    }

    HRESULT             hr = S_OK;
	CConnectionScheduleDlg	dlg (pWnd);
    dlg.SetTitle (pszTitle);
	dlg.SetConnectionByteArray (INOUT *pprgbData);
    dlg.SetFlags (dwFlags);

	if (IDOK != dlg.DoModal ())
		hr = S_FALSE;

    // Delete CWnd
    if ( pWnd )
    {
        pWnd->Detach ();
        delete pWnd;
    }

    return hr;
} // ConnectionScheduleDialog ()



HRESULT
ReplicationScheduleDialog (
	HWND hwndParent,		// IN: Parent's window handle
	BYTE ** pprgbData,	    // INOUT: Pointer to pointer to array of 21 bytes (one bit per hour)
	LPCTSTR pszTitle)		// IN: Dialog title
{
    return ReplicationScheduleDialogEx (hwndParent, pprgbData, pszTitle, 0);
} // ReplicationScheduleDialog ()


HRESULT ReplicationScheduleDialogEx (
    HWND hwndParent,       // parent window
    BYTE ** pprgbData,     // pointer to pointer to array of 84 bytes
    LPCTSTR pszTitle,     // dialog title
    DWORD   dwFlags)      // option flags
{
	AFX_MANAGE_STATE (AfxGetStaticModuleState ());
	ASSERT (::IsWindow (hwndParent));
	ASSERT (pprgbData);
	ASSERT (pszTitle);
	ENDORSE (NULL == *pprgbData);	// TRUE => Use default logon hours (7x24)

	if (*pprgbData == NULL)
	{
		BYTE * pargbData;	// Pointer to allocated array of bytes
		pargbData = (BYTE *)LocalAlloc (0, 7*24);	// Allocate 168 bytes
		if ( !pargbData )
			return E_OUTOFMEMORY;
		// Set the logon hours to be valid 24 hours a day and 7 days a week.
		memset (OUT pargbData, -1, 7*24);
		*pprgbData = pargbData;
	}

    // If hwndParent passed in, create a CWnd to pass as the parent window
    CWnd* pWnd = 0;
    if ( ::IsWindow (hwndParent) )
    {
        pWnd = new CWnd;
        if ( pWnd )
        {
            pWnd->Attach (hwndParent);
        }
        else
            return E_OUTOFMEMORY;
    }

    HRESULT             hr = S_OK;
	CReplicationScheduleDlg	dlg (pWnd);
    dlg.SetTitle (pszTitle);
	dlg.SetConnectionByteArray (INOUT *pprgbData);
    dlg.SetFlags (dwFlags);
	if (IDOK != dlg.DoModal ())
		hr = S_FALSE;

    // Delete CWnd
    if ( pWnd )
    {
        pWnd->Detach ();
        delete pWnd;
    }

    return hr;
}   // ReplicationScheduleDialogEx

/////////////////////////////////////////////////////////////////////////////
// CConnectionScheduleDlg dialog


CConnectionScheduleDlg::CConnectionScheduleDlg(CWnd* pParent)
	: CScheduleBaseDlg(CConnectionScheduleDlg::IDD, true, pParent),
	m_prgbData168 (0)
{
	EnableAutomation();

	//{{AFX_DATA_INIT(CConnectionScheduleDlg)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
}


void CConnectionScheduleDlg::OnFinalRelease()
{
	// When the last reference for an automation object is released
	// OnFinalRelease is called.  The base class will automatically
	// deletes the object.  Add additional cleanup required for your
	// object before calling the base class.

	CScheduleBaseDlg::OnFinalRelease();
}

void CConnectionScheduleDlg::DoDataExchange(CDataExchange* pDX)
{
	CScheduleBaseDlg::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CConnectionScheduleDlg)
	DDX_Control(pDX, IDC_RADIO_NONE, m_buttonNone);
	DDX_Control(pDX, IDC_RADIO_ONE, m_buttonOne);
	DDX_Control(pDX, IDC_RADIO_TWO, m_buttonTwo);
	DDX_Control(pDX, IDC_RADIO_FOUR, m_buttonFour);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CConnectionScheduleDlg, CScheduleBaseDlg)
	//{{AFX_MSG_MAP(CConnectionScheduleDlg)
	ON_BN_CLICKED(IDC_RADIO_FOUR, OnRadioFour)
	ON_BN_CLICKED(IDC_RADIO_NONE, OnRadioNone)
	ON_BN_CLICKED(IDC_RADIO_ONE, OnRadioOne)
	ON_BN_CLICKED(IDC_RADIO_TWO, OnRadioTwo)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

BEGIN_DISPATCH_MAP(CConnectionScheduleDlg, CScheduleBaseDlg)
	//{{AFX_DISPATCH_MAP(CConnectionScheduleDlg)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	//}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()

// Note: we add support for IID_IDSScheduleDlg to support typesafe binding
//  from VBA.  This IID must match the GUID that is attached to the 
//  dispinterface in the .ODL file.

// {701CFB36-AEF8-11D1-9864-00C04FB94F17}
static const IID IID_IDSScheduleDlg =
{ 0x701cfb36, 0xaef8, 0x11d1, { 0x98, 0x64, 0x0, 0xc0, 0x4f, 0xb9, 0x4f, 0x17 } };

BEGIN_INTERFACE_MAP(CConnectionScheduleDlg, CScheduleBaseDlg)
	INTERFACE_PART(CConnectionScheduleDlg, IID_IDSScheduleDlg, Dispatch)
END_INTERFACE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CConnectionScheduleDlg message handlers

BOOL CConnectionScheduleDlg::OnInitDialog() 
{
	CScheduleBaseDlg::OnInitDialog();
	
	// Set up the "none" legend
	m_legendNone.Init (this, IDC_STATIC_LEGEND_NONE, &m_schedulematrix, NONE_PER_HOUR);

	// Set up the "one" legend
	m_legendOne.Init (this, IDC_STATIC_LEGEND_ONE, &m_schedulematrix, ONE_PER_HOUR);

	// Set up the "two" legend
	m_legendTwo.Init (this, IDC_STATIC_LEGEND_TWO, &m_schedulematrix, TWO_PER_HOUR);
	
	// Set up the "four" legend
	m_legendFour.Init (this, IDC_STATIC_LEGEND_FOUR, &m_schedulematrix, FOUR_PER_HOUR);
	
    if ( GetFlags () & SCHED_FLAG_READ_ONLY )
    {
        // Disable the grid settings buttons
        m_buttonNone.EnableWindow (FALSE);
        m_buttonOne.EnableWindow (FALSE);
        m_buttonTwo.EnableWindow (FALSE);
        m_buttonFour.EnableWindow (FALSE);
    }

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CConnectionScheduleDlg::OnOK() 
{
	if ( m_prgbData168 )
	{
		GetByteArray (OUT m_prgbData168);

		// Convert back the hours to GMT time.
		ConvertConnectionHoursToGMT (INOUT m_prgbData168, m_bAddDaylightBias);
	}
	
	CScheduleBaseDlg::OnOK();
}


void CConnectionScheduleDlg::UpdateButtons ()
{
	UINT nHour = 0;
	UINT nDay = 0;
	UINT nNumHours = 0;
	UINT nNumDays = 0;

	m_schedulematrix.GetSel (OUT nHour, OUT nDay, OUT nNumHours, OUT nNumDays);

	// Assume in each case that all selected squares are all set one way until 
	// proven otherwise.  These are 'int' so that I can add them up afterwards
	// to assure that only one of the buttons will be checked.
	int fNoneAllSet = 1;
	int fOneAllSet = 1;
	int fTwoAllSet = 1;
	int fFourAllSet = 1;

	if (nNumHours > 0)
	{
		for (UINT iDayOfWeek = nDay; iDayOfWeek < nDay+nNumDays; iDayOfWeek++)
		{
			for (UINT iHour = nHour; iHour < nHour+nNumHours; iHour++)
			{
				switch (m_schedulematrix.GetPercentage (iHour, iDayOfWeek))
				{
				case NONE_PER_HOUR:
					fOneAllSet = 0;
					fTwoAllSet = 0;
					fFourAllSet = 0;
					break;

				case ONE_PER_HOUR:
					fNoneAllSet = 0;
					fTwoAllSet = 0;
					fFourAllSet = 0;
					break;

				case TWO_PER_HOUR:
					fNoneAllSet = 0;
					fOneAllSet = 0;
					fFourAllSet = 0;
					break;

				case FOUR_PER_HOUR:
					fNoneAllSet = 0;
					fOneAllSet = 0;
					fTwoAllSet = 0;
					break;

				default:
					ASSERT (0);
					break;
				}
			} // for
		} // for
	}
	else
	{
		fNoneAllSet = 0;
		fOneAllSet = 0;
		fTwoAllSet = 0;
		fFourAllSet = 0;
	}

	// Ensure that at most, only one of these is 'true'
	ASSERT ((fNoneAllSet + fOneAllSet + fTwoAllSet + fFourAllSet <= 1));
	m_buttonNone.SetCheck (fNoneAllSet);
	m_buttonOne.SetCheck (fOneAllSet);
	m_buttonTwo.SetCheck (fTwoAllSet);
	m_buttonFour.SetCheck (fFourAllSet);
}

void CConnectionScheduleDlg::OnRadioFour() 
{
	UINT nHour = 0;
	UINT nDay = 0;
	UINT nNumHours = 0;
	UINT nNumDays = 0;

	m_schedulematrix.GetSel (OUT nHour, OUT nDay, OUT nNumHours, OUT nNumDays);
	if (nNumHours <= 0)
		return;	// Nothing selected
	m_schedulematrix.SetPercentage (FOUR_PER_HOUR, nHour, nDay, nNumHours, nNumDays);
	UpdateButtons ();
}

void CConnectionScheduleDlg::OnRadioNone() 
{
	UINT nHour = 0;
	UINT nDay = 0;
	UINT nNumHours = 0;
	UINT nNumDays = 0;

	m_schedulematrix.GetSel (OUT nHour, OUT nDay, OUT nNumHours, OUT nNumDays);
	if (nNumHours <= 0)
		return;	// Nothing selected
	m_schedulematrix.SetPercentage (NONE_PER_HOUR, nHour, nDay, nNumHours, nNumDays);
	UpdateButtons ();
}

void CConnectionScheduleDlg::OnRadioOne() 
{
	UINT nHour = 0;
	UINT nDay = 0;
	UINT nNumHours = 0;
	UINT nNumDays = 0;

	m_schedulematrix.GetSel (OUT nHour, OUT nDay, OUT nNumHours, OUT nNumDays);
	if (nNumHours <= 0)
		return;	// Nothing selected
	m_schedulematrix.SetPercentage (ONE_PER_HOUR, nHour, nDay, nNumHours, nNumDays);
	UpdateButtons ();
}

void CConnectionScheduleDlg::OnRadioTwo() 
{
	UINT nHour = 0;
	UINT nDay = 0;
	UINT nNumHours = 0;
	UINT nNumDays = 0;

	m_schedulematrix.GetSel (OUT nHour, OUT nDay, OUT nNumHours, OUT nNumDays);
	if (nNumHours <= 0)
		return;	// Nothing selected
	m_schedulematrix.SetPercentage (TWO_PER_HOUR, nHour, nDay, nNumHours, nNumDays);
	UpdateButtons ();
}

void CConnectionScheduleDlg::InitMatrix()
{
	if ( m_prgbData168 )
	{
		BYTE rgData[SCHEDULE_DATA_ENTRIES];		// Array of logonhours bits
		// Make a copy of the connection hours (in case the user click on cancel button)
		memcpy (OUT rgData, IN m_prgbData168, sizeof (rgData));
		// Convert the hours from GMT to local hours.
		ConvertConnectionHoursFromGMT (INOUT rgData, m_bAddDaylightBias);
		// Initialize the matrix
		InitMatrix2 (IN rgData);
	}
}

void CConnectionScheduleDlg::SetConnectionByteArray(INOUT BYTE rgbData [SCHEDULE_DATA_ENTRIES])
{
	ASSERT (rgbData);
	m_prgbData168 = rgbData;
}

// This table represent the numbers of bits set in the lower nibble of the BYTE.
// 0 bits -> 0
// 1 bit -> 25
// 2 or 3 bits -> 50
// 4 bits -> 100
static BYTE setConversionTable[16] = 
	{NONE_PER_HOUR,	// 0000
	ONE_PER_HOUR,	// 0001
	ONE_PER_HOUR,	// 0010
	TWO_PER_HOUR,	// 0011
	ONE_PER_HOUR,	// 0100
	TWO_PER_HOUR,	// 0101
	TWO_PER_HOUR,   // 0110
	TWO_PER_HOUR,   // 0111
	ONE_PER_HOUR,   // 1000
	TWO_PER_HOUR,   // 1001
	TWO_PER_HOUR,   // 1010
	TWO_PER_HOUR,   // 1011
	TWO_PER_HOUR,   // 1100
	TWO_PER_HOUR,   // 1101
	TWO_PER_HOUR,   // 1110
	FOUR_PER_HOUR}; // 1111

UINT CConnectionScheduleDlg::GetPercentageToSet(const BYTE bData)
{
	ASSERT ((bData & 0x0F) < 16);
	return setConversionTable[bData & 0x0F];
}


BYTE CConnectionScheduleDlg::GetMatrixPercentage(UINT nHour, UINT nDay)
{
	BYTE	byResult = 0;

	switch (m_schedulematrix.GetPercentage (nHour, nDay))
	{
	case NONE_PER_HOUR:
		// value remains 0n
		break;

	case ONE_PER_HOUR:
		byResult = FIRST_15_MINUTES;
		break;

	case TWO_PER_HOUR:
		byResult = FIRST_15_MINUTES | THIRD_15_MINUTES;
		break;

	case FOUR_PER_HOUR:
		byResult = FIRST_15_MINUTES | SECOND_15_MINUTES | THIRD_15_MINUTES | FOURTH_15_MINUTES;
		break;

	default:
		ASSERT (0);
		break;
	}

	return byResult;
}

UINT CConnectionScheduleDlg::GetExpectedArrayLength()
{
	return SCHEDULE_DATA_ENTRIES;
}

// Called when WM_TIMECHANGE is received
void CConnectionScheduleDlg::TimeChange()
{
	m_buttonNone.EnableWindow (FALSE);
	m_buttonOne.EnableWindow (FALSE);
	m_buttonTwo.EnableWindow (FALSE);
	m_buttonFour.EnableWindow (FALSE);
}

/////////////////////////////////////////////////////////////////////////////
// CReplicationScheduleDlg dialog


CReplicationScheduleDlg::CReplicationScheduleDlg(CWnd* pParent)
	: CScheduleBaseDlg(CReplicationScheduleDlg::IDD, true, pParent),
	m_prgbData168 (0)
{
	EnableAutomation();

	//{{AFX_DATA_INIT(CReplicationScheduleDlg)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
}


void CReplicationScheduleDlg::OnFinalRelease()
{
	// When the last reference for an automation object is released
	// OnFinalRelease is called.  The base class will automatically
	// deletes the object.  Add additional cleanup required for your
	// object before calling the base class.

	CScheduleBaseDlg::OnFinalRelease();
}

void CReplicationScheduleDlg::DoDataExchange(CDataExchange* pDX)
{
	CScheduleBaseDlg::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CReplicationScheduleDlg)
	DDX_Control(pDX, IDC_RADIO_NONE, m_buttonNone);
	DDX_Control(pDX, IDC_RADIO_FOUR, m_buttonFour);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CReplicationScheduleDlg, CScheduleBaseDlg)
	//{{AFX_MSG_MAP(CReplicationScheduleDlg)
	ON_BN_CLICKED(IDC_RADIO_FOUR, OnRadioFour)
	ON_BN_CLICKED(IDC_RADIO_NONE, OnRadioNone)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

BEGIN_DISPATCH_MAP(CReplicationScheduleDlg, CScheduleBaseDlg)
	//{{AFX_DISPATCH_MAP(CReplicationScheduleDlg)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	//}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()

// Note: we add support for IID_IDSScheduleDlg to support typesafe binding
//  from VBA.  This IID must match the GUID that is attached to the 
//  dispinterface in the .ODL file.

// {8DE6E2DA-7B4E-11d2-AC13-00C04F79DDCA}
static const IID IID_IReplicationScheduleDlg = 
{ 0x8de6e2da, 0x7b4e, 0x11d2, { 0xac, 0x13, 0x0, 0xc0, 0x4f, 0x79, 0xdd, 0xca } };

BEGIN_INTERFACE_MAP(CReplicationScheduleDlg, CScheduleBaseDlg)
	INTERFACE_PART(CReplicationScheduleDlg, IID_IReplicationScheduleDlg, Dispatch)
END_INTERFACE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CReplicationScheduleDlg message handlers

BOOL CReplicationScheduleDlg::OnInitDialog() 
{
	CScheduleBaseDlg::OnInitDialog();
	

 	// Set up the "none" legend
	m_legendNone.Init (this, IDC_STATIC_LEGEND_NONE, &m_schedulematrix, NONE_PER_HOUR);

	// Set up the "four" legend
	m_legendFour.Init (this, IDC_STATIC_LEGEND_FOUR, &m_schedulematrix, FOUR_PER_HOUR);
	
    if ( GetFlags () & SCHED_FLAG_READ_ONLY )
    {
        // Disable the grid settings buttons
        m_buttonNone.EnableWindow (FALSE);
        m_buttonFour.EnableWindow (FALSE);
    }

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CReplicationScheduleDlg::OnOK() 
{
	if ( m_prgbData168 )
	{
		GetByteArray (OUT m_prgbData168);

		// Convert back the hours to GMT time.
		ConvertConnectionHoursToGMT (INOUT m_prgbData168, m_bAddDaylightBias);
	}
	
	CScheduleBaseDlg::OnOK();
}


void CReplicationScheduleDlg::UpdateButtons ()
{
	UINT nHour = 0;
	UINT nDay = 0;
	UINT nNumHours = 0;
	UINT nNumDays = 0;

	m_schedulematrix.GetSel (OUT nHour, OUT nDay, OUT nNumHours, OUT nNumDays);

	// Assume in each case that all selected squares are all set one way until 
	// proven otherwise.  These are 'int' so that I can add them up afterwards
	// to assure that only one of the buttons will be checked.
	int fNoneAllSet = 1;
    int fFourAllSet = 1;

	if (nNumHours > 0)
	{
		for (UINT iDayOfWeek = nDay; iDayOfWeek < nDay+nNumDays; iDayOfWeek++)
		{
			for (UINT iHour = nHour; iHour < nHour+nNumHours; iHour++)
			{
				switch (m_schedulematrix.GetPercentage (iHour, iDayOfWeek))
				{
				case NONE_PER_HOUR:
                    fFourAllSet = 0;
					break;

				case FOUR_PER_HOUR:
					fNoneAllSet = 0;
					break;

				default:
					ASSERT (0);
					break;
				}
			} // for
		} // for
	}
	else
	{
		fNoneAllSet = 0;
	}

    ASSERT (fNoneAllSet + fFourAllSet <= 1);
	m_buttonNone.SetCheck (fNoneAllSet);
	m_buttonFour.SetCheck (fFourAllSet);
}

void CReplicationScheduleDlg::OnRadioFour() 
{
	UINT nHour = 0;
	UINT nDay = 0;
	UINT nNumHours = 0;
	UINT nNumDays = 0;

	m_schedulematrix.GetSel (OUT nHour, OUT nDay, OUT nNumHours, OUT nNumDays);
	if (nNumHours <= 0)
		return;	// Nothing selected
	m_schedulematrix.SetPercentage (FOUR_PER_HOUR, nHour, nDay, nNumHours, nNumDays);
	UpdateButtons ();
}

void CReplicationScheduleDlg::OnRadioNone() 
{
	UINT nHour = 0;
	UINT nDay = 0;
	UINT nNumHours = 0;
	UINT nNumDays = 0;

	m_schedulematrix.GetSel (OUT nHour, OUT nDay, OUT nNumHours, OUT nNumDays);
	if (nNumHours <= 0)
		return;	// Nothing selected
	m_schedulematrix.SetPercentage (NONE_PER_HOUR, nHour, nDay, nNumHours, nNumDays);
	UpdateButtons ();
}


void CReplicationScheduleDlg::InitMatrix()
{
	if ( m_prgbData168 )
	{
		BYTE rgData[SCHEDULE_DATA_ENTRIES];		// Array of logonhours bits
		// Make a copy of the connection hours (in case the user click on cancel button)
		memcpy (OUT rgData, IN m_prgbData168, sizeof (rgData));
		// Convert the hours from GMT to local hours.
		ConvertConnectionHoursFromGMT (INOUT rgData, m_bAddDaylightBias);
		// Initialize the matrix
		InitMatrix2 (IN rgData);
	}
}

void CReplicationScheduleDlg::SetConnectionByteArray(INOUT BYTE rgbData [SCHEDULE_DATA_ENTRIES])
{
	ASSERT (rgbData);
	m_prgbData168 = rgbData;
}


// This table represent the numbers of bits set in the lower nibble of the BYTE.
// 0 bits -> 0
// 1 bit -> 25
// 2 or 3 bits -> 50
// 4 bits -> 100
static BYTE setConversionTableForReplication[16] = 
	{NONE_PER_HOUR,	// 0000
	FOUR_PER_HOUR,	// 0001
	FOUR_PER_HOUR,	// 0010
	FOUR_PER_HOUR,	// 0011
	FOUR_PER_HOUR,	// 0100
	FOUR_PER_HOUR,	// 0101
	FOUR_PER_HOUR,  // 0110
	FOUR_PER_HOUR,  // 0111
	FOUR_PER_HOUR,  // 1000
	FOUR_PER_HOUR,  // 1001
	FOUR_PER_HOUR,  // 1010
	FOUR_PER_HOUR,  // 1011
	FOUR_PER_HOUR,  // 1100
	FOUR_PER_HOUR,  // 1101
	FOUR_PER_HOUR,  // 1110
	FOUR_PER_HOUR}; // 1111

UINT CReplicationScheduleDlg::GetPercentageToSet(const BYTE bData)
{
	ASSERT ((bData & 0x0F) < 16);
	return setConversionTableForReplication[bData & 0x0F];
}


BYTE CReplicationScheduleDlg::GetMatrixPercentage(UINT nHour, UINT nDay)
{
	BYTE	byResult = 0;

	switch (m_schedulematrix.GetPercentage (nHour, nDay))
	{
	case NONE_PER_HOUR:
		// value remains 0n
		break;

	case ONE_PER_HOUR:
	case TWO_PER_HOUR:
	case FOUR_PER_HOUR:
		byResult = FIRST_15_MINUTES | SECOND_15_MINUTES | THIRD_15_MINUTES | FOURTH_15_MINUTES;
		break;

	default:
		ASSERT (0);
		break;
	}

	return byResult;
}

UINT CReplicationScheduleDlg::GetExpectedArrayLength()
{
	return SCHEDULE_DATA_ENTRIES;
}

// Called when WM_TIMECHANGE is received
void CReplicationScheduleDlg::TimeChange()
{
	m_buttonNone.EnableWindow (FALSE);
	m_buttonFour.EnableWindow (FALSE);
}


/////////////////////////////////////////////////////////////////////
//	Converts the connection hours from local time to GMT.
void 
ConvertConnectionHoursToGMT (INOUT BYTE rgbData[SCHEDULE_DATA_ENTRIES], IN bool bAddDaylightBias)
{
	VERIFY ( ::NetpRotateLogonHoursBYTE (rgbData, SCHEDULE_DATA_ENTRIES, TRUE, bAddDaylightBias) );
}

/////////////////////////////////////////////////////////////////////
//	Converts the connection hours from GMT to local time.
void
ConvertConnectionHoursFromGMT (INOUT BYTE rgbData[SCHEDULE_DATA_ENTRIES], IN bool bAddDaylightBias)
{
	VERIFY ( ::NetpRotateLogonHoursBYTE (rgbData, SCHEDULE_DATA_ENTRIES, FALSE, bAddDaylightBias) );
}