// HeaderDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Controls.h"
#include "HeaderDlg.h"

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

/////////////////////////////////////////////////////////////////////////////
// CHeaderDlg property page

IMPLEMENT_DYNCREATE(CHeaderDlg, CPropertyPage)

CHeaderDlg::CHeaderDlg() : CPropertyPage(CHeaderDlg::IDD)
{
	//{{AFX_DATA_INIT(CHeaderDlg)
	m_bListHotTrack = FALSE;
	m_bListButtons = TRUE;
	m_bListFullDrag = FALSE;
	m_bListDragDrop = FALSE;
	m_bBasicHotTrack = FALSE;
	m_bBasicHidden = FALSE;
	m_bBasicFullDrag = FALSE;
	m_bBasicDragDrop = FALSE;
	m_bBasicButtons = FALSE;
	m_bListHidden = FALSE;
	m_bListIcon = FALSE;
	m_bListText = TRUE;
	m_bListBitmap = FALSE;
	m_nListFormat = 0;
	m_bListBmpOnRight = FALSE;
	//}}AFX_DATA_INIT
	m_psp.dwFlags &= ~PSP_HASHELP;
	m_hBmpPlanet = NULL;
	m_hBmpOrbit = NULL;
	m_hBmpRotate = NULL;
}

CHeaderDlg::~CHeaderDlg()
{
	if (m_hBmpPlanet != NULL)
		DeleteObject (m_hBmpPlanet);
	if (m_hBmpOrbit != NULL)
		DeleteObject (m_hBmpOrbit);
	if (m_hBmpRotate != NULL)
		DeleteObject (m_hBmpRotate);
}

void CHeaderDlg::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CHeaderDlg)
	DDX_Control(pDX, IDC_HEADER_LISTCONTROL, m_HeaderListCtrl);
	DDX_Check(pDX, IDC_HEADER_LISTHOTTRACK, m_bListHotTrack);
	DDX_Check(pDX, IDC_HEADER_LISTBUTTONS, m_bListButtons);
	DDX_Check(pDX, IDC_HEADER_LISTFULLDRAG, m_bListFullDrag);
	DDX_Check(pDX, IDC_HEADER_LISTDRAGDROP, m_bListDragDrop);
	DDX_Check(pDX, IDC_HEADER_BASICHOTTRACK, m_bBasicHotTrack);
	DDX_Check(pDX, IDC_HEADER_BASICHIDDEN, m_bBasicHidden);
	DDX_Check(pDX, IDC_HEADER_BASICFULLDRAG, m_bBasicFullDrag);
	DDX_Check(pDX, IDC_HEADER_BASICDRAGDROP, m_bBasicDragDrop);
	DDX_Check(pDX, IDC_HEADER_BASICBUTTONS, m_bBasicButtons);
	DDX_Check(pDX, IDC_HEADER_LISTHIDDEN, m_bListHidden);
	DDX_Check(pDX, IDC_HEADER_LISTICON, m_bListIcon);
	DDX_Check(pDX, IDC_HEADER_LISTTEXT, m_bListText);
	DDX_Check(pDX, IDC_HEADER_LISTBITMAP, m_bListBitmap);
	DDX_Radio(pDX, IDC_HEADER_LISTLEFT, m_nListFormat);
	DDX_Check(pDX, IDC_HEADER_LISTBMPONRIGHT, m_bListBmpOnRight);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CHeaderDlg, CPropertyPage)
	//{{AFX_MSG_MAP(CHeaderDlg)
	ON_BN_CLICKED(IDC_HEADER_LISTBUTTONS, OnHeaderListbuttons)
	ON_BN_CLICKED(IDC_HEADER_LISTHOTTRACK, OnHeaderListhottrack)
	ON_BN_CLICKED(IDC_HEADER_LISTFULLDRAG, OnHeaderListfulldrag)
	ON_BN_CLICKED(IDC_HEADER_LISTDRAGDROP, OnHeaderListdragdrop)
	ON_BN_CLICKED(IDC_HEADER_BASICDRAGDROP, OnHeaderBasicdragdrop)
	ON_BN_CLICKED(IDC_HEADER_BASICBUTTONS, OnHeaderBasicbuttons)
	ON_BN_CLICKED(IDC_HEADER_BASICFULLDRAG, OnHeaderBasicfulldrag)
	ON_BN_CLICKED(IDC_HEADER_BASICHIDDEN, OnHeaderBasichidden)
	ON_BN_CLICKED(IDC_HEADER_BASICHOTTRACK, OnHeaderBasichottrack)
	ON_BN_CLICKED(IDC_HEADER_LISTTEXT, OnHeaderListtext)
	ON_BN_CLICKED(IDC_HEADER_LISTICON, OnHeaderListicon)
	ON_BN_CLICKED(IDC_HEADER_LISTBITMAP, OnHeaderListbitmap)
	ON_BN_CLICKED(IDC_HEADER_LISTLEFT, OnFormatLabel)
	ON_BN_CLICKED(IDC_HEADER_LISTBMPONRIGHT, OnHeaderListBmponRight)
	ON_BN_CLICKED(IDC_HEADER_LISTRIGHT, OnFormatLabel)
	ON_BN_CLICKED(IDC_HEADER_LISTCENTER, OnFormatLabel)
	ON_BN_CLICKED(IDC_HEADER_LISTHIDDEN, OnHeaderListhidden)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CHeaderDlg message handlers

