/*

* 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:  Acts as an adapter between plugin and browser.

*

*/

// INCLUDE FILES

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

#include <e32std.h>

#include <e32def.h>

#include <eikdef.h>

#include <eikenv.h>

#include <eikappui.h>

#include <SysUtil.h>

#include <AknUtils.h>

#include "WebFrame.h"

#include "HttpDefs.h"

#include <brctldefs.h>

#include "StaticObjectsContainer.h"

#include <pluginadapterinterface.h>

#include "PluginWin.h"

#include "PluginSkin.h"

#include "PluginHandler.h"

#include "PluginStream.h"

#include "WebView.h"

#include "WebFrameView.h"

#include "WebSurface.h"

#include "BrCtl.h"

#include "Frame.h"

#include "WebCursor.h"

#include "WebPointerEventHandler.h"

#include "WebPageScrollHandler.h"

#include "WebKitLogger.h"

#include "WebCoreGraphicsContext.h"

#include <rt_gestureif.h>

using namespace WebCore;

using namespace RT_GestureHelper;

using namespace stmGesture; 

// CONSTANTS

const TInt KPluginGranularity = 3;

_LIT(KPath,"c:\\system\\temp\\");

void panicPlugin(TInt error = KErrNone)

{

    User::Panic(_L("Plugin Handling Panic"), error);

}

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

// PluginWin::PluginWin

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

PluginWin::PluginWin(PluginSkin* pluginskin)

    : m_pluginskin(pluginskin)

    , m_windowedPlugin(true), m_fullscreen(false), m_windowCreated(false), m_visibilty(false)

{

}

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

// PluginWin::ConstructL

// Symbian 2nd phase constructor can leave.

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

void PluginWin::ConstructL( const WebView& view )

{

    if (m_windowedPlugin) {

        CreateWindowL((CCoeControl*)&view);

        ActivateL();

		m_windowCreated = true;

    } else {

        SetContainerWindowL(*view.brCtl()->CCoeControlParent());

        m_bitmap = new (ELeave) CFbsBitmap();

        TDisplayMode mode = m_transparentPlugin ? EColor16MA : WebCore::StaticObjectsContainer::instance()->webSurface()->displayMode();

        m_bitmap->Create(TSize(0,0), mode);

    }

    // Add the focus/foreground observer

    ControlEnv()->AddForegroundObserverL( *this ) ;

    m_pluginHasBitmap = false;

    m_pausedBitmap = NULL;

    m_BitmapSupported = false;

}

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

// PluginWin::~PluginWin

// Deconstructor.

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

//

PluginWin::~PluginWin()

{

    PluginHandler* pluginHandler = WebCore::StaticObjectsContainer::instance()->pluginHandler();

    int index = pluginHandler->getVisiblePlugins().Find(m_pluginskin);

    if (index != KErrNotFound)

        pluginHandler->getVisiblePlugins().Remove(index);

    TRAP_IGNORE( setPluginFocusL( EFalse ) );

    // Remove the foreground observer

    ControlEnv()->RemoveForegroundObserver( *this );

    delete m_bitmap;

   if (m_pausedBitmap)

        {

        delete m_pausedBitmap;

        }

}

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

// PluginWin::NewL

// Two-phased constructor.

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

//

PluginWin* PluginWin::NewL( PluginSkin* pluginskin,

                            const WebView& view  )

{

    PluginWin* self = new( ELeave ) PluginWin(pluginskin);

    return self;

}

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

// PluginWin::PositionChanged

// Update the size of the control.

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

//

void PluginWin::PositionChanged()

{

    windowChanged();

}

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

// PluginWin::SizeChanged

// Update the size of the control.

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

//

void PluginWin::SizeChanged()

{

    windowChanged();

}

void PluginWin::windowChanged()

{

    TRAPD(ret, windowChangedL());

    if (ret != KErrNone) {

        delete m_bitmap;

        m_bitmap = NULL;

    }

    if (m_forceScroll)

    	m_forceScroll = EFalse;

}

void PluginWin::windowChangedL()

{

    if (m_fullscreen) return;

    PlayPausePluginL();

    if (m_pluginskin->getNPPluginFucs() && m_pluginskin->getNPPluginFucs()->setwindow ){

        NPWindow  window;

    TRect rect( m_pluginskin->getPluginWinRect() );

    TRect clipRect = m_pluginskin->getClipRect();

    TRect myRect = Rect();

        if (!m_windowedPlugin) {

            myRect.Move(-myRect.iTl.iX, -myRect.iTl.iY); // windowed CCoeControl uses its own coordinates

        }

    TRect passedRect = clipRect;

    passedRect.Intersection(rect);

    TPoint tl = myRect.iTl - passedRect.iTl;

        // Coordinates for the plugin always start from (0,0) and are relative

        // to the parent CCoeControl

        rect.Move(tl);

        clipRect.Move(tl);

        clipRect.Intersection(myRect);

        window.x = rect.iTl.iX;

        window.y = rect.iTl.iY;

        window.width = rect.Width();

        window.height = rect.Height();

        window.type = m_windowedPlugin ? NPWindowTypeWindow : NPWindowTypeDrawable ;

        clipRect.iTl.iX = Max(clipRect.iTl.iX, 0);

        clipRect.iTl.iY = Max(clipRect.iTl.iY, 0);

        clipRect.iBr.iX = Max(clipRect.iBr.iX, 0);

        clipRect.iBr.iY = Max(clipRect.iBr.iY, 0);

        window.clipRect.top = clipRect.iTl.iY;

        window.clipRect.left = clipRect.iTl.iX;

        window.clipRect.bottom =clipRect.iBr.iY;

        window.clipRect.right = clipRect.iBr.iX;

        if (m_windowedPlugin) {

             window.window =  (MPluginAdapter*)this;

        } else {

             m_bitmap->Resize(rect.Size());

             window.window = (CFbsBitmap*)m_bitmap;

        }

		if (!m_windowedPlugin || m_windowCreated)

			m_pluginskin->getNPPluginFucs()->setwindow(m_pluginskin->getNPP(), &window );

    }

}

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

