domwindow.cpp

linux下开源浏览器WebKit的源码,市面上的很多商用浏览器都是移植自WebKit

{
    if (!m_frame)
        return;

    m_frame->document()->updateLayoutIgnorePendingStylesheets();

    FrameView* view = m_frame->view();
    if (!view)
        return;

    view->scrollBy(IntSize(x, y));
}

void DOMWindow::scrollTo(int x, int y) const
{
    if (!m_frame)
        return;

    m_frame->document()->updateLayoutIgnorePendingStylesheets();

    FrameView* view = m_frame->view();
    if (!view)
        return;

    int zoomedX = static_cast<int>(x * m_frame->pageZoomFactor());
    int zoomedY = static_cast<int>(y * m_frame->pageZoomFactor());
    view->setScrollPosition(IntPoint(zoomedX, zoomedY));
}

void DOMWindow::moveBy(float x, float y) const
{
    if (!m_frame)
        return;

    Page* page = m_frame->page();
    if (!page)
        return;

    if (m_frame != page->mainFrame())
        return;

    FloatRect fr = page->chrome()->windowRect();
    FloatRect update = fr;
    update.move(x, y);
    // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
    adjustWindowRect(screenAvailableRect(page->mainFrame()->view()), fr, update);
    page->chrome()->setWindowRect(fr);
}

void DOMWindow::moveTo(float x, float y) const
{
    if (!m_frame)
        return;

    Page* page = m_frame->page();
    if (!page)
        return;

    if (m_frame != page->mainFrame())
        return;

    FloatRect fr = page->chrome()->windowRect();
    FloatRect sr = screenAvailableRect(page->mainFrame()->view());
    fr.setLocation(sr.location());
    FloatRect update = fr;
    update.move(x, y);     
    // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
    adjustWindowRect(sr, fr, update);
    page->chrome()->setWindowRect(fr);
}

void DOMWindow::resizeBy(float x, float y) const
{
    if (!m_frame)
        return;

    Page* page = m_frame->page();
    if (!page)
        return;

    if (m_frame != page->mainFrame())
        return;

    FloatRect fr = page->chrome()->windowRect();
    FloatSize dest = fr.size() + FloatSize(x, y);
    FloatRect update(fr.location(), dest);
    adjustWindowRect(screenAvailableRect(page->mainFrame()->view()), fr, update);
    page->chrome()->setWindowRect(fr);
}

void DOMWindow::resizeTo(float width, float height) const
{
    if (!m_frame)
        return;

    Page* page = m_frame->page();
    if (!page)
        return;

    if (m_frame != page->mainFrame())
        return;

    FloatRect fr = page->chrome()->windowRect();
    FloatSize dest = FloatSize(width, height);
    FloatRect update(fr.location(), dest);
    adjustWindowRect(screenAvailableRect(page->mainFrame()->view()), fr, update);
    page->chrome()->setWindowRect(fr);
}

inline void DOMWindow::setInlineEventListenerForType(const AtomicString& eventType, PassRefPtr<EventListener> eventListener)
{
    Document* document = this->document();
    if (!document)
        return;
    document->setWindowInlineEventListenerForType(eventType, eventListener);
}

inline EventListener* DOMWindow::inlineEventListenerForType(const AtomicString& eventType) const
{
    Document* document = this->document();
    if (!document)
        return 0;
    return document->windowInlineEventListenerForType(eventType);
}

EventListener* DOMWindow::onabort() const
{
    return inlineEventListenerForType(eventNames().abortEvent);
}

void DOMWindow::setOnabort(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().abortEvent, eventListener);
}

EventListener* DOMWindow::onblur() const
{
    return inlineEventListenerForType(eventNames().blurEvent);
}

void DOMWindow::setOnblur(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().blurEvent, eventListener);
}

EventListener* DOMWindow::onchange() const
{
    return inlineEventListenerForType(eventNames().changeEvent);
}

void DOMWindow::setOnchange(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().changeEvent, eventListener);
}

EventListener* DOMWindow::onclick() const
{
    return inlineEventListenerForType(eventNames().clickEvent);
}

void DOMWindow::setOnclick(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().clickEvent, eventListener);
}

EventListener* DOMWindow::ondblclick() const
{
    return inlineEventListenerForType(eventNames().dblclickEvent);
}

void DOMWindow::setOndblclick(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().dblclickEvent, eventListener);
}

EventListener* DOMWindow::onerror() const
{
    return inlineEventListenerForType(eventNames().errorEvent);
}

void DOMWindow::setOnerror(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().errorEvent, eventListener);
}

EventListener* DOMWindow::onfocus() const
{
    return inlineEventListenerForType(eventNames().focusEvent);
}

void DOMWindow::setOnfocus(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().focusEvent, eventListener);
}

EventListener* DOMWindow::onkeydown() const
{
    return inlineEventListenerForType(eventNames().keydownEvent);
}