BOOL CHeaderDlg::OnInitDialog() 
{
char *szTitles [] =
	{
	"Planet",
	"Orbit",
	"Rotation"
	};
#define TITLES (sizeof(szTitles)/sizeof(char *))

const char *szPlanets [] =
	{
	"Mercury",
	"Venus",
	"Earth",
	"Mars",
	"Jupiter",
	"Saturn",
	"Uranus",
	"Neptune",
	"Pluto"
	};

	CPropertyPage::OnInitDialog();

	CRect rc;
	m_HeaderListCtrl.GetWindowRect (&rc);
	CHeaderCtrl *header = m_HeaderListCtrl.GetHeaderCtrl ();
	LV_COLUMN	lc;
	HDITEM		hi;

	memset (&lc, '\0', sizeof (LV_COLUMN));
	memset (&hi, '\0', sizeof (HDITEM));
	lc.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;	
	for (int sub = 0; sub < TITLES; ++sub)
	{
		lc.iImage = sub;
		lc.pszText = szTitles[sub];
		lc.cx = (rc.right - rc.left) / 3 - 2;
		lc.iSubItem = sub;
		m_HeaderListCtrl.InsertColumn (sub, &lc);
	}
//
//	Calculate the parent window for the list box
//	so it is the same size as the list control.
//
	CRect rcAdv;
	::GetWindowRect (GetDlgItem(IDC_HEADER_ADVANCED)->m_hWnd, rcAdv);
	ScreenToClient (&rcAdv);
	CRect rcBasic;
	::GetWindowRect (GetDlgItem(IDC_HEADER_BASIC)->m_hWnd, rcBasic);
	ScreenToClient (&rcBasic);
	CRect rcCtrl;
	m_HeaderListCtrl.GetWindowRect (&rcCtrl);
	ScreenToClient (&rcCtrl);
	CRect rcListBox (rcBasic);
	rcListBox.left += rcCtrl.left - rcAdv.left;
	rcListBox.right -= rcAdv.right - rcCtrl.right;
	rcListBox.top = rcCtrl.top;
	rcListBox.bottom = rcCtrl.bottom;
//
//	Create the list box parent window. Use the
//	static window type.
//
	m_ListParent.CreateEx (0, "static", NULL, WS_CHILD | WS_VISIBLE | SS_SUNKEN,
							rcListBox, this, IDC_HEADER_LISTBOX);
	m_ListParent.ShowWindow (SW_SHOWNORMAL);
//
//	Initialize the window variables. This will
//	create the list box and its header control.
//
	m_ListParent.Initialize ();
//
//	Load the owner draw list box with file structures
//
	WIN32_FIND_DATA fd;
	HANDLE hFind;
	int nItem = 0;
	if ((hFind = FindFirstFile (_T("*.*"), &fd)) != NULL)
	{
		do
		{
			if (fd.cFileName[0] == '.')
				continue;
			m_ListParent.AddListItem (fd);
		} while (FindNextFile (hFind, &fd) == TRUE);
	}
	m_ListParent.SetSelection (0);
//
//	Disable the hot track button in the basic group
//	and the bitmap on right button in the list box
//	group. Hot Track requires button style, and
//	bitmap on right requires bitmap format.
//
	::EnableWindow (GetDlgItem (IDC_HEADER_BASICHOTTRACK)->m_hWnd, FALSE);
	::EnableWindow (GetDlgItem(IDC_HEADER_LISTBMPONRIGHT)->m_hWnd, FALSE);
//
//	Load the bitmaps for the list control header.
//
    HINSTANCE hInst = AfxGetInstanceHandle ();
	m_hBmpPlanet = (HBITMAP) LoadImage (hInst,
							 MAKEINTRESOURCE(IDB_HEADER_SMALLEARTH), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR);
	m_hBmpOrbit = (HBITMAP) LoadImage (hInst,
							 MAKEINTRESOURCE(IDB_HEADER_ORBIT), IMAGE_BITMAP, 32, 16, LR_DEFAULTCOLOR);
	m_hBmpRotate = (HBITMAP) LoadImage (hInst,
							 MAKEINTRESOURCE(IDB_HEADER_DAYNIGHT), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR);
//
//	Set the image list for the list control header.
//	Note that this image list is completely separate
//	from the other two that may be used with the
//	list control.
//
	m_imageOneTwoThree.Create (IDB_ONETWOTHREE, 16, 2, RGB(0x00, 0x80, 0x80));
	header->SetImageList (&m_imageOneTwoThree);
	return (TRUE);
}

