// MDITextEditorView.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 "MDITextEditor.h"

#include "MDITextEditorDoc.h"
#include "MDITextEditorView.h"
#include "MainFrm.h"

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

enum SyntaxEditUpdateViewHint
{
	xtpHintWhiteSpace = (xtpEditHintLast + 1),
};

/////////////////////////////////////////////////////////////////////////////
// CMDITextEditorView

IMPLEMENT_DYNCREATE(CMDITextEditorView, CViewBase)

BEGIN_MESSAGE_MAP(CMDITextEditorView, CViewBase)
	//{{AFX_MSG_MAP(CMDITextEditorView)
	ON_WM_CONTEXTMENU()
	ON_COMMAND(ID_EDIT_FIND_SILENT, OnEditFindSilent)
	ON_COMMAND(ID_EDIT_TABIFY, OnEditTabify)
	ON_COMMAND(ID_EDIT_UNTABIFY, OnEditUnTabify)
	ON_COMMAND(ID_EDIT_UPPERCASE, OnEditUppercase)
	ON_COMMAND(ID_EDIT_LOWERCASE, OnEditLowercase)
	ON_COMMAND(ID_EDIT_WHITESPACE, OnEditWhiteSpace)
	ON_UPDATE_COMMAND_UI(ID_EDIT_WHITESPACE, OnUpdateEditWhiteSpace)
	ON_COMMAND(ID_EDIT_COLLAPSEALL, OnEditCollapseAll)
	ON_COMMAND(ID_EDIT_EXPANDALL, OnEditExpandAll)
	ON_COMMAND(ID_TOOLS_BOOKMARK, OnToolsBookmark)
	ON_COMMAND(ID_TOOLS_BREAKPOINT, OnToolsBreakpoint)
	ON_COMMAND(ID_TOOLS_NEXT_BOOKMARK, OnToolsNextBookmark)
	ON_UPDATE_COMMAND_UI(ID_TOOLS_NEXT_BOOKMARK, OnUpdateToolsNextBookmark)
	ON_COMMAND(ID_TOOLS_PREV_BOOKMARK, OnToolsPrevBookmark)
	ON_UPDATE_COMMAND_UI(ID_TOOLS_PREV_BOOKMARK, OnUpdateToolsPrevBookmark)
	ON_COMMAND(ID_TOOLS_OPTIONS, OnToolsOptions)
	ON_UPDATE_COMMAND_UI(ID_TOOLS_OPTIONS, OnUpdateToolsOptions)
	ON_COMMAND(ID_FILE_GOTO, OnFileGoTo)
	ON_COMMAND(ID_FILE_PAGE_SETUP, CViewBase::OnFilePageSetup)
	ON_COMMAND(ID_EDIT_READONLY, OnReadOnly)
	ON_UPDATE_COMMAND_UI(ID_EDIT_READONLY, OnUpdateReadOnly)
	ON_COMMAND(ID_TOOLS_RELOADSYNTAX, OnReloadSyntax)
	ON_COMMAND(ID_TOOLS_RELOADSYNTAX2INIMODE, OnReloadSyntax2IniMode)
	ON_COMMAND(ID_TOOLS_RELOADSYNTAXMODE, OnReloadSyntaxMode)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CViewBase::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CViewBase::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CViewBase::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMDITextEditorView construction/destruction

CMDITextEditorView::CMDITextEditorView()
	: m_dwLastUpdate(0)
	, m_dwParserStart(0)
{
	m_rcMargin.left   = 25;
	m_rcMargin.right  = 25;
	m_rcMargin.top	= 50;
	m_rcMargin.bottom = 50;

	CString sPath = CXTPSyntaxEditCtrl::GetModulePath();

	BOOL bFileMode = TRUE;
	// bFileMode = !bFileMode;

	// Add _tsetlocale call to allow some text functions (like isleadbyte) works correctly
	// A good place for this is CMainFrame implementation (see CMainFrame constructor).
	// EXAMPLE:
	// _tsetlocale(LC_ALL, _T(""));

	if (bFileMode)
		GetEditCtrl().SetConfigFile(CXTPSyntaxEditCtrl::GetModulePath()
									+ _T("EditConfig\\SyntaxEdit.ini"));
	// Test for remote config
	// GetEditCtrl().SetConfigFile(_T("\\\\Midc\\software\\TempFolderForTesting\\SyntaxEdit.ini"));

	if (!bFileMode)
	{
#include "_cpp1_schclass.h"
#include "ColorsDataEntry.h"

		GetEditCtrl().SetSyntaxAndColorScheme(sScheme, sColorTheme);
	}
}