void DOMWindow::setOnkeydown(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().keydownEvent, eventListener);
}

EventListener* DOMWindow::onkeypress() const
{
    return inlineEventListenerForType(eventNames().keypressEvent);
}

void DOMWindow::setOnkeypress(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().keypressEvent, eventListener);
}

EventListener* DOMWindow::onkeyup() const
{
    return inlineEventListenerForType(eventNames().keyupEvent);
}

void DOMWindow::setOnkeyup(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().keyupEvent, eventListener);
}

EventListener* DOMWindow::onload() const
{
    return inlineEventListenerForType(eventNames().loadEvent);
}

void DOMWindow::setOnload(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().loadEvent, eventListener);
}

EventListener* DOMWindow::onmousedown() const
{
    return inlineEventListenerForType(eventNames().mousedownEvent);
}

void DOMWindow::setOnmousedown(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().mousedownEvent, eventListener);
}

EventListener* DOMWindow::onmousemove() const
{
    return inlineEventListenerForType(eventNames().mousemoveEvent);
}

void DOMWindow::setOnmousemove(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().mousemoveEvent, eventListener);
}

EventListener* DOMWindow::onmouseout() const
{
    return inlineEventListenerForType(eventNames().mouseoutEvent);
}

void DOMWindow::setOnmouseout(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().mouseoutEvent, eventListener);
}

EventListener* DOMWindow::onmouseover() const
{
    return inlineEventListenerForType(eventNames().mouseoverEvent);
}

void DOMWindow::setOnmouseover(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().mouseoverEvent, eventListener);
}

EventListener* DOMWindow::onmouseup() const
{
    return inlineEventListenerForType(eventNames().mouseupEvent);
}

void DOMWindow::setOnmouseup(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().mouseupEvent, eventListener);
}

EventListener* DOMWindow::onmousewheel() const
{
    return inlineEventListenerForType(eventNames().mousewheelEvent);
}

void DOMWindow::setOnmousewheel(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().mousewheelEvent, eventListener);
}

EventListener* DOMWindow::onreset() const
{
    return inlineEventListenerForType(eventNames().resetEvent);
}

void DOMWindow::setOnreset(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().resetEvent, eventListener);
}

EventListener* DOMWindow::onresize() const
{
    return inlineEventListenerForType(eventNames().resizeEvent);
}

void DOMWindow::setOnresize(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().resizeEvent, eventListener);
}

EventListener* DOMWindow::onscroll() const
{
    return inlineEventListenerForType(eventNames().scrollEvent);
}

void DOMWindow::setOnscroll(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().scrollEvent, eventListener);
}

EventListener* DOMWindow::onsearch() const
{
    return inlineEventListenerForType(eventNames().searchEvent);
}

void DOMWindow::setOnsearch(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().searchEvent, eventListener);
}

EventListener* DOMWindow::onselect() const
{
    return inlineEventListenerForType(eventNames().selectEvent);
}

void DOMWindow::setOnselect(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().selectEvent, eventListener);
}

EventListener* DOMWindow::onsubmit() const
{
    return inlineEventListenerForType(eventNames().submitEvent);
}

void DOMWindow::setOnsubmit(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().submitEvent, eventListener);
}

EventListener* DOMWindow::onunload() const
{
    return inlineEventListenerForType(eventNames().unloadEvent);
}

void DOMWindow::setOnunload(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().unloadEvent, eventListener);
}

EventListener* DOMWindow::onbeforeunload() const
{
    return inlineEventListenerForType(eventNames().beforeunloadEvent);
}

void DOMWindow::setOnbeforeunload(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().beforeunloadEvent, eventListener);
}

EventListener* DOMWindow::onwebkitanimationstart() const
{
    return inlineEventListenerForType(eventNames().webkitAnimationStartEvent);
}

void DOMWindow::setOnwebkitanimationstart(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().webkitAnimationStartEvent, eventListener);
}

EventListener* DOMWindow::onwebkitanimationiteration() const
{
    return inlineEventListenerForType(eventNames().webkitAnimationIterationEvent);
}

void DOMWindow::setOnwebkitanimationiteration(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().webkitAnimationIterationEvent, eventListener);
}

EventListener* DOMWindow::onwebkitanimationend() const
{
    return inlineEventListenerForType(eventNames().webkitAnimationEndEvent);
}

void DOMWindow::setOnwebkitanimationend(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().webkitAnimationEndEvent, eventListener);
}

EventListener* DOMWindow::onwebkittransitionend() const
{
    return inlineEventListenerForType(eventNames().webkitTransitionEndEvent);
}

void DOMWindow::setOnwebkittransitionend(PassRefPtr<EventListener> eventListener)
{
    setInlineEventListenerForType(eventNames().webkitTransitionEndEvent, eventListener);
}

} // namespace WebCore