mghtml_settings.cpp

monqueror一个很具有参考价值的源玛

// mghtml_settings.cpp:
// restore the global parameters for the browser.
// ------------------------------------------------------------
#include <pwd.h>
#include <unistd.h>
#include <sys/types.h>
#include "render_interface.h"
#include "mgpoint.h"
#include "mgrect.h"
#include "mgsize.h"
#include "mgcolor.h"
#include "mgcolorgroup.h"
#include "mgpen.h"
#include "mgbrush.h"
#include "mgpixmap.h"
#include "mgbitmap.h"
#include "mgfont.h"
#include "mgfontinfo.h"
#include "mgfontmetrics.h"
#include "mginlines.h"
#include "mgpainter.h"
#include "mghtml_settings.h"
#include "mghtmldefaults.h"
#include <pthread.h>
#include <semaphore.h>
#include "../include/typedef.h"
#include "../main/main.h" 

#define MAXFONTSIZES 15
const int defaultSmallFontSizes[MAXFONTSIZES] = { 7, 8, 10, 12, 14, 18, 24, 28, 34, 40, 48, 56, 68, 82, 100 };
const int defaultMediumFontSizes[MAXFONTSIZES] = { 8, 10, 12, 14, 18, 24, 28, 34, 40, 48, 56, 68, 82, 100, 120 };
const int defaultLargeFontSizes[MAXFONTSIZES] = { 10, 14, 18, 24, 28, 34, 40, 48, 56, 68, 82, 100, 120, 150 };


MGHTMLSettings::KJavaScriptAdvice MGHTMLSettings::strToAdvice(const QString& _str)
{
	KJavaScriptAdvice ret = KJavaScriptDunno;
	if (!_str)
		ret = KJavaScriptDunno;
	if (_str.lower() == QString::fromLatin1("accept"))
		ret = KJavaScriptAccept;
	else if (_str.lower() == QString::fromLatin1("reject"))
		ret = KJavaScriptReject;
	return ret;
}

const char* MGHTMLSettings::adviceToStr(KJavaScriptAdvice _advice)
{
	switch( _advice ) 
	{
		case KJavaScriptAccept: 
			return "Accept";
		case KJavaScriptReject: 
			return "Reject";
		default: return 0;
	}
	return 0;
}


void MGHTMLSettings::splitDomainAdvice(const QString& configStr, QString &domain,
						KJavaScriptAdvice &javaAdvice, KJavaScriptAdvice& javaScriptAdvice)
{
	QString tmp(configStr);
	int splitIndex = tmp.find(':');
	if ( splitIndex == -1)
	{
		domain = configStr;
		javaAdvice = KJavaScriptDunno;
		javaScriptAdvice = KJavaScriptDunno;
	}
	else
	{
		domain = tmp.left(splitIndex);
		QString adviceString = tmp.mid( splitIndex+1, tmp.length() );
		int splitIndex2 = adviceString.find( ':' );
		if( splitIndex2 == -1 )
		{
        	 // Java advice only
			javaAdvice = strToAdvice( adviceString );
			javaScriptAdvice = KJavaScriptDunno;
		} 
		else
		{
			// Java and JavaScript advice
			javaAdvice = strToAdvice( adviceString.left( splitIndex2 ) );
			javaScriptAdvice = strToAdvice( adviceString.mid( splitIndex2+1,
									adviceString.length() ) );
		}
	}
}


MGHTMLSettings::MGHTMLSettings()
{
	init();
}

void MGHTMLSettings::init()
{
	init(true);
}