void CMDITextEditorView::OnReloadSyntaxMode()
{
#include "_cpp2_schclass.h"
#include "ColorsDataEntry1.h"

	if (GetEditCtrl().GetEditBuffer())
		GetEditCtrl().SetSyntaxAndColorScheme(sScheme, sColorTheme);
}

void CMDITextEditorView::OnReloadSyntax2IniMode()
{
	GetEditCtrl().ReloadSyntaxConfigFileMode();
	CString sFile = CXTPSyntaxEditCtrl::GetModulePath() + _T("EditConfig\\SyntaxEdit.ini");

	CFileDialog dlg(TRUE, _T("ini"), _T("*.ini"));
	if (dlg.DoModal() == IDOK)
		sFile = dlg.GetPathName();
	GetEditCtrl().SetConfigFile(sFile);
}

void CMDITextEditorView::OnReloadSyntax()
{
#include "_cpp2_schclass.h"
#include "ColorsDataEntry1.h"

	if (GetEditCtrl().GetEditBuffer())
		GetEditCtrl().SetSyntaxAndColorScheme(sScheme, sColorTheme, TRUE, TRUE);
}

CMDITextEditorView::~CMDITextEditorView()
{
}

BOOL CMDITextEditorView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CViewBase::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CMDITextEditorView printing

BOOL CMDITextEditorView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return CViewBase::OnPreparePrinting(pInfo);
}

void CMDITextEditorView::OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
{
	CViewBase::OnBeginPrinting(pDC, pInfo);
}

void CMDITextEditorView::OnEndPrinting(CDC* pDC, CPrintInfo* pInfo)
{
	CViewBase::OnEndPrinting(pDC, pInfo);
}

void CMDITextEditorView::OnPrintHeader(CDC* pDC, CPrintInfo* pInfo)
{
	CXTPFontDC fontDC(pDC, GetEditCtrl().GetPaintManager()->GetFont(),
					  ::GetSysColor(COLOR_WINDOWTEXT));

	CPoint ptFrom;
	ptFrom.x = m_rcMargin.left;
	ptFrom.y = m_rcMargin.top - 5;
	pDC->MoveTo(ptFrom);

	CPoint ptTo;
	ptTo.x = pInfo->m_rectDraw.right - m_rcMargin.right;
	ptTo.y = m_rcMargin.top - 5;
	pDC->LineTo(ptTo);

	CString csPathName = GetDocument()->GetPathName();
	CString csFileName = csPathName.Right(csPathName.GetLength()
										  - (csPathName.ReverseFind('\\') + 1));

	if (csFileName.IsEmpty())
	{
		csFileName = GetDocument()->GetTitle();
		csFileName.Remove('*');
	}

	CSize sizeText = pDC->GetTextExtent(csFileName);
	int x		   = m_rcMargin.left;
	int y		   = m_rcMargin.top - 10 - sizeText.cy;
	pDC->TextOut(x, y, csFileName);

	CTime tmCurrent = CTime::GetCurrentTime();
	CString csTime  = tmCurrent.Format(_T("%m-%d-%Y %I:%M%p"));
	sizeText		= pDC->GetTextExtent(csTime);

	pDC->SetBkColor(::GetSysColor(COLOR_WINDOW));
	pDC->TextOut((ptTo.x - sizeText.cx), y, csTime);
}

void CMDITextEditorView::OnPrintFooter(CDC* pDC, CPrintInfo* pInfo)
{
	CXTPFontDC fontDC(pDC, GetEditCtrl().GetPaintManager()->GetFont(),
					  ::GetSysColor(COLOR_WINDOWTEXT));

	int iBottomPos = (pInfo->m_rectDraw.Height() - m_rcMargin.bottom + 5);

	CPoint ptFrom;
	ptFrom.x = m_rcMargin.left;
	ptFrom.y = iBottomPos;
	pDC->MoveTo(ptFrom);

	CPoint ptTo;
	ptTo.x = pInfo->m_rectDraw.right - m_rcMargin.right;
	ptTo.y = iBottomPos;
	pDC->LineTo(ptTo);

	CString csPageNo;
	csPageNo.Format(_T("Page %d of %d"), pInfo->m_nCurPage, pInfo->GetMaxPage());

	pDC->SetBkColor(::GetSysColor(COLOR_WINDOW));
	pDC->TextOut(m_rcMargin.left, iBottomPos + 5, csPageNo);
}

