html_formimpl.cpp

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

            m_render = new RenderSubmitButton(view, this);
            break;
        case IMAGE:
        {
            m_render = new RenderImageButton(this);
            setHasEvents();
            break;
        }
        case RESET:
            m_render = new RenderResetButton(view, this);
            break;
        case FILE:
            m_render = new RenderFileButton(view, this);
            break;
        case HIDDEN:
            m_render = 0;
            break;
        case BUTTON:
            m_render = new RenderPushButton(view, this);
            break;
        }

        if (m_render)
        {
            m_render->setPart (_view->part());
            m_render->setStyle(m_style);
#ifdef FORMS_DEBUG
            kdDebug( 6030 ) << "adding " << m_render->renderName() << " as child of " << r->renderName() << endl;
#endif
            QString state = document->registerElement(this);
            if ( !state.isEmpty())
            {
#ifdef FORMS_DEBUG
                kdDebug( 6030 ) << "Restoring InputElem name=" << _name.string() <<
                    " state=" << state << endl;
#endif
                restoreState( state );
            }

            r->addChild(m_render, _next ? _next->renderer() : 0);
        }
    }
    NodeBaseImpl::attach(_view);

    if (m_render && _type == IMAGE) {
        static_cast<RenderImageButton*>
            (m_render)->setImageUrl(_src,
                                    static_cast<HTMLDocumentImpl *>(document)->URL(),
                                    static_cast<HTMLDocumentImpl *>(document)->docLoader());

    }
}


bool HTMLInputElementImpl::encoding(khtml::encodingList& encoding)
{

    if (_name.isEmpty()) return false;

    // ### local8Bit() is probably wrong here
    switch (_type) {
        case HIDDEN:
        case TEXT:
        case PASSWORD:
            // always successful
            encoding += m_value.string().local8Bit();
            return true;
        case CHECKBOX:

            if( checked() )
            {
                encoding += ( m_value.isNull() ? QCString("on") : m_value.string().local8Bit() );
                return true;
            }
            break;

        case RADIO:

            if( checked() )
            {
                encoding += m_value.string().local8Bit();
                return true;
            }
            break;

        case BUTTON:
        case RESET:
            // those buttons are never successful
            return false;

        case IMAGE:
            break;
			/*
            if(_clicked)
            {
                _clicked = false;
                encoding += m_value.string().local8Bit();
                return true; // coordinate submit are currently a special case in formData
            }
            break;
			*/

        case SUBMIT:

            if (m_render && static_cast<RenderSubmitButton*>(m_render)->clicked())
            {
                QCString enc_str = m_value.isNull() ?
                                   static_cast<RenderSubmitButton*>(m_render)->defaultLabel().local8Bit() : value().string().local8Bit();

                if (m_render)
                    static_cast<RenderSubmitButton*>(m_render)->setClicked(false);

                if(!enc_str.isEmpty())
                {
                    encoding += enc_str;
                    return true;
                }
            }
            break;

        case FILE:
        {
            QString local;

            // if no filename at all is entered, return successful, however empty
            if(m_filename.isEmpty())
                return true;

            //if ( KIO::NetAccess::download(KURL(m_filename.string()), local) )
			if( true )
            {
                QFile file(local);
                if (file.open(IO_ReadOnly))
                {
                    QByteArray filearray(file.size()+1);
                    file.readBlock( filearray.data(), file.size());
                    // not really necessary, but makes it easier
                    filearray[filearray.size()-1] = '\0';
                    file.close();

                    encoding += filearray;
                    //KIO::NetAccess::removeTempFile( local );

                    return true;
                }
                else
                {
                    //KMessageBox::error(0L, i18n("Cannot open downloaded file.\nSubmit a bugreport"));
                    //KIO::NetAccess::removeTempFile( local );
                    return false;
                }
            }
            else {
                //KMessageBox::sorry(0L, i18n("Error downloading file:\n%1").arg(KIO::NetAccess::lastErrorString()));
                return false;
            }
            break;
        }
    }
    return false;
}

