#include "stdafx.h"
#include "DimOptionDlg.h"
#include "ui_ComboInListView.h"
#include "coretools.h"

#define IDC_COMBOBOXINLISTVIEW 0x1235

////////////////////////////////////////////////////////////////////////////////
#pragma region CDimOptionDlg
IMPLEMENT_DYNAMIC(CDimOptionDlg, CAcUiDialog)

BEGIN_MESSAGE_MAP(CDimOptionDlg, CAcUiDialog)
	ON_WM_CREATE()
	ON_BN_CLICKED(IDOK, &CDimOptionDlg::OnBnClickedOk)
END_MESSAGE_MAP()

CDimOptionDlg::CDimOptionDlg(CWnd * parent): CAcUiDialog(IDD, parent)
{
	m_dict.ReadByDWG();
}

CDimOptionDlg::~CDimOptionDlg()
{
}

BOOL CDimOptionDlg::OnInitDialog()
{
	CAcUiDialog::OnInitDialog();

	CRect rect;
	m_ctrlPos.GetWindowRect(rect);
	ScreenToClient(rect);

	m_list.MoveWindow(rect);

	return 1;
}

void CDimOptionDlg::DoDataExchange(CDataExchange * pDX)
{
	CAcUiDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_STATIC_POS, m_ctrlPos);
}

int CDimOptionDlg::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CAcUiDialog::OnCreate(lpCreateStruct) == -1)
		return -1;
	m_list.Create(WS_CHILD | WS_VISIBLE | WS_TABSTOP, CRect(), this, 0x1001);
	m_list.setWDictPtr(&m_dict);
	m_list.InitializeGrid();
	//m_list.SetExtendedStyle(0);
	m_list.ModifyStyleEx(0, WS_EX_CLIENTEDGE);
	return 0;
}

BOOL CDimOptionDlg::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
	NMHDR* pNMHDR = (NMHDR*)lParam;
	if (pNMHDR->idFrom == IDC_COMBOBOXINLISTVIEW)
	{
		LV_DISPINFO *pInfo = (LV_DISPINFO*)lParam;
		int iItem = pInfo->item.iItem;
		int iSubItem = pInfo->item.iSubItem;
		m_list.modifyPsCombo(iItem, pInfo->item.iIndent);
	}
	return CAcUiDialog::OnNotify(wParam, lParam, pResult);
}

void CDimOptionDlg::OnBnClickedOk()
{
	using namespace DIMJson;
	WValue v;
	WDict dict;
	m_list.saveToWDict(dict);
	dict.WriteToDWG();

	CAcUiDialog::OnOK();
}
#pragma endregion

#pragma region WDictGridList
BEGIN_MESSAGE_MAP(WDictGridList, CSuperGridCtrl)
	ON_WM_CREATE()
END_MESSAGE_MAP()
WDictGridList::WDictGridList() { }

WDictGridList::~WDictGridList() { }

