www.pudn.com > TidyWin32-src.zip > ConfigPage.cpp

#include "StdAfx.h" 
 
#include "ConfigPage.h" 
#include "TidyProxy.h" 
 
//------------------------------------------------------------------- 
// Markup 
 
LRESULT CMarkupConfig::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 
{ 
	ATLControls::CComboBox doctypeCombo; 
	doctypeCombo.Attach(GetDlgItem(IDC_CONF_DOCTYPE)); 
	doctypeCombo.AddString("omit"); 
	doctypeCombo.AddString("auto"); 
	doctypeCombo.AddString("strict"); 
	doctypeCombo.AddString("loose"); 
	doctypeCombo.AddString(""); 
 
	Update(); 
 
	return 1; 
} 
 
void CMarkupConfig::Update() 
{ 
	// Doctype 
	ATLControls::CComboBox doctypeCombo; 
	doctypeCombo.Attach(GetDlgItem(IDC_CONF_DOCTYPE)); 
	string doctype = m_pTidyProxy->GetDocType(); 
	doctypeCombo.SetWindowText(doctype.c_str()); 
 
	// Booleans 
	SetCheckBox(m_pTidyProxy->GetTidyMark(), IDC_CONF_TIDYMARK); 
	SetCheckBox(m_pTidyProxy->GetHideEndTags(), IDC_CONF_HIDE_ENDTAGS); 
	SetCheckBox(m_pTidyProxy->GetEncloseBodyText(), IDC_CONF_ENC_BODY_TEXT); 
	SetCheckBox(m_pTidyProxy->GetEncloseBlockText(), IDC_CONF_ENC_BLOCK_TEXT); 
 
	// New tags 
	SetDlgItemText(IDC_CONF_NEW_EMPTYTAGS, 
		m_pTidyProxy->GetNewTags(CTidyProxy::NewEmptyTags).c_str()); 
	SetDlgItemText(IDC_CONF_NEW_INLINETAGS, 
		m_pTidyProxy->GetNewTags(CTidyProxy::NewInlineTags).c_str()); 
	SetDlgItemText(IDC_CONF_NEW_BLTAGS, 
		m_pTidyProxy->GetNewTags(CTidyProxy::NewBlockTags).c_str()); 
	SetDlgItemText(IDC_CONF_NEW_PRETAGS, 
		m_pTidyProxy->GetNewTags(CTidyProxy::NewPreTags).c_str()); 
} 
 
void CMarkupConfig::Validate() 
{ 
	const tmpStrSize = 1024; 
	char tmpStr[tmpStrSize]; 
 
	// Doctype 
	ATLControls::CComboBox doctypeCombo; 
	doctypeCombo.Attach(GetDlgItem(IDC_CONF_DOCTYPE)); 
	doctypeCombo.GetWindowText(tmpStr, tmpStrSize); 
	m_pTidyProxy->SetDocType(tmpStr); 
 
	if (strlen(tmpStr) != 0 && 
		doctypeCombo.FindString(-1, tmpStr) == CB_ERR) 
		doctypeCombo.AddString(tmpStr); 
 
	// Booleans 
	m_pTidyProxy->SetTidyMark(GetCheckBox(IDC_CONF_TIDYMARK)); 
	m_pTidyProxy->SetHideEndTags(GetCheckBox(IDC_CONF_HIDE_ENDTAGS)); 
	m_pTidyProxy->SetEncloseBodyText(GetCheckBox(IDC_CONF_ENC_BODY_TEXT)); 
	m_pTidyProxy->SetEncloseBlockText(GetCheckBox(IDC_CONF_ENC_BLOCK_TEXT)); 
 
	// New tags 
	GetDlgItemText(IDC_CONF_NEW_EMPTYTAGS, tmpStr, tmpStrSize); 
	m_pTidyProxy->SetNewTags(CTidyProxy::NewEmptyTags, tmpStr); 
	GetDlgItemText(IDC_CONF_NEW_INLINETAGS, tmpStr, tmpStrSize); 
	m_pTidyProxy->SetNewTags(CTidyProxy::NewInlineTags, tmpStr); 
	GetDlgItemText(IDC_CONF_NEW_BLTAGS, tmpStr, tmpStrSize); 
	m_pTidyProxy->SetNewTags(CTidyProxy::NewBlockTags, tmpStr); 
	GetDlgItemText(IDC_CONF_NEW_PRETAGS, tmpStr, tmpStrSize); 
	m_pTidyProxy->SetNewTags(CTidyProxy::NewPreTags, tmpStr); 
} 
 
