html_baseimpl.cpp

将konqueror浏览器移植到ARM9 2410中

    view = 0;
}

HTMLFrameSetElementImpl::~HTMLFrameSetElementImpl()
{
    delete m_rows;
    delete m_cols;
}

const DOMString HTMLFrameSetElementImpl::nodeName() const
{
    return "FRAMESET";
}

ushort HTMLFrameSetElementImpl::id() const
{
    return ID_FRAMESET;
}

void HTMLFrameSetElementImpl::parseAttribute(AttrImpl *attr)
{
    switch(attr->attrId)
    {
    case ATTR_ROWS:
        m_rows = attr->val()->toLengthList();
        m_totalRows = m_rows->count();
        break;
    case ATTR_COLS:
        m_cols = attr->val()->toLengthList();
        m_totalCols = m_cols->count();
        break;
    case ATTR_FRAMEBORDER:
        // false or "no" or "0"..
        if ( attr->value().toInt() == 0 ) {
            frameborder = false;
            m_border = 0;
        }
        frameBorderSet = true;
        break;
    case ATTR_NORESIZE:
        noresize = true;
        break;
    case ATTR_BORDER:
        m_border = attr->val()->toInt();
        if(!m_border)
            frameborder = false;
        break;
    case ATTR_ONLOAD:
        setHTMLEventListener(EventImpl::LOAD_EVENT,
	    ownerDocument()->createHTMLEventListener(attr->value().string()));
        break;
    case ATTR_ONUNLOAD:
        setHTMLEventListener(EventImpl::UNLOAD_EVENT,
	    ownerDocument()->createHTMLEventListener(attr->value().string()));
        break;
    default:
        HTMLElementImpl::parseAttribute(attr);
    }
}

void HTMLFrameSetElementImpl::attach()
{
    KHTMLView* w = ownerDocument()->view();
    // inherit default settings from parent frameset
    HTMLElementImpl* node = static_cast<HTMLElementImpl*>(parentNode());
    while(node)
    {
        if(node->id() == ID_FRAMESET)
        {
            HTMLFrameSetElementImpl* frameset = static_cast<HTMLFrameSetElementImpl*>(node);
            if(!frameBorderSet)  frameborder = frameset->frameBorder();
            if(!noresize)  noresize = frameset->noResize();
            break;
        }
        node = static_cast<HTMLElementImpl*>(node->parentNode());
    }

    setStyle(ownerDocument()->styleSelector()->styleForElement( this ));
    view = w;
    khtml::RenderObject *r = _parent->renderer();

    // ignore display: none for this element!
    if ( !r )
      return;

    khtml::RenderFrameSet *renderFrameSet = new khtml::RenderFrameSet( this, w, m_rows, m_cols );
    m_render = renderFrameSet;
    m_render->setStyle(m_style);
    r->addChild( m_render, nextRenderer() );

    HTMLElementImpl::attach();
}

// verifies that we have enough m_rows/m_cols entries for the actual document structure
// if there are not enough, we add fake ones.
// ### investigate IE's behaviour in such cases more closely
bool HTMLFrameSetElementImpl::verifyLayout()
{
    QList<khtml::Length>* layoutAttr = 0;

    if(m_cols) layoutAttr = m_cols;
    if(m_rows) layoutAttr = m_rows;

    if(!layoutAttr) {
        layoutAttr = new QList<Length>;
        layoutAttr->setAutoDelete(true);
        m_rows = layoutAttr;
        static_cast<khtml::RenderFrameSet*>(m_render)->m_rows = layoutAttr;
    }

    bool changed = false;
    unsigned int l = layoutAttr->count();
    unsigned int i = 0;

    for(HTMLElementImpl* node = static_cast<HTMLElementImpl*>(firstChild());
        node;
        node = static_cast<HTMLElementImpl*>(node->nextSibling()), i++) {
        if(i < l) continue;

        if(node->id() == ID_FRAMESET)
            layoutAttr->append(new Length(1, khtml::Relative));
        else
            layoutAttr->append(new Length(0, khtml::Fixed));
        changed = true;
    }
    if(m_rows)
        m_totalRows = i;
    else
        m_totalCols = i;

    return changed;
}

bool HTMLFrameSetElementImpl::prepareMouseEvent( int _x, int _y,
                                                 int _tx, int _ty,
                                                 MouseEvent *ev )
{
    _x-=_tx;
    _y-=_ty;

    NodeImpl *child = _first;
    while(child)
    {
        if(child->id() == ID_FRAMESET)
            if(child->prepareMouseEvent( _x, _y, _tx, _ty, ev )) return true;
        child = child->nextSibling();
    }

    if(noresize) return true;

    if ( !m_render || !m_render->layouted() )
    {
      kdDebug( 6030 ) << "ugh, not layouted or not attached?!" << endl;
      return true;
    }
    if ( (m_render->style() && m_render->style()->visiblity() == HIDDEN) )
      return true;

    if (static_cast<khtml::RenderFrameSet *>(m_render)->canResize( _x, _y, ev->type )) {
        ev->innerNode = Node(this);
        return true;
    }
    else
        return false;
}