// PluginWin::ProcessEventL

// Procces a user interface event.

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

//

void PluginWin::processEventL( TPluginEventType eventType,

                                TBool& consumed )

{

    consumed = EFalse;

    switch ( eventType ) {

        case EEventActivate:

        {

            WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();

            CBrCtl*   brCtl = control(m_pluginskin->frame());    

            WebView*  view = brCtl->webView();

            if ( m_notifier )

            {

            TPoint pt = TPoint(0,0); 

            if (cursor) {

                pt = cursor->position() + view->PositionRelativeToScreen() - 

                        m_control->PositionRelativeToScreen();

                }

            m_notifier->NotifyL( MPluginNotifier::EPluginActivated, (void*) &pt );

            cursor->cursorUpdate(EFalse);

            consumed = ETrue;

            setPluginFocusL( ETrue );

            m_pluginskin->pluginFocusChanged(ETrue);

            }

            else

            {

            m_pluginskin->frame()->frameView()->topView()->setFocusedElementType(TBrCtlDefs::EElementBrokenImage);

            cursor->cursorUpdate(ETrue);

            consumed = EFalse;     

            setPluginFocusL( EFalse );

            }

            break;

        }

        case EEventDeactivate:

                if( m_notifier )

                {

                    m_notifier->NotifyL( MPluginNotifier::EPluginDeactivated, (void*) 0 );

                }

            consumed = ETrue;

            setPluginFocusL( EFalse );

        break;

        case EEventLoseFocus:

        if ( m_notifier ) {

            HandleLosingForeground();

            consumed = ETrue;

        }

        break;

        case EEventGainFocus:

            HandleGainingForeground();

            consumed = ETrue;

        break;

        default:

        break;

    }

}

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

// PluginWin::OfferKeyEventL

// Hands a key event to the control.

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

//

TKeyResponse PluginWin::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                         TEventCode aType )

{

    TKeyResponse ret = EKeyWasNotConsumed;

    if ( m_control ) {

        ret = m_control->OfferKeyEventL( aKeyEvent, aType );

    }

    else if (!m_windowedPlugin && m_pluginskin->getNPPluginFucs() && m_pluginskin->getNPPluginFucs()->event) {

        WebCursor* c = StaticObjectsContainer::instance()->webCursor();

        TPoint pt = (c->position());

        pt = m_pluginskin->frame()->frameView()->viewCoordsInFrameCoords(pt);

        pt -= m_pluginskin->rect().iTl;

        NPEvent event;

        NPEventKey eventKey;

        event.event = ENppEventKey;

        eventKey.keyEvent = &aKeyEvent;

        eventKey.type = aType;

        eventKey.reserved = static_cast<void*>(&pt);

        event.param = &eventKey;

        ret = (TKeyResponse)m_pluginskin->getNPPluginFucs()->event(m_pluginskin->getNPP(), static_cast<void*>(&event));

    }

    return ret;

}

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

// PluginWin::ComponentControl

// Return the child control by index.

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

//

CCoeControl* PluginWin::ComponentControl( TInt /*aIndex*/ ) const

{

    return 0;

}

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

// PluginWin::CountComponentControls

// Return the number of child controls.

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

//

TInt PluginWin::CountComponentControls() const

{

    return 0;

}

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

// HandlePointerEventL

// Handles Pointer Events

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

void PluginWin::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

    if (!m_windowedPlugin && m_pluginskin->getNPPluginFucs() && m_pluginskin->getNPPluginFucs()->event) {

        NPEvent event;

        NPEventPointer ep;

        event.event = ENppEventPointer;

        TPoint pt;

        if (m_pluginskin->pluginPlayer()) {

            pt = aPointerEvent.iPosition;

            pt -= Rect().iTl;

            pt = m_pluginskin->frame()->frameView()->toDocCoords(pt);

        }

        else {

            pt = m_pluginskin->frame()->frameView()->viewCoordsInFrameCoords(aPointerEvent.iPosition);

            pt -= m_pluginskin->rect().iTl;

        }

        TPointerEvent pe(aPointerEvent);

        pe.iPosition = pt;

        ep.pointerEvent = &pe;

        ep.reserved = NULL;

        event.param = &ep;

        m_pluginskin->getNPPluginFucs()->event(m_pluginskin->getNPP(), static_cast<void*>(&event));

    }

}

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