void WDictGridList::InitializeSubGrid(WDictItem *pItem, CTreeItem *pTree)
{
	if (!pItem) return;

	int type(pItem->GetType());

	switch (type)
	{
	case TYPE_WDict:
	{
		WDict *p((WDict*)pItem);
		CItemInfo* lp = new CItemInfo();
		lp->setDataType(CItemInfo::WDict);
		lp->SetImage(0);
		lp->SetItemText(pItem->m_sName);
		lp->AddSubItemText(_T(""));
		lp->AddSubItemText(pItem->m_sDesc);
		CTreeItem *pSub(NULL);
		if (pTree)
			pSub = InsertItem(pTree, lp);
		else
			pSub = InsertRootItem(lp);

		for (p->MoveToFirst(); !p->IsOut(); p->MoveToNext())
		{
			InitializeSubGrid(p->GetCurData(), pSub);
		}
	}
	break;
	case TYPE_WBoolItem:
	{
		WBoolItem *p((WBoolItem*)pItem);
		CItemInfo* lp = new CItemInfo();
		lp->setDataType(CItemInfo::WBool);
		lp->SetImage(0);
		lp->SetItemText(pItem->m_sName);
		if (p->m_data)
			lp->AddSubItemText(_T("是"));
		else
			lp->AddSubItemText(_T("否"));
		lp->SetControlType(lp->combobox, 0);
		CStringList list;
		list.AddTail(_T("是"));
		list.AddTail(_T("否"));
		lp->SetListData(0, &list);
		lp->AddSubItemText(pItem->m_sDesc);
		InsertItem(pTree, lp);
	}
	break;
	case TYPE_WCharItem:
	{
		WCharItem *p((WCharItem*)pItem);
		CItemInfo* lp = new CItemInfo();
		lp->setDataType(CItemInfo::WChar);
		lp->SetImage(0);
		lp->SetItemText(pItem->m_sName);
		lp->AddSubItemText(p->m_data);
		lp->AddSubItemText(pItem->m_sDesc);
		InsertItem(pTree, lp);
	}
	break;
	case TYPE_WLongItem:
	{
		WLongItem *p((WLongItem*)pItem);
		CItemInfo* lp = new CItemInfo();
		lp->setDataType(CItemInfo::WLong);
		lp->SetImage(0);
		lp->SetItemText(pItem->m_sName);
		CString s;
		s.Format(_T("%d"), p->m_data);
		lp->AddSubItemText(s);
		lp->AddSubItemText(pItem->m_sDesc);
		InsertItem(pTree, lp);
	}
	break;
	case TYPE_WDoubleItem:
	{
		WDoubleItem *p((WDoubleItem*)pItem);
		CItemInfo* lp = new CItemInfo();
		lp->setDataType(CItemInfo::WDouble);
		lp->SetImage(0);
		lp->SetItemText(pItem->m_sName);
		CString s;
		s.Format(_T("%.2f"), p->m_data);
		lp->AddSubItemText(s);
		lp->AddSubItemText(pItem->m_sDesc);
		InsertItem(pTree, lp);
	}
	break;
	case TYPE_WCStringItem:
	{
		WCStringItem *p((WCStringItem*)pItem);
		CItemInfo* lp = new CItemInfo();
		lp->setDataType(CItemInfo::WCString);
		lp->SetImage(0);
		lp->SetItemText(pItem->m_sName);
		lp->AddSubItemText(p->m_data);
		lp->AddSubItemText(pItem->m_sDesc);
		InsertItem(pTree, lp);
	}
	break;
	case TYPE_WSelectItem:
	{
		WSelectItem *p((WSelectItem*)pItem);
		CItemInfo* lp = new CItemInfo();
		lp->setDataType(CItemInfo::WCombo);
		lp->SetImage(0);
		lp->SetItemText(pItem->m_sName);
		CStringList list;
		for (p->MoveToFirst(); !p->IsOut(); p->MoveToNext())
			list.AddTail(p->GetCurData());
		POSITION pos = list.FindIndex(p->m_data);
		lp->AddSubItemText(list.GetAt(pos));
		lp->SetControlType(lp->combobox, 0);
		lp->SetListData(0, &list);
		lp->AddSubItemText(pItem->m_sDesc);
		InsertItem(pTree, lp);
	}
	break;
	default:
		break;
	}
}

void WDictGridList::InitializeGrid(void)
{
	SetExtendedStyle(LVS_EX_GRIDLINES);

	LPCTSTR lpszCols[] = { _T("类型\\选项"),_T("值"),_T("描述信息"),0 };
	LV_COLUMN   lvColumn;
	//initialize the columns
	lvColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	lvColumn.fmt = LVCFMT_LEFT;
	lvColumn.cx = 200;
	for (int x = 0; lpszCols[x] != NULL; x++)
	{
		if (x)
			lvColumn.cx = 150;

		lvColumn.pszText = const_cast<LPTSTR>(lpszCols[x]);
		InsertColumn(x, &lvColumn);
	}

	if (!m_pDict) return;
	WDict *pDict(m_pDict);
	for (pDict->MoveToFirst(); !pDict->IsOut(); pDict->MoveToNext())
	{
		WDictItem *pCurDict = pDict->GetCurData();
		if (pCurDict == NULL)
			continue;
		InitializeSubGrid(pCurDict, NULL);
	}
}