//------------------------------------------------------------------- 
// Cleanup 
 
LRESULT CCleanupConfig::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 
{ 
	Update(); 
	return 1; 
} 
 
void CCleanupConfig::Update() 
{ 
	// Booleans 
	SetCheckBox(m_pTidyProxy->GetMakeClean(), IDC_CONF_CLEAN); 
	SetCheckBox(m_pTidyProxy->GetDropFontTags(), IDC_CONF_DROP_FONT); 
	SetCheckBox(m_pTidyProxy->GetLogicalEmphasis(), IDC_CONF_LOGEMPH); 
	SetCheckBox(m_pTidyProxy->GetDropEmptyParas(), IDC_CONF_DROP_EMPTYPARAS); 
	SetCheckBox(m_pTidyProxy->GetWord2000(), IDC_CONF_WORD2000); 
	SetCheckBox(m_pTidyProxy->GetFixComments(), IDC_CONF_FIX_COMMENTS); 
	SetCheckBox(m_pTidyProxy->GetFixBackslash(), IDC_CONF_FIX_BACKSLASH); 
 
	// Alt text 
	string altText = m_pTidyProxy->GetAltText(); 
	SetDlgItemText(IDC_CONF_ALTTEXT, altText.c_str()); 
} 
 
void CCleanupConfig::Validate() 
{ 
	const tmpStrSize = 1024; 
	char tmpStr[tmpStrSize]; 
 
	// Booleans 
	m_pTidyProxy->SetMakeClean(GetCheckBox(IDC_CONF_CLEAN)); 
	m_pTidyProxy->SetDropFontTags(GetCheckBox(IDC_CONF_DROP_FONT)); 
	m_pTidyProxy->SetLogicalEmphasis(GetCheckBox(IDC_CONF_LOGEMPH)); 
	m_pTidyProxy->SetDropEmptyParas(GetCheckBox(IDC_CONF_DROP_EMPTYPARAS)); 
	m_pTidyProxy->SetWord2000(GetCheckBox(IDC_CONF_WORD2000)); 
	m_pTidyProxy->SetFixComments(GetCheckBox(IDC_CONF_FIX_COMMENTS)); 
	m_pTidyProxy->SetFixBackslash(GetCheckBox(IDC_CONF_FIX_BACKSLASH)); 
 
	// Alt text 
	GetDlgItemText(IDC_CONF_ALTTEXT, tmpStr, tmpStrSize); 
	m_pTidyProxy->SetAltText(tmpStr); 
} 
 
//------------------------------------------------------------------- 
// XML 
 
LRESULT CXMLConfig::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 
{ 
	Update(); 
	return 1; 
} 
 
void CXMLConfig::Update() 
{ 
	// Booleans 
	SetCheckBox(m_pTidyProxy->GetXmlTags(), IDC_CONF_INPUT_XML); 
	SetCheckBox(m_pTidyProxy->GetXmlOut(), IDC_CONF_OUTPUT_XML); 
	SetCheckBox(m_pTidyProxy->GetxHTML(), IDC_CONF_OUTPUT_XHTML); 
	SetCheckBox(m_pTidyProxy->GetXmlPi(), IDC_CONF_XML_DECL); 
	SetCheckBox(m_pTidyProxy->GetXmlPIs(), IDC_CONF_XML_PI_STYLE); 
	SetCheckBox(m_pTidyProxy->GetXmlSpace(), IDC_CONF_ADD_XML_SPACE); 
} 
 
void CXMLConfig::Validate() 
{ 
	// Booleans 
	m_pTidyProxy->SetXmlTags(GetCheckBox(IDC_CONF_INPUT_XML)); 
	m_pTidyProxy->SetXmlOut(GetCheckBox(IDC_CONF_OUTPUT_XML)); 
	m_pTidyProxy->SetxHTML(GetCheckBox(IDC_CONF_OUTPUT_XHTML)); 
	m_pTidyProxy->SetXmlPi(GetCheckBox(IDC_CONF_XML_DECL)); 
	m_pTidyProxy->SetXmlPIs(GetCheckBox(IDC_CONF_XML_PI_STYLE)); 
	m_pTidyProxy->SetXmlSpace(GetCheckBox(IDC_CONF_ADD_XML_SPACE)); 
} 
 
