/*
* Descent 3 
* Copyright (C) 2024 Parallax Software
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.

--- HISTORICAL COMMENTS FOLLOW ---

 * $Logfile: /DescentIII/Main/editor/GrFontDialog.cpp $
 * $Revision: 1.1.1.1 $
 * $Date: 2003-08-26 03:57:38 $
 * $Author: kevinb $
 *
 * Font Editor
 *
 * $Log: not supported by cvs2svn $
 * 
 * 11    4/17/99 6:15p Samir
 * replaced gr.h with grdefs.h and fixed resulting compile bugs.
 * 
 * 10    5/08/98 5:23p Samir
 * added font brightness and grayscale caps.
 * 
 * 9     4/30/98 3:02p Samir
 * better error checking.
 * 
 * 8     4/29/98 3:13p Samir
 * fixed font translation.
 * 
 * 7     4/23/98 6:38p Jason
 * made bitmaps use 1555 format
 * 
 * 6     3/31/98 3:49p Jason
 * added memory lib
 * 
 * 5     3/06/98 3:34p Samir
 * Fixed font image scanning to scan multiple rows of fonts.
 * 
 * 4     1/28/98 3:29p Samir
 * Increased max height of font.
 * 
 * 3     1/12/98 5:22p Samir
 * Fixed up font reading.
 * 
 * 2     9/02/97 3:28p Matt
 * Got rid of warnings
 * 
 * 6     6/03/97 5:37p Mark
 * 
 *	6	6/03/97	5:32p	Jeff
 * Added Context Sensitive Help
 *
 * 5     2/06/97 3:08p Samir
 * Improved font saving for monochrome fonts
 *
 * $NoKeywords: $
 */
// GrFontDialog.cpp : implementation file
//

#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>

#include "editor.h"
#include "GrFontDialog.h"

#include "gr.h"
#include "mono.h"
#include "bitmap.h"
#include "gametexture.h"
#include "manage.h"
#include "mem.h"

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

#define COLOR_FONT		1
#define MONOCHROME_FONT		2
#define GRADIENT_FONT	3

#define FT_COLOR				1
#define FT_PROPORTIONAL		2
#define FT_KERNED				4
#define FT_GRADIENT			8


//	Font File stuff

typedef FILE* FONTFILE;

#define BITS_TO_BYTES(x)    (((x)+7)>>3)

inline int WRITE_FONT_INT(FONTFILE ffile, int i) {
	return fwrite(&i, sizeof(i), 1, (FILE *)ffile);
}

inline int WRITE_FONT_SHORT(FONTFILE ffile, int16_t s) {
	return fwrite(&s, sizeof(s), 1, (FILE *)ffile);
}

inline int WRITE_FONT_BYTE(FONTFILE ffile, uint8_t c) {
	return fwrite(&c, sizeof(c), 1, (FILE *)ffile);
}

inline int WRITE_FONT_DATA(FONTFILE ffile, void *buf, int size, int nelem)
{
	int i;
	i = (int)fwrite(buf, size, nelem, (FILE *)ffile);

	ASSERT(i == nelem);

	return i;
}  

inline FONTFILE OPEN_FONT(char *filename) {
	FONTFILE fp;

	fp = (FONTFILE)fopen(filename, "wb");
	if (!fp) return NULL;

	return fp;
}

inline void CLOSE_FONT(FONTFILE ffile) {
	fclose((FILE *)ffile);
}


/////////////////////////////////////////////////////////////////////////////
// CGrFontDialog dialog


CGrFontDialog::CGrFontDialog(CWnd* pParent /*=NULL*/)
	: CDialog(CGrFontDialog::IDD, pParent)
{
	//{{AFX_DATA_INIT(CGrFontDialog)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT

	m_FontPicBm = -1;
	m_DataBuffer = NULL;

	ZeroMemory(&m_FontRecord, sizeof(m_FontRecord));
}


