// MergeView.cpp
//
// (c)1998-2025 Codejock Software, All Rights Reserved.
//
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
// CONSENT OF CODEJOCK SOFTWARE.
//
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
// IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
// SINGLE COMPUTER.
//
// CONTACT INFORMATION:
// support@codejock.com
// http://www.codejock.com
//
/////////////////////////////////////////////////////////////////////////////

#include "StdAfx.h"
#include "GridSample.h"
#include "MergeView.h"
#include "GridSampleView.h"
#include "resource.h"

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

//////////////////////////////////////////////////////////////////////////
// CMergeFrame

BEGIN_MESSAGE_MAP(CMergeFrame, CFrameWnd)
	//{{AFX_MSG_MAP(CMergeFrame)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

static UINT indicators[] = {
	ID_SEPARATOR, // status line indicator
	ID_INDICATOR_CAPS,
	ID_INDICATOR_NUM,
	ID_INDICATOR_SCRL,
};

int CMergeFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	if (!m_wndStatusBar.Create(this)
		|| !m_wndStatusBar.SetIndicators(indicators, sizeof(indicators) / sizeof(UINT)))
	{
		TRACE0("Failed to create status bar\n");
		return -1; // fail to create
	}

#ifdef _XTP_INCLUDE_COMMANDBARS

	if (!InitCommandBars())
		return -1;

	CXTPCommandBars* pCommandBars = GetCommandBars();

	pCommandBars->SetMenu(_T("Menu Bar"), IDR_MERGE);
	pCommandBars->SetAllCaps(FALSE);
	pCommandBars->SetTheme(xtpThemeNativeWinXP);
	pCommandBars->GetPaintManager()->m_bAutoResizeIcons = TRUE;

#endif

	return 0;
}

void CMergeFrame::OnDestroy()
{
	((CGridSampleView*)m_pOwnerView)->m_pWndMerge = NULL;

	CFrameWnd::OnDestroy();
}

/////////////////////////////////////////////////////////////////////////////
// CMergeView

IMPLEMENT_DYNCREATE(CMergeView, CXTPGridView)

CMergeView::CMergeView()
	: m_bAutoSizing(TRUE)
	, m_bWatermark(FALSE)
	, m_pPreviewState(NULL)
{
}

CMergeView::~CMergeView()
{
}

BEGIN_MESSAGE_MAP(CMergeView, CXTPGridView)
	//{{AFX_MSG_MAP(CMergeView)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, OnFilePrintPreview)

	ON_COMMAND_RANGE(ID_GRID_HORIZONTAL_NOGRIDLINES, ID_GRID_HORIZONTAL_SOLID, OnGridHorizontal)
	ON_COMMAND_RANGE(ID_GRID_VERTICAL_NOGRIDLINES, ID_GRID_VERTICAL_SOLID, OnGridVertical)
	ON_UPDATE_COMMAND_UI_RANGE(ID_GRID_HORIZONTAL_NOGRIDLINES, ID_GRID_HORIZONTAL_SOLID,
							   OnUpdateGridHorizontal)
	ON_UPDATE_COMMAND_UI_RANGE(ID_GRID_VERTICAL_NOGRIDLINES, ID_GRID_VERTICAL_SOLID,
							   OnUpdateGridVertical)

	// Command handler
	ON_COMMAND(ID_GRIDCONTROL_ALLOWEDIT, OnGridAllowEdit)
	ON_COMMAND(ID_GRIDCONTROL_EDITONCLICK, OnGridEditOnClick)

	ON_COMMAND(ID_GRIDCONTROL_AUTOSIZING, OnGridAutoSizing)
	ON_COMMAND(ID_GRIDCONTROL_FOCUSSUBITEMS, OnGridFocusSubItems)
	ON_COMMAND(ID_GRIDCONTROL_WATERMARK, OnGridWatermark)

	// Update handler
	ON_UPDATE_COMMAND_UI(ID_GRIDCONTROL_ALLOWEDIT, OnUpdateGridAllowEdit)
	ON_UPDATE_COMMAND_UI(ID_GRIDCONTROL_EDITONCLICK, OnUpdateGridEditOnClick)

	ON_UPDATE_COMMAND_UI(ID_GRIDCONTROL_AUTOSIZING, OnUpdateGridAutoSizing)
	ON_UPDATE_COMMAND_UI(ID_GRIDCONTROL_FOCUSSUBITEMS, OnUpdateGridFocusSubItems)
	ON_UPDATE_COMMAND_UI(ID_GRIDCONTROL_WATERMARK, OnUpdateGridWatermark)

	//}}AFX_MSG_MAP