void HTMLInputElementImpl::reset()
{
    setValue(getAttribute(ATTR_VALUE));
    setChecked(getAttribute(ATTR_CHECKED) != 0);
    if ((_type == SUBMIT || _type == RESET || _type == BUTTON || _type == IMAGE) && m_render)
        static_cast<RenderSubmitButton*>(m_render)->setClicked(false);
}

void HTMLInputElementImpl::setChecked(bool _checked)
{
    qDebug("setchecked %d", _checked);

    m_checked = _checked;
    if (_type == RADIO && _form && m_checked)
        _form->radioClicked(this);
    setChanged(true);
}


DOMString HTMLInputElementImpl::value() const
{
    if(m_value.isNull())
        return DOMString(""); // some JS sites obviously need this

    return m_value;
}


void HTMLInputElementImpl::setValue(DOMString val)
{
    switch (_type) {
    case TEXT:
    case PASSWORD:
        m_value = (val.isNull() ? DOMString("") : val);
        setChanged(true);
        break;
    case FILE:
        // sorry, can't change this!
        m_value = m_filename;
    default:
        setAttribute(ATTR_VALUE,val);
    }
}

bool HTMLInputElementImpl::mouseEvent( int _x, int _y, int button, MouseEventType type,
                                       int _tx, int _ty, DOMString &url,
                                       NodeImpl *&innerNode, long &offset )
{
    bool wasPressed = pressed();
    bool ret = HTMLGenericFormElementImpl::mouseEvent(_x,_y,button,type,_tx,_ty,url,innerNode,offset);
    if (_type == IMAGE && (type == MouseClick || ((type == MouseRelease) && wasPressed))) {
        xPos = _x - _tx - m_render->xPos();
        yPos = _y - _ty - m_render->yPos();
        _clicked = true;
        if(_form) _form->prepareSubmit();
        return true;
    }
    return ret;
}

void HTMLInputElementImpl::setOwnerDocument(DocumentImpl *_document)
{
    if (ownerDocument())
	ownerDocument()->removeElement(this);
    HTMLGenericFormElementImpl::setOwnerDocument(_document);
}


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

HTMLLabelElementImpl::HTMLLabelElementImpl(DocumentImpl *doc, HTMLFormElementImpl *f)
    : HTMLGenericFormElementImpl(doc, f)
{
}

HTMLLabelElementImpl::HTMLLabelElementImpl(DocumentImpl *doc)
    : HTMLGenericFormElementImpl(doc)
{
}

HTMLLabelElementImpl::~HTMLLabelElementImpl()
{
}

const DOMString HTMLLabelElementImpl::nodeName() const
{
    return "LABEL";
}

ushort HTMLLabelElementImpl::id() const
{
    return ID_LABEL;
}

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

HTMLLegendElementImpl::HTMLLegendElementImpl(DocumentImpl *doc, HTMLFormElementImpl *f)
    : HTMLGenericFormElementImpl(doc, f)
{
}

HTMLLegendElementImpl::HTMLLegendElementImpl(DocumentImpl *doc)
    : HTMLGenericFormElementImpl(doc)
{
}

HTMLLegendElementImpl::~HTMLLegendElementImpl()
{
}

const DOMString HTMLLegendElementImpl::nodeName() const
{
    return "LEGEND";
}

ushort HTMLLegendElementImpl::id() const
{
    return ID_LEGEND;
}

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

HTMLSelectElementImpl::HTMLSelectElementImpl(DocumentImpl *doc)
    : HTMLGenericFormElementImpl(doc)
{
    m_multiple = false;
    view = 0;
    // 0 means invalid (i.e. not set)
    m_size = 0;
}

HTMLSelectElementImpl::HTMLSelectElementImpl(DocumentImpl *doc, HTMLFormElementImpl *f)
    : HTMLGenericFormElementImpl(doc, f)
{
    m_multiple = false;
    view = 0;
    // 0 means invalid (i.e. not set)
    m_size = 0;
}

ushort HTMLSelectElementImpl::id() const
{
    return ID_SELECT;
}

DOMString HTMLSelectElementImpl::type() const
{
    return (m_multiple ? "select-multiple" : "select-one");
}