void CGrFontDialog::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CGrFontDialog)
		// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CGrFontDialog, CDialog)
	//{{AFX_MSG_MAP(CGrFontDialog)
	ON_BN_CLICKED(IDC_NEW, OnNew)
	ON_WM_PAINT()
	ON_WM_CREATE()
	ON_BN_CLICKED(IDC_SAVEAS, OnSaveAs)
	ON_BN_CLICKED(IDC_SAVE, OnSave)
	ON_WM_DESTROY()
	ON_EN_KILLFOCUS(IDC_EDIT_MINASCII, OnKillfocusEditMinascii)
	ON_EN_KILLFOCUS(IDC_EDIT_FONTNAME, OnKillfocusEditFontname)
	ON_BN_CLICKED(IDC_LOCK, OnLock)
	ON_BN_CLICKED(IDC_CHECKIN, OnCheckin)
	ON_WM_HELPINFO()
	ON_EN_KILLFOCUS(IDC_BRIGHTNESS, OnKillfocusBrightness)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CGrFontDialog message handlers


void CGrFontDialog::OnNew() 
{
// TODO: Add your control notification handler code here
//	Bring up Open TGA dialog.
	CString filter = "D3 bitmap files (*.tga; *lbm; *.bbm)|*.tga; *.lbm; *.bbm|Targa files (*.tga)|*.tga|IFF files (*.bbm; *.lbm)|*.bbm; *.lbm||";

	CFileDialog dlg_open(TRUE, 0,0, OFN_FILEMUSTEXIST, (LPCTSTR)filter, this);

	if (dlg_open.DoModal() == IDCANCEL) return;

//	Okay, load in the proper picture for the font
	char filename[255];
	int bm_handle;

	lstrcpy(filename, dlg_open.GetPathName());

	if (m_FontPicBm > -1) bm_FreeBitmap(m_FontPicBm);
	m_FontPicBm = -1;
	
	mprintf(0, "Loading font template: %s...", filename);
	bm_handle = bm_AllocLoadFileBitmap(filename, 0);
	if (bm_handle<0) {
		mprintf(0, "shit!\n");
		OutrageMessageBox ("Couldn't open the font template file.");
		return;
	}
	mprintf(0, "finished!\n");

	m_FontPicBm = bm_handle;

//	Get MinAscii and other needed info before extracting font.

	if (!extract_font(&m_FontRecord)) {
		OutrageMessageBox("Unable to generate font from template %s.", filename);
		return;
	}

	UpdateDialog();

//	Display font on screen.
	CWnd::Invalidate();	
}


void CGrFontDialog::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	CWnd *fontwnd;
	RECT rect;
	int w, h;

	if (m_FontPicBm > -1) {
		grHardwareSurface surf(bm_w(m_FontPicBm, 0), bm_h(m_FontPicBm, 0), bm_bpp(m_FontPicBm));

		fontwnd = GetDlgItem(IDC_STATIC_FONTVIEW);
		fontwnd->GetWindowRect(&rect);
		ScreenToClient(&rect);

		w = rect.right-rect.left-4;
		h = rect.bottom-rect.top-4;

		if (w > (surf.width()-4)) w = surf.width() - 4;
		if (h > (surf.height()-4)) h = surf.height() - 4;

	//	load bitmap, convert transparency to pure black and then blt
		surf.load(m_FontPicBm);
		surf.replace_color(TRANSPARENT_COLOR32, 0);
			
		Desktop_surf->attach_to_window((unsigned)m_hWnd);
		Desktop_surf->blt(rect.left+2,rect.top+2,&surf, 0, 0, w, h);	
		Desktop_surf->attach_to_window((unsigned)NULL);
	}
}


int CGrFontDialog::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CDialog::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	return 0;
}


BOOL CGrFontDialog::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
// TODO: Add extra initialization here
	CButton *radio;
	CButton *gray_check = (CButton *)GetDlgItem(IDC_PROP_GRADIANT);
	CEdit *brightness = (CEdit *)GetDlgItem(IDC_BRIGHTNESS);
	char str[8];

	gray_check->EnableWindow(FALSE);

	radio = (CButton *)GetDlgItem(IDC_PROP_MONO);
	radio->SetCheck(0);

	lstrcpy(m_FontName, "Untitled");
	lstrcpy(m_FontFileName, "Untitled");
	
	m_Brightness = 10;

	sprintf(str, "%.1f", m_Brightness/10.0f);
	brightness->SetWindowText(str);

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}


