/*

* Copyright (c) 2007 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:  WebFormFillPopup.cpp

*

*/

// INCLUDE FILES

#include <browser_platform_variant.hrh>

#include <../bidi.h>

#include <brctldialogsprovider.h>

#include "WebFormFillPopup.h"

#include "WebView.h"

#include "WebFrame.h"

#include "WebFrameView.h"

#include <brctldefs.h>

#include "PopupSelectListBox.h"

#include "WebFepTextEditor.h"

#include "FormFillCallback.h"

#include "Page.h"

#include "WebChromeClient.h"

#include <aknenv.h>

#include <coemain.h>

#include <eikpanic.h>

#include <aknedsts.h>

#include <AknUtils.h>

#include "eikon.hrh"

static const TInt KMaxNumToShow = 6; // max number of list items to show

static const TInt KInitArraySize = 10; // initial array size

static const TInt KBorderSize = 1; // List Box Border size

static const TInt KListBoxPadding = 12;

static const TInt KListBoxMinWidth = 100;

static const TInt KListBoxMargin = 6;

WebFormFillPopup* WebFormFillPopup::NewL(WebView* parent, CFont* font, MFormFillCallback* callback)

{

    WebFormFillPopup* self = new (ELeave) WebFormFillPopup(parent, font, callback);

    CleanupStack::PushL(self);

    self->ConstructL(font);

    CleanupStack::Pop();

    return self;

}

WebFormFillPopup::WebFormFillPopup(WebView* parent, CFont* font, MFormFillCallback* callback) :

m_parent(parent), m_font(font), m_callback(callback)

{

}

WebFormFillPopup::~WebFormFillPopup()

{

    MakeVisible(EFalse);

    m_parent->setFormFillPopup(NULL);

    delete m_listBox;

}

void WebFormFillPopup::ConstructL(CFont* aFont)

{

    m_parent->setFormFillPopup(this);

    ConstructListBoxL(aFont);

    ClearData();

}

void WebFormFillPopup::ConstructListBoxL(CFont* aFont)

{

    m_listBox = new (ELeave) PopupSelectListBox();

    m_listBox->ConstructL(m_parent, EFalse, aFont);

    m_listBox->CreateScrollBarFrameL(ETrue);

    m_listBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOff);

    m_listBox->SetListBoxObserver(this);

    m_listBox->SetBorder(TGulBorder::ESingleGray);

    m_listBox->SetBackground( TRgb(212, 212, 212) );

    m_listBox->SetFocus(ETrue);

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

    m_listBox->ActivateL();

    m_listBox->SetRect(TRect(TPoint(0,0), TSize(10,10)));

    MakeVisible(EFalse);

}

void WebFormFillPopup::addRow(const TPtrC& row)

{

    TBrCtlSelectOptionData* data = new TBrCtlSelectOptionData(row, EFalse, EFalse, EFalse);

    m_data.Append(data);

}

void WebFormFillPopup::invalidate()

{

    MakeVisible(ETrue);

    positionListBox();

    // now update the listbox

    m_listBox->UpdateContentL(m_data);

}

void WebFormFillPopup::ClearData()

{

    m_data.ResetAndDestroy();

    MakeVisible(EFalse);

}

void WebFormFillPopup::positionListBox()

{

    TRect r = m_parent->Rect();

    r.Shrink(KListBoxMargin, KListBoxMargin);

    // size

    TInt width = 0;

    for (TInt i=0; i<m_data.Count(); ++i)

    {

        TInt w = m_font->MeasureText(m_data[i]->Text());

        width = width > w ? width : w;

    }

    width += KListBoxPadding;

    // clamp width to [100, screen_width]

    width = width > KListBoxMinWidth ? width : KListBoxMinWidth;

    width = width < r.Width() ? width : r.Width();

    // only change the rect when it gets wider or position changed, to avoid

    // unnecessary flicking.

    TInt x = m_pos.iX;

    TInt y = m_pos.iY;

    if (width > m_listBox->Rect().Width() || m_posChanged)

    {

        // x position

        if (x + width > r.Width() )

            x = r.Width() - width;

        x = x > 0 ? x : 0;

        // y position

        TInt height = m_font->HeightInPixels()*KMaxNumToShow;

            y += m_inputHeight;

        SetRect(TRect(TPoint(x, y), TSize(width, height)));

    }

}

TKeyResponse WebFormFillPopup::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

{

    TKeyResponse response = EKeyWasNotConsumed;

    // We only pass ArrowUp, ArrowDown and Activate to listbox, to prevent Listbox

    // eating up all the keyevents.

    switch (aKeyEvent.iCode)

        {

        case EKeyUpArrow:             // North

        case EKeyDownArrow:           // South

            response = m_listBox->OfferKeyEventL(aKeyEvent, aType);

            break;

        case EKeyDevice3:

        case EKeyEnter:

            response = m_listBox->OfferKeyEventL(aKeyEvent, aType);

            m_callback->cancelPopup();

            break;

        case EKeyLeftArrow:           // West

        case EKeyRightArrow:          // East

            MakeVisible(EFalse);

            response = m_parent->OfferKeyEventL(aKeyEvent, aType);

            m_callback->cancelPopup();

            break;

// All of the diagonal KeyEvents are allowed to flow through the "default" case...

//

//      case EKeyRightUpArrow:        // Northeast

//      case EStdKeyDevice11:         //   : Extra KeyEvent supports diagonal event simulator wedge

//      case EKeyRightDownArrow:      // Southeast

//      case EStdKeyDevice12:         //   : Extra KeyEvent supports diagonal event simulator wedge

//      case EKeyLeftDownArrow:       // Southwest

//      case EStdKeyDevice13:         //   : Extra KeyEvent supports diagonal event simulator wedge

//      case EKeyLeftUpArrow:         // Northwest

//      case EStdKeyDevice10:         //   : Extra KeyEvent supports diagonal event simulator wedge

        default:

            response = m_parent->OfferKeyEventL(aKeyEvent, aType);

            break;

    }

    return response;

}

