main.h

矩阵编码和马尔可夫链的实现例程。实现类似黑客帝国数字屏保

/*
 Copyright (c) 2001 
 Author: Konstantin Boukreev 
 E-mail: [e-mail] 

 Created: 20.12.2001 16:05:00
 Version: 1.0.0

*/

// Main.h : Declaration of the _Main

#ifndef __MAIN_H_
#define __MAIN_H_

#include "resource.h"       // main symbols
#include "MatrixBlitter.h"
#include "Markov.h"

// Help and App commands
#define ID_APP_ABOUT                    0xE140
#define ID_APP_EXIT                     0xE141
#define ID_FILE_OPEN                    0xE101
#define ID_FILE_CLOSE                   0xE102

/////////////////////////////////////////////////////////////////////////////
// _Main

class _Main : 
	public CDialogImpl<_Main>
{
	MatrixBlitter		m_blitter;
	MatrixBlitter		m_blitter2;
	UINT_PTR			m_timer;
	CContainedWindow	m_pane;
	std::string			m_filename;
		
public:
	_Main()
		: m_pane("STATIC", this, 1),
		m_blitter2(GetChar)
	{
	}

	~_Main()
	{
		delete g_markov;
		g_markov = 0;
	}

	enum { IDD = IDD_MAIN };

 BEGIN_MSG_MAP(_Main)
	MESSAGE_HANDLER(WM_INITDIALOG,	OnInitDialog)
	MESSAGE_HANDLER(WM_DESTROY,		OnDestroy)
	MESSAGE_HANDLER(WM_TIMER,		OnTimer)
	MESSAGE_HANDLER(WM_ERASEBKGND,	OnEraseBknd)
	MESSAGE_HANDLER(WM_HSCROLL,		OnSliderScroll); 
	COMMAND_ID_HANDLER(IDOK,		OnOK)
	COMMAND_ID_HANDLER(IDCANCEL,	OnOK)
	COMMAND_ID_HANDLER(ID_APP_ABOUT,OnAbout)	
	COMMAND_ID_HANDLER(ID_APP_EXIT, OnOK)
	COMMAND_ID_HANDLER(ID_FILE_OPEN,OnOpen)
	COMMAND_ID_HANDLER(ID_FILE_CLOSE,OnClose)
	COMMAND_ID_HANDLER(ID_FEEDBACK,	OnFeedback)
	ALT_MSG_MAP(1)
		MESSAGE_HANDLER(WM_PAINT,	OnPaintPane)
 END_MSG_MAP()


	LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
	{
		SendDlgItemMessage(IDC_SLIDER1, TBM_SETRANGE, 0, MAKELONG(0, 10));
		SendDlgItemMessage(IDC_SLIDER1, TBM_SETPOS, TRUE, LPARAM(10));

		HWND hPane = GetDlgItem(IDC_PANE);
		HDC hdc = ::GetDC(hPane);
		RECT rc;
		
		::GetClientRect(hPane, &rc);
	
		m_blitter2.SetSpeed(0, 10);	
		m_blitter2.Init(hdc, rc.right - rc.left, rc.bottom - rc.top, 25);

		GetClientRect(&rc);

		m_blitter.SetColor(RGB(221, 221, 221));
		m_blitter.SetHeadColor(RGB(225, 192, 192));
		m_blitter.SetBackColor(GetSysColor(COLOR_BTNFACE));		
		m_blitter.Init(hdc, rc.right - rc.left, rc.bottom - rc.top, 40);
			
		::ReleaseDC(hPane, hdc);
		m_pane.SubclassWindow(hPane);
		m_timer = SetTimer(0, 30);

		UIUpdate();
		return 1;  // Let the system set the focus
	}

	LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
	{
		KillTimer(m_timer);
		return 0;
	}

	LRESULT OnOK(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
	{
		EndDialog(wID);
		return 0;
	}

	LRESULT OnAbout(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
	{	
		MessageBox(
			_T("\"Just Matrix\" Application\n")
			_T("Copyright (c) 2001 Konstantin Boukreev\n")
			_T("[e-mail]\n")
			_T("\n")
			_T("Have a fun with Matrix code and Markov chains :)\n")
			_T("\n")
			_T("Disclaimer: ")
			_T("This application has not any serious sense except entertainment"),
			_T("Just Matrix"),
			MB_OK);
		return 0;
	}

	LRESULT OnFeedback(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
	
	bool OpenHLink(const TCHAR* url);
	
	void UIUpdate()
	{
		HMENU hMenu = GetSubMenu(GetMenu(), 0);
		EnableMenuItem(hMenu, ID_FILE_CLOSE,MF_BYCOMMAND | (g_markov ? MF_ENABLED: MF_GRAYED )); 		
	}

	LRESULT OnOpen(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
	{					
		OPENFILENAME ofn = {0};
	
		TCHAR buffer[MAX_PATH] = {0};
		
		if (m_filename.size())
			lstrcpy(buffer, m_filename.c_str());
		
		ofn.lStructSize	= sizeof OPENFILENAME;
		ofn.lpstrFile	= buffer;
		ofn.nMaxFile	= MAX_PATH;	
		ofn.hwndOwner	= m_hWnd;
		ofn.Flags		= OFN_EXPLORER|OFN_HIDEREADONLY;
		ofn.lpstrFilter = _T("Text files (*.txt)\0*.txt\0")
						  _T("All files\0*.*\0");
		
		TCHAR dir[MAX_PATH];
		if (GetModuleFileName(GetModuleHandle(0), dir, MAX_PATH))
		{
			PathRemoveFileSpec(dir);
			ofn.lpstrInitialDir = dir;
		}
			
		if (!GetOpenFileName(&ofn))
			return 0;

		m_filename.erase();

		OnClose(0, 0, 0, bHandled);

		HCURSOR hCursor = SetCursor(LoadCursor(0, IDC_WAIT));
		try 
		{			
			g_markov = markov_chains::create_from_file(buffer);
			m_blitter2.SetDamping(0.1f);
			m_filename = ofn.lpstrFile;
		}				
		catch(...)
		{
			delete g_markov;
			g_markov = 0;
		}
		SetCursor(hCursor);
		UIUpdate();		
		return 0;
	}

	LRESULT OnClose(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
	{	
		HCURSOR hCursor = SetCursor(LoadCursor(0, IDC_WAIT));
		delete g_markov;
		g_markov = 0;
		g_vec.clear();
		m_blitter2.SetDamping(0.75f);
		SetCursor(hCursor);
		UIUpdate();
		return 0;
	}

	LRESULT OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
	{
		m_blitter.Refresh();
		m_blitter.Render();

		m_blitter2.Refresh();
		m_blitter2.Render();
				
		Invalidate(TRUE);

		HDC hdc = m_pane.GetDC();
		m_blitter2.Blit(hdc, 0, 0);
		m_pane.ReleaseDC(hdc);

		return 0;
	}
	
	LRESULT OnSliderScroll(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
	{
		UINT code = LOWORD(wParam);
		if (code == TB_ENDTRACK)
		{
			int pos = SendDlgItemMessage(IDC_SLIDER1, TBM_GETPOS);
			m_blitter2.SetActivity((float)pos / 10.f);
		}		
		return 0;
	}

	LRESULT OnPaintPane(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
	{	
		PAINTSTRUCT ps;
		HDC hdc = m_pane.BeginPaint(&ps);
		m_blitter2.Blit(hdc, 0, 0);
		m_pane.EndPaint(&ps);
		return 0;
	}

	LRESULT OnEraseBknd(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
	{
		m_blitter.Blit((HDC)wParam, 0, 0);
		return 0;
	}

 private:
	struct sentence
	{
		sentence() 	{ memset(this, 0, sizeof(sentence)); }
		
		char*	 x1;
		char*	 x2;	
		unsigned l1;
		unsigned l2;	
		unsigned idx;

		void init(markov_chains& markov)
		{		
			markov_chains::iterator i = markov.begin();
			std::advance(i, rand() % markov.size());
			x1 = (*i).first;
			x2 = (*i).second;
			l1 = strlen(x1);
			l2 = strlen(x2);
			idx = 0;
		}

		void update(markov_chains& markov)
		{
			char* s = (char *)markov.find(x1, x2);
			if (s) 
			{
				x1 = x2;
				l1 = 0;
				x2 = s;
				l2 = strlen(s);
				idx = 0;
				return;
			}		
			
			init(markov);					
		}

		char next(markov_chains& markov) 
		{		
			if (l1)
			{
				if (idx < l1)
					return x1[idx++];
				l1  = 0;
				idx = 0;

				return ' ';
			}			
			
			if (idx < l2) 
				return x2[idx++];
			
			update(markov);
			return ' ';
		}

		bool empty() { return !x1 || !x2;}
	};

	static char GetChar(int x)		
	{		
		if (x != -1 && g_markov)
		{
			if (g_vec.size() <= (unsigned)x)
				g_vec.resize(x + 1);
			sentence& sen = g_vec[x];
			if (sen.empty())			
				sen.init(*g_markov);
			return sen.next(*g_markov);		
		}
		return MatrixBlitter::GetChar(x);
	}

	static markov_chains * g_markov;
	static std::vector<sentence> g_vec;
};

#endif //__MAIN_H_