html_inlineimpl.cpp

最新Nokia手机浏览器全套源代码完美版。

        
        if (attr->value().string().lower().compare("focus") == 0) {
            // We have a valid "on focus" soundstart
            soundstartValue = "focus";
            m_soundstart->onFocus = true;
            m_soundstart->onSelect = false;
        }
        addSoundstartAttribute(soundstartName, soundstartValue);
        m_soundstart->hasSoundstartAttr = true;
        break;
        }
    case ATTR_SRC:
        {
        if (!m_soundstart) {
            // Create a Soundstart data structure, if not break
            m_soundstart = new SoundstartData;
            if (!m_soundstart) break;
        }
        m_soundstart->hasSrcAttr = true;
        QString srcAttrName(getAttrName(ATTR_SRC).string().lower());
        m_soundstart->srcUrl = attr->value().string().lower();
        addSoundstartAttribute(srcAttrName, m_soundstart->srcUrl);
        break;
        }
    case ATTR_LOOP:
        {
        if (!m_soundstart) {
            // Create a Soundstart data structure, if not break
            m_soundstart = new SoundstartData;
            if (!m_soundstart) break;
        }
        QString loopAttrName(getAttrName(ATTR_LOOP).string().lower());
        QString loopAttrValue(attr->value().string().lower());    
        addSoundstartAttribute(loopAttrName, loopAttrValue);
        break;
        }
    case ATTR_VOLUME:
        {
        if (!m_soundstart) {
            // Create a Soundstart data structure, if not break
            m_soundstart = new SoundstartData;
            if (!m_soundstart) break;
        }
        QString volumeAttrName(getAttrName(ATTR_VOLUME).string().lower());
        QString volumeAttrValue(attr->value().string().lower());
        addSoundstartAttribute(volumeAttrName, volumeAttrValue);
        break;
        }
#endif      
    case ATTR_NAME:
    case ATTR_TITLE:
    case ATTR_REL:
#if NOKIA_CHANGES
    case ATTR_TELBOOK:
    case ATTR_EMAIL:
#endif    
  break;
    default:
        HTMLElementImpl::parseHTMLAttribute(attr);
    }
}

void HTMLAnchorElementImpl::accessKeyAction(bool sendToAnyElement)
{
    // send the mouse button events iff the
    // caller specified sendToAnyElement
    click(sendToAnyElement);
}

bool HTMLAnchorElementImpl::isURLAttribute(AttributeImpl *attr) const
{
    return attr->id() == ATTR_HREF;
}
#if NOKIA_CHANGES
bool HTMLAnchorElementImpl::rendererIsNeeded(RenderStyle *style)
{
    // If we are not doing fast display (page preview) and we have valid
    // soundstart anchor, create a soundstart widget. We check here because we
    // are only interested in creating soundstart on the second pass, not page
    // preview (fast display) pass.
    if (!getDocument()->fastDisplayMode() && m_soundstart &&
        m_soundstart->hasSoundstartAttr && m_soundstart->hasSrcAttr) {
        createSoundstart();
        }
        
    return HTMLElementImpl::rendererIsNeeded(style);
}

void HTMLAnchorElementImpl::addSoundstartAttribute(QString attributeName, QString attributeValue)
    {
    if (!m_soundstart)
        return;

    QStringList::Iterator it;
    TInt index(0);
    for (it = m_soundstart->attributeNameList.begin(); it != m_soundstart->attributeNameList.end(); ++it) {
        QString nameAttr = *it;

        // Do we need to override the default loop value
        if ((nameAttr.compare("loop") == 0) && (attributeName.compare("loop") == 0) &&
            m_soundstart->overrideDefaultLoop) {
            // Remove the default loop attribute
            m_soundstart->overrideDefaultLoop = false;
            QString valueAttr = m_soundstart->attributeValueList[index];
            m_soundstart->attributeNameList.remove(nameAttr);
            m_soundstart->attributeValueList.remove(valueAttr);
            // Reinitialize the iterator, since we just removed an entry
            it = m_soundstart->attributeNameList.begin();
            index = 0;
            }
        else if (nameAttr.compare(attributeName) == 0) {
            // Already in the list
            return;
            }
        ++index;
    }
    
    // Not already in the list, place attributes into list
    m_soundstart->attributeNameList.append(attributeName);
    m_soundstart->attributeValueList.append(attributeValue);
}

void HTMLAnchorElementImpl::createSoundstart()
{
    if (!m_soundstart)
        return;
    
    QString baseUrl = getDocument()->baseURL();
    KHTMLPart* khtmlPart = getDocument()->part();

    KURL completedUrl;
    if (!m_soundstart->srcUrl.isEmpty())
        completedUrl = khtmlPart->completeURL(m_soundstart->srcUrl);

   m_soundstart->qWidget = KWQ(khtmlPart)->createSoundstart(completedUrl,
                                                         m_soundstart->attributeNameList,
                                                         m_soundstart->attributeValueList,
                                                         baseUrl);
}
#endif  // NOKIA_CHANGES