// Handle the key event from touch device

TKeyResponse WebFormFillPopup::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

{

    TKeyResponse response = EKeyWasNotConsumed;

    // We only pass ArrowUp, ArrowDown and Activate to listbox, to prevent Listbox

    // eating up all the keyevents.

    switch (aKeyEvent.iCode)

        {

        case EKeyUpArrow:             // North

        case EKeyDownArrow:           // South

            response = m_listBox->OfferKeyEventL(aKeyEvent, aType);

            break;

        case EKeyDevice3:

        case EKeyEnter:

            response = m_listBox->OfferKeyEventL(aKeyEvent, aType);

            m_callback->cancelPopup();

            break;

        case EKeyLeftArrow:           // West

        case EKeyRightArrow:          // East

            MakeVisible(EFalse);

            m_callback->cancelPopup();

            response = EKeyWasConsumed;

            break;

        // All of the diagonal KeyEvents are to be ignored and consumed

        case EKeyRightUpArrow:        // Northeast

        case EStdKeyDevice11:         //   : Extra KeyEvent supports diagonal event simulator wedge

        case EKeyRightDownArrow:      // Southeast

        case EStdKeyDevice12:         //   : Extra KeyEvent supports diagonal event simulator wedge

        case EKeyLeftDownArrow:       // Southwest

        case EStdKeyDevice13:         //   : Extra KeyEvent supports diagonal event simulator wedge

        case EKeyLeftUpArrow:         // Northwest

        case EStdKeyDevice10:         //   : Extra KeyEvent supports diagonal event simulator wedge

            response = EKeyWasConsumed;

            break;

        // Allow vkb keyevents to be handled later.

        default:

            response = EKeyWasNotConsumed;

            break;

    }

    if (response == EKeyWasConsumed) {

      m_parent->page()->chrome()->client()->setElementVisibilityChanged(false);

    }

    return response;

}

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

{

    return m_listBox;

}

TInt WebFormFillPopup::CountComponentControls() const

{

    return 1;

}

void WebFormFillPopup::SizeChanged()

{

    m_listBox->SetRect( Rect() );

}

void WebFormFillPopup::HandleListBoxEventL(CEikListBox* aListBox, TListBoxEvent aEventType)

{

    if (aListBox != m_listBox)

        return;

#ifdef BRDO_SINGLE_CLICK_ENABLED_FF

    if (aEventType == EEventItemDoubleClicked || aEventType == EEventEnterKeyPressed || aEventType == EEventItemSingleClicked || aEventType == EEventEmptyAreaClicked)

#else        

    if (aEventType == EEventItemDoubleClicked || aEventType == EEventEnterKeyPressed)

#endif        

    {

        // get the selected item from listbox

        m_listBox->View()->UpdateSelectionL(CListBoxView::ESingleSelection);

        const CListBoxView::CSelectionIndexArray* selected = m_listBox->SelectionIndexes();

        if (m_listBox->IsFocused())

        {

            MakeVisible(EFalse);

            if(selected != NULL && m_data[selected->At(0)] )

               m_callback->autoComplete(m_data[selected->At(0)]->Text());

        }

    }

    else if (aEventType == EEventPenDownOnItem) {

        if (!m_listBox->IsFocused()) {

            m_listBox->SetFocus(ETrue); // highlight first item

            m_listBox->DrawNow();

        }

    }

}

TCoeInputCapabilities WebFormFillPopup::InputCapabilities() const

{

    // tricky!!! we need to retain T9 capabilities of WebKitView.

    return m_parent->fepTextEditor()->InputCapabilities();

}

void WebFormFillPopup::clear()

{

    ClearData();

}

void WebFormFillPopup::setLocationHintInDoc(const TRect& r, WebCore::Frame* frame)

{    

    if (!frame)

        return;

    WebFrame* webFrame = kit(frame);

    // now lets reverse back to the root frame to figure out the screen position

    TPoint pt = webFrame->frameView()->frameCoordsInViewCoords(r.iTl);

    m_posChanged = !(pt == m_pos);

    m_pos = pt;

    m_inputHeight = r.Height();

}

void WebFormFillPopup::MakeVisible(TBool aVisible)

{

    if (aVisible == IsVisible())

        return;

    CCoeControl::MakeVisible(aVisible);

    if ( aVisible )

    {

        m_listBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

        m_listBox->MakeVisible(ETrue);

        // for touch we want to prevent list from focusing and closing the VKB

        if (!AknLayoutUtils::PenEnabled()){

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

        }

    }

    else

    {

        m_listBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOff);

        m_listBox->MakeVisible(EFalse);

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

    }

}

void WebFormFillPopup::reDraw()

{

    m_listBox->DrawNow();

}

void WebFormFillPopup::handleCommandL(int command)

{

    switch (command)

    {

    case TBrCtlDefs::ECommandCancel:

        MakeVisible(EFalse);

        m_callback->cancelPopup();

        break;

    }

}

void WebFormFillPopup::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

    if (Rect().Contains(aPointerEvent.iPosition)) {

        m_listBox->HandlePointerEventL( aPointerEvent );

    }

    else {

        m_callback->cancelPopup();

    }

    m_parent->page()->chrome()->client()->setElementVisibilityChanged(false);

}

//  End of File