END_MESSAGE_MAP()

	/////////////////////////////////////////////////////////////////////////////
	// CMergeView drawing

	/////////////////////////////////////////////////////////////////////////////
	// CMergeView diagnostics

#ifdef _DEBUG
void CMergeView::AssertValid() const
{
	CView::AssertValid();
}

void CMergeView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMergeView message handlers

int CMergeView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CXTPGridView::OnCreate(lpCreateStruct) == -1)
		return -1;

	CXTPGridControl& wndGrid = GetGridCtrl();

	int nWidth				 = 0;
	CString type			 = _T("RT_SVG");
	CXTPImageManager* imgMgr = wndGrid.GetImageManager();

	nWidth = XTP_DPI_X(16);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_SMALL_DOCUMENT, 0, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_SMALL_EXCLAMATION_BLUE, 1, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_SMALL_BOOKMARK, 2, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_SMALL_MAIL, 3, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_SMALL_MAIL_OPEN, 4, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_SMALL_MAIL_ARROW_LEFT, 5, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_SMALL_EXCLAMATION_RED, 6, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_SMALL_PIN_BLUE, 7, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_SMALL_PIN_RED, 8, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_SMALL_BUTTON_ARROW_DOWN, 9, nWidth);

	nWidth = XTP_DPI_X(32);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_LARGE_DOCUMENT, 0, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_LARGE_EXCLAMATION_BLUE, 1, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_LARGE_BOOKMARK, 2, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_LARGE_MAIL, 3, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_LARGE_MAIL_OPEN, 4, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_LARGE_MAIL_ARROW_LEFT, 5, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_LARGE_EXCLAMATION_RED, 6, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_LARGE_PIN_BLUE, 7, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_LARGE_PIN_RED, 8, nWidth);
	imgMgr->SetVectorIcon(type, IDR_SVG_GRID_LARGE_BUTTON_ARROW_DOWN, 9, nWidth);

	wndGrid.AllowEdit(TRUE);
	wndGrid.PreviewAllowEdit(TRUE);
	wndGrid.EnablePreviewMode(TRUE);
	wndGrid.ShowHeaderRows(TRUE);
	wndGrid.ShowFooterRows(TRUE);
	wndGrid.PinFooterRows(FALSE);

	int nFreezeCount = 3;
	int nColumnCount = 6;
	int nHeaderCount = 5;
	int nFooterCount = 5;
	int nRecordCount = 20;
	int nColumn;
	int nRecord;
	int nFreeze;

	CXTPGridRecord* pRecord;

	for (nFreeze = 0; nFreeze < nFreezeCount; nFreeze++)
	{
		CString sName;
		sName.Format(_T("Freeze %d"), nFreeze);
		wndGrid.AddColumn(new CXTPGridColumn(nFreeze, sName, 140, TRUE));
	}

	for (nColumn = nFreezeCount; nColumn < nFreezeCount + nColumnCount; nColumn++)
	{
		CString sName;
		sName.Format(_T("Column %d"), nColumn);
		CXTPGridColumn* pColumn = new CXTPGridColumn(nColumn, sName, 140, TRUE);
		pColumn					= wndGrid.AddColumn(pColumn);

		/*
				if (1+nFreezeCount == nColumn ||
					 2+nFreezeCount == nColumn)
				{
					CXTPGridRecordItemEditOptions *pEditOptions = pColumn->GetEditOptions();
					pEditOptions->AddConstraint(_T("Column Constraint 0"), 0);
					pEditOptions->AddConstraint(_T("Column Constraint 1"), 1);
					pEditOptions->AddConstraint(_T("Column Constraint 2"), 2);
					pEditOptions->m_bConstraintEdit = TRUE;
					pEditOptions->m_bAllowEdit = TRUE;
					pEditOptions->AddComboButton(TRUE);
				}
		*/
	}

	//////////////////////////////////////////////////////////////////////////
	// Add header records
	//////////////////////////////////////////////////////////////////////////

	for (nRecord = 0; nRecord < nHeaderCount; nRecord++)
	{
		pRecord = wndGrid.GetHeaderRecords()->Add(new CXTPGridRecord());

		for (nFreeze = 0; nFreeze < nFreezeCount; nFreeze++)
		{
			CString sText;
			sText.Format(_T("Freeze %d, %d"), nRecord, nFreeze);

			CXTPGridRecordItemText* pItem = new CXTPGridRecordItemText(sText);
			pItem->SetIconIndex(nFreeze);
			pRecord->AddItem(pItem);
		}
		for (nColumn = 0; nColumn < nColumnCount; nColumn++)
		{
			CString sText;
			sText.Format(_T("Header %d, %d"), nRecord, nColumn);

			CXTPGridRecordItemText* pItem = new CXTPGridRecordItemText(sText);
			pItem->SetIconIndex(nColumn);
			pRecord->AddItem(pItem);
		}
	}

	//////////////////////////////////////////////////////////////////////////
	// Add records
	//////////////////////////////////////////////////////////////////////////

	for (nRecord = 0; nRecord < nRecordCount; nRecord++)
	{
		pRecord = wndGrid.AddRecord(new CXTPGridRecord());

		for (nFreeze = 0; nFreeze < nFreezeCount; nFreeze++)
		{
			CString sText;
			sText.Format(_T("Freeze %d, %d"), nRecord, nFreeze);

			CXTPGridRecordItemText* pItem = new CXTPGridRecordItemText(sText);
			pItem->SetIconIndex(nFreeze);
			pRecord->AddItem(pItem);
		}
		for (nColumn = 0; nColumn < nColumnCount; nColumn++)
		{
			CString sText;

			if (1 == nColumn && 1 == nRecord)
			{
				sText.Format(_T("Long text for merged item %d, %d"), nRecord, nColumn);
			}
			else
			{
				sText.Format(_T("Row %d, %d"), nRecord, nColumn);
			}

			CXTPGridRecordItemText* pItem = new CXTPGridRecordItemText(sText);
			// pItem->SetIconIndex(nColumn);
			pRecord->AddItem(pItem);
		}

		if (nRecord >= 5 && nRecord <= 10 && FALSE)
		{
			CString sText;
			sText.Format(_T("Item preview for row %d"), nRecord);
			CXTPGridRecordItemPreview* pItem = new CXTPGridRecordItemPreview(sText);
			pItem->SetIconIndex(4);
			pRecord->SetPreviewItem(pItem);
		}
	}

	//////////////////////////////////////////////////////////////////////////
	//
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	// Add footer records
	//////////////////////////////////////////////////////////////////////////

	for (nRecord = 0; nRecord < nFooterCount; nRecord++)
	{
		pRecord = wndGrid.GetFooterRecords()->Add(new CXTPGridRecord());

		for (nFreeze = 0; nFreeze < nFreezeCount; nFreeze++)
		{
			CString sText;
			sText.Format(_T("Freeze %d, %d"), nRecord, nFreeze);

			CXTPGridRecordItemText* pItem = new CXTPGridRecordItemText(sText);
			pItem->SetIconIndex(nFreeze);
			pRecord->AddItem(pItem);
		}
		for (nColumn = 0; nColumn < nColumnCount; nColumn++)
		{
			CString sText;
			sText.Format(_T("Footer %d, %d"), nRecord, nColumn);

			CXTPGridRecordItemText* pItem = new CXTPGridRecordItemText(sText);
			pItem->SetIconIndex(nColumn);
			pRecord->AddItem(pItem);
		}
	}

	wndGrid.AllowEdit(TRUE);

	for (nColumn = 0; nColumn < nFreezeCount + nColumnCount; nColumn++)
	{
		CXTPGridColumn* pColumn = wndGrid.GetColumns()->GetAt(nColumn);

		pColumn->SetAlignment(xtpColumnTextWordBreak | xtpColumnTextVCenter);
		//	pColumn->EnableResize(TRUE);
		pColumn->GetEditOptions()->m_dwEditStyle |= ES_MULTILINE | ES_AUTOVSCROLL | ES_WANTRETURN;
	}

	wndGrid.m_bFreeHeightMode = TRUE; // possibility to resize rows
	// wndGrid.GetPaintManager()->SetFixedRowHeight(FALSE);

	wndGrid.FocusSubItems(TRUE);
	wndGrid.Populate();

	wndGrid.GetGridHeader()->SetAutoColumnSizing(FALSE);
	wndGrid.AdjustScrollBars();

	wndGrid.GetGridHeader()->AllowColumnRemove(FALSE);
	wndGrid.SetFreezeColumnsCount(nFreezeCount);