// -------------------------------------------------------------------------

HTMLBRElementImpl::HTMLBRElementImpl(DocumentPtr *doc) : HTMLElementImpl(doc)
{
}

HTMLBRElementImpl::~HTMLBRElementImpl()
{
}

NodeImpl::Id HTMLBRElementImpl::id() const
{
    return ID_BR;
}

bool HTMLBRElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const
{
    if (attr == ATTR_CLEAR) {
        result = eUniversal;
        return false;
    }
    
    return HTMLElementImpl::mapToEntry(attr, result);
}

void HTMLBRElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
{
    switch (attr->id())
    {
    case ATTR_CLEAR:
    {
        DOMString str = attr->value();
        // If the string is empty, then don't add the clear property. 
        // <br clear> and <br clear=""> are just treated like <br> by Gecko,
        // Mac IE, etc. -dwh
        if (!str.isEmpty()) {
            if (strcasecmp(str,"all") == 0) 
                str = "both";
            addCSSProperty(attr, CSS_PROP_CLEAR, str);
        }
        break;
    }
    default:
        HTMLElementImpl::parseHTMLAttribute(attr);
    }
}

RenderObject *HTMLBRElementImpl::createRenderer(RenderArena *arena, RenderStyle *style)
{
     return new (arena) RenderBR(this);
}

// -------------------------------------------------------------------------

HTMLFontElementImpl::HTMLFontElementImpl(DocumentPtr *doc)
    : HTMLElementImpl(doc)
{
}

HTMLFontElementImpl::~HTMLFontElementImpl()
{
}

NodeImpl::Id HTMLFontElementImpl::id() const
{
    return ID_FONT;
}

// Allows leading spaces.
// Allows trailing nonnumeric characters.
// Returns 10 for any size greater than 9.
static bool parseFontSizeNumber(const DOMString &s, int &size)
{
    unsigned pos = 0;
    
    // Skip leading spaces.
    while (pos < s.length() && s[pos].isSpace())
        ++pos;
    
    // Skip a plus or minus.
    bool sawPlus = false;
    bool sawMinus = false;
    if (pos < s.length() && s[pos] == '+') {
        ++pos;
        sawPlus = true;
    } else if (pos < s.length() && s[pos] == '-') {
        ++pos;
        sawMinus = true;
    }
    
    // Parse a single digit.
    if (pos >= s.length() || !s[pos].isNumber())
        return false;
    int num = s[pos++].digitValue();
    
    // Check for an additional digit.
    if (pos < s.length() && s[pos].isNumber())
        num = 10;
    
    if (sawPlus) {
        size = num + 3;
        return true;
    }
    
    // Don't return 0 (which means 3) or a negative number (which means the same as 1).
    if (sawMinus) {
        size = num == 1 ? 2 : 1;
        return true;
    }
    
    size = num;
    return true;
}

bool HTMLFontElementImpl::mapToEntry(NodeImpl::Id attr, MappedAttributeEntry& result) const
{
    switch(attr)
    {
        case ATTR_SIZE:
        case ATTR_COLOR:
        case ATTR_FACE:
            result = eUniversal;
            return false;
        default:
            break;
    }
    
    return HTMLElementImpl::mapToEntry(attr, result);
}

void HTMLFontElementImpl::parseHTMLAttribute(HTMLAttributeImpl *attr)
{
    switch(attr->id())
    {
    case ATTR_SIZE:
    {
        int num;
        if (parseFontSizeNumber(attr->value(), num)) {
            int size;
            switch (num)
            {
            case 2: size = CSS_VAL_SMALL; break;
            case 0: // treat 0 the same as 3, because people expect it to be between -1 and +1
            case 3: size = CSS_VAL_MEDIUM; break;
            case 4: size = CSS_VAL_LARGE; break;
            case 5: size = CSS_VAL_X_LARGE; break;
            case 6: size = CSS_VAL_XX_LARGE; break;
            default:
                if (num > 6)
                    size = CSS_VAL__KHTML_XXX_LARGE;
                else
                    size = CSS_VAL_X_SMALL;
            }
            addCSSProperty(attr, CSS_PROP_FONT_SIZE, size);
        }
        break;
    }
    case ATTR_COLOR:
        addHTMLColor(attr, CSS_PROP_COLOR, attr->value());
        break;
    case ATTR_FACE:
        addCSSProperty(attr, CSS_PROP_FONT_FAMILY, attr->value());
        break;
    default:
        HTMLElementImpl::parseHTMLAttribute(attr);
    }
}