CItemInfo* WDictGridList::CopyData(CItemInfo* lpSrc)
{
	ASSERT(lpSrc != NULL);
	CItemInfo* lpDest = new CItemInfo;
	lpDest->CopyObjects(lpSrc);
	return lpDest;
}

void WDictGridList::OnControlLButtonDown(UINT nFlags, CPoint point, LVHITTESTINFO & ht)
{
	CTreeItem*pSelItem = GetTreeItem(ht.iItem);
	if (pSelItem != NULL)
	{
		CItemInfo* pInfo = GetData(pSelItem);
		CItemInfo::CONTROLTYPE ctrlType;
		if (pInfo->GetControlType(ht.iSubItem - 1, ctrlType))
		{
			if (ctrlType == pInfo->combobox)
			{
				CStringList* list = NULL;
				pInfo->GetListData(ht.iSubItem - 1, list);
				if (list)
				{
					CComboBox * pList = ShowList(ht.iItem, ht.iSubItem, list);
				}
			}
		}
		/*
		else //activate default edit control
			CSuperGridCtrl::OnControlLButtonDown(nFlags, point, ht);
		*/
	}
}

void WDictGridList::OnUpdateListViewItem(CTreeItem * lpItem, LV_ITEM * plvItem)
{
	//put some extra validation here 
	CString str = (CString)plvItem->pszText;
	if (!str.Compare(_T("Bugs: Impossible")))
	{
		str += _T(" (selfconfidence allright)");//that's valid enough	:?
		CItemInfo *lp = GetData(lpItem);
		if (lp != NULL)
		{
			if (plvItem->iSubItem == 0)
				lp->SetItemText(str);
			else //subitem data 
				lp->SetSubItemText(plvItem->iSubItem - 1, str);
			UpdateData(lpItem, lp); //update internal nodes
		}
		SetItemText(plvItem->iItem, plvItem->iSubItem, str.GetBuffer(1));
	}
	else
		CSuperGridCtrl::OnUpdateListViewItem(lpItem, plvItem);
}


BOOL WDictGridList::OnVkReturn(void)
{
	BOOL bResult = FALSE;
	int iItem = GetNextItem(-1, LVNI_ALL | LVNI_SELECTED);
	if (GetCurSubItem() != -1 && iItem != -1)
	{
		CTreeItem*pSelItem = GetTreeItem(iItem);
		if (pSelItem != NULL)
		{
			CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);
			int iSubItem = Header_OrderToIndex(pHeader->m_hWnd, GetCurSubItem());
			CItemInfo* pInfo = GetData(pSelItem);
			CItemInfo::CONTROLTYPE ctrlType;
			if (pInfo->GetControlType(iSubItem - 1, ctrlType))
			{
				switch (ctrlType)
				{
					/*put in your own control here*/
				case pInfo->datecontrol:break;
				case pInfo->spinbutton:break;
				case pInfo->dropdownlistviewwhatevercontrol:break;
				case pInfo->combobox:
				{

					CStringList* list = NULL;
					pInfo->GetListData(iSubItem - 1, list);
					CComboBox * pList = ShowList(iItem, iSubItem, list);
					bResult = TRUE; //I'll handle it from here
				}break;
				default:break;
				}
			}
		}
	}
	return bResult;
}

BOOL WDictGridList::OnItemLButtonDown(LVHITTESTINFO & ht)
{
	return 1;
}