void CGrFontDialog::OnSaveAs() 
{
	CString filter = "Outrage font files (*.fnt)|*.fnt||";
	
	CFileDialog dlg(FALSE, 0, 0, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, (LPCTSTR)filter, this);
	
	if (dlg.DoModal() == IDCANCEL) return;
	
	lstrcpy(m_FontFileName, dlg.GetPathName());
	
	save_font_file(&m_FontRecord);

	UpdateDialog();
}


void CGrFontDialog::OnSave() 
{
	if (strcmp(m_FontFileName, "Untitled") == 0) 
		OnSaveAs();
	else {
		save_font_file(&m_FontRecord);
	}
}


void CGrFontDialog::OnDestroy() 
{
	CDialog::OnDestroy();
	
	if (m_DataBuffer) delete[] m_DataBuffer;
	if (m_FontPicBm > -1) bm_FreeBitmap(m_FontPicBm);
	m_FontPicBm = -1;	
}


void CGrFontDialog::UpdateDialog()
{
	CButton *radio;
	CEdit *edit;
	CStatic *text;
	char buf[64];

//	Setup any necessary changes to control states in the dialog reflecting extraction of font.
	radio = (CButton *)GetDlgItem(IDC_PROP_MONO); radio->SetCheck(0);
	radio = (CButton *)GetDlgItem(IDC_PROP_BITMAPPED); radio->SetCheck(0);
	radio = (CButton *)GetDlgItem(IDC_PROP_GRADIANT); radio->SetCheck(0);

	switch (m_FontType)
	{
		case COLOR_FONT: radio = (CButton *)GetDlgItem(IDC_PROP_BITMAPPED); radio->SetCheck(1); break;
		case MONOCHROME_FONT: radio = (CButton *)GetDlgItem(IDC_PROP_MONO); radio->SetCheck(1); break;
		default: Int3();
	}

//	Set filename static text.  Set 'Untitled' name.  Change static text font info.
	edit = (CEdit *)GetDlgItem(IDC_EDIT_MINASCII);
	_itoa(m_FontRecord.min_ascii, buf, 10);
	edit->SetWindowText(buf);
	text = (CStatic *)GetDlgItem(IDC_STATIC_MAXASCII);
	_itoa(m_FontRecord.max_ascii, buf, 10);
	text->SetWindowText(buf);
	text = (CStatic *)GetDlgItem(IDC_STATIC_FONTNAME);
	text->SetWindowText(m_FontFileName);

	edit = (CEdit *)GetDlgItem(IDC_EDIT_FONTNAME);
	edit->SetWindowText(m_FontName);

	if (m_FontProp) {
		text = (CStatic *)GetDlgItem(IDC_STATIC_PROP);
		text->SetWindowText("Proportional");
	}
	else {
		text = (CStatic *)GetDlgItem(IDC_STATIC_PROP);
		text->SetWindowText("");
	}
}


void CGrFontDialog::OnKillfocusEditMinascii() 
{
	CEdit *edit = (CEdit *)GetDlgItem(IDC_EDIT_MINASCII);
	char buf[4];
	int num_char = m_FontRecord.max_ascii - m_FontRecord.min_ascii + 1;;
											  
	edit->GetWindowText(buf, 4);
	m_FontRecord.min_ascii = atoi(buf);		
	m_FontRecord.max_ascii = m_FontRecord.min_ascii + num_char-1;

	UpdateDialog();
}


void CGrFontDialog::OnKillfocusEditFontname() 
{
	CEdit *edit = (CEdit *)GetDlgItem(IDC_EDIT_FONTNAME);
	edit->GetWindowText(m_FontName,32);
}



//	========================================================================================
//	Font Extraction from Bitmap routines
//	========================================================================================

#define PIX(_x,_y) m_FontBmData[(_x) + (_y) * m_FontBmW]