void HTMLFrameSetElementImpl::defaultEventHandler(EventImpl *evt)
{
    if (evt->isMouseEvent())
        static_cast<khtml::RenderFrameSet *>(m_render)->userResize(static_cast<MouseEventImpl*>(evt));
}

khtml::FindSelectionResult HTMLFrameSetElementImpl::findSelectionNode( int _x, int _y, int _tx, int _ty,
                                                                DOM::Node & node, int & offset )
{
    _x-=_tx;
    _y-=_ty;
    NodeImpl *child = _first;
    while(child)
    {
        if(child->id() == ID_FRAMESET)
            return child->findSelectionNode( _x, _y, _tx, _ty, node, offset ); // to be checked
        child = child->nextSibling();
    }
    return SelectionPointAfter;
}

void HTMLFrameSetElementImpl::detach()
{
    HTMLElementImpl::detach();
    // ### send the event when we actually get removed from the doc instead of here
    dispatchHTMLEvent(EventImpl::UNLOAD_EVENT,false,false);
}


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

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

HTMLHeadElementImpl::~HTMLHeadElementImpl()
{
}

const DOMString HTMLHeadElementImpl::nodeName() const
{
    return "HEAD";
}

ushort HTMLHeadElementImpl::id() const
{
    return ID_HEAD;
}

void HTMLHtmlElementImpl::attach()
{
    setStyle(ownerDocument()->styleSelector()->styleForElement( this ));
    khtml::RenderObject *r = _parent->renderer();

    // ignore display: none for this element!
    if ( !r )
      return;

    m_render = new khtml::RenderHtml();
    m_render->setStyle(m_style);
    r->addChild( m_render, nextRenderer() );

    HTMLElementImpl::attach();
}


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

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

HTMLHtmlElementImpl::~HTMLHtmlElementImpl()
{
}

const DOMString HTMLHtmlElementImpl::nodeName() const
{
    return "HTML";
}

ushort HTMLHtmlElementImpl::id() const
{
    return ID_HTML;
}


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

HTMLIFrameElementImpl::HTMLIFrameElementImpl(DocumentPtr *doc) : HTMLFrameElementImpl(doc)
{
    frameBorder = false;
    marginWidth = 0;
    marginHeight = 0;
    needWidgetUpdate = false;
}

HTMLIFrameElementImpl::~HTMLIFrameElementImpl()
{
}

const DOMString HTMLIFrameElementImpl::nodeName() const
{
    return "IFRAME";
}

ushort HTMLIFrameElementImpl::id() const
{
    return ID_IFRAME;
}

void HTMLIFrameElementImpl::parseAttribute(AttrImpl *attr )
{
  DOM::DOMStringImpl *stringImpl = attr->value().implementation();
  QString val = QConstString( stringImpl->s, stringImpl->l ).string();
  switch (  attr->attrId )
  {
    case ATTR_WIDTH:
      addCSSLength( CSS_PROP_WIDTH, attr->value());
      break;
    case ATTR_HEIGHT:
      addCSSLength( CSS_PROP_HEIGHT, attr->value() );
      break;
    case ATTR_SRC:
      needWidgetUpdate = true; // ### do this for scrolling, margins etc?
      HTMLFrameElementImpl::parseAttribute( attr );
      break;
    default:
      HTMLFrameElementImpl::parseAttribute( attr );
  }
}

void HTMLIFrameElementImpl::attach()
{
  setStyle(ownerDocument()->styleSelector()->styleForElement( this ));

  KHTMLView* w = ownerDocument()->view();
  // limit to how deep we can nest frames
  KHTMLPart *part = w->part();
  int depth = 0;
  while ((part = part->parentPart()))
    depth++;
  if (depth > 6) {
      style()->setDisplay( NONE );
      return;
  }

  khtml::RenderObject *r = _parent->renderer();

  if(r && m_style->display() != NONE) {

      // we need a unique name for every frame in the frameset. Hope that's unique enough.
      if(name.isEmpty())
      {
          name = DOMString(w->part()->requestFrameName());
          kdDebug( 6030 ) << "creating frame name: " << name.string() << endl;
      }

      khtml::RenderPartObject *renderFrame = new khtml::RenderPartObject( w, this );
      m_render = renderFrame;
      m_render->setStyle(m_style);
      r->addChild( m_render, nextRenderer() );
      renderFrame->updateWidget();
      needWidgetUpdate = false;
  }

  HTMLElementImpl::attach();
}

void HTMLIFrameElementImpl::applyChanges(bool top, bool force)
{
    if (needWidgetUpdate) {
        if(m_render)  static_cast<RenderPartObject*>(m_render)->updateWidget();
        needWidgetUpdate = false;
    }
    HTMLElementImpl::applyChanges(top,force);
}

DocumentImpl* HTMLIFrameElementImpl::frameDocument() const
{
    if ( !m_render ) return 0;

    RenderPartObject* render = static_cast<RenderPartObject*>( m_render );

    if(render->m_widget && render->m_widget->inherits("KHTMLView"))
        return static_cast<KHTMLView*>( render->m_widget )->part()->xmlDocImpl();

    return 0;
}