/*

* 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:   Implemetation of CWebKiCursor

*

*/

#include "config.h"

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

#include <stdlib.h>

#include "StaticObjectsContainer.h"

#include "WebView.h"

#include "WebFrame.h"

#include "WebFrameView.h"

#include "WebFrameBridge.h"

#include "Frame.h"

#include "Document.h"

#include "Node.h"

#include "Element.h"

#include "HTMLImageElement.h"

#include "RenderImage.h"

#include "BrCtl.h"

#include "HTMLNames.h"

#include "HTMLElement.h"

#include "MouseEvent.h"

#include "EventNames.h"

#include "WebUtil.h"

#include "SettingsContainer.h"

#include "WebCursor.h"

#include "Page.h"

#include "FocusController.h"

#include <AknUtils.h>

#include "PlatformScrollbar.h"

#include "eikon.hrh"

const int KMiddleStep = 8;

const int KFlipAdjust =12;

const int KCursorIncremental = 17;         // 17 pixels

const int KTransparencyTime = 8000*1000; //8s

const int KTransparencyMoveThreshold = 15;

const int KAggressiveSearch = 50;

#define KCursorOffset TPoint(-3,-4)

using namespace WebCore;

using namespace EventNames;

using namespace HTMLNames;

// ============================= LOCAL FUNCTIONS ===============================

inline IntPoint nearestPointInRect(const IntPoint &point, const IntRect &rect)

{

  //Error condition

  if (rect.isEmpty()) return IntPoint(0,0);

  int y = std::max(rect.y(), std::min(rect.bottom(), point.y()));

  int x = std::max(rect.x(), std::min(rect.right(), point.x()));

  return IntPoint(x,y);

}

