Work/m68hc11/backup/codeview.cpp

#include <m68hc11/codeview.hpp>
#include <m68hc11/m68hc11.hpp>
#include <printman/printman.hpp>
#include <fileio/fileio.hpp>
#include <common/profile.hpp>
#include <common/rgbcolor.hpp>
#include <common/crsctrl.hpp>
#include <common/keydata.hpp>

CodeView::CodeView(void)
: WinHookProc(WinHookProc::HookBefore)
{
  mCreateHandler.setCallback(this,&CodeView::createHandler);
  mSizeHandler.setCallback(this,&CodeView::sizeHandler);
	mCloseHandler.setCallback(this,&CodeView::closeHandler);
	mDestroyHandler.setCallback(this,&CodeView::destroyHandler);
	mCommandHandler.setCallback(this,&CodeView::commandHandler);
	mKeyUpHandler.setCallback(this,&CodeView::keyUpHandler);
	mKeyDownHandler.setCallback(this,&CodeView::keyDownHandler);
	mLeftButtonDownHandler.setCallback(this,&CodeView::leftButtonDownHandler);
	mSetFocusHandler.setCallback(this,&CodeView::setFocusHandler);
	MDIWindow::insertHandler(MDIWindow::CreateHandler,&mCreateHandler);
	MDIWindow::insertHandler(MDIWindow::SizeHandler,&mSizeHandler);
	MDIWindow::insertHandler(MDIWindow::CloseHandler,&mCloseHandler);
	MDIWindow::insertHandler(MDIWindow::DestroyHandler,&mDestroyHandler);
	MDIWindow::insertHandler(MDIWindow::CommandHandler,&mCommandHandler);
	MDIWindow::insertHandler(MDIWindow::SetFocusHandler,&mSetFocusHandler);
	WinHookProc::insertHandler(MDIWindow::KeyDownHandler,&mKeyDownHandler);
	WinHookProc::insertHandler(WinHookProc::KeyUpHandler,&mKeyUpHandler);
	WinHookProc::insertHandler(WinHookProc::LeftButtonDownHandler,&mLeftButtonDownHandler);
}

CodeView::~CodeView()
{
	MDIWindow::removeHandler(MDIWindow::CreateHandler,&mCreateHandler);
	MDIWindow::removeHandler(MDIWindow::SizeHandler,&mSizeHandler);
	MDIWindow::removeHandler(MDIWindow::CloseHandler,&mCloseHandler);
	MDIWindow::removeHandler(MDIWindow::DestroyHandler,&mDestroyHandler);
	MDIWindow::removeHandler(MDIWindow::CommandHandler,&mCommandHandler);
	MDIWindow::removeHandler(MDIWindow::SetFocusHandler,&mSetFocusHandler);
	WinHookProc::removeHandler(MDIWindow::KeyDownHandler,&mKeyDownHandler);
	WinHookProc::removeHandler(WinHookProc::KeyUpHandler,&mKeyUpHandler);
	WinHookProc::removeHandler(WinHookProc::LeftButtonDownHandler,&mLeftButtonDownHandler);
}