void CMDITextEditorView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
{
	// Print header in application-customized mode
	//	OnPrintHeader(pDC, pInfo);

	//	CRect rcDraw_orig = pInfo->m_rectDraw;

	//	pInfo->m_rectDraw.top += m_rcMargin.top;
	//	pInfo->m_rectDraw.bottom -= m_rcMargin.bottom;

	// Print body
	CViewBase::OnPrint(pDC, pInfo);

	//	pInfo->m_rectDraw = rcDraw_orig;
	// Print footer
	//	OnPrintFooter(pDC, pInfo);
}

/////////////////////////////////////////////////////////////////////////////
// CMDITextEditorView diagnostics

#ifdef _DEBUG
void CMDITextEditorView::AssertValid() const
{
	CViewBase::AssertValid();
}

void CMDITextEditorView::Dump(CDumpContext& dc) const
{
	CViewBase::Dump(dc);
}

CMDITextEditorDoc* CMDITextEditorView::GetDocument() // non-debug version is inline
{
	_ASSERTE(m_pDocument->IsKindOf(RUNTIME_CLASS(CMDITextEditorDoc)));
	return (CMDITextEditorDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMDITextEditorView message handlers

BOOL CMDITextEditorView::OnRowColChanged(NMHDR* pNMHDR, LRESULT* pResult)
{
	if (!CViewBase::OnRowColChanged(pNMHDR, pResult))
		return FALSE;

	XTP_EDIT_NMHDR_ROWCOLCHANGED* pNMHDR_RCC = (XTP_EDIT_NMHDR_ROWCOLCHANGED*)pNMHDR;
	if (!pNMHDR_RCC)
		return FALSE;

	theApp.m_pMainFrame->SetRowCol(pNMHDR_RCC->nRow, pNMHDR_RCC->nCol);

	*pResult = 0;
	return TRUE;
}

BOOL CMDITextEditorView::OnParseEvent(NMHDR* pNMHDR, LRESULT* pResult)
{
	if (!CViewBase::OnParseEvent(pNMHDR, pResult))
		return FALSE;

	XTP_EDIT_NMHDR_PARSEEVENT* pNMParseEvent = (XTP_EDIT_NMHDR_PARSEEVENT*)pNMHDR;
	if (!pNMParseEvent)
		return FALSE;

	CDocument* pDoc = GetDocument();
	if (!pDoc)
		return FALSE;

	const int cnUpdateTimeOut = 500;
	CString strMsg;
	BOOL bUpdate = TRUE;

	if (pNMParseEvent->code == xtpEditOnTextBlockParsed)
	{
		DWORD dwTime = ::GetTickCount();
		bUpdate		 = labs(dwTime - m_dwLastUpdate) >= cnUpdateTimeOut;

		CXTPSyntaxEditLexTextBlock* pTBended = (CXTPSyntaxEditLexTextBlock*)pNMParseEvent->wParam;
		if (pTBended && bUpdate)
		{
			m_dwLastUpdate = dwTime;

			DWORD dwTime1 = GetTickCount(); // DEBUG
			double dTime  = labs(dwTime1 - m_dwParserStart) / 1000.0;

			strMsg.Format(_T(" Parsing time(%.1f sec). Line(%d)."), dTime,
						  pTBended->m_PosEndLC.nLine);

			//			strMsg.Format(_T(" Parsing time(%.3f sec). Last parsed block: (%d,%d -
			//%d,%d)::%s"), 				dTime, 				pTBended->m_PosStartLC.nLine,
			// pTBended->m_PosStartLC.nCol, 				pTBended->m_PosEndLC.nLine,
			// pTBended->m_PosEndLC.nCol, 				pTBended->m_ptrLexClass ?
			// pTBended->m_ptrLexClass->GetClassName() 				: _T("?<NULL>") );
		}
	}

	else if (pNMParseEvent->code == xtpEditOnParserStarted)
	{
		strMsg = _T("*** Parser Started");

		m_dwParserStart = GetTickCount();
	}

	else if (pNMParseEvent->code == xtpEditOnParserEnded)
	{
		if (!pNMParseEvent->wParam || (pNMParseEvent->wParam & xtpEditLPR_RunFinished))
		{
			DWORD dwTime1 = GetTickCount();
			double dTime  = labs(dwTime1 - m_dwParserStart) / 1000.0;
			strMsg.Format(_T(" Parsing time(%.3f sec)."), dTime);
		}
	}

	if (bUpdate)
	{
		CString strTitle = pDoc->GetTitle();
		int nFIdx		 = strTitle.Find(_T(" :.: "));
		if (nFIdx >= 0)
		{
			strTitle = strTitle.Left(nFIdx);

			nFIdx = strTitle.Find(_T("*"));
			if (nFIdx >= 0)
			{
				strTitle = strTitle.Left(nFIdx);
			}
			strTitle.TrimRight();
		}

		if (pDoc->IsModified())
		{
			strTitle += _T(" * ");
		}

		if (strMsg.GetLength() > 0)
		{
			strTitle += _T(" :.: ");
			strTitle += strMsg;
		}

		pDoc->SetTitle(strTitle);
	}

	*pResult = 0;
	return TRUE;
}

void CMDITextEditorView::OnContextMenu(CWnd* /*pWnd*/, CPoint point)
{
	if (point.x == -1 && point.y == -1)
	{
		// keystroke invocation
		CRect rect;
		GetClientRect(rect);
		ClientToScreen(rect);

		point = rect.TopLeft();
		point.Offset(5, 5);
	}

	CMenu menu;
	VERIFY(menu.LoadMenu(IDR_MDITEXTYPE));

	CMenu* pPopup = menu.GetSubMenu(1);
	_ASSERTE(pPopup != NULL);

	CWnd* pWndPopupOwner = this;
	while (pWndPopupOwner->GetStyle() & WS_CHILD)
		pWndPopupOwner = pWndPopupOwner->GetParent();

#ifdef _XTP_INCLUDE_COMMANDBARS
	((CXTPMDIFrameWnd*)AfxGetMainWnd())
		->GetCommandBars()
		->TrackPopupMenuEx(pPopup, TPM_RIGHTBUTTON, point.x, point.y);
#else
	pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, pWndPopupOwner);
#endif
}

void CMDITextEditorView::OnEditFindSilent()
{
	if (!GetFindReplaceDlg())
		return;

	CString csSelText;
	GetEditCtrl().GetSelectionText(csSelText);

	if (csSelText.IsEmpty())
	{
		CPoint pt(GetCaretPos());
		pt.y += 2;

		GetEditCtrl().SelectWord(pt);
		GetEditCtrl().GetSelectionText(csSelText);
	}

	csSelText = csSelText.SpanExcluding(_T("\r\n"));
	csSelText.Replace(_T("\t"), _T("    "));

	if (csSelText.IsEmpty())
	{
		csSelText = _T(" ");
	}
	else
	{
		GetFindReplaceDlg()->m_csFindText = csSelText;
	}

	BOOL bShiftKey = (::GetKeyState(VK_SHIFT) & KF_UP) != 0;

	if (GetEditCtrl().Find(csSelText, GetFindReplaceDlg()->m_bMatchWholeWord,
						   GetFindReplaceDlg()->m_bMatchCase, !bShiftKey))
	{
		SetDirty();
	}
}

void CMDITextEditorView::OnEditTabify()
{
	GetEditCtrl().TabifySelection();
}

void CMDITextEditorView::OnEditUnTabify()
{
	GetEditCtrl().UnTabifySelection();
}

void CMDITextEditorView::OnEditUppercase()
{
	GetEditCtrl().UppercaseSelection();
}

void CMDITextEditorView::OnEditLowercase()
{
	GetEditCtrl().LowercaseSelection();
}

void CMDITextEditorView::OnEditWhiteSpace()
{
	// toggle whitespace.
	GetEditCtrl().EnableWhiteSpace(!GetEditCtrl().IsEnabledWhiteSpace());

	CDocument* pDoc = GetDocument();
	if (pDoc)
	{
		pDoc->UpdateAllViews(this, xtpHintWhiteSpace,
							 GetEditCtrl().IsEnabledWhiteSpace() ? (CObject*)1 : NULL);
	}
}

void CMDITextEditorView::OnUpdateEditWhiteSpace(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(GetEditCtrl().IsEnabledWhiteSpace());
}

void CMDITextEditorView::OnEditCollapseAll()
{
	GetEditCtrl().CollapseAll();
}

void CMDITextEditorView::OnEditExpandAll()
{
	GetEditCtrl().ExpandAll();
}

void CMDITextEditorView::OnToolsBookmark()
{
	int iRow = GetEditCtrl().GetCurRow();
	GetEditCtrl().AddRemoveBookmark(iRow);
	UpdateAllViews();
}

void CMDITextEditorView::OnToolsBreakpoint()
{
	int iRow = GetEditCtrl().GetCurRow();
	GetEditCtrl().AddRemoveBreakPoint(iRow);
	UpdateAllViews();
}

void CMDITextEditorView::OnToolsNextBookmark()
{
	GetEditCtrl().NextBookmark();
}

void CMDITextEditorView::OnUpdateToolsOptions(CCmdUI* pCmdUI)
{
	pCmdUI->Enable(GetEditCtrl().IsConfigFileMode());
}

void CMDITextEditorView::OnUpdateToolsNextBookmark(CCmdUI* pCmdUI)
{
	pCmdUI->Enable(GetEditCtrl().HasBookmarks());
}

void CMDITextEditorView::OnToolsPrevBookmark()
{
	GetEditCtrl().PrevBookmark();
}

void CMDITextEditorView::OnUpdateToolsPrevBookmark(CCmdUI* pCmdUI)
{
	pCmdUI->Enable(GetEditCtrl().HasBookmarks());
}

void CMDITextEditorView::OnToolsOptions()
{
	// Create dialog object
	CXTPSyntaxEditPropertiesDlg dlg(this);

	// Instantiate dialog
	if (dlg.DoModal() == IDOK)
	{
		// Copy settings to remaining views.
		theApp.UpdateAllViews(this);
	}

	// GetEditCtrl().EnableEditAccelerators(FALSE);
}

void CMDITextEditorView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint)
{
	CViewBase::OnUpdate(pSender, lHint, pHint);

	if (pSender == this)
	{
		return;
	}

	switch (lHint)
	{
		case xtpHintWhiteSpace: break;
	}
}