#if _XTPLIB_VERSION_PREFIX >= 1511
	wndGrid.GetPaintManager()->m_bAllowMergeCells = TRUE;
	wndGrid.GetHeaderRecords()->MergeItems(CXTPGridRecordItemRange(3, 4, 1, 2));
	wndGrid.GetHeaderRecords()->MergeItems(CXTPGridRecordItemRange(1, 1, 1, 2));

	wndGrid.GetFooterRecords()->MergeItems(CXTPGridRecordItemRange(2, 3, 3, 4));
	wndGrid.GetFooterRecords()->MergeItems(CXTPGridRecordItemRange(0, 0, 3, 4));
	wndGrid.GetFooterRecords()->MergeItems(CXTPGridRecordItemRange(5, 6, 2, 3));

	wndGrid.GetRecords()->MergeItems(CXTPGridRecordItemRange(4, 6, 1, 4));
	wndGrid.GetRecords()->MergeItems(CXTPGridRecordItemRange(2, 3, 3, 5));
	wndGrid.GetRecords()->MergeItems(CXTPGridRecordItemRange(0, 2, 17, 19));
	wndGrid.GetRecords()->MergeItems(CXTPGridRecordItemRange(7, 8, 7, 9));
#endif

	// wndGrid.ShowGroupBy(TRUE);

	wndGrid.GetPaintManager()->m_bShowNonActiveInPlaceButton = TRUE;
	wndGrid.GetPaintManager()->SetGridStyle(TRUE, xtpGridGridSolid);