/////////////////////////////////////////////////////////////////////////////
// Basic group handler functions

void CHeaderDlg::OnHeaderBasicdragdrop() 
{
	UpdateData (TRUE);
	if (m_bBasicDragDrop)
	{
		m_ListParent.GetHeaderCtrl()->ModifyStyle (0, HDS_DRAGDROP, TRUE);
	}
	else
	{
		m_ListParent.GetHeaderCtrl()->ModifyStyle (HDS_DRAGDROP, 0, TRUE);
	}
}

void CHeaderDlg::OnHeaderBasicbuttons() 
{
	UpdateData (TRUE);
	if (m_bBasicButtons)
	{
		::EnableWindow (GetDlgItem (IDC_HEADER_BASICHOTTRACK)->m_hWnd, TRUE);
		m_ListParent.GetHeaderCtrl()->ModifyStyle (0, HDS_BUTTONS, TRUE);
	}
	else
	{
		m_bBasicHotTrack = FALSE;
		::EnableWindow (GetDlgItem (IDC_HEADER_BASICHOTTRACK)->m_hWnd, FALSE);
		m_ListParent.GetHeaderCtrl()->ModifyStyle (HDS_BUTTONS, 0, TRUE);
	}
	UpdateData (FALSE);
}

void CHeaderDlg::OnHeaderBasicfulldrag() 
{
	UpdateData (TRUE);
	if (m_bBasicFullDrag)
	{
		m_ListParent.GetHeaderCtrl()->ModifyStyle (0, HDS_FULLDRAG, TRUE);
	}
	else
	{
		m_ListParent.GetHeaderCtrl()->ModifyStyle (HDS_FULLDRAG, 0, TRUE);
	}
}

void CHeaderDlg::OnHeaderBasichidden() 
{
	UpdateData (TRUE);
	if (m_bBasicHidden)
	{
		m_ListParent.HideHeader(true);
	}
	else
	{
		m_ListParent.HideHeader(false);
	}
}