//------------------------------------------------------------------- 
// Encoding 
 
LRESULT CEncodingConfig::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 
{ 
	Update(); 
	return 1; 
} 
 
void CEncodingConfig::Update() 
{ 
	// Character encoding 
	switch (m_pTidyProxy->GetCharEncoding()) { 
	case CTidyProxy::Enc_Raw: 
		CheckRadioButton(IDC_CONF_ENC_RAW, IDC_CONF_ENC_MACROMAN, IDC_CONF_ENC_RAW); 
		break; 
	case CTidyProxy::Enc_ASCII: 
		CheckRadioButton(IDC_CONF_ENC_RAW, IDC_CONF_ENC_MACROMAN, IDC_CONF_ENC_ASCII); 
		break; 
	case CTidyProxy::Enc_Latin1: 
		CheckRadioButton(IDC_CONF_ENC_RAW, IDC_CONF_ENC_MACROMAN, IDC_CONF_ENC_LATIN1); 
		break; 
	case CTidyProxy::Enc_UTF8: 
		CheckRadioButton(IDC_CONF_ENC_RAW, IDC_CONF_ENC_MACROMAN, IDC_CONF_ENC_UTF8); 
		break; 
	case CTidyProxy::Enc_ISO2022: 
		CheckRadioButton(IDC_CONF_ENC_RAW, IDC_CONF_ENC_MACROMAN, IDC_CONF_ENC_2022); 
		break; 
	case CTidyProxy::Enc_MacRoman: 
		CheckRadioButton(IDC_CONF_ENC_RAW, IDC_CONF_ENC_MACROMAN, IDC_CONF_ENC_MACROMAN); 
		break; 
	} 
 
	// Booleans 
	SetCheckBox(m_pTidyProxy->GetNumEntities(), IDC_CONF_NUM_ENT); 
	SetCheckBox(m_pTidyProxy->GetQuoteMarks(), IDC_CONF_QUOTE_MARKS); 
	SetCheckBox(m_pTidyProxy->GetQuoteNbsp(), IDC_CONF_QUOTE_NBSP); 
	SetCheckBox(m_pTidyProxy->GetQuoteAmpersand(), IDC_CONF_QUOTE_AMP); 
} 
 
void CEncodingConfig::Validate() 
{ 
	// Character encoding 
	if (IsDlgButtonChecked(IDC_CONF_ENC_RAW)) 
		m_pTidyProxy->SetCharEncoding(CTidyProxy::Enc_Raw); 
	else if (IsDlgButtonChecked(IDC_CONF_ENC_ASCII)) 
		m_pTidyProxy->SetCharEncoding(CTidyProxy::Enc_ASCII); 
	else if (IsDlgButtonChecked(IDC_CONF_ENC_LATIN1)) 
		m_pTidyProxy->SetCharEncoding(CTidyProxy::Enc_Latin1); 
	else if (IsDlgButtonChecked(IDC_CONF_ENC_UTF8)) 
		m_pTidyProxy->SetCharEncoding(CTidyProxy::Enc_UTF8); 
	else if (IsDlgButtonChecked(IDC_CONF_ENC_2022)) 
		m_pTidyProxy->SetCharEncoding(CTidyProxy::Enc_ISO2022); 
	else if (IsDlgButtonChecked(IDC_CONF_ENC_MACROMAN)) 
		m_pTidyProxy->SetCharEncoding(CTidyProxy::Enc_MacRoman); 
 
	// Booleans 
	m_pTidyProxy->SetNumEntities(GetCheckBox(IDC_CONF_NUM_ENT)); 
	m_pTidyProxy->SetQuoteMarks(GetCheckBox(IDC_CONF_QUOTE_MARKS)); 
	m_pTidyProxy->SetQuoteNbsp(GetCheckBox(IDC_CONF_QUOTE_NBSP)); 
	m_pTidyProxy->SetQuoteAmpersand(GetCheckBox(IDC_CONF_QUOTE_AMP)); 
} 
 