#if _XTPLIB_VERSION_PREFIX >= 1511
//	wndGrid.GetPaintManager()->SetColumnStyle(xtpGridColumnResource);
#else
//	wndGrid.GetPaintManager()->SetColumnStyle(xtpGridColumnOffice2007);
#endif

	/*
		// Alternate background color
		wndGrid.GetPaintManager()->m_bUseAlternativeBackground = TRUE;
		wndGrid.GetPaintManager()->m_clrControlBack            = RGB(192,192,192);
		wndGrid.GetPaintManager()->m_clrAlternativeBackground  = RGB(160,160,160);
	*/

#if _XTPLIB_VERSION_PREFIX >= 1511
	// Constraints not supported in 15.1.1
	CXTPGridRecordItem* pItem;
	pItem										= wndGrid.GetRecords()->GetAt(1)->GetItem(0);
	CXTPGridRecordItemEditOptions* pEditOptions = pItem->GetEditOptions(NULL);
	pEditOptions->AddConstraint(_T("Constraint 0"), 0);
	pEditOptions->AddConstraint(_T("Constraint 1"), 1);
	pEditOptions->AddConstraint(_T("Constraint 2"), 2);
	pEditOptions->m_bConstraintEdit = TRUE;
	pEditOptions->m_bAllowEdit		= TRUE;
	pEditOptions->AddComboButton(TRUE);
#endif

	wndGrid.ShowGroupBy(TRUE);
	wndGrid.SetFocus();

	// wndGrid.GetPaintManager()->m_clrControlBack = RGB(255,0,0);

	return 0;
}

void CMergeView::OnDestroy()
{
	base::OnDestroy();

	// Close print preview
	if (NULL != m_pPreviewState)
	{
		m_pPreviewState->lpfnCloseProc((CFrameWnd*)AfxGetMainWnd());
		m_pPreviewState = NULL;
	}
}

void CMergeView::OnEndPrintPreview(CDC* pDC, CPrintInfo* pInfo, POINT point, CPreviewView* pView)
{
	base::OnEndPrintPreview(pDC, pInfo, point, pView);
	m_pPreviewState = NULL;
}

void CMergeView::OnGridHorizontal(UINT nID)
{
	GetGridCtrl().SetGridStyle(FALSE, (XTPGridGridStyle)(nID - ID_GRID_HORIZONTAL_NOGRIDLINES));
}

void CMergeView::OnGridVertical(UINT nID)
{
	GetGridCtrl().SetGridStyle(TRUE, (XTPGridGridStyle)(nID - ID_GRID_VERTICAL_NOGRIDLINES));
}

void CMergeView::OnUpdateGridHorizontal(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(((int)pCmdUI->m_nID - ID_GRID_HORIZONTAL_NOGRIDLINES)
					 == GetGridCtrl().GetGridStyle(FALSE));
}

void CMergeView::OnUpdateGridVertical(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(((int)pCmdUI->m_nID - ID_GRID_VERTICAL_NOGRIDLINES)
					 == GetGridCtrl().GetGridStyle(TRUE));
}