TInt TransparencyTimerCb(TAny* any)

    {

    WebCursor* c = static_cast<WebCursor*>(any);

    c->setTransparent(true);

    return EFalse;

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// CWebKitCursor::NewL

// Two-phased constructor.

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

WebCursor* WebCursor::NewL()

    {

    WebCursor* self = new (ELeave) WebCursor();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// WebCursor::WebCursor

// Constructor.

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

WebCursor::WebCursor() :

        m_pos(TPoint(KInitialOffset,KInitialOffset))

      , m_previousLr(0)

      , m_previousTb(0)

      , m_view(0)

      , m_visible(true)

      , m_flipcounter(0)

      , m_type(PointerCursor)

      , m_flipCounter(0)

    {

    }

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

// WebCursor::~WebCursor

// Deconstructor.

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

WebCursor::~WebCursor()

    {

    m_sprite.Close();

    delete m_transarrowmask;

    delete m_transtimer;

    }

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

// WebCursor::ConstructL

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

void WebCursor::ConstructL()

    {

    m_transtimer = CPeriodic::NewL(CActive::EPriorityStandard);

    m_visible = !AknLayoutUtils::PenEnabled();

    }

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

// WebCursor::SetCurrentView

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

void WebCursor::setCurrentView(WebView& view)

    {

    if (!m_view)

    {

        m_view = &view;

        constructSprite();

    }

    m_view = &view;

    setOpaqueUntil(KTransparencyTime);

    m_transcount = 0;

    }

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

// WebCursor::ConstructSprite

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

void WebCursor::constructSprite()

    {

    //tot:fixme

    m_arrow = StaticObjectsContainer::instance()->webCannedImages()->getImage(WebCannedImages::EImageArrowBitmap);

    m_hand = StaticObjectsContainer::instance()->webCannedImages()->getImage(WebCannedImages::EImageFingerBitmap);

    m_ibeam = StaticObjectsContainer::instance()->webCannedImages()->getImage(WebCannedImages::EImageIBeam);

    m_selectMulti = StaticObjectsContainer::instance()->webCannedImages()->getImage(WebCannedImages::EImageSelectMulti);

    //iSmartLinkPhoneImage = StaticObjectsContainer::instance()->webCannedImages()->getImage(WebCannedImages::EImageSmartLinkPhone);

    //iSmartLinkEmailImage = StaticObjectsContainer::instance()->webCannedImages()->getImage(WebCannedImages::EImageSmartLinkEmail);

    m_wait = StaticObjectsContainer::instance()->webCannedImages()->getImage(WebCannedImages::EImageWaitArrowBitmap);

    TSize s = m_arrow.m_msk->SizeInPixels();

    m_transarrowmask = new (ELeave) CFbsBitmap();

    m_transarrowmask->Create(s,m_arrow.m_msk->DisplayMode());

    CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(m_transarrowmask);

    CleanupStack::PushL(dev);

    CFbsBitGc* gc;

    User::LeaveIfError(dev->CreateContext(gc));

    gc->BitBlt(TPoint(0,0),m_arrow.m_msk);

    m_transarrowmask->LockHeap();

    TUint8* data = (TUint8*)m_transarrowmask->DataAddress();

    TUint8* end = data + s.iWidth*s.iHeight;

    // divide all pixels by 3

    while ( data<end )

        {

        *(data++) /= 3;

        }

    m_transarrowmask->UnlockHeap();

    delete gc;

    CleanupStack::PopAndDestroy();

    /////////////////////////////////

    m_sprite = RWsSprite(m_view->ControlEnv()->WsSession());

    RWindowTreeNode *window =  (RDrawableWindow* )m_view->brCtl()->CCoeControlParent()->DrawableWindow();

    m_sprite.Construct(*window,TPoint(KInitialOffset,KInitialOffset),ESpriteNoChildClip);

    TSpriteMember spriteMem;

    spriteMem.iBitmap = 0;

    spriteMem.iMaskBitmap = 0;

    spriteMem.iInvertMask = ETrue;

    m_sprite.AppendMember(spriteMem);

    m_sprite.Activate();

    }

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

// WebCursor::CursorUpdate

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

void WebCursor::setCursor(CursorTypes type)

{

    m_sprite.SetPosition( m_pos );

    m_type = type;

    if (m_visible) {

        TSpriteMember spriteMem;

        switch( type )

            {

            case PointerCursor:

            default:

                {

                spriteMem.iBitmap = m_waiton ? m_wait.m_img : m_arrow.m_img;

                spriteMem.iMaskBitmap = m_waiton ? m_wait.m_img :

                    (m_transparent && m_transcount > KTransparencyMoveThreshold ? m_transarrowmask : m_arrow.m_msk);

                break;

                }

           case HandCursor:

                {

                spriteMem.iBitmap = m_hand.m_img;

                spriteMem.iMaskBitmap = m_hand.m_msk;

                break;

                }

           case IBeamCursor:

                {

               /*tot:fixme if ( m_view->FocusedElementType() == TBrCtlDefs::EElementSmartLinkTel )

                    {

                    spriteMem.iBitmap = iSmartLinkPhoneImage.m_img;

                    spriteMem.iMaskBitmap = iSmartLinkPhoneImage.m_msk;

                    }

                else if ( m_view->FocusedElementType() == TBrCtlDefs::EElementSmartLinkEmail )

                    {

                    spriteMem.iBitmap = iSmartLinkEmailImage.m_img;

                    spriteMem.iMaskBitmap = iSmartLinkEmailImage.m_msk;

                    }

                else*/

                    {

                    spriteMem.iBitmap = m_ibeam.m_img;

                    spriteMem.iMaskBitmap = m_ibeam.m_msk;

                    }

                break;

                }

           case SelectMultiCursor:

               {

                    spriteMem.iBitmap = m_selectMulti.m_img;

                    spriteMem.iMaskBitmap = m_selectMulti.m_msk;

                    break;

               }

            }

        spriteMem.iOffset = KCursorOffset;

        spriteMem.iInvertMask = ETrue;

        m_sprite.UpdateMember( 0, spriteMem );

    } else {

        TSpriteMember spriteMem;

        spriteMem.iBitmap = 0;

        spriteMem.iMaskBitmap = 0;

        spriteMem.iInvertMask = ETrue;

        m_sprite.UpdateMember( 0, spriteMem );

    }

}

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

// WebCursor::CursorUpdate

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

void WebCursor::cursorUpdate(bool visible)

{

    if (!m_view || !m_view->brCtl()->settings())

        return;

    if ( m_view->showCursor() ) {

        m_visible = visible && (!m_view->brCtl()->settings()->getTabbedNavigation() || m_view->focusedElementType() == TBrCtlDefs::EElementSelectMultiBox); // check for tabbedNavigation here because it is called from so many places.

    }

    resetTransparency();

    CursorTypes type = PointerCursor;

    TBrCtlDefs::TBrCtlElementType elType = m_view->focusedElementType();

    if (m_visible) {

        if (elType == TBrCtlDefs::EElementNone || elType == TBrCtlDefs::EElementBrokenImage)

            type = PointerCursor;

        else if (elType == TBrCtlDefs::EElementSmartLinkTel || elType == TBrCtlDefs::EElementSmartLinkEmail)

            type = IBeamCursor;

        else if (m_view->brCtl()->settings()->getTabbedNavigation() && elType == TBrCtlDefs::EElementSelectMultiBox)

            type = SelectMultiCursor;

        else

            type = HandCursor;

    }

    setCursor(type);

}

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

// CWebKitCursor::getFrameAtPoint

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

WebFrame* WebCursor::getFrameAtPoint(const TPoint& viewPos_)

    {

    if (!m_view)

        return 0;

    WebFrame* frameAtPoint = m_view->mainFrame()->frameAtPoint(viewPos_);

    if (!frameAtPoint)

        frameAtPoint = m_view->mainFrame();

    return frameAtPoint;

    }

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

// WebCursor::Reset

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

void WebCursor::reset()

    {

    m_view->setFocusedElementType(TBrCtlDefs::EElementNone);

    cursorUpdate(true);

    m_nodeRect = TRect();

    }

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

// WebCursor::SetWaitCursor

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

void WebCursor::setWaitCursor(bool waiton)

    {

    m_waiton = waiton;

    if (m_waiton)

        setCursor(PointerCursor);

    else

        cursorUpdate(m_visible);

    }

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

// WebCursor::OffsetCursor

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

void WebCursor::offsetCursor(const TPoint& offset)

    {

    m_pos -= offset;

    m_nodeRect.Move(-offset.iX,-offset.iY);

    }

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

// WebCursor::SetTransparent

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

void WebCursor::setTransparent(bool transparent)

{

    if (transparent)

        m_transtimer->Cancel();

    if (m_transparent != transparent) {

        m_transparent = transparent;

        // only pointer cursor is transparent

        if (m_transparent && m_view->focusedElementType() == TBrCtlDefs::EElementNone)

            setCursor(PointerCursor);

        else

            cursorUpdate(m_visible);

    }

}

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

// WebCursor::SetOpaqueUntil

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

void WebCursor::setOpaqueUntil(int microsecs)

    {

    setTransparent(false);

    m_transtimer->Cancel();

    m_transtimer->Start(microsecs,0,TCallBack(TransparencyTimerCb,this));

    }

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

// WebCursor::IncreaseTransparencyMoveCount

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

void WebCursor::increaseTransparencyMoveCount()

    {

    ++m_transcount;

    }

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

// WebCursor::ResetTransparency

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

void WebCursor::resetTransparency()

    {

    m_transcount = 0;

    setOpaqueUntil(KTransparencyTime);

    }

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

// WebCursor::innerRect()

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

void WebCursor::innerRect(TRect& rect)

{

  TPoint c = rect.Center();

  int z = m_view->scalingFactor();

  int dx = KCursorIncremental * z / 100;

  int dy = KCursorIncremental * z / 100;

  dx = Max(dx, 2 * rect.Width() / 5);

  dy = Max(dy, 2 * rect.Height() / 5);

  rect.Shrink(dx, dy);

  if (!rect.IsNormalized()) {

    rect.SetRect(c, c);

  }

}

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

// WebCursor::frameHasContentToScroll()

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

bool WebCursor::frameHasContentToScroll(WebFrame* frame, TPoint& delta)

{

    WebFrameView* rfv = frame->frameView();

    TPoint contentpos = rfv->contentPos();

    TSize contentsize = rfv->contentSize();

    bool hasContentToScrollY = false;

    bool hasContentToScrollX = false;

    if (delta.iY > 0)

        {

        hasContentToScrollY = (contentpos.iY < (contentsize.iHeight - rfv->rect().Height()));

        }

    else if (delta.iY < 0)

        {

        hasContentToScrollY = (contentpos.iY > 0);

        }

    if (delta.iX > 0)

        {

        hasContentToScrollX = (contentpos.iX < (contentsize.iWidth - rfv->rect().Width()));

        }

    else if (delta.iX < 0)

        {

        hasContentToScrollX = (contentpos.iX > 0);

        }

    return hasContentToScrollY || hasContentToScrollX;

}

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

// WebCursor::determineScrollingFrame()

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

WebFrame*  WebCursor::determineScrollingFrame(int border1, int border2, int pos,

                                              WebFrame* fr1, WebFrame* fr2, TPoint& delta)

{

  WebFrame* ret = NULL;

  if (pos < border1 && pos < border2) return ret; //"magic" line has not been reached

  if (pos >= border1 && pos >= border2) {

      if (border1 > border2) {

          ret = frameHasContentToScroll(fr2, delta) ? fr2 : fr1;

      }

      else {

          ret = frameHasContentToScroll(fr1, delta) ? fr1 : fr2;

      }

  }

  else if (border1 <= pos && pos <= border2) {//"magic" line of fr1 was hit first

      ret = fr1;

  }

  else if (border2 <= pos && pos <= border1) {//"magic" line of fr2 was hit first

      ret = fr2;

  }

  return ret;

}

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

// WebCursor::calculateScrollableFrameView()

// TODO: Investigate diagonal events, especially in the light of IFrames.

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

WebFrame* WebCursor::calculateScrollableFrameView(TPoint& pos, TPoint& delta, TRect& fRect, bool autoscroll)

{

  WebFrame* frame = getFrameAtPoint(pos);

  WebFrame* ret_frame = NULL;

  WebFrameView* mfView = m_view->mainFrame()->frameView();

  TPoint docContPos = mfView->toViewCoords(mfView->contentPos());

  int z = m_view->scalingFactor();

  m_incrLimit.iX = Abs(delta.iX) * 2 * z / 100;

  m_incrLimit.iY = Abs(delta.iY) * 2 * z / 100;

  for (; frame; frame = frame->parentFrame())  {

    bool hScroll = frame->frameView()->hScrollbar()->isEnabled();

    bool vScroll = frame->frameView()->vScrollbar()->isEnabled();

          // Dont scroll a frameset

    if (frame->parentFrame() && frame->parentFrame()->isFrameSet()) {

      continue;

    }

    else if (frame->parentFrame() && !hScroll && !vScroll) {

      continue;

    }

    else if (!frame->parentFrame()) { //main view

      hScroll = true;

      vScroll = true;

    }

    WebFrame*  pf = frame->parentFrame() ? frame->parentFrame() : m_view->mainFrame();

    WebFrameView* pfv = pf->frameView();

    WebFrameView* ppfv = pf->parentFrame() ? pf->parentFrame()->frameView() : NULL;

    TRect pfRect = pfv->rect();

    if (ppfv) {// parent frame is not a main frame

        pfRect = TRect(ppfv->frameCoordsInViewCoords(pfRect.iTl),

                          ppfv->frameCoordsInViewCoords(pfRect.iBr));

    }

    WebFrameView* fv = frame->frameView();

    TRect framerect = fv ->rect();

    if (frame->parentFrame()) {// frame is not a main frame

       framerect = TRect(pfv->frameCoordsInViewCoords(framerect.iTl),

                         pfv->frameCoordsInViewCoords(framerect.iBr));

    }

    TRect pfInnerRect = pfRect;

    innerRect(pfInnerRect);

    TRect fInnerRect = framerect;

    innerRect(fInnerRect);

    // See which "magic" line we crossed first

    if (delta.iY > 0) {  //scroll down.

        ret_frame = determineScrollingFrame(pfInnerRect.iBr.iY, fInnerRect.iBr.iY, pos.iY, pf, frame, delta);

        m_incrLimit.iY = Min (m_incrLimit.iY, Abs(framerect.iBr.iY - pos.iY));

    }

    else if (delta.iY < 0) { //scroll up.

        ret_frame = determineScrollingFrame(-pfInnerRect.iTl.iY, -fInnerRect.iTl.iY, -pos.iY, pf, frame, delta);

        m_incrLimit.iY = Min (m_incrLimit.iY, Abs(pos.iY - framerect.iTl.iY));

    }

    if (delta.iX > 0) {

        ret_frame = determineScrollingFrame(pfInnerRect.iBr.iX, fInnerRect.iBr.iX, pos.iX, pf, frame, delta);

        m_incrLimit.iX = Min (m_incrLimit.iX, Abs(framerect.iBr.iX - pos.iX));

    }

    else if (delta.iX < 0) {

        ret_frame = determineScrollingFrame(-pfInnerRect.iTl.iX, -fInnerRect.iTl.iX, -pos.iX, pf, frame, delta);

        m_incrLimit.iX = Min (m_incrLimit.iX, Abs(pos.iX - framerect.iTl.iX));

    }

    fRect = (ret_frame == frame) ? framerect : pfRect;