//------------------------------------------------------------------- 
// Layout 
 
LRESULT CLayoutConfig::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 
{ 
	Update(); 
	return 1; 
} 
 
void CLayoutConfig::Update() 
{ 
	const tmpStrSize = 32; 
	char tmpStr[tmpStrSize]; 
 
	// Indent 
	switch (m_pTidyProxy->GetIndent()) { 
	case CTidyProxy::Log3_False: 
		CheckRadioButton(IDC_CONF_INDENT_NO, IDC_CONF_INDENT_AUTO, IDC_CONF_INDENT_NO); 
		break; 
	case CTidyProxy::Log3_True: 
		CheckRadioButton(IDC_CONF_INDENT_NO, IDC_CONF_INDENT_AUTO, IDC_CONF_INDENT_YES); 
		break; 
	case CTidyProxy::Log3_Maybe: 
		CheckRadioButton(IDC_CONF_INDENT_NO, IDC_CONF_INDENT_AUTO, IDC_CONF_INDENT_AUTO); 
		break; 
	} 
 
	// Indent spaces 
	unsigned int spaces = m_pTidyProxy->GetIndentSpaces(); 
	sprintf(tmpStr, "%u", spaces); 
	SetDlgItemText(IDC_CONF_INDENT_SPACES, tmpStr); 
 
	// Wrap margin 
	unsigned int wraplen = m_pTidyProxy->GetWrapMargin(); 
    if (wraplen == 0x7FFFFFFF)	// see tidy::AdjustConfig() 
        wraplen = 0; 
	sprintf(tmpStr, "%u", wraplen); 
	SetDlgItemText(IDC_CONF_WRAP_MARGIN, tmpStr); 
 
	// Tab size 
	unsigned int tabsize = m_pTidyProxy->GetTabSize(); 
	sprintf(tmpStr, "%u", tabsize); 
	SetDlgItemText(IDC_CONF_TABSIZE, tmpStr); 
 
	// Booleans 
	SetCheckBox(m_pTidyProxy->GetIndentAttributes(), IDC_CONF_INDENT_ATTRS); 
	SetCheckBox(m_pTidyProxy->GetWrapAttVals(), IDC_CONF_WRAP_ATTRS); 
	SetCheckBox(m_pTidyProxy->GetWrapScriptlets(), DC_CONF_WRAP_SCRIPTS); 
	SetCheckBox(m_pTidyProxy->GetWrapAsp(), DC_CONF_WRAP_ASP); 
	SetCheckBox(m_pTidyProxy->GetWrapJste(), DC_CONF_WRAP_JSTE); 
	SetCheckBox(m_pTidyProxy->GetWrapPhp(), DC_CONF_WRAP_PHP); 
	SetCheckBox(m_pTidyProxy->GetBreakBeforeBR(), IDC_CONF_BREAK_BR); 
	SetCheckBox(m_pTidyProxy->GetUpperCaseTags(), IDC_CONF_UPPER_TAGS); 
	SetCheckBox(m_pTidyProxy->GetUpperCaseAttrs(), IDC_CONF_UPPER_ATTRS); 
	SetCheckBox(m_pTidyProxy->GetLiteralAttribs(), IDC_CONF_LITERAL_ATTRS); 
} 
 