inline uint16_t MAKE_565_FROM_555(uint16_t jcol)
{
	ddgr_color pix32=GR_16_TO_COLOR (jcol);
	int red=GR_COLOR_RED(pix32);
	int green=GR_COLOR_GREEN (pix32);
	int blue=GR_COLOR_BLUE (pix32);

	uint16_t newpix=((red>>3)<<11)|((green>>2)<<5)|(blue>>3);
	return newpix;
}


BOOL CGrFontDialog::extract_font(gr_font_file_record *ft)
{
	int bmx, bmy;
	int cur_char;

//	grab font template bitmap data from the bitmap library and retrieve characters
//	store relevent information in file record.
	m_FontBmData = bm_data(m_FontPicBm, 0);
	m_FontBmW = bm_w(m_FontPicBm,0); m_FontBmH = bm_h(m_FontPicBm, 0);
	m_CharMaxWidth = m_CharHeight = 0;
	m_FontProp = FALSE;
	m_FontType = MONOCHROME_FONT;
	m_FgColor = NEW_TRANSPARENT_COLOR;

	if (m_DataBuffer) delete[] m_DataBuffer;
	m_DataBuffer = new uint16_t[1024*MAX_FONT_CHARS];
	m_DataPtr = m_DataBuffer;

//	assume upper left pixel is background color, and first-found other
//	color is box color
	m_BgColor = PIX(0,0);

	for (bmy = 0;bmy  < m_FontBmH; bmy++) 
	{
		for (bmx = 0;bmx < m_FontBmW && PIX(bmx,bmy)==m_BgColor; bmx++) ;
		if (PIX(bmx,bmy)!= m_BgColor) break;
	}				

	m_BoxColor = PIX(bmx,bmy);

//	Get all data from current line.
	mprintf(0, "Parsing font...");
	mprintf(0," read_characters: ");

	for (cur_char=0;bmy < m_FontBmH && cur_char<MAX_FONT_CHARS;) 
	{
		cur_char = read_font_line(cur_char, bmx, bmy);
		if (cur_char == -1) {
			delete[] m_DataBuffer;
			m_DataBuffer = NULL;
			mprintf(0, "fuck!\n");
			return FALSE;
		}
		bmy += m_CharHeight+1;

	//search for start of next box
		for (;bmy < m_FontBmH;bmy++) {
			for (bmx = 0;bmx<m_FontBmW && PIX(bmx,bmy)!=m_BoxColor;bmx++) ;
			if ((PIX(bmx,bmy)==m_BoxColor) && (PIX(bmx,bmy+1) == m_BoxColor)) 
				break;
		}

		if (bmy == m_FontBmH)
			break;
//		if (PIX(bmx,bmy+1) != m_BoxColor) 
//			break;
	}  
	mprintf(0, "\nDone!\n");			

//	now fill in font information & store it into our file record. this information
//	can be used to save the font
	ft->width = m_CharMaxWidth;
	ft->height = m_CharHeight;
	ft->flags = (m_FontProp?FT_PROPORTIONAL:0) + ((m_FontType==COLOR_FONT)?FT_COLOR:0);
	ft->baseline = m_CharHeight;
	ft->min_ascii = 0;
	ft->max_ascii = cur_char-1;
	ft->raw_data = (uint8_t *)m_DataBuffer;
	ft->char_data = NULL;
	ft->char_widths = m_CharWidths;
	ft->kern_data= NULL;

	CButton *gray_check = (CButton *)GetDlgItem(IDC_PROP_GRADIANT);
	if (ft->flags & FT_COLOR) 
		gray_check->EnableWindow(TRUE);
	else
		gray_check->EnableWindow(FALSE);

	return TRUE;
}