// PluginWin::RefreshPlugin

//

// Refresh the plugin. - Called by PluginSkin

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

//

TInt PluginWin::refreshPlugin(CFbsBitGc& bitmapContext,TRect aRect)

{

    if (m_control && IsVisible() && m_control->DrawableWindow())

        m_control->DrawNow();

    if (!m_windowedPlugin && m_bitmap) {

        NPEvent event;

        event.event = ENppEventDraw;

        event.param = 0;

        if (m_pluginskin->getNPPluginFucs() && m_pluginskin->getNPPluginFucs()->event) {

            m_pluginskin->getNPPluginFucs()->event(m_pluginskin->getNPP(), static_cast<void*>(&event));

        }

        bitmapContext.DrawBitmap(aRect, m_bitmap);

    }

    return KErrNone;

}

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

// PluginWin::MakeVisible

//

// Hides or shows the PluginInst.

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

//

void PluginWin::makeVisible( TBool visible )

    {

    WebView* view = control(m_pluginskin->frame())->webView();

    if(!view)

        return;

    if((!m_pluginHasBitmap) && (IsVisible() != visible) && (!view->isPinchZoom()))

    {

        CCoeControl::MakeVisible(visible);

    }

    PluginHandler* pluginHandler = WebCore::StaticObjectsContainer::instance()->pluginHandler();

    int index = pluginHandler->getVisiblePlugins().Find(m_pluginskin);

    if (visible && (m_visibilty != visible) && (index == KErrNotFound)) {

        pluginHandler->getVisiblePlugins().AppendL(m_pluginskin);

        m_visibilty = visible;

    }

    else if (!visible && (index != KErrNotFound)) {

        pluginHandler->getVisiblePlugins().Remove(index);

        m_visibilty = visible;

    }

    NotifyPluginVisible(visible);

    if (!m_windowedPlugin && m_pluginskin->getNPPluginFucs() && m_pluginskin->getNPPluginFucs()->event) {

        NPEvent event;

        NpEventVisibility ev;

        event.event = ENppEventVisibility;

        ev.visible = visible;

        ev.reserved = 0;

        event.param = &ev;

        m_pluginskin->getNPPluginFucs()->event(m_pluginskin->getNPP(), static_cast<void*>(&event));

    }

}

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

// PluginWin::HandleControlEventL

//

// Handles an event from an observed control.

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

//

void PluginWin::HandleControlEventL( CCoeControl* /*aControl*/,

                                      TCoeEvent /*aEventType*/ )

{

}

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

// PluginWin::SetPluginFocusL

// Give or take focus from the plugin. The calls AddToStackL or RemoveFromStackL

// will cause the CCoeControl architecture to call SetFocus, which will end up

// calling ViewFocusChanged().

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

//

void PluginWin::setPluginFocusL(TBool focus)

{

    if (focus) {

        if (!m_pluginfocus) {

            m_pluginfocus = ETrue;

            iEikonEnv->EikAppUi()->AddToStackL(this);

            SetFocus(ETrue);

        }

    }

    else {

        if (m_pluginfocus) {

            m_pluginfocus = EFalse;

            iEikonEnv->EikAppUi()->RemoveFromStack( this );

            SetFocus(EFalse);

        }

    }

}

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

// PluginWin::ResizePluginRect

//

// Resize the plugin rect. This requires that we set the iRect and re-layout

// the render object.

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

//

void PluginWin::resizePluginRect(TRect& rect)

{

    // Get our current rect

    TRect skinRect( m_pluginskin->rect() );

    // If the rect sizes are the same, we don't need to save and relayout

    if (skinRect.Size() == rect.Size()) {

        return;

    }

    // Set the PluginSkin rect, used by WebCore and PluginWin for layout.

    // The adjusted rect has the new size, but same starting point

    TRect adjustedRect (skinRect.iTl, rect.Size() );

    m_pluginskin->setRect(adjustedRect);

    m_pluginskin->resized();

}

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

// PluginWin::HandleGainingForeground

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

//

void PluginWin::HandleGainingForeground()

{

    if (m_notifier) {

        if(m_pluginHasBitmap)

            { 

            ClearPluginBitmap(); 

            m_pluginskin->activateVisiblePlugins(); 

            }

        TRAP_IGNORE(m_notifier->NotifyL(MPluginNotifier::EApplicationFocusChanged, (void*)1));

    }

}

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

// PluginWin::HandleLosingForeground

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

//

void PluginWin::HandleLosingForeground()

{

    if (m_notifier) {

        TRAP_IGNORE(m_notifier->NotifyL(MPluginNotifier::EApplicationFocusChanged, (void*)0));

    }

}

// Functions from MPluginAdapter

HBufC8* PluginWin::PluginDataUrl()

{

    if (m_pluginskin)

        return m_pluginskin->url();

    return NULL;