void CMDITextEditorView::OnFileGoTo()
{
	m_dlgGoTo.ShowDialog(&GetEditCtrl(), FALSE /*select line*/, TRUE /*hide after search*/);
}

void CMDITextEditorView::OnReadOnly()
{
	GetEditCtrl().SetReadOnly(!GetEditCtrl().IsReadOnly());
}

void CMDITextEditorView::OnUpdateReadOnly(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(GetEditCtrl().IsReadOnly() ? 1 : 0);
}

void CMDITextEditorView::OnInitialUpdate()
{
	CXTPSyntaxEditView::OnInitialUpdate();

	static BOOL bFirstDocument = TRUE;
	if (bFirstDocument)
	{
		bFirstDocument = FALSE;

		GetEditCtrl().SetText(
			_T("\r\nThis sample demonstrates features of the SyntaxEdit control.\r\n\r\n")
			_T("Depending on a loaded file type it will apply different syntax ")
			_T("highlighting schemes and use different keywords vocabulary."));
	}

	//// TODO: Uncomment this code snippet in order to test a custom C++ syntax coloring.

	//#include "_cpp1_schclass.h"
	//#include "ColorsDataEntry.h"
	//
	//	GetEditCtrl().SetConfigFile(_T(""), FALSE);
	//
	//	GetEditCtrl().m_bUseMonitor = FALSE;
	//
	//	if (GetEditCtrl().GetEditBuffer())
	//	{
	//		GetEditCtrl().GetEditBuffer()->SetFileExt(_T(".cpp"));
	//	}
	//
	//	GetEditCtrl().SetSyntaxAndColorScheme(sScheme, sColorTheme);
	//	OnUpdate(NULL, xtpEditHintInitView, NULL);
}