1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Frame in webkit side

    15 *

    16 */

    17 

    18 

    19 #include "config.h"

    20 #include "../../bidi.h"

    21 #include "WebFrame.h"

    22 #include "WebCoreWidget.h"

    23 #include "WebCoreFrameBridge.h"

    24 #include "WebFrameBridge.h"

    25 #include "WebFrameView.h"

    26 #include "WebView.h"

    27 #include "WebChromeClient.h"

    28 #include "WebFrameLoaderClient.h"

    29 

    30 #include "Page.h"

    31 #include "Frame.h"

    32 #include "FrameView.h"

    33 #include "FrameTree.h"

    34 #include "FrameLoader.h"

    35 #include "DocumentLoader.h"

    36 #include "SelectionController.h"

    37 #include "SubstituteData.h"

    38 #include "RenderWidget.h"

    39 

    40 #include "HTMLNames.h"

    41 #include "GraphicsContext.h"

    42 #include "HTMLFormElement.h"

    43 #include "ResourceRequest.h"

    44 #include "webkitlogger.h"

    45 #include "webutil.h"

    46 #include "PluginSkin.h"

    47 #include "kjs_proxy.h"

    48 #if PLATFORM(SYMBIAN)

    49 #include "oom.h"

    50 #endif

    51 

    52 using namespace WebCore;

    53 using namespace HTMLNames;

    54 

    55 WebFrame::WebFrame() :

    56     m_view(0)

    57    ,m_bridge(0)

    58 {

    59 }

    60 

    61 WebFrame::~WebFrame() 

    62 {

    63     if (m_view)

    64         m_view->deref();

    65 }

    66 

    67 void WebFrame::initWithWebFrameView(WebFrameView* view, WebView* topView, WebFrameBridge* bridge)

    68 {

    69     if (m_view)

    70         m_view->deref();

    71     m_view = view;

    72     if (m_view) {

    73         m_view->ref();

    74         m_view->setWebFrame(this);

    75         m_view->setTopView(topView);

    76     }

    77     setBridge(bridge);

    78 }

    79 

    80 void WebFrame::loadRequest(const WebCore::ResourceRequest& request,const WebCore::String* windowType)

    81 {

    82     FrameLoader* fl = frameLoader();

    83     if (fl) {

    84         if(windowType)

    85             fl->load(request,*windowType);

    86         else

    87             fl->load(request);

    88     }

    89         

    90  }

    91 

    92 void WebFrame::loadData(const WebCore::ResourceRequest& request, WebCore::SubstituteData& substituteData)

    93 {

    94     if (FrameLoader* fl = frameLoader())

    95         fl->load(request, substituteData);

    96 }

    97 

    98 void WebFrame::loadURL(const TDesC8& url, TInt cachemode, const String& referrer,const WebCore::String* windowType) 

    99 {

   100 #if PLATFORM(SYMBIAN)

   101     OOM_PRE_CHECK(1024*1024, 0, "WebFrame::loadURL")

   102 #endif

   103     ResourceRequestCachePolicy cachePolicy;

   104     switch (cachemode) 

   105     {

   106     default:

   107     case TBrCtlDefs::ECacheModeNormal: 

   108         cachePolicy = UseProtocolCachePolicy;

   109         break;

   110     case TBrCtlDefs::ECacheModeNoCache:

   111         cachePolicy = ReloadIgnoringCacheData;

   112         break;

   113     case TBrCtlDefs::ECacheModeHistory:

   114         cachePolicy = ReturnCacheDataElseLoad;

   115         break;

   116     case TBrCtlDefs::ECacheModeOnlyCache:

   117         cachePolicy = ReturnCacheDataDontLoad;

   118         break;

   119     }

   120     ResourceRequest request = (KURL(url));

   121     request.setMainLoad(true);

   122     request.setCachePolicy(cachePolicy);

   123     if(!referrer.isNull())

   124         request.setHTTPReferrer(referrer);

   125     request.setHTTPMethod("GET");

   126     loadRequest(request,windowType);

   127 #if PLATFORM(SYMBIAN)

   128     OOM_POST_CHECK_FAILED(return;)

   129 #endif    

   130 }

   131 

   132 // Called by the bridge to load into a sub-frmae

   133 void WebFrame::loadURL(const TPtrC8 url, const TPtrC referrer, WebFrame* childFrame)

   134 {

   135     /* fixme tot: do we need to hook up with bf list?

   136     HistoryItem* parentItem = core(this)->loader()->currentHistoryItem();

   137     FrameLoadType loadType = _frameLoader()->loadType();

   138     FrameLoadType childLoadType = FrameLoadTypeRedirectWithLockedHistory;

   139 

   140     if (parentItem && parentItem->children().size() && 

   141         (isBackForwardLoadType(loadType) 

   142         || loadType == FrameLoadTypeReload 

   143         || loadType == FrameLoadTypeReloadAllowingStaleData)) 

   144     {

   145         HistoryItem* childItem = parentItem->childItemWithName(childFrame->name());

   146         if (childItem) {

   147             childLoadType = loadType;

   148 

   149             if (isBackForwardLoadType(loadType))

   150                 core(childFrame)->loader()->setProvisionalHistoryItem(childItem);

   151             else

   152                 core(childFrame)->loader()->setCurrentHistoryItem(childItem);

   153         }

   154     }*/

   155 

   156     // tot fixme: saved pages not implemented.

   157     FrameLoadType childLoadType = frameLoader()->loadType();

   158     childFrame->frameLoader()->load(url, referrer, childLoadType, String(), 0, 0);

   159 }

   160 

   161 void WebFrame::paintRect(WebCoreGraphicsContext& gc, const TRect& rect)

   162 {

   163     WebCore::GraphicsContext ctx(&gc);

   164     core(this)->paint(&ctx, enclosingIntRect(rect));

   165 }

   166 

   167 FrameLoader* WebFrame::frameLoader()

   168 {

   169     Frame* frame = core(this);

   170     return frame ? frame->loader() : 0;

   171 }

   172 

   173 bool WebFrame::isMainFrame() const

   174 {

   175     Frame* coreFrame = core(this);

   176     if (!coreFrame)

   177         return false;

   178     return coreFrame == coreFrame->page()->mainFrame();

   179 }

   180 

   181 // selection

   182 bool WebFrame::hasSelection()

   183 {

   184     if (Frame* coreFrame = core(this)) {

   185         return !coreFrame->selectionController()->isNone();

   186     }

   187     return false;

   188 }

   189 

   190 void WebFrame::clearSelection()

   191 {

   192     Frame* coreFrame = core(this);

   193     if (!coreFrame)

   194         return;

   195     coreFrame->selectionController()->clear();

   196 }

   197 

   198 WebFrame* WebFrame::findFrameWithSelection()

   199 {

   200     Frame* coreFrame = core(this);

   201     for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame))

   202         if (kit(frame)->hasSelection())

   203             return kit(frame);

   204     

   205     return 0;

   206 }

   207 

   208 void WebFrame::stopLoading()

   209 {

   210     if (FrameLoader* fl = frameLoader())

   211         fl->stopForUserCancel();

   212 }

   213 

   214 void WebFrame::reload()

   215 {

   216     frameLoader()->reload();

   217 }

   218 

   219 WebFrame* WebFrame::findFrameNamed(const TPtr& name)

   220 {

   221     Frame* coreFrame = core(this);

   222     if (!coreFrame)

   223         return 0;

   224     return kit(coreFrame->tree()->find(name));

   225 }

   226 

   227 WebFrame* WebFrame::parentFrame()

   228 {

   229     Frame* coreFrame = core(this);

   230     if (!coreFrame) 

   231         return 0;

   232     return kit(coreFrame->tree()->parent());

   233 }

   234 

   235 bool WebFrame::isIframe() const

   236 {

   237     Frame* coreFrame = core(this);

   238     if (!coreFrame)

   239         return false;

   240     Frame* pf = coreFrame->tree()->parent();

   241     if (pf)

   242         return !pf->isFrameSet();

   243     return false;

   244 }

   245 

   246 bool WebFrame::isFrameSet() const

   247 {

   248     Frame* coreFrame = core(this);

   249     if (!coreFrame)

   250         return false;

   251     return coreFrame->isFrameSet();

   252 }

   253 

   254 WTF::Vector<WebFrame*> WebFrame::childFrames()

   255 {

   256     Frame* coreFrame = core(this);

   257     if (!coreFrame)

   258         return WTF::Vector<WebFrame*>();

   259 

   260     WTF::Vector<WebFrame*> children;

   261     children.reserveCapacity(coreFrame->tree()->childCount());

   262     for (Frame* child = coreFrame->tree()->firstChild(); child; child = child->tree()->nextSibling())

   263         children.append(kit(child));

   264     return children;

   265 }

   266 

   267 void WebFrame::addChild(WebFrame* child)

   268 {

   269     core(this)->tree()->appendChild(adoptRef(core(child)));

   270     if (child->documentLoader())

   271         child->documentLoader()->setOverrideEncoding(documentLoader()->overrideEncoding());

   272 

   273     // update the view heirachy

   274     m_view->addChild(child->frameView());

   275 }

   276 

   277 DocumentLoader* WebFrame::documentLoader()

   278 {

   279     return frameLoader()->documentLoader();

   280 }

   281 

   282 void WebFrame::notifyPluginsOfScrolling()

   283 {

   284     Frame* coreFrame = core(this);

   285     for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame)) {

   286         PassRefPtr<HTMLCollection> objects = frame->document()->objects();       

   287         for (Node* n = objects->firstItem(); n; n = objects->nextItem()) 

   288             notifyPluginOfScrolling(n->renderer());             

   289 

   290         PassRefPtr<HTMLCollection> embeds = frame->document()->embeds();       

   291         for (Node* n = embeds->firstItem(); n; n = embeds->nextItem()) 

   292             notifyPluginOfScrolling(n->renderer()); 

   293 

   294         }

   295 }

   296 

   297 void WebFrame::notifyPluginOfScrolling(RenderObject* renderer)

   298 {        

   299     MWebCoreObjectWidget* view = widget(renderer);

   300     //Don't repaint the plugin objects if Browser is in PageView mode

   301     if (view) {

   302         view->positionChanged();

   303         TRect r = m_view->toDocCoords(static_cast<PluginSkin*>(view)->getPluginWinRect());

   304         m_view->topView()->scheduleRepaint(r);

   305     }

   306 }

   307 

   308 PluginSkin* WebFrame::focusedPlugin()

   309 {

   310     int pluginCount = 0;

   311     Frame* coreFrame = core(this);

   312     MWebCoreObjectWidget* view = NULL;

   313     MWebCoreObjectWidget* tmpView = NULL;

   314 

   315     for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame)) {

   316         PassRefPtr<HTMLCollection> objects = frame->document()->objects();     

   317         for (Node* n = objects->firstItem(); n; n = objects->nextItem()) {

   318             tmpView = widget(n); 

   319             if (tmpView) {

   320                 pluginCount++;

   321                 view = tmpView;

   322                 if (view->isActive()) {

   323                     return static_cast<PluginSkin*>(view);

   324                 }

   325             }

   326         }

   327 

   328         PassRefPtr<HTMLCollection> embeds = frame->document()->embeds();       

   329         for (Node* n = embeds->firstItem(); n; n = embeds->nextItem()) {

   330             tmpView = widget(n);

   331             if (tmpView) { 

   332                 pluginCount++;

   333                 view = tmpView;

   334                 if (view->isActive()) {

   335                     return static_cast<PluginSkin*>(view);

   336                 }

   337             }

   338         }

   339     }

   340     //no focused plugin. If only one plugin is present return that plugin

   341     if(pluginCount == 1 && view) {

   342         return static_cast<PluginSkin*>(view);           

   343     } //endof pluginCount = 1

   344 

   345     return NULL;    

   346 }

   347 

   348 void WebFrame::setFrameView(WebFrameView* v) 

   349 {

   350     if (m_view)

   351         m_view->deref();

   352     m_view = v;

   353     if (m_view)

   354         m_view->ref();

   355 }

   356 

   357 void WebFrame::setBridge(WebFrameBridge* b)

   358 {

   359     if (m_bridge) 

   360         m_bridge->deref();

   361     m_bridge = b;

   362     if (m_bridge) 

   363         m_bridge->ref();

   364 }

   365 

   366 WebFrame* WebFrame::frameAtPoint(const TPoint& pt_)

   367 {

   368     WTF::Vector<WebFrame*> ch = childFrames();

   369     WebFrame* frm = 0;

   370     // Check the children of the frame only if this frame also contains pt_

   371     // If a child iframe is bigger than the parent, it should not be picked.

   372     if (m_view->rectInGlobalCoords().Contains(pt_)) {

   373         Vector<WebFrame*>::iterator end = ch.end();

   374         for (Vector<WebFrame*>::iterator itr = ch.begin(); itr != end; itr++) {

   375             WebFrame* f = (*itr);

   376             if( (f = f->frameAtPoint(pt_ + m_view->toViewCoords(m_view->contentPos()))) != 0 )

   377                 {

   378                 // TODO: this only fixes www.aol.com login iframe issue,

   379                 // a better solution is to check the z-index for each frame.

   380                 // Anyway, overlapping iframes are not common.

   381                 frm = f;

   382                 }

   383         }

   384 

   385         if (frm)

   386             return frm;

   387 

   388 

   389         return this;

   390     }

   391     return 0;

   392 }

   393 

   394 int WebFrame::imageCount(bool visibleOnly_) 

   395 {   

   396     int imageCount = imageCountInFrame(*this, visibleOnly_);

   397     //

   398     WTF::Vector<WebFrame*> ch = childFrames();

   399     WebFrame* frm = 0;

   400     

   401     Vector<WebFrame*>::iterator end = ch.end();

   402     for (Vector<WebFrame*>::iterator itr = ch.begin(); itr != end; itr++)

   403         imageCount+=(*itr)->imageCount(visibleOnly_);

   404         

   405     return imageCount;

   406 }

   407 

   408 CArrayFixFlat<TBrCtlImageCarrier>* WebFrame::imageData(bool visibleOnly_) 

   409 {   

   410     CArrayFixFlat<TBrCtlImageCarrier>* imageList = imagesInFrame(*this, visibleOnly_);

   411     //

   412     WTF::Vector<WebFrame*> ch = childFrames();

   413     WebFrame* frm = 0;

   414     

   415     Vector<WebFrame*>::iterator end = ch.end();

   416     for (Vector<WebFrame*>::iterator itr = ch.begin(); itr != end; itr++) {

   417         CArrayFixFlat<TBrCtlImageCarrier>* childImageList = (*itr)->imageData(visibleOnly_);

   418         for (int i = 0; i < childImageList->Count(); i++)

   419             imageList->AppendL(childImageList->At(i));

   420         childImageList->Reset();

   421         delete childImageList;

   422     }

   423        

   424     return imageList;

   425 }

   426 

   427 CArrayFixFlat<TBrCtlSubscribeTo>* WebFrame::findSubscribeTo() 

   428 {   

   429     CArrayFixFlat<TBrCtlSubscribeTo>* linkList = findSubscribeToInFrame(*this);

   430     //

   431     WTF::Vector<WebFrame*> ch = childFrames();

   432     WebFrame* frm = 0;

   433     

   434     Vector<WebFrame*>::iterator end = ch.end();

   435     for (Vector<WebFrame*>::iterator itr = ch.begin(); itr != end; itr++) {

   436         CArrayFixFlat<TBrCtlSubscribeTo>* childLinkList = (*itr)->findSubscribeTo();

   437         for (int i = 0; i < childLinkList->Count(); i++)

   438             linkList->AppendL(childLinkList->At(i));

   439         childLinkList->Reset();

   440         delete childLinkList;

   441     }

   442     return linkList;

   443 }

   444 

   445 DOMDocument* WebFrame::DOMDocument()

   446 {

   447     return 0;

   448 }

   449 

   450 void WebFrame::scalingFactorChanged(int factor)

   451 {

   452     bridge()->scalingFactorChanged(factor);

   453 }

   454 

   455 // helpers

   456 Frame* core(const WebFrame* frame)

   457 {

   458     if (!frame)

   459         return NULL;

   460     

   461     if (!frame->bridge())

   462         return NULL;

   463 

   464     return frame->bridge()->frame();

   465 }

   466 

   467 WebFrame* kit(Frame* frame)

   468 {

   469     return frame ? ((WebFrameBridge *)frame->bridge())->webFrame(): NULL;

   470 }

   471 

   472 WebView *kit(Page* page)

   473 {

   474     return page ? static_cast<WebChromeClient*>(page->chrome()->client())->webView() : 0;

   475 }

   476 

   477 WebFrame* mainFrame(WebFrame* frame) 

   478 {

   479     if (!frame)

   480         return 0;

   481     if (frame->isMainFrame())

   482         return frame;

   483     

   484     Frame* coreFrame = core(frame);

   485     if (!coreFrame)

   486         return 0;

   487     return kit(coreFrame->page()->mainFrame());

   488 }

   489 

   490 CBrCtl* control(WebCore::Frame* frame) 

   491 {

   492     return control(kit(frame));

   493 }

   494 

   495 CBrCtl* control(const WebFrame* webFrame)

   496 {

   497     if (webFrame && webFrame->frameView())

   498         return webFrame->frameView()->topView()->brCtl();

   499     return NULL;

   500 }

   501 

   502 MWebCoreObjectWidget* widget(RenderObject* render_) 

   503 {   

   504     if (!render_)

   505         return NULL;

   506         

   507     if (render_->isWidget()) {

   508         Widget* widget = static_cast<RenderWidget*>(render_)->widget();

   509         if (widget) {

   510             MWebCoreWidget* view = widget->getView();    

   511             if(view && view->isObjectView())

   512                 return static_cast<MWebCoreObjectWidget*>(view);

   513         }

   514     }

   515     return NULL;    

   516 }

   517 

   518 

   519 MWebCoreObjectWidget* widget(Node* node_) 

   520 {   

   521     if (!node_)

   522         return NULL;

   523         

   524     return widget(node_->renderer());

   525 }

   526 

   527 bool WebFrame::executeScript(const WebCore::String& script)

   528 {

   529     bool result = false;

   530     KJSProxy *proxy = core(this)->scriptProxy();

   531     if (proxy) {

   532         KJS::JSValue *v = proxy->evaluate(String(), 0, script);

   533         if (v)

   534             result = true;

   535     }

   536     return result;

   537 }

   538 

   539 void WebFrame::makeVisiblePlugins(TBool visible)

   540 {

   541     MWebCoreObjectWidget* view = NULL;

   542     int pluginCount = 0;

   543     Frame* coreFrame = core(this);

   544     PluginSkin* ptr = 0;

   545     for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame)) {

   546 

   547         PassRefPtr<HTMLCollection> objects = frame->document()->objects();     

   548         for (Node* n = objects->firstItem(); n; n = objects->nextItem()) {

   549             view = widget(n); 

   550             if (view) {

   551                 ptr = static_cast<PluginSkin*>(view);

   552                 ptr->makeVisible(visible);

   553             }

   554         }

   555         PassRefPtr<HTMLCollection> embeds = frame->document()->embeds();       

   556         for (Node* n = embeds->firstItem(); n; n = embeds->nextItem()) {

   557             view = widget(n);

   558             if (view) {

   559                 ptr = static_cast<PluginSkin*>(view);

   560                 ptr->makeVisible(visible);

   561             }

   562         }

   563     }

   564 }

   565 

   566 

   567 inline int xInRect(const IntRect& r, int x)

   568 {

   569 	return std::min(std::max(x, r.location().x()), r.location().x() + r.width());

   570 }

   571 

   572 inline int yInRect(const IntRect& r, int y)

   573 {

   574 	return std::min(std::max(y, r.location().y()), r.location().y() + r.height());

   575 }

   576 

   577 Node* WebFrame::getClosestAnchorElement(const TPoint& viewPt, TPoint& newPos)

   578 {

   579     IntPoint pt = m_view->viewCoordsInFrameCoords(viewPt);

   580     

   581     Frame* coreFrame = core(this);

   582 

   583 	int dist = 99999999;

   584 	Node* result = 0;

   585 	//for (Node* n=links->firstItem(); n; n=links->nextItem()) {

   586 	for(Node* n = coreFrame->document(); n != 0; n = n->traverseNextNode()) {

   587         if(n->isFocusable() || n->hasTagName(areaTag)) {

   588 			IntRect r = n->getRect();

   589 			if (r.contains(pt)) {

   590 				dist = 0;

   591 				result = n;

   592 				break;

   593 			}

   594 			

   595 			int x = xInRect(r, pt.x());

   596 			int y = yInRect(r, pt.y());

   597 			int d = (pt.x() - x) * (pt.x() - x) + (pt.y() - y) * (pt.y() - y);

   598 			if (dist > d) {

   599 				dist = d;

   600 				result = n;

   601 			}

   602         }

   603 	}

   604 	

   605     // check if we are close enough and calcualte with zoom factor. 

   606     if (dist< (400/m_view->topView()->scalingFactor() * 100)) {

   607         IntRect r = result->getRect();

   608         r.inflate(-2);

   609         TPoint docPos(xInRect(r, pt.x()), yInRect(r, pt.y()));

   610         newPos = m_view->frameCoordsInViewCoords(docPos);

   611         return result;        

   612     }

   613     

   614     return 0;

   615 }

   616 

   617 // END OF FILE