khtml_settings.cc

将konqueror浏览器移植到ARM9 2410中

      }

	  //save all the settings into the new keywords if they don't exist
	  if( check_old_java ){
	    QStringList domainConfig;
	  	PolicyMap::Iterator it;
	  	for( it = javaDomainPolicy.begin(); it != javaDomainPolicy.end(); ++it ){
          QCString javaPolicy = adviceToStr( it.data() );
          QCString javaScriptPolicy = adviceToStr( KJavaScriptDunno );
          domainConfig.append(QString::fromLatin1("%1:%2:%3").arg(it.key()).arg(javaPolicy).arg(javaScriptPolicy));
	  	}
        config->writeEntry( "JavaDomainSettings", domainConfig );
	  }

	  if( check_old_ecma ){
	    QStringList domainConfig;
	    PolicyMap::Iterator it;
	  	for( it = javaScriptDomainPolicy.begin(); it != javaScriptDomainPolicy.end(); ++it ){
          QCString javaPolicy = adviceToStr( KJavaScriptDunno );
          QCString javaScriptPolicy = adviceToStr( it.data() );
          domainConfig.append(QString::fromLatin1("%1:%2:%3").arg(it.key()).arg(javaPolicy).arg(javaScriptPolicy));
	  	}
        config->writeEntry( "ECMADomainSettings", domainConfig );
	  }
    }
  }
}


// Local helper for isJavaEnabled & isJavaScriptEnabled.
static bool lookup_hostname_policy(const QString& hostname,
                                   const PolicyMap& policy,
                                   const bool default_retval)
{
  if (hostname.isEmpty()) {
    return default_retval;
  }

  // First check whether there is a perfect match.
  if( policy.contains( hostname ) ) {
    // yes, use it (unless dunno)
    KHTMLSettings::KJavaScriptAdvice adv = policy[ hostname ];
    if( adv == KHTMLSettings::KJavaScriptReject ) {
      return false;
    } else if( adv == KHTMLSettings::KJavaScriptAccept ) {
      return true;
    }
  }

  // Now, check for partial match.  Chop host from the left until
  // there's no dots left.
  QString host_part = hostname;
  int dot_idx = -1;
  while( (dot_idx = host_part.find(QChar('.'))) >= 0 ) {
    host_part.remove(0,dot_idx);
    if( policy.contains( host_part ) ) {
      KHTMLSettings::KJavaScriptAdvice adv = policy[ host_part ];
      if( adv == KHTMLSettings::KJavaScriptReject ) {
        return false;
      } else if( adv == KHTMLSettings::KJavaScriptAccept ) {
        return true;
      }
    }
    // assert(host_part[0] == QChar('.'));
    host_part.remove(0,1); // Chop off the dot.
  }

  // No domain-specific entry, or was dunno: use global setting
  return default_retval;
}

bool KHTMLSettings::isJavaEnabled( const QString& hostname )
{
  return lookup_hostname_policy(hostname, javaDomainPolicy, m_bEnableJava);
}

bool KHTMLSettings::isJavaScriptEnabled( const QString& hostname )
{
  return lookup_hostname_policy(hostname, javaScriptDomainPolicy, m_bEnableJavaScript);
}

bool KHTMLSettings::isPluginsEnabled( const QString& hostname )
{
  // FIXME: hostname is ignored (dnaber, 2001-01-03)
  return m_bEnablePlugins;
}

bool KHTMLSettings::isCSSEnabled( const QString& /*hostname*/ )
{
#if 0
      // First check whether there is a Domain-specific entry.
  if( cssDomainPolicy.contains( hostname ) ) {
        // yes, use it (unless dunno)
        KJavaScriptAdvice adv = cssDomainPolicy[ hostname ];
        if( adv == KJavaScriptReject )
          return false;
        else if( adv == KJavaScriptAccept )
          return true;
  }

#endif
  // No domain-specific entry, or was dunno: use global setting
  return m_bEnableCSS;
}


void KHTMLSettings::resetFontSizes()
{
    m_fontSizes.clear();
    int sizeAdjust = m_fontSize + lookupFont(m_charset,6).toInt() + 3;
    if ( sizeAdjust < 0 )
	sizeAdjust = 0;
    if ( sizeAdjust > 9 )
	sizeAdjust = 9;
    //kdDebug(6050) << "KHTMLSettings::resetFontSizes adjustment is " << sizeAdjust << endl;
    const float factor = 1.11820715;
    float scale = 1.0 / ( factor*factor*factor );
    for ( int i = 0; i < MAXFONTSIZES; i++ ) {
      	m_fontSizes << ( KMAX( int( m_fontSize * scale + 0.5), m_minFontSize ) );
        scale *= factor;
    }
}

void KHTMLSettings::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;
}


QString KHTMLSettings::settingsToCSS() const
{
    // lets start with the link properties
    QString 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";

    if(m_hoverLink)
        str += "a:link:hover, a:visited:hover { text-decoration: underline; }\n";

    return str;
}

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

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

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

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

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

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

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

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

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

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

void KHTMLSettings::setDefaultCharset( QFont::CharSet c, bool enforce )
{
    m_defaultCharset = c;
    enforceCharset = enforce;
    if(enforce)
        internalSetCharset(c);
}

void KHTMLSettings::resetCharset()
{
    internalSetCharset(m_defaultCharset);
    setScript( m_defaultCharset );
}

void KHTMLSettings::setCharset( QFont::CharSet c)
{
    if (!enforceCharset)
       internalSetCharset(c);
}

void KHTMLSettings::internalSetCharset( QFont::CharSet c )
{
    m_charset = c;
    availFamilies = KGlobal::charsets()->availableFamilies( m_charset ).join(",");
    resetFontSizes();
}

void KHTMLSettings::setScript( QFont::CharSet c )
{
    //kdDebug(6050) << "KHTMLSettings::setScript to " << c << endl;
    m_script = c;
}

QString KHTMLSettings::userStyleSheet() const
{
    return m_userSheet;
}