void MGHTMLSettings::init(bool reset)
{
	char strConfFile[MAX_PATH + 1];
//#ifdef NO_LOGIN
	strncpy (strConfFile, getpwuid(getuid())->pw_dir, MAX_PATH);	// home/david
	if (strConfFile[strlen(strConfFile) - 1] != '/')		// home/david/
		strncat(strConfFile, "/", MAX_PATH);	
//#else
//	strncpy (strConfFile, "/etc/Minigui.conf", MAX_PATH);		// /etc/Minigui.conf
//	if(GetIntValueFromEtcFile(strConfFile, "MainWndAttr", "startx", &(MainWndAttrib->start_x)) != ETC_OK)	// !!!!!
//	{
//		strncpy(strConfFile, "/usr/local/lib/shared", MAX_PATH);
//	}
//	strncpy(strConfile + strlen(strConfFile), "/browser/", MAX_PATH);
//#endif
	strncat (strConfFile, ".", MAX_PATH);				// home/david/.
	strncat (strConfFile, CONF_FILENAME, MAX_PATH);			// home/david/.browser

	resetFontSizes();
	if(GetIntValueFromEtcFile(strConfFile, "FONTS", "minFontSize", &m_minFontSize) != ETC_OK)
	{
		m_minFontSize = 6;
	}
	if(m_minFontSize < 6)
		m_minFontSize = 6;

// !!!!! read it from config file.
	defaultFonts = QStringList();
	defaultFonts.append ("Song");
	defaultFonts.append ("Song");
	defaultFonts.append ("SansSerif");
	defaultFonts.append ("Courier");
	defaultFonts.append ("Helvtica");
	defaultFonts.append ("Timers");

	fontsForCharset [MGFont::ISO_8859_1] = QStringList();
	fontsForCharset [MGFont::ISO_8859_1].append ("Song");
	fontsForCharset [MGFont::ISO_8859_1].append ("Song");
	fontsForCharset [MGFont::ISO_8859_1].append ("SansSerif");
	fontsForCharset [MGFont::ISO_8859_1].append ("Courier");
	fontsForCharset [MGFont::ISO_8859_1].append ("Helvtica");
	fontsForCharset [MGFont::ISO_8859_1].append ("Times");

	fontsForCharset [MGFont::GB_2312] = QStringList();
	fontsForCharset [MGFont::GB_2312].append ("Song");
	fontsForCharset [MGFont::GB_2312].append ("Song");
	fontsForCharset [MGFont::GB_2312].append ("SansSerif");
	fontsForCharset [MGFont::GB_2312].append ("Courier");
	fontsForCharset [MGFont::GB_2312].append ("Helvtica");
	fontsForCharset [MGFont::GB_2312].append ("Times");

	fontsForCharset [MGFont::Big5] = QStringList();
	fontsForCharset [MGFont::Big5].append ("Ming");
	fontsForCharset [MGFont::Big5].append ("Ming");
	fontsForCharset [MGFont::Big5].append ("SansSerif");
	fontsForCharset [MGFont::Big5].append ("Courier");
	fontsForCharset [MGFont::Big5].append ("Helvtica");
	fontsForCharset [MGFont::Big5].append ("Times");	
	
	m_fontSize = 12;	
	enforceCharset = true;
	m_encoding = "GB_2312";
	setCharset (MGFont::GB_2312);
	
	// !!!!! read from config file.
	m_underlineLink = TRUE;
	m_bChangeCursor = TRUE;
	m_bAutoLoadImages = TRUE;
	m_textColor = MG::blue;
	m_linkColor = MG::blue;
	m_vLinkColor = MG::darkBlue;
	m_bEnableCSS = true;
	m_bEnableJava = FALSE;
	m_bEnableJavaScript = FALSE;
	m_hLinkCursor = LoadCursorFromFile ("/usr/local/lib/minigui/res/cursor/harrow.cur");
	
/*    QStringList chSets = KGlobal::charsets()->availableCharsetNames();
    for ( QStringList::Iterator it = chSets.begin(); it != chSets.end(); ++it ) {
	if ( reset || config->hasKey( *it ) ){
	    QStringList fonts = config->readListEntry( *it );
	    if( fonts.count() != 6 ) 
		fonts = defaultFonts;
	    fontsForCharset[KGlobal::charsets()->xNameToID(*it)] = fonts;
	}
    }

  if ( reset || config->hasKey( "DefaultEncoding" ) )
    {
        setCharset(KGlobal::charsets()->nameToID(config->readEntry( "DefaultEncoding", "iso-8859-1") ) );
    };

  if ( reset || config->hasKey( "EnforceDefaultCharset" ) )
    enforceCharset = config->readBoolEntry( "EnforceDefaultCharset", false );

  if ( reset || config->hasKey( "DefaultEncoding" ) )
    m_encoding = config->readEntry( "DefaultEncoding", "iso8859-1" );

        if( reset || config->hasKey( "JavaScriptDomainAdvice" ) ) {
          QStringList domainList = config->readListEntry( "JavaScriptDomainAdvice" );
          for (QStringList::ConstIterator it = domainList.begin();
                   it != domainList.end(); ++it) {
                QString domain;
                KJavaScriptAdvice javaAdvice;
                KJavaScriptAdvice javaScriptAdvice;
                splitDomainAdvice(*it, domain, javaAdvice, javaScriptAdvice);
                javaDomainPolicy[domain] = javaAdvice;
                javaScriptDomainPolicy[domain] = javaScriptAdvice;
          }
        }
  }*/
}