long HTMLSelectElementImpl::selectedIndex() const
{
    uint i;
    for (i = 0; i < m_listItems.size(); i++) {
        if (m_listItems[i]->id() == ID_OPTION
            && static_cast<HTMLOptionElementImpl*>(m_listItems[i])->selected())
            return listToOptionIndex(int(i)); // selectedIndex is the *first* selected item; there may be others
    }
    return -1;
}

void HTMLSelectElementImpl::setSelectedIndex( long  index )
{
    // deselect all other options and select only the new one
    int listIndex;
    for (listIndex = 0; listIndex < int(m_listItems.size()); listIndex++) {
        if (m_listItems[listIndex]->id() == ID_OPTION)
            static_cast<HTMLOptionElementImpl*>(m_listItems[listIndex])->setSelected(false);
    }
    listIndex = optionToListIndex(index);
    if (listIndex >= 0)
        static_cast<HTMLOptionElementImpl*>(m_listItems[listIndex])->setSelected(true);

    setChanged(true);
}

long HTMLSelectElementImpl::length() const
{
    int len = 0;
    uint i;
    for (i = 0; i < m_listItems.size(); i++) {
        if (m_listItems[i]->id() == ID_OPTION)
            len++;
    }
    return len;
}

#if 0
void HTMLSelectElementImpl::add( const HTMLElement &, const HTMLElement & )
{
    // ###
}
#endif

void HTMLSelectElementImpl::remove( long  )
{
    // ###
}

QString HTMLSelectElementImpl::state( )
{
    return m_render ? static_cast<RenderSelect*>(m_render)->state() : QString::null;
}

void HTMLSelectElementImpl::restoreState(const QString &state)
{
    if (m_render)
        static_cast<RenderSelect*>(m_render)->restoreState(state);
    setChanged(true);
}

NodeImpl *HTMLSelectElementImpl::insertBefore ( NodeImpl *newChild, NodeImpl *refChild )
{
    NodeImpl *result = HTMLGenericFormElementImpl::insertBefore(newChild,refChild);
    recalcListItems();
    return result;
}

NodeImpl *HTMLSelectElementImpl::replaceChild ( NodeImpl *newChild, NodeImpl *oldChild )
{
    NodeImpl *result = HTMLGenericFormElementImpl::replaceChild(newChild,oldChild);
    recalcListItems();
    return result;
}

NodeImpl *HTMLSelectElementImpl::removeChild ( NodeImpl *oldChild )
{
    NodeImpl *result = HTMLGenericFormElementImpl::removeChild(oldChild);
    recalcListItems();
    return result;
}

NodeImpl *HTMLSelectElementImpl::appendChild ( NodeImpl *newChild )
{
    NodeImpl *result = HTMLGenericFormElementImpl::appendChild(newChild);
    recalcListItems();
    setChanged(true);
    return result;
}

void HTMLSelectElementImpl::parseAttribute(AttrImpl *attr)
{
    switch(attr->attrId)
    {
    case ATTR_SIZE:
        m_size = attr->val()->toInt();
        break;
    case ATTR_MULTIPLE:
        m_multiple = (attr->val() != 0);
        break;
    case ATTR_ACCESSKEY:
        // ### ignore for the moment
        break;
    case ATTR_ONFOCUS:
    case ATTR_ONBLUR:
    case ATTR_ONSELECT:
    case ATTR_ONCHANGE:
        // ###
        break;
    default:
        HTMLGenericFormElementImpl::parseAttribute(attr);
    }
}

void HTMLSelectElementImpl::attach(MGHTMLView *_view)
{
    m_style = document->styleSelector()->styleForElement(this, _view->part());
    view = _view;

    khtml::RenderObject *r = _parent->renderer();
    if(r)
    {
        RenderSelect *f = new RenderSelect(view, this);
        if (f)
        {
            m_render = f;
            m_render->setPart (_view->part());
            m_render->setStyle(m_style);
            r->addChild(m_render, _next ? _next->renderer() : 0);
        }
    }
    NodeBaseImpl::attach(_view);
}


bool HTMLSelectElementImpl::encoding(khtml::encodingList& encoded_values)
{