CComboBox * WDictGridList::ShowList(int nItem, int nCol, CStringList * lstItems)
{
	CString strFind = GetItemText(nItem, nCol);

	//basic code start
	CRect rect;
	int offset = 0;
	// Make sure that the item is visible
	if (!EnsureVisible(nItem, TRUE)) return NULL;
	GetSubItemRect(nItem, nCol, LVIR_BOUNDS, rect);
	// Now scroll if we need to expose the column
	CRect rcClient;
	GetClientRect(rcClient);
	if (offset + rect.left < 0 || offset + rect.left > rcClient.right)
	{
		CSize size;
		size.cx = offset + rect.left;
		size.cy = 0;
		Scroll(size);
		rect.left -= size.cx;
	}

	rect.left += offset;
	rect.right = rect.left + GetColumnWidth(nCol);
	if (rect.right > rcClient.right)
		rect.right = rcClient.right;
	//basic code end

	rect.bottom += 10 * rect.Height();//dropdown area

	DWORD dwStyle = WS_CHILD
		| WS_VISIBLE
		| WS_VSCROLL
		//| WS_HSCROLL
		| CBS_DROPDOWNLIST
		| CBS_NOINTEGRALHEIGHT
		| CBS_DISABLENOSCROLL;
	CComboBox *pList = new CComboInListView(nItem, nCol, lstItems);
	pList->Create(dwStyle, rect, this, IDC_COMBOBOXINLISTVIEW);
	pList->ModifyStyleEx(0, WS_EX_CLIENTEDGE);//can we tell at all
	pList->SetHorizontalExtent(CalcHorzExtent(pList, lstItems));
	pList->SelectString(0, strFind);
	pList->ShowDropDown();
	m_iOldIdx = pList->GetCurSel();
	// The returned pointer should not be saved
	return pList;
}

int WDictGridList::CalcHorzExtent(CWnd * pWnd, CStringList * pList)
{
	int nExtent = 0;
	if (pWnd != NULL)
	{
		CDC* pDC = pWnd->GetDC();
		HFONT hFont = (HFONT)pWnd->SendMessage(WM_GETFONT); //why not pWnd->GetFont();..I like the send thing alot and
		CFont *pFont = CFont::FromHandle(hFont);			//this way I get to use this function..cool :)
		if (pFont != NULL)										//ya what ever makes me happy,.right :}
		{
			CFont* pOldFont = pDC->SelectObject(pFont);
			CSize newExtent;
			POSITION pos = pList->GetHeadPosition();
			while (pos != NULL)
			{
				CString str(pList->GetNext(pos));
				newExtent = pDC->GetTextExtent(str);
				newExtent.cx += 6;
				if (newExtent.cx > nExtent)
				{
					nExtent = newExtent.cx;
				}
			}
			pDC->SelectObject(pOldFont);
		}
		pWnd->ReleaseDC(pDC);
	}
	return nExtent;
}

int WDictGridList::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CSuperGridCtrl::OnCreate(lpCreateStruct) == -1)
		return -1;
	if (!m_image.Create(IDB_DIM_CONFIG_IMG, 16, 1, RGB(0, 255, 255)))
		return -1;

	SetImageList(&m_image, LVSIL_SMALL);
	CImageList *pImageList = GetImageList(LVSIL_SMALL);
	if (pImageList)
		ImageList_GetIconSize(pImageList->m_hImageList, &m_cxImage, &m_cyImage);
	else
		return -1;

	double dScale(CoreTools::GetDPIScale());
	m_cxImage = static_cast<int>(m_cxImage * dScale);
	m_cyImage = static_cast<int>(m_cyImage * dScale);

	return 0;
}

int WDictGridList::FindItemByName(LPCTSTR pszName)
{
	LVFINDINFO info;
	info.flags = LVFI_PARTIAL | LVFI_STRING;
	info.psz = pszName;
	return FindItem(&info);
}

void WDictGridList::saveToWDict(WDict &dict)
{
	int count = GetItemCount();
	CString str0, str1, str2;
	dict.m_sName = _T("系统参数配置");
	dict.m_sDesc = _T("1");
	for (int i = 0; i < count; ++i)
	{
		CTreeItem *pTree = GetTreeItem(i);
		if (!GetParentItem(pTree))
			treeItemToWDict(pTree, &dict);
	}
}