void CHeaderDlg::OnHeaderBasichottrack() 
{
	UpdateData (TRUE);
	if (m_bBasicHotTrack)
	{
		m_ListParent.GetHeaderCtrl()->ModifyStyle (0, HDS_HOTTRACK, TRUE);
	}
	else
	{
		m_ListParent.GetHeaderCtrl()->ModifyStyle (HDS_HOTTRACK, 0, TRUE);
	}
}

/////////////////////////////////////////////////////////////////////////////
// List control group handler functions

void CHeaderDlg::OnHeaderListbuttons() 
{
	UpdateData (TRUE);
	if (m_bListButtons)
	{
		::EnableWindow (GetDlgItem (IDC_HEADER_LISTHOTTRACK)->m_hWnd, TRUE);
		m_HeaderListCtrl.GetHeaderCtrl()->ModifyStyle (0, HDS_BUTTONS, TRUE);
	}
	else
	{
		::EnableWindow (GetDlgItem (IDC_HEADER_LISTHOTTRACK)->m_hWnd, FALSE);
		m_HeaderListCtrl.GetHeaderCtrl()->ModifyStyle (HDS_BUTTONS, 0, TRUE);
	}
}

void CHeaderDlg::OnHeaderListhottrack() 
{
	UpdateData (TRUE);
	if (m_bListHotTrack)
	{
		m_HeaderListCtrl.GetHeaderCtrl()->ModifyStyle (0, HDS_HOTTRACK, TRUE);
	}
	else
	{
		m_HeaderListCtrl.GetHeaderCtrl()->ModifyStyle (HDS_HOTTRACK, 0, TRUE);
	}
}

void CHeaderDlg::OnHeaderListfulldrag() 
{
	UpdateData (TRUE);
	if (m_bListFullDrag)
	{
		m_HeaderListCtrl.GetHeaderCtrl()->ModifyStyle (0, HDS_FULLDRAG, TRUE);
	}
	else
	{
		m_HeaderListCtrl.GetHeaderCtrl()->ModifyStyle (HDS_FULLDRAG, 0, TRUE);
	}
}

void CHeaderDlg::OnHeaderListdragdrop() 
{
	UpdateData (TRUE);
	if (m_bListDragDrop)
	{
		m_HeaderListCtrl.GetHeaderCtrl()->ModifyStyle (0, HDS_DRAGDROP, TRUE);
	}
	else
	{
		m_HeaderListCtrl.GetHeaderCtrl()->ModifyStyle (HDS_DRAGDROP, 0, TRUE);
	}
}

void CHeaderDlg::OnHeaderListtext() 
{
	UpdateData (TRUE);
	HDITEM hi;
	memset (&hi, '\0', sizeof (HDITEM));
	CHeaderCtrl *header = m_HeaderListCtrl.GetHeaderCtrl ();
	hi.mask = HDI_FORMAT;

	header->GetItem (0, &hi);
	if (m_bListText)
	{
		hi.mask = HDI_FORMAT;
		hi.fmt |= HDF_STRING;
		hi.iImage = 0;
		header->SetItem (0, &hi);
		hi.iImage = 1;
		header->SetItem (1, &hi);
		hi.iImage = 2;
		header->SetItem (2, &hi);
	}
	else
	{
		hi.mask = HDI_FORMAT;
		hi.fmt &= ~HDF_STRING;
		header->SetItem (0, &hi);
		header->SetItem (1, &hi);
		header->SetItem (2, &hi);
	}
}