int CGrFontDialog::read_font_line(int cur_char, int& bmx, int& bmy)
{
	while (bmx < m_FontBmW && PIX(bmx+1,bmy) == m_BoxColor) 
	{
		int res;
		res = read_font_char(cur_char, bmx, bmy);
		if (res == 0) return -1;
		else if (res == 1) {
			bmx += m_CharWidths[cur_char]+1;
			cur_char++;
		}
		else if (res == 2) {
			break;
		}
		else break;
	}

	return cur_char;
}
 
 
int CGrFontDialog::read_font_char(int cur_char, int& bmx, int& bmy)
{
	int w,h,x,y;
	bool box_edge = false;

	mprintf(0," %d-(%d,%d)",cur_char,bmx,bmy);

	while (PIX(bmx+1,bmy+1) == m_BoxColor)
		bmx++;		//deal with double-thick vertical lines

	for (w=0;PIX(bmx+1+w,bmy+1)!=m_BoxColor;w++)
	{
		if (PIX(bmx+1+w,bmy)!=m_BoxColor) {
			if (box_edge) {
				OutrageMessageBox("Read probable premature eol at (%d,%d).\n", bmx+1+w, bmy);
				w--;
				return 2;
			}
			else {
				OutrageMessageBox("Suspected error at pixel coordindates %d,%d (char %d)",bmx+1+w,bmy, cur_char);
				return 0;
			}
		}
		else {
			box_edge = true;
		}
	}

	box_edge = false;

	for (h=0;PIX(bmx+1,bmy+1+h)!=m_BoxColor;h++)
	{
		if (PIX(bmx,bmy+1+h)!=m_BoxColor) {
			if (box_edge) {
				OutrageMessageBox("Read probable premature end of row at (%d,%d).\n", bmx, bmy+1+h);
				h--;
				return 2;
			}
			else {
				OutrageMessageBox("Suspected error at pixel coordindates %d,%d (char %d)",bmx,bmy+1+h, cur_char);
				return 0;
			}
		}
		else {
			box_edge = true;
		}
	}

	if (w==0 || h==0) {
		OutrageMessageBox("Character %d has width of %d and height of %d",cur_char,w,h);
		return 0;
	}

	m_CharWidths[cur_char] = w;

	if (m_CharMaxWidth !=0 && w != m_CharMaxWidth)
		m_FontProp = TRUE;

	if (w > m_CharMaxWidth) m_CharMaxWidth = w;

	if (m_CharHeight == 0)
		m_CharHeight = h;
	else if (m_CharHeight != h) {
		OutrageMessageBox("Char %d is wrong height (height = %d, correct height = %d)",cur_char,h,m_CharHeight);
		return 0;
	}

	for (y=0;y<h;y++)
		for (x=0;x<w;x++) 
		{
			uint16_t c;

			if ((c=PIX(bmx+1+x,bmy+1+y)) == m_BgColor)
				c = 0x07e0;									// must go back 565 pure green (old transparent)
			else if (! (m_FgColor & OPAQUE_FLAG))
				m_FgColor = c; 
			else if (m_FgColor != c) { 	// c here is 1555 !! remember this.
				m_FontType = COLOR_FONT;				
			 //	mprintf(0, "%d,%d\n", bmx+1+x, bmy+1+y);
			}

			if (c != 0x07e0) 
				*m_DataPtr++ = MAKE_565_FROM_555(c);  // here 555 pure green will turn into 565 pure green transparent.
			else
				*m_DataPtr++ = 0x07e0;

			ASSERT(m_DataPtr < m_DataBuffer+(1024*256));
		}

	return 1;
}