bool MGHTMLSettings::isJavaEnabled( const QString& hostname )
{
	if( javaDomainPolicy.contains( hostname ) )
	{
		KJavaScriptAdvice adv = javaDomainPolicy[ hostname ];
		if( adv == KJavaScriptReject )
			return false;
		else if( adv == KJavaScriptAccept )
			return true;
  	}
	return m_bEnableJava;
}


bool MGHTMLSettings::isJavaScriptEnabled( const QString& hostname )
{
	if( javaScriptDomainPolicy.contains( hostname ) )
	{
		KJavaScriptAdvice adv = javaScriptDomainPolicy[ hostname ];
		if( adv == KJavaScriptReject )
			return false;
		else if( adv == KJavaScriptAccept )
			return true;
	}
	return m_bEnableJavaScript;
}

bool MGHTMLSettings::isCSSEnabled( const QString& /*hostname*/ )
{
#if 0
	if( cssDomainPolicy.contains( hostname ) ) 
	{
		KJavaScriptAdvice adv = cssDomainPolicy[ hostname ];
		if( adv == KJavaScriptReject )
			return false;
		else if( adv == KJavaScriptAccept )
			return true;
	}
#endif
	return m_bEnableCSS;
}


void MGHTMLSettings::resetFontSizes()
{
	m_fontSizes.clear();
	for ( int i = 0; i < MAXFONTSIZES; i++ )
		if( m_fontSize == 0 ) // small
			m_fontSizes << defaultSmallFontSizes[ i ];
		else if( m_fontSize == 2 ) // large
			m_fontSizes << defaultLargeFontSizes[ i ];
		else
			m_fontSizes << defaultMediumFontSizes[ i ];
}


void MGHTMLSettings::setFontSizes(const QValueList<int> &_newFontSizes )		//!!!!!
{
    QValueList<int> newFontSizes;
    newFontSizes = _newFontSizes;
    while ( newFontSizes.count() > m_fontSizes.count() )
      newFontSizes.remove( newFontSizes.fromLast() );

    QValueList<int>::ConstIterator it = newFontSizes.begin();
    QValueList<int>::ConstIterator end = newFontSizes.end();
    for (int i = 0; it != end; it++ )
      m_fontSizes[ i++ ] = *it;
}


MGString MGHTMLSettings::settingsToCSS() const
{
	// lets start with the link properties
	MGString str = "a:link {\ncolor: ";
	str += m_linkColor.name();
	str += ";";
	if(m_underlineLink)
		str += "\ntext-decoration: underline;";

	if( m_bChangeCursor )
	{
		str += "\ncursor: pointer;";
		str += "\n}\ninput[type=image] { cursor: pointer;";
	}
	str += "\n}\n";
	str += "a:visited {\ncolor: ";
	str += m_vLinkColor.name();
	str += ";";
	if(m_underlineLink)
		str += "\ntext-decoration: underline;";

	if( m_bChangeCursor )
		str += "\ncursor: pointer;";
	str += "\n}\n";
	return str;
}

QString MGHTMLSettings::lookupFont(const MGFont::CharSet &charset, int i) const
{
	QString font = defaultFonts[0];
	const QStringList &fontList = fontsForCharset[charset];
	if (fontList.count() > (unsigned int)i)
		font = fontList[i];
	if (font.isEmpty())
		font = defaultFonts[i]; 
	return font;
}

QString MGHTMLSettings::stdFontName() const 
{
	return lookupFont(m_charset,0);
}

QString MGHTMLSettings::fixedFontName() const
{
	return lookupFont(m_charset,1);
}

QString MGHTMLSettings::serifFontName() const
{
	return lookupFont(m_charset,2);
}

QString MGHTMLSettings::sansSerifFontName() const
{
	return lookupFont(m_charset,3);
}

QString MGHTMLSettings::cursiveFontName() const
{
	return lookupFont(m_charset,4);
}

QString MGHTMLSettings::fantasyFontName() const
{
	return lookupFont(m_charset,5);
}

void MGHTMLSettings::setFont(const MGFont::CharSet &charset, int i, const QString &n)
{
	QStringList fontList = fontsForCharset[charset];
	while (fontList.count() <= (unsigned int)i)
		fontList.append(QString::null);
	fontList[i] = n;
}

void MGHTMLSettings::setStdFontName(const QString &n)
{
	setFont(m_charset, 0, n);
}

void MGHTMLSettings::setFixedFontName(const QString &n)
{
	setFont(m_charset, 1, n);
}

void MGHTMLSettings::setCharset(MGFont::CharSet c) 
{
	m_charset = c;
}