void WDictGridList::treeItemToWDict(CTreeItem *pTree, WDict *pDict)
{
	CItemInfo *pInfo = GetData(pTree);
	switch (pInfo->getDataType())
	{
	case CItemInfo::WDict:
	{
		WDict *pNewDict = new WDict();
		pNewDict->m_sName = pInfo->GetItemText();
		pNewDict->m_sDesc = pInfo->GetSubItem(1);

		POSITION pos = GetHeadPosition(pTree);
		while (pos)
		{
			CTreeItem *pSub = GetNextChild(pTree, pos);
			treeItemToWDict(pSub, pNewDict);
		}
		pDict->AddTail(pNewDict);
	}
	break;
	case CItemInfo::WBool:
	{
		WBoolItem *p = new WBoolItem();
		p->m_sName = pInfo->GetItemText();
		p->m_sDesc = pInfo->GetSubItem(1);
		p->m_data = pInfo->GetSubItem(0) == _T("是") ? TRUE : FALSE;
		pDict->AddTail(p);
	}
	break;
	case CItemInfo::WChar:
	{
		WCharItem *p = new WCharItem();
		p->m_sName = pInfo->GetItemText();
		p->m_sDesc = pInfo->GetSubItem(1);
		p->m_data = pInfo->GetSubItem(0).GetAt(0);
		pDict->AddTail(p);
	}
	break;
	case CItemInfo::WLong:
	{
		WLongItem *p = new WLongItem();
		p->m_sName = pInfo->GetItemText();
		p->m_sDesc = pInfo->GetSubItem(1);
		p->m_data = _ttoi(pInfo->GetSubItem(0));
		pDict->AddTail(p);
	}
	break;
	case CItemInfo::WDouble:
	{
		WDoubleItem *p = new WDoubleItem();
		p->m_sName = pInfo->GetItemText();
		p->m_sDesc = pInfo->GetSubItem(1);
		p->m_data = _wtof(pInfo->GetSubItem(0));
		pDict->AddTail(p);
	}
	break;
	case CItemInfo::WCString:
	{
		WCStringItem *p = new WCStringItem();
		p->m_sName = pInfo->GetItemText();
		p->m_sDesc = pInfo->GetSubItem(1);
		p->m_data = pInfo->GetSubItem(0);
		pDict->AddTail(p);
	}
	break;
	case CItemInfo::WCombo:
	{
		WSelectItem *p = new WSelectItem();
		p->m_sName = pInfo->GetItemText();
		p->m_sDesc = pInfo->GetSubItem(1);
		CString s = pInfo->GetSubItem(0);
		CStringList *pList(NULL);
		pInfo->GetListData(0, pList);
		if (pList)
		{
			POSITION pos = pList->GetHeadPosition();
			int idx(0), _idx(0);
			CString ss(_T(""));
			while (pos)
			{
				ss = pList->GetNext(pos);
				if (ss == s) idx = _idx;
				p->AddTail(ss);
				_idx++;
			}
			p->m_data = idx;
		}
		pDict->AddTail(p);
	}
	break;
	default:
		break;
	}
}

void WDictGridList::modifyPsCombo(const int &iTitleItem, const int &curIdx)
{
	CString str = GetItemText(iTitleItem, 0);
	if (str != _T("标注单位")) return;

	if (m_iOldIdx == curIdx) return;

	int idxPs = FindItemByName(_T("模型空间默认当前比例"));
	if (idxPs == -1) return;

	CString strPs = GetItemText(idxPs, 1);
	
	double dPscale(_wtof(strPs));
	if (m_iOldIdx == 0 && curIdx == 1) // mm -> M
		dPscale /= 1000.0;
	else if (m_iOldIdx == 1 && curIdx == 0) // M -> mm
		dPscale *= 1000.0;

	str.Format(_T("%.2f"), dPscale);

	CTreeItem *pTree = GetTreeItem(idxPs);
	if (pTree != NULL)
	{
		CItemInfo *pInfo = GetData(pTree);
		if (pInfo)
		{
			pInfo->SetSubItemText(0, str);
			//UpdateData(pTree, pInfo);
		}
		SetItemText(idxPs, 1, str);
	}

	m_iOldIdx = curIdx;
}

BOOL WDictGridList::OnDeleteItem(CTreeItem* pItem, int nIndex)
{
	return 1;
}



BOOL WDictGridList::OnItemExpanding(CTreeItem *pItem, int iItem)
{
	return 1;
}


BOOL WDictGridList::OnItemExpanded(CTreeItem* pItem, int iItem)
{
	return 1;
}


BOOL WDictGridList::OnCollapsing(CTreeItem *pItem)
{
	return 1;
}



BOOL WDictGridList::OnItemCollapsed(CTreeItem *pItem)
{
	return 1;
}

#pragma endregion