diff -r 000000000000 -r dd21522fd290 webengine/osswebengine/WebKit/s60/webview/WebFrameView.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebKit/s60/webview/WebFrameView.cpp	Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,588 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:   Frame in webkit side
+*
+*/
+
+
+#include "config.h"
+#include "../../bidi.h"
+#include "WebFrameView.h"
+#include "WebFrame.h"
+#include "WebView.h"
+#include "WebCursor.h"
+#include "WebFrameBridge.h"
+#include "WebCoreGraphicsContext.h"
+#include "GraphicsContext.h"
+#include "PlatformScrollbar.h"
+#include "PageScaler.h"
+#include "webkitlogger.h"
+#include "BrCtl.h"
+using namespace WebCore;
+
+WebFrameView::WebFrameView() : 
+      m_parent(NULL),
+      m_hasBorder(true),
+      m_refCount(1)
+{
+    m_hScrollbar = new WebCore::PlatformScrollbar(this, WebCore::HorizontalScrollbar, WebCore::RegularScrollbar);
+    m_vScrollbar = new WebCore::PlatformScrollbar(this, WebCore::VerticalScrollbar, WebCore::RegularScrollbar); 
+    m_horizontalScrollBarMode = ScrollbarAuto;
+    m_verticalScrollBarMode = ScrollbarAuto;
+}
+
+WebFrameView::~WebFrameView() 
+{
+    delete m_hScrollbar;
+    delete m_vScrollbar;
+}
+
+void WebFrameView::setTopView(WebView* v)
+{
+    m_topView = v;
+}
+
+void WebFrameView::setWebFrame(WebFrame* f)
+{
+    m_frame = f;
+}
+
+WebFrameView* WebFrameView::initWithFrame(TRect frame)
+{
+    setRect(frame);
+    return this;
+}
+
+void WebFrameView::draw(WebCoreGraphicsContext& gc, const TRect& r)
+{
+    TRect vr(visibleRect());
+    TRect rect(r);
+    if (isScaled() || m_frame->isFrameSet())
+        rect.Grow(1,1);             // eliminate rounding errors
+    TRect frameRect(m_frameRect);
+
+    rect.Move(-frameRect.iTl);
+    rect.Move(m_contentPos);
+    if (vr.Intersects(rect)) {
+        // save the gc state
+        TWebCoreSavedContext saved(gc.save());
+        // set the current frame
+        gc.setView(*this);
+
+        TPoint cpos(toViewCoords(m_contentPos));
+
+        gc.setOrigin(gc.origin()+toViewCoords(m_frameRect.iTl)-cpos);
+        rect.Intersection(vr);
+        // calculate clip for zoom level
+        TRect clip(toViewCoords(rect));
+        
+        // set clipping
+        if (gc.hasClipping()) {
+            TRect t(gc.clippingRect());
+            t.Move(-toViewCoords(m_frameRect.iTl)+cpos);
+            clip.Intersection(t);
+        }
+        
+        gc.setClippingRect( clip );
+
+        // draw frame content
+        m_frame->paintRect(gc, rect);
+        gc.cancelClipping();
+        gc.setOrigin( gc.origin() + cpos);
+        if (m_parent) {
+            WebFrameView* parent = m_parent;
+            TRect frameClip(0,0,KMaxTInt,KMaxTInt);
+            do {
+                TRect pr = parent->visibleRect();
+                TRect fc(TRect(parent->frameCoordsInViewCoords(pr.iTl), parent->frameCoordsInViewCoords(pr.iBr))); 
+                frameClip.Intersection(fc);
+                parent = parent->m_parent;
+            }
+            while(parent);
+            frameClip = TRect(viewCoordsInFrameCoords(frameClip.iTl), viewCoordsInFrameCoords(frameClip.iBr)); 
+            frameClip = TRect(toViewCoords(frameClip));
+            frameClip.Move(-cpos);
+            gc.setClippingRect( frameClip );
+        }
+        // draw frame border
+        CFbsBitGc& realgc = gc.gc();
+        if (m_hasBorder && !m_frame->isFrameSet()) {
+            // already moved the origin
+            TRect borderRect(TPoint(-1,-1),toViewCoords(m_frameRect).Size());
+            borderRect.iBr += TPoint(2,2);
+            realgc.SetPenColor(TRgb(0x55,0x55,0x55));
+            realgc.SetPenStyle(CGraphicsContext::ESolidPen);
+            realgc.SetBrushStyle(CGraphicsContext::ENullBrush);
+            realgc.SetPenSize(TSize(1,1));
+            realgc.DrawRect(borderRect);
+            // double border in bottom/right
+            borderRect.iBr += TPoint(1,1);
+            realgc.DrawRect(borderRect);
+        }
+
+        // draw scrollbars
+        rect.Move( -m_contentPos );
+        WebCore::GraphicsContext ctx(&gc);
+        if (m_vScrollbar->isEnabled())
+            m_vScrollbar->paint(&ctx, rect);
+        if (m_hScrollbar->isEnabled())
+            m_hScrollbar->paint(&ctx, rect);
+
+        gc.cancelClipping();
+        gc.restore(saved);
+    }
+}
+
+void WebFrameView::invalidateRect(const TRect& rect, TBool drawNow)
+{
+    TRect r(rect);
+    if (m_parent) {
+        TRect frameRect(m_frameRect);
+        r.Move(frameRect.iTl - m_contentPos);
+        r.Intersection(frameRect);
+        m_parent->invalidateRect(r, drawNow);
+    }
+    else {
+        // fix rounding errors from zooming
+        if (isScaled() || m_frame->isFrameSet())
+            r.Grow(1,1);
+    }
+
+    if (!m_topView->isClosing()) {
+        if(drawNow)
+            m_topView->syncRepaint(r);
+        else
+            m_topView->scheduleRepaint(r);
+    }
+}
+
+void WebFrameView::activate()
+{
+}
+
+void WebFrameView::setRect(const TRect& rect)
+{
+    TRect frameRect(rect);
+
+    if (m_frameRect!=frameRect) {
+
+        m_frameRect = frameRect;
+        checkScrollbarVisibility();
+    }
+}
+
+int WebFrameView::getBidiWidth()
+{
+    TInt bidiWidth = KMaxTInt;
+    // don't limit bidi width for low subframes
+    if (!(toViewCoords(m_frameRect).Height()<150 && m_parent))
+        bidiWidth = m_topView->maxBidiSize().iWidth;
+
+    return bidiWidth;
+}
+
+void WebFrameView::checkScrollbarVisibility()
+{
+    if (!m_parent || m_parent->frame()->isFrameSet()) {
+        m_vScrollbar->setEnabled(false);
+        m_hScrollbar->setEnabled(false);
+        return;
+    }
+    bool vScrollbar = m_vScrollbar->isEnabled();
+    bool hScrollbar = m_hScrollbar->isEnabled();
+    
+    if (!m_allowsScrolling) {
+        m_vScrollbar->setEnabled(false);
+        m_hScrollbar->setEnabled(false);
+        return;
+    }
+    TRect frameRect(m_frameRect);
+    switch(m_verticalScrollBarMode) {
+        default:
+        case ScrollbarAlwaysOff:
+            vScrollbar = false;
+        break;
+        case ScrollbarAlwaysOn:
+            vScrollbar = true;
+        break;
+        case ScrollbarAuto:
+            vScrollbar = contentSize().iHeight > frameRect.Height();
+        break;
+    }
+
+    switch(m_horizontalScrollBarMode) {
+        default:
+        case ScrollbarAlwaysOff:
+            hScrollbar = false;
+        break;
+        case ScrollbarAlwaysOn:
+            hScrollbar = false;
+        break;
+        case ScrollbarAuto:
+            hScrollbar = contentSize().iWidth > frameRect.Width();
+        break;
+    }
+    
+    m_hScrollbar->setEnabled(hScrollbar);
+    m_vScrollbar->setEnabled(vScrollbar);
+
+    TRect r(TPoint(0,0), frameRect.Size() - TSize(vScrollbar? KScrollbarWidth : 0, hScrollbar ? KScrollbarWidth : 0));
+    if (hScrollbar) {
+        m_hScrollbar->setRect(TRect(TPoint(r.iTl.iX, r.iBr.iY ), TSize(r.Width(), KScrollbarWidth)));
+        m_hScrollbar->setProportion(r.Width(), m_contentSize.iWidth);
+    }
+
+    if (vScrollbar)  {
+        m_vScrollbar->setRect(TRect(TPoint(r.iBr.iX, r.iTl.iY), TSize(KScrollbarWidth, r.Height())));
+        m_vScrollbar->setProportion(r.Height(), m_contentSize.iHeight);
+    }
+}
+
+void WebFrameView::setCursor(CursorTypes cursorType)
+{
+    if (m_topView && StaticObjectsContainer::instance()->webCursor())
+        StaticObjectsContainer::instance()->webCursor()->setCursor(cursorType);
+}
+
+void WebFrameView::setParent(MScrollView* parent)
+{
+    m_parent = static_cast<WebFrameView*>(parent);
+}
+
+TRect WebFrameView::rect() const
+{
+    return m_frameRect;
+}
+
+TRect WebFrameView::visibleRect() const
+{
+    TSize s(m_frameRect.Size());
+    return TRect(m_contentPos, s );
+}
+
+void WebFrameView::scrollTo(const TPoint& aPoint)
+{
+    if (m_parent) {
+        // tot:fixme frame scrolling when frame-flat is off
+        if (m_frame->isIframe()) {
+            // iframe, support scrolling
+            if (aPoint != m_contentPos) {
+                TPoint p(nearestPointInFrame(aPoint));
+                m_contentPos = p;
+                m_frame->notifyPluginsOfScrolling();
+                m_topView->syncRepaint( TRect(0,0,KMaxTInt/2,KMaxTInt/2) );
+            }
+        }
+        else {
+            if (aPoint.iX==0 && aPoint.iY==0) {
+                // this gets called for all frames during loading, needs to be ignored (breaks some cases though)
+                return;
+            }
+
+            TPoint p(0, aPoint.iY); // don't to x shifts, they are confusing here
+            // subframes don't scroll in the current implementation, scroll the main frame
+            p += toDocCoords(rectInGlobalCoords().iTl);
+            m_topView->mainFrame()->frameView()->scrollTo(p);
+        }
+    }
+    else {
+        // main frame, scroll
+        if (aPoint != m_contentPos) {
+            TPoint p( nearestPointInFrame(aPoint) );
+            TBool copyScroll = m_mayUseCopyScroll;
+
+            if( p != aPoint && m_topView->inFindState() ) {
+                p = aPoint;
+                m_topView->clearOffScreenBitmap();
+                copyScroll = EFalse;
+            }
+
+            TPoint from( toViewCoords(m_contentPos) );
+            TPoint to( toViewCoords(p) );
+
+            m_topView->scrollBuffer(to, from, copyScroll);
+            m_contentPos = p;
+
+            
+            m_frame->notifyPluginsOfScrolling();
+            
+            
+            if( m_topView->pageScaler() && m_topView->pageScaler()->Visible())
+                m_topView->pageScaler()->DocumentViewportMoved();
+
+            //Update scroll bar , thumb position
+            m_topView->updateScrollbars(m_contentSize.iHeight, m_contentPos.iY, m_contentSize.iWidth, m_contentPos.iX);
+            
+            // trigger painting
+            m_topView->syncRepaint();
+        }
+    }
+}
+
+
+bool WebFrameView::needScroll(const TPoint& aPoint)
+{
+    bool rv = false;
+    if (m_parent) {
+        if (m_frame->isIframe()) {
+            if (aPoint != m_contentPos) {
+                rv = true;
+            }
+        }
+        else {
+            if (!(aPoint.iX==0 && aPoint.iY==0)){
+                 rv = true;
+            }
+        }
+    }
+    else {
+        // main frame
+        if (aPoint != m_contentPos) {
+            TPoint p( nearestPointInFrame(aPoint) );
+            TBool copyScroll = m_mayUseCopyScroll;
+
+            if( m_contentPos != p ){
+                rv = true;
+            }
+        }
+    }
+    return rv;
+}
+
+TPoint WebFrameView::nearestPointInFrame(const TPoint &aPoint)
+{
+    if( m_parent && !m_frame->isIframe() ) return aPoint;
+    TSize frameSize( m_frameRect.Size() );
+    TPoint p(aPoint);
+    p.iX = Min(contentSize().iWidth - frameSize.iWidth, p.iX);
+    p.iY = Min(contentSize().iHeight - frameSize.iHeight, p.iY);
+    p.iX = Max(0, p.iX);
+    p.iY = Max(0, p.iY);
+
+    return p;
+}
+
+void WebFrameView::resizeContent(const TSize &size)
+{
+
+    if (!m_parent) {
+        if (m_topView->brCtl()->capabilities()&TBrCtlDefs::ECapabilityFitToScreen) {
+            if( size.iHeight != 0 && size.iWidth != 0 ){
+                m_topView->updateMinZoomLevel(size);
+            }
+        }
+    }
+
+    if (size != m_contentSize) {
+
+        m_resizeByEngine = ETrue;
+        m_contentSize = size;
+        checkScrollbarVisibility();
+        
+        //maybe the content got smaller and we need to scroll back to view?
+        TPoint p( nearestPointInFrame(m_contentPos) );
+        if (p!=m_contentPos)
+            // this will also update scrollbars is necessary
+            scrollTo(p);
+        else if (!m_parent) {
+            // top level
+            m_topView->updateScrollbars(m_contentSize.iHeight, m_contentPos.iY, m_contentSize.iWidth, m_contentPos.iX);
+        }
+    }
+}
+
+void WebFrameView::setMayUseCopyScroll(TBool aCopy)
+{
+    m_mayUseCopyScroll = aCopy;
+}
+
+TPoint WebFrameView::convertContentToView(const TPoint& aConvert)
+{
+    return frameCoordsInViewCoords(aConvert);
+}
+
+TPoint WebFrameView::convertViewToContent(const TPoint& aConvert)
+{
+    return viewCoordsInFrameCoords( aConvert );
+}
+
+TBool WebFrameView::hasHorizontalScrollbar() const 
+{
+    return m_vScrollbar != NULL;
+}
+
+TBool WebFrameView::hasVerticalScrollbar() const
+{
+    return m_hScrollbar != NULL;
+}
+
+void WebFrameView::setHorizontalScrollingMode(ScrollbarMode aMode)
+{
+    m_horizontalScrollBarMode = aMode;
+    checkScrollbarVisibility();
+}
+
+WebCore::ScrollbarMode WebFrameView::verticalScrollingMode() 
+{
+    return m_verticalScrollBarMode;
+}
+
+void WebFrameView::setVerticalScrollingMode(ScrollbarMode aMode)
+{
+    m_verticalScrollBarMode = aMode;
+    checkScrollbarVisibility();
+}
+
+WebCore::ScrollbarMode WebFrameView::horizontalScrollingMode()
+{
+    return m_horizontalScrollBarMode;
+}
+
+void WebFrameView::setScrollingMode(ScrollbarMode aMode)
+{
+    setHorizontalScrollingMode(aMode);
+    setVerticalScrollingMode(aMode);
+}
+
+void WebFrameView::setScrollbarsSuppressed(TBool /*aSuppressed*/,TBool /*aRepaintOnUnsuppress*/ )
+{
+    // ### NOT IMPLEMENTED
+}
+
+void WebFrameView::addChild(MWebCoreWidget* aChild)
+{
+    if(aChild)
+        aChild->setParent(this);
+}
+
+TInt WebFrameView::scalingFactor() const
+{
+    if (m_topView)
+        return m_topView->scalingFactor();
+    return 100;
+}
+
+TPoint WebFrameView::viewCoordsInFrameCoords(const TPoint &aPoint)
+{
+    TPoint pt = aPoint;
+
+    pt += toViewCoords(m_contentPos);
+    WebFrameView* pv = m_parent;
+    while(pv)
+        {
+        pt += pv->toViewCoords(pv->m_contentPos);
+        pv = pv->m_parent;
+        }
+
+    pt -= rectInGlobalCoords().iTl;
+    pt = m_topView->mainFrame()->frameView()->toDocCoords(pt);
+    return pt;
+}
+
+TPoint WebFrameView::frameCoordsInViewCoords(const TPoint &aPoint)
+{
+    TPoint pt(aPoint);
+
+    pt = m_topView->mainFrame()->frameView()->toViewCoords(aPoint);
+    pt += rectInGlobalCoords().iTl;
+    pt -= toViewCoords(m_contentPos);
+    WebFrameView* pv= m_parent;
+    while(pv)
+        {
+        pt -= pv->toViewCoords(pv->m_contentPos);
+        pv = pv->m_parent;
+        }
+    return pt;
+}
+
+TRect WebFrameView::rectInGlobalCoords() const
+{
+    TRect rect(toViewCoords(m_frameRect));
+
+    for (WebFrameView* p = m_parent; p; p=p->m_parent)
+        rect.Move(toViewCoords(p->m_frameRect.iTl));
+
+    return rect;
+}
+
+void WebFrameView::setNeedsDisplay(TBool n) 
+{
+}
+
+void WebFrameView::setFocus(TBool aFocus) 
+{
+}
+
+void WebFrameView::makeVisible(TBool aVisible) 
+{
+}
+
+TBool WebFrameView::isFocused() const
+{
+    return ETrue;
+}
+
+TBool WebFrameView::isVisible() const
+{
+    return ETrue;
+}
+
+TSize WebFrameView::contentSize() const
+{
+    return m_contentSize;
+}
+
+void WebFrameView::setAllowsScrolling(bool allowsScrolling)
+{
+    m_allowsScrolling = allowsScrolling;
+}
+
+void WebFrameView::setMarginWidth(int marginWidth)
+{
+}
+
+void WebFrameView::setMarginHeight(int marginHeight)
+{
+}
+
+int WebFrameView::marginWidth() const
+{
+    return 0;
+}
+
+int WebFrameView::marginHeight() const 
+{
+    return 0;
+}
+
+WebFrameView* WebFrameView::viewClassForMIMEType(const WebCore::String& MIMEType) 
+{
+    return NULL;
+}
+
+void WebFrameView::valueChanged(WebCore::Scrollbar*) 
+{
+}
+
+WebCore::IntRect WebFrameView::windowClipRect() const
+{
+    return WebCore::IntRect();
+}
+
+void WebFrameView::setContentPos(TPoint pt)
+{
+    m_contentPos = pt;
+}
+
+// END OF FILE