CallbackData::ReturnType CodeView::keyDownHandler(CallbackData &someCallbackData)
{
  KeyData keyData(someCallbackData);

  if(keyData.isEscapeKey())return (CallbackData::ReturnType)TRUE;
	notifyCurrentLine();
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType CodeView::keyUpHandler(CallbackData &someCallbackData)
{
  notifyCurrentLine();
  return FALSE;
}

CallbackData::ReturnType CodeView::leftButtonDownHandler(CallbackData &someCallbackData)
{
  notifyCurrentLine();
  return FALSE;
}

CallbackData::ReturnType CodeView::createHandler(CallbackData &someCallbackData)
{
  Rect controlRect;

	getControlRect(controlRect);
	mRichEditControl.createControl(*this,controlRect,EditControlID,WS_VSCROLL|WS_HSCROLL);
	hookWin(mRichEditControl);
	mRichEditControl.wantReturn(TRUE);
//  mRichEditControl.setCharFormat("MS Sans Serif",FontMagic);  // "Courier New"
//  mRichEditControl.setCharFormat("Courier",FontMagic);  // "Courier New"
//  mRichEditControl.setCharFormat("Courier New",FontMagic);  // "Courier New"
//  mRichEditControl.setCharFormat("Courier New",8);  // "Courier New"
	Font font("Courier New",12);
	mRichEditControl.setFont(font);
  mRichEditControl.setTextColor(RGBColor(0,0,0));
	mRichEditControl.setBkGndColor(RGBColor(255,255,255));
	mRichEditControl.setReadOnly(FALSE);
	mRichEditControl.limitText(0);
	mRichEditControl.setFocus();
	mClipboard=::new Clipboard(*this);
	mClipboard.disposition(PointerDisposition::Delete);
	setTitle(String());
  return FALSE;
}

CallbackData::ReturnType CodeView::sizeHandler(CallbackData &someCallbackData)
{
  Rect controlRect;

	if(SIZE_RESTORED==someCallbackData.wParam())mRichEditControl.show(SW_SHOWNORMAL);
	getControlRect(controlRect);
  mRichEditControl.moveWindow(controlRect,TRUE);
  return FALSE;
}

CallbackData::ReturnType CodeView::closeHandler(CallbackData &someCallbackData)
{
  return FALSE;
}

CallbackData::ReturnType CodeView::destroyHandler(CallbackData &someCallbackData)
{
  if(!mRichEditControl.isDirty())return FALSE;
	if(IDOK!=::MessageBox(*this,(LPSTR)"Do you want to save the changes?",(LPSTR)"The file has been changed",MB_YESNO))return FALSE;
	save();
	unhookWin();
  return FALSE;
}

CallbackData::ReturnType CodeView::commandHandler(CallbackData &/*someCallbackData*/)
{
  return FALSE;
}

CallbackData::ReturnType CodeView::setFocusHandler(CallbackData &someCallbackData)
{
  mRichEditControl.setFocus();
	notifyCurrentLine();
  return (CallbackData::ReturnType)FALSE;
}

void CodeView::setTitle(const String &strTitle)
{
  String strCaption;
	String strBase;

  if(strTitle.isNull())mTitle=String(STRING_UNTITLED);
	else mTitle=strTitle;
	windowText(strCaption);
	strBase=strCaption.betweenString(0,'-');
	strBase.trimRight();
	strBase+=String(" - [")+mTitle+String("]");
	setCaption(strBase);
}

BOOL CodeView::save(void)
{
	Block<String> lineStrings;

	mRichEditControl.getLines(lineStrings);
	mRichEditControl.isDirty(FALSE);
	return saveCode(lineStrings,getTitle());
}

BOOL CodeView::save(const String &strPathFileName)
{
  Block<String> lineStrings;

	setTitle(strPathFileName);
  mRichEditControl.getLines(lineStrings);
	mRichEditControl.isDirty(FALSE);
	return saveCode(lineStrings,strPathFileName);
}

void CodeView::find(void)
{
  mEditFind.perform(*this,mRichEditControl);
}

void CodeView::cut(void)
{
  if(!mClipboard.isOkay()||!mRichEditControl.isValid())return;
	String strText;
	if(mRichEditControl.getSelectedText(strText))mClipboard->setClipboard(strText);
	mRichEditControl.cutSelection();
}

void CodeView::copy(void)
{
  if(!mClipboard.isOkay()||!mRichEditControl.isValid())return;
	String strText;
	if(!mRichEditControl.getSelectedText(strText))return;
	mClipboard->setClipboard(strText);
}

void CodeView::paste(void)
{
  if(!mClipboard.isOkay())return;
	mRichEditControl.pasteSpecial(CF_TEXT);
}

BOOL CodeView::saveCode(Block<String> &codeLines,const String &strPathFileName)
{
  FileIO outFile;
	CursorControl cursorControl;

	if(!codeLines.size())return FALSE;
	outFile.open(strPathFileName,FileIO::GenericWrite,FileIO::FileShareRead,FileIO::Open(FileIO::CreateAlways));
	if(!outFile.isOkay())return FALSE;
	for(int lineIndex=0;lineIndex<codeLines.size();lineIndex++)
	{															  
	  String &strLine=codeLines[lineIndex];
		if(!strLine.isNull()&&(*((char*)strLine)==0x0A||*((char*)strLine)==0x0D))
		{
		  if(strLine.length()<=2)strLine="\n";
			else *((char*)strLine)=' ';
		}
		if(-1==strLine.strchr('\r'))strLine.insert("\r",strLine.length()-1);
		outFile.write((char*)strLine,strLine.length());
	}
	outFile.close();
	return TRUE;
}

void CodeView::open(const String &pathFileName)
{
  FileIO inFile;
	String strLine;
	String strLines;
	String crlf("\n");

	strLine.reserve(1024);
	strLines.reserve(250000);
	inFile.open(pathFileName);
	if(!inFile.isOkay())return;
	while(inFile.readLine(strLine))
	{
	  strLines+=strLine;
		strLines+=crlf;
	}
	mRichEditControl.setCaption(strLines);
	mRichEditControl.isDirty(FALSE);
	setTitle(pathFileName);
	inFile.close();
}

void CodeView::print(void)
{
  String strPrinter;
  PrintManager printManager;
	Block<String> codeLines;
	Font textFont("Helv",36);

	if(!printManager.choosePrinter((GUIWindow&)*(getFrame()),strPrinter))return;
	printManager.openPrinter(strPrinter,(GUIWindow&)*(getFrame()),getTitle());
	printManager.printLines(codeLines,textFont,Point(10,10));
	printManager.endDoc();
}

void CodeView::notifyCurrentLine(void)
{
  CallbackData lineData(0,mRichEditControl.getCaretPosition());
	mLineHandler.callback(lineData);
}

void CodeView::getControlRect(Rect &controlRect)
{
  clientRect(controlRect);
	controlRect.left(BorderWidth);
	controlRect.top(BorderWidth);
	controlRect.right((controlRect.right()-BorderWidth)+1);
	controlRect.bottom((controlRect.bottom()-BorderWidth)+1);
}

// *** virtuals

void CodeView::preRegister(WNDCLASS &wndClass)
{
	wndClass.hbrBackground =(HBRUSH)COLOR_APPWORKSPACE;
}

void CodeView::preCreate(MDICREATESTRUCT &createStruct)
{
}