void CHeaderDlg::OnHeaderListicon() 
{
	UpdateData (TRUE);
	HDITEM hi;
	memset (&hi, '\0', sizeof (HDITEM));
	CHeaderCtrl *header = m_HeaderListCtrl.GetHeaderCtrl ();
	hi.mask = HDI_FORMAT;

	header->GetItem (0, &hi);
	if (m_bListIcon)
	{
		hi.mask = HDI_IMAGE | HDI_FORMAT;
		hi.fmt |= HDF_IMAGE;
		hi.iImage = 0;
		header->SetItem (0, &hi);
		hi.iImage = 1;
		header->SetItem (1, &hi);
		hi.iImage = 2;
		header->SetItem (2, &hi);
	}
	else
	{
		hi.mask = HDI_FORMAT;
		hi.fmt &= ~HDF_IMAGE;
		header->SetItem (0, &hi);
		header->SetItem (1, &hi);
		header->SetItem (2, &hi);
	}
}

void CHeaderDlg::OnHeaderListbitmap() 
{
	UpdateData (TRUE);
	HDITEM hi;
	memset (&hi, '\0', sizeof (HDITEM));
	CHeaderCtrl *header = m_HeaderListCtrl.GetHeaderCtrl ();
	hi.mask = HDI_FORMAT;

	header->GetItem (0, &hi);
	if (m_bListBitmap)
	{
		hi.mask = HDI_BITMAP | HDI_FORMAT;
		hi.fmt |= HDF_BITMAP;
		hi.hbm = m_hBmpPlanet;
		header->SetItem (0, &hi);
		hi.hbm = m_hBmpOrbit;
		header->SetItem (1, &hi);
		hi.hbm = m_hBmpRotate;
		header->SetItem (2, &hi);
		::EnableWindow (GetDlgItem(IDC_HEADER_LISTBMPONRIGHT)->m_hWnd, TRUE);
	}
	else
	{
		hi.mask = HDI_FORMAT;
		hi.fmt &= ~HDF_BITMAP;
		header->SetItem (0, &hi);
		header->SetItem (1, &hi);
		header->SetItem (2, &hi);
		::EnableWindow (GetDlgItem(IDC_HEADER_LISTBMPONRIGHT)->m_hWnd, FALSE);
	}
}

void CHeaderDlg::OnFormatLabel() 
{
	UpdateData (TRUE);
	HDITEM hi;
	memset (&hi, '\0', sizeof (HDITEM));
	CHeaderCtrl *header = m_HeaderListCtrl.GetHeaderCtrl ();
	hi.mask = HDI_FORMAT;
	header->GetItem (0, &hi);
	hi.fmt &= ~(HDF_LEFT | HDF_RIGHT | HDF_CENTER);	
	switch (m_nListFormat)
	{
		case 0:		// Left
			hi.fmt |= HDF_LEFT;
			break;
		case 1:		// Right
			hi.fmt |= HDF_RIGHT;
			break;
		case 2:		// Center
			hi.fmt |= HDF_CENTER;
			break;
		default:
			return;
	}
	header->SetItem (0, &hi);
	header->SetItem (1, &hi);
	header->SetItem (2, &hi);
}

void CHeaderDlg::OnHeaderListBmponRight() 
{
	UpdateData (TRUE);
	HDITEM hi;
	memset (&hi, '\0', sizeof (HDITEM));
	CHeaderCtrl *header = m_HeaderListCtrl.GetHeaderCtrl ();
	hi.mask = HDI_FORMAT;
	header->GetItem (0, &hi);
	if (m_bListBmpOnRight)
	{
		hi.fmt |= HDF_BITMAP_ON_RIGHT;
	}
	else
	{
		hi.fmt &= ~HDF_BITMAP_ON_RIGHT;
	}
	header->SetItem (0, &hi);
	header->SetItem (1, &hi);
	header->SetItem (2, &hi);
}

void CHeaderDlg::OnHeaderListhidden() 
{
	UpdateData (TRUE);
	if (m_bListHidden)
	{
		m_HeaderListCtrl.ModifyStyle (0, LVS_NOCOLUMNHEADER, TRUE);
	}
	else
	{
		m_HeaderListCtrl.ModifyStyle (LVS_NOCOLUMNHEADER, 0, TRUE);
	}
}