void CMergeView::OnGridAllowEdit()
{
	GetGridCtrl().AllowEdit(!GetGridCtrl().IsAllowEdit());

	CXTPGridSections* pSections		= GetGridCtrl().GetSections();
	CXTPGridSection* pSectionHeader = pSections->GetAt(xtpGridSectionHeader);
	pSectionHeader->AllowEdit(GetGridCtrl().IsAllowEdit());

	CXTPGridSection* pSectionFooter = pSections->GetAt(xtpGridSectionFooter);
	pSectionFooter->AllowEdit(GetGridCtrl().IsAllowEdit());
}

void CMergeView::OnUpdateGridAllowEdit(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(GetGridCtrl().IsAllowEdit() ? TRUE : FALSE);
}

void CMergeView::OnGridEditOnClick()
{
	GetGridCtrl().EditOnClick(!GetGridCtrl().IsEditOnClick());
}

void CMergeView::OnUpdateGridEditOnClick(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(GetGridCtrl().IsAllowEdit() && GetGridCtrl().IsEditOnClick() ? TRUE : FALSE);

	if (!GetGridCtrl().IsAllowEdit())
		pCmdUI->Enable(FALSE);
}

void CMergeView::OnGridFocusSubItems()
{
	GetGridCtrl().FocusSubItems(!GetGridCtrl().IsFocusSubItems());
}

void CMergeView::OnUpdateGridFocusSubItems(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(GetGridCtrl().IsFocusSubItems() ? TRUE : FALSE);
}

void CMergeView::OnUpdateGridAutoSizing(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(m_bAutoSizing ? 1 : 0);
}

void CMergeView::OnGridAutoSizing()
{
	m_bAutoSizing = !m_bAutoSizing;

	for (int nColumn = 3; nColumn < GetGridCtrl().GetColumns()->GetCount(); nColumn++)
	{
		GetGridCtrl().GetColumns()->GetAt(nColumn)->SetAutoSize(m_bAutoSizing);
	}
}

void CMergeView::OnFilePrintPreview()
{
#ifdef _XTP_INCLUDE_COMMANDBARS
	// In derived classes, implement special window handling here
	// Be sure to Unhook Frame Window close if hooked.

	// must not create this on the frame.  Must outlive this function
	m_pPreviewState = new CPrintPreviewState;

	// DoPrintPreview's return value does not necessarily indicate that
	// Print preview succeeded or failed, but rather what actions are necessary
	// at this point.  If DoPrintPreview returns TRUE, it means that
	// OnEndPrintPreview will be (or has already been) called and the
	// pState structure will be/has been deleted.
	// If DoPrintPreview returns FALSE, it means that OnEndPrintPreview
	// WILL NOT be called and that cleanup, including deleting pState
	// must be done here.

	if (!DoPrintPreview(XTP_IDD_PREVIEW_DIALOGBAR, this, RUNTIME_CLASS(CXTPPreviewView),
						m_pPreviewState))
	{
		// In derived classes, reverse special window handling here for
		// Preview failure case
		TRACE0("Error: DoPrintPreview failed.\n");
		AfxMessageBox(AFX_IDP_COMMAND_FAILURE);
		delete m_pPreviewState;
		m_pPreviewState = NULL;
	}
#else
	CXTPGridView::OnFilePrintPreview();
#endif
}

/////////////////////////////////////////////////////////////////////////////

void CMergeView::OnGridWatermark()
{
	CXTPGridControl& wndGrid = GetGridCtrl();

	m_bWatermark = !m_bWatermark;

	if (m_bWatermark)
	{
		CBitmap bmpWatermark;

		if (bmpWatermark.LoadBitmap(IDB_CODEJOCKGEAR))
		{
			wndGrid.SetWatermarkBitmap(bmpWatermark, 64);
			wndGrid.GetPaintManager()->m_bPrintWatermark = TRUE;
		}
	}
	else
	{
		wndGrid.SetWatermarkBitmap(HBITMAP(NULL), 0);
		wndGrid.GetPaintManager()->m_bPrintWatermark = FALSE;
	}

	wndGrid.RedrawControl();
}

void CMergeView::OnUpdateGridWatermark(CCmdUI* pCmdUI)
{
	pCmdUI->Enable(TRUE);
	pCmdUI->SetCheck(m_bWatermark ? 0 : 1);
}