BOOL CGrFontDialog::save_font_file(gr_font_file_record *ft)
{
	uint8_t *tmp_data;
	int16_t *tmp_widths;
	uint8_t **tmp_cdata;
	FONTFILE ffile;
	uint32_t id = 0xfeedbaba;
	int num_char;
	bool grayed_font;
	CButton *gray_check = (CButton *)GetDlgItem(IDC_PROP_GRADIANT);

	if (gray_check->GetCheck() == 1) 
		grayed_font = true;
	else
		grayed_font = false;

//	save data pointers.  We don't write these out to the file.
	tmp_data = ft->raw_data;
	tmp_widths = ft->char_widths;
	tmp_cdata = ft->char_data;

//	Adjust font record for file write.
	ft->flags = (m_FontProp?FT_PROPORTIONAL:0) + ((m_FontType==COLOR_FONT)?FT_COLOR:0) + 
		((m_FontType==GRADIENT_FONT)?FT_GRADIENT:0) + (grayed_font?FT_GRADIENT:0);
	ft->raw_data = NULL;
	ft->char_data = NULL;
	ft->char_widths = NULL;
	ft->kern_data= NULL;

//	write to file
	mprintf(0, "Saving font data...");
   //	sprintf(filename, "%s\\%s", LocalManageGraphicsDir, m_FontFileName);
	ffile = OPEN_FONT(m_FontFileName);
	if (!ffile) {
		OutrageMessageBox("Unable to save font %s.", m_FontFileName);
		return FALSE;
	}
	
//	Write file id.
	WRITE_FONT_INT(ffile, id);

//	Write Header
//	baseline brightness located in upper 8 bits.
	ft->baseline = ft->baseline & 0x00ff;
	ft->baseline = ft->baseline | (m_Brightness << 8);

	WRITE_FONT_SHORT(ffile, ft->width);
	WRITE_FONT_SHORT(ffile, ft->height);
	WRITE_FONT_SHORT(ffile, ft->flags);
	WRITE_FONT_SHORT(ffile, ft->baseline);
	WRITE_FONT_BYTE(ffile, ft->min_ascii);
	WRITE_FONT_BYTE(ffile, ft->max_ascii);
	WRITE_FONT_DATA(ffile, m_FontName, 32, 1);
	
	num_char = ft->max_ascii - ft->min_ascii + 1;

//	Write widths now if necessary.(FT_PROPORTIONAL)
	if (ft->flags & FT_PROPORTIONAL) {
		for (int i = 0; i < num_char; i++)
			WRITE_FONT_SHORT(ffile, tmp_widths[i]);
	}

	if (ft->flags & FT_COLOR) {
		WRITE_FONT_INT(ffile, (int)(m_DataPtr-m_DataBuffer)*sizeof(uint16_t));
		WRITE_FONT_DATA(ffile, (uint8_t *)m_DataBuffer, (m_DataPtr-m_DataBuffer)*sizeof(uint16_t), 1);
	}
	else {
	// bitpack for mono font storage:: 16bpp -> 8 bits/1 byte
		int i,x,y,w,cnt=0;
		uint16_t *p = m_DataBuffer;
		uint8_t *bits;

		bits = (uint8_t *)mem_malloc(256 * MAX_FONT_CHARS);

		for (i = 0; i < num_char; i++)
		{
			for (y = 0; y < ft->height; y++) 
			{
				uint8_t mask, datum;

				w = (ft->flags & FT_PROPORTIONAL) ? tmp_widths[i] : ft->width;

				ASSERT(w <= 48);			// Max width size shall be 32 pixels 

				mask = 0x80; datum = 0;

				for (x = 0; x < w; x++) 
				{
					if (mask == 0) {
						bits[cnt++] = datum;
						datum = 0;
						mask = 0x80;
					}
					if (*p++ != 0x07e0) datum |= mask;
					mask >>= 1;
				}

				bits[cnt++] = datum;
			}
		}

		WRITE_FONT_INT(ffile, cnt);
		WRITE_FONT_DATA(ffile, bits, cnt, 1);
		mem_free(bits);
	}

//	We should add kerning support here.

//	Close font.
	CLOSE_FONT(ffile);
	mprintf(0, "Done.\n");

	ft->raw_data = tmp_data;
	ft->char_widths = tmp_widths;
	ft->char_data = tmp_cdata;

	return TRUE;
}


void CGrFontDialog::OnLock() 
{
	// TODO: Add your control notification handler code here
	
}


void CGrFontDialog::OnCheckin() 
{
	// TODO: Add your control notification handler code here
	
}

BOOL CGrFontDialog::OnHelpInfo(HELPINFO* pHelpInfo) 
{
	// TODO: Add your message handler code here and/or call default
	WinHelp(HID_FONTEDITORDLG,HELP_CONTEXT);
	return TRUE;
	//return CDialog::OnHelpInfo(pHelpInfo);
}


void CGrFontDialog::OnKillfocusBrightness() 
{
	CEdit *edit = (CEdit *)GetDlgItem(IDC_BRIGHTNESS);
	char str[8];

	edit->GetWindowText(str, 7);

	m_Brightness = (int)(atof(str) * 10.0);
}