void CLayoutConfig::Validate() 
{ 
	const tmpStrSize = 32; 
	char tmpStr[tmpStrSize]; 
 
	// Indent 
	if (IsDlgButtonChecked(IDC_CONF_INDENT_NO)) 
		m_pTidyProxy->SetIndent(CTidyProxy::Log3_False); 
	else if (IsDlgButtonChecked(IDC_CONF_INDENT_YES)) 
		m_pTidyProxy->SetIndent(CTidyProxy::Log3_True); 
	else if (IsDlgButtonChecked(IDC_CONF_INDENT_AUTO)) 
		m_pTidyProxy->SetIndent(CTidyProxy::Log3_Maybe); 
 
	// Indent spaces 
	GetDlgItemText(IDC_CONF_INDENT_SPACES, tmpStr, tmpStrSize); 
	m_pTidyProxy->SetIndentSpaces(atoi(tmpStr)); 
 
	// Wrap margin 
	GetDlgItemText(IDC_CONF_WRAP_MARGIN, tmpStr, tmpStrSize); 
	m_pTidyProxy->SetWrapMargin(atoi(tmpStr)); 
 
	// Tab size 
	GetDlgItemText(IDC_CONF_TABSIZE, tmpStr, tmpStrSize); 
	m_pTidyProxy->SetTabSize(atoi(tmpStr)); 
 
	// Booleans 
	m_pTidyProxy->SetIndentAttributes(GetCheckBox(IDC_CONF_INDENT_ATTRS)); 
	m_pTidyProxy->SetWrapAttVals(GetCheckBox(IDC_CONF_WRAP_ATTRS)); 
	m_pTidyProxy->SetWrapScriptlets(GetCheckBox(DC_CONF_WRAP_SCRIPTS)); 
	m_pTidyProxy->SetWrapAsp(GetCheckBox(DC_CONF_WRAP_ASP)); 
	m_pTidyProxy->SetWrapJste(GetCheckBox(DC_CONF_WRAP_JSTE)); 
	m_pTidyProxy->SetWrapPhp(GetCheckBox(DC_CONF_WRAP_PHP)); 
	m_pTidyProxy->SetBreakBeforeBR(GetCheckBox(IDC_CONF_BREAK_BR)); 
	m_pTidyProxy->SetUpperCaseTags(GetCheckBox(IDC_CONF_UPPER_TAGS)); 
	m_pTidyProxy->SetUpperCaseAttrs(GetCheckBox(IDC_CONF_UPPER_ATTRS)); 
	m_pTidyProxy->SetLiteralAttribs(GetCheckBox(IDC_CONF_LITERAL_ATTRS)); 
} 
 
//------------------------------------------------------------------- 
// Operation 
 
LRESULT COperationConfig::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 
{ 
	Update(); 
	return 1; 
} 
 
void COperationConfig::Update() 
{ 
	// Error file 
	string errFName = m_pTidyProxy->GetErrorFile(); 
	SetDlgItemText(IDC_CONF_ERRFILE, errFName.c_str()); 
 
	// Booleans 
	SetCheckBox(m_pTidyProxy->GetOnlyErrors(), IDC_CONF_MARKUP); 
	SetCheckBox(m_pTidyProxy->GetQuiet(), IDC_CONF_QUIET); 
	SetCheckBox(m_pTidyProxy->GetShowWarnings(), IDC_CONF_WARNINGS); 
	SetCheckBox(m_pTidyProxy->GetBurstSlides(), IDC_CONF_SLIDES); 
	SetCheckBox(m_pTidyProxy->Getwriteback(), IDC_CONF_WRITEBACK); 
	SetCheckBox(m_pTidyProxy->GetKeepFileTimes(), IDC_CONF_KEEPTIME); 
	SetCheckBox(m_pTidyProxy->GetEmacs(), IDC_CONF_GNU_EMACS); 
} 
 
void COperationConfig::Validate() 
{ 
	const tmpStrSize = 128; 
	char tmpStr[tmpStrSize]; 
 
	// Error file 
	GetDlgItemText(IDC_CONF_ERRFILE, tmpStr, tmpStrSize); 
	m_pTidyProxy->SetErrorFile(tmpStr); 
 
	// Booleans 
	m_pTidyProxy->SetOnlyErrors(GetCheckBox(IDC_CONF_MARKUP)); 
	m_pTidyProxy->SetQuiet(GetCheckBox(IDC_CONF_QUIET)); 
	m_pTidyProxy->SetShowWarnings(GetCheckBox(IDC_CONF_WARNINGS)); 
	m_pTidyProxy->SetBurstSlides(GetCheckBox(IDC_CONF_SLIDES)); 
	m_pTidyProxy->Setwriteback(GetCheckBox(IDC_CONF_WRITEBACK)); 
	m_pTidyProxy->SetKeepFileTimes(GetCheckBox(IDC_CONF_KEEPTIME)); 
	m_pTidyProxy->SetEmacs(GetCheckBox(IDC_CONF_GNU_EMACS)); 
} 
 
//-------------------------------------------------------------------