/*

* 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:   WebFepTextEditor.cpp

*

*/

#include "config.h"

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

#include "WebFepTextEditor.h"

#include "WebEditorClient.h"

#include "WebTextFormatMask.h"

#include "WebView.h"

#include "WebFrame.h"

#include "Page.h"

#include "FocusController.h"

#include "Frame.h"

#include "Editor.h"

#include "HtmlNames.h"

#include "EventHandler.h"

#include "HtmlInputElement.h"

#include "HtmlTextAreaElement.h"

#include "PlatformKeyboardEvent.h"

#include "CSSPropertyNames.h"

#include "CSSValueKeywords.h"

#include <coemain.h>

#include <eikpanic.h>

#include <aknedsts.h>

#include <aknutils.h>

#include "Text.h"

using namespace WebCore;

static const int kInfinite = -1;

_LIT(KBlankDesC," ");

GLDEF_C void Panic(TEikPanic aPanic)

    {

    _LIT(KPanicCat,"WEBKIT-FEP");

    User::Panic(KPanicCat,aPanic);

    }

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

// CWebFepTextEditor

// 

// 

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

CWebFepTextEditor::CWebFepTextEditor(WebView* aView)

    : m_webView(aView),

      m_textFormatMask(NULL),

      m_inlineEditText(NULL)

{

    // Set up the extended capabilities

    TRAP_IGNORE(

        m_ExtendedInputCapabilities = CAknExtendedInputCapabilities::NewL();

        );

    // Set alignment on m_ExtendedInputCapabilities, yes it checks if NULL

    // The EInputEditorAlignXXX flags are defined for 5.0+ platforms

#if defined(BRDO_BROWSER_50_FF)

    SetAlignment( CAknExtendedInputCapabilities::EInputEditorAlignBidi );

#endif

	EnableCcpu(ETrue);

}

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

// ~CWebFepTextEditor

// 

// 

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

CWebFepTextEditor::~CWebFepTextEditor()

    {

    delete m_state;

    delete m_inlineEditText;

    delete m_textFormatMask;

    }

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

// CreateTextFormatMask

// 

// 

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

void CWebFepTextEditor::CreateTextFormatMask()

{

    if (!m_textFormatMask) {        

        Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();

        if (frame &&

            frame->document() &&

            frame->document()->focusedNode()) {                

            RenderStyle* s = frame->document()->focusedNode()->renderStyle();      

            if (s && 

            	(!s->wapInputFormat().isEmpty() || s->wapInputRequired())){            

                m_textFormatMask = new WebTextFormatMask(s->wapInputFormat(), s->wapInputRequired());

            }

        }

    }

}              

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

// UpdateEditingMode

// 

// 

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

void CWebFepTextEditor::UpdateEditingMode()

{        

    Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();

    if (frame) {

        SelectionController* sc = frame->selectionController();

        if (sc && sc->isContentEditable() && sc->isInPasswordField()) {       

            // Set the state as if it was the CEikSecretEditor

            CAknEdwinState* state = static_cast<CAknEdwinState*>(State(KNullUid));  

            if (state) {

                state->SetFlags( EAknEditorFlagNoLRNavigation |

                                        EAknEditorFlagLatinInputModesOnly |

                                        EAknEditorFlagNoT9 |

                                        EAknEditorFlagUseSCTNumericCharmap );

                state->SetDefaultInputMode(EAknEditorSecretAlphaInputMode);

                state->SetCurrentInputMode(EAknEditorSecretAlphaInputMode);

                state->SetPermittedCases(EAknEditorLowerCase|EAknEditorUpperCase);

                state->SetCurrentCase(EAknEditorLowerCase);    

                state->SetPermittedInputModes(EAknEditorSecretAlphaInputMode | EAknEditorNumericInputMode);

                state->SetDefaultCase(EAknEditorLowerCase);

                state->SetSpecialCharacterTableResourceId(R_AVKON_SPECIAL_CHARACTER_TABLE_DIALOG_LATIN_ONLY);    

                state->SetNumericKeymap(EAknEditorPlainNumberModeKeymap);

            }

        }

        else {       

            CreateTextFormatMask();

            TUint currentCase ( EAknEditorLowerCase ) ;

            TUint permittedCase ( EAknEditorAllCaseModes ) ;

            TUint inputMode( EAknEditorNullInputMode );

            TUint permittedInputModes( EAknEditorAllInputModes );            

            TUint flags( EAknEditorFlagDefault ); 

            TUint numericKeyMap( EAknEditorStandardNumberModeKeymap ); 

            if (GetStateFromFormatMask(currentCase, permittedCase, inputMode, permittedInputModes, flags, numericKeyMap)) {             

                UpdateFlagsState(flags);

                UpdateInputModeState(inputMode, permittedInputModes, numericKeyMap);

                UpdateCaseState(currentCase, permittedCase);                 

            }

            else {

                CAknEdwinState* state = static_cast<CAknEdwinState*>(State(KNullUid));  

                if (state) {

                    state->SetPermittedInputModes(EAknEditorAllInputModes);

                    state->SetPermittedCases(EAknEditorAllCaseModes);//allow everything

                }

            }

        }

    }   // End of if (frame)

}

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

// CancelEditingMode

// 

// 

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

void CWebFepTextEditor::CancelEditingMode()

    {        

    delete m_textFormatMask;

    m_textFormatMask = NULL;

    delete m_inlineEditText;    

    m_inlineEditText = NULL;    

    UpdateFlagsState(EAknEditorFlagDefault);

    UpdateInputModeState(EAknEditorNullInputMode, EAknEditorAllInputModes,EAknEditorStandardNumberModeKeymap);

    UpdateCaseState(EAknEditorLowerCase, EAknEditorAllCaseModes);            

    CancelFepInlineEdit();

    }

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

// ActivatePenInputRequest

// 

// 

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

void CWebFepTextEditor::ActivatePenInputRequest()

{ 

    CAknEdwinState* state = static_cast<CAknEdwinState*>(State(KNullUid));                

    if ( state ) {                    

        TRAP_IGNORE( state->ReportAknEdStateEventL(MAknEdStateObserver::EAknActivatePenInputRequest ) );

    }    

}

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

// DeactivatePenInputRequest

// 

// 

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

void CWebFepTextEditor::DeactivatePenInputRequest()

    {        

    }

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

// InputCapabilities

// 

// 

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

TCoeInputCapabilities CWebFepTextEditor::InputCapabilities()    

{

    Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();

    if (frame) {

        SelectionController* sc = frame->selectionController();

        if (sc && sc->isContentEditable()) {       

            // Set up the input capabilities, based on the <input> box

            TUint caps = TCoeInputCapabilities::ENavigation;                

            if ( sc->isInPasswordField() ) {           

                caps |= TCoeInputCapabilities::ESecretText;                            

            }

            else {

                CAknEdwinState* state = static_cast<CAknEdwinState*>(State(KNullUid));                

                if ( state ) {                    

                    if ( state->PermittedInputModes() == EAknEditorNumericInputMode ) {

                        caps |= (TCoeInputCapabilities::EWesternNumericIntegerPositive |

                                 TCoeInputCapabilities::EWesternNumericIntegerNegative)| 

                                 TCoeInputCapabilities::EAllText;

                    }        

                    else if (  state->PermittedInputModes() == EAknEditorTextInputMode ) {            

                        caps |= TCoeInputCapabilities::EWesternAlphabetic;

                    }

                    else if (  state->PermittedInputModes() == (EAknEditorTextInputMode | EAknEditorNumericInputMode) ) {            

                        caps |= (TCoeInputCapabilities::EWesternNumericIntegerPositive |

                                 TCoeInputCapabilities::EWesternNumericIntegerNegative |

                                 TCoeInputCapabilities::EWesternAlphabetic);

                    }

                    else {

                        caps |=  TCoeInputCapabilities::EAllText;         

                    }            

                }

            }

            // Set up the extended input capabilities, based on dir="rtl".

            // EInputEditorAlignXXX flags are only valid for 5.0+ platform.

#if defined(BRDO_BROWSER_50_FF)

            if ( IsDirectionRTL() ) {

                SetAlignment(CAknExtendedInputCapabilities::EInputEditorAlignRight );

            }

            else {

                SetAlignment(CAknExtendedInputCapabilities::EInputEditorAlignBidi );

            }

#endif

            // Set up the ObjectProvider, so ExtendedInputCapablities can be called by FEP.

            // MObjectProvider callback method MopSupplyObject().

            TCoeInputCapabilities inputCaps( caps, this, NULL, TUid::Uid(0x100056de), this );

            inputCaps.SetObjectProvider( this );

            return inputCaps;

        }

    }

    // Empty input capabilities

    TCoeInputCapabilities emptyCaps(TCoeInputCapabilities::ENone);

    emptyCaps.SetObjectProvider( this );

    return emptyCaps;

}

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

// from MCoeFepAwareTextEditor  

//

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

// StartFepInlineEditL

// 

// 

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

void CWebFepTextEditor::StartFepInlineEditL(

      const TDesC& aInitialInlineText,

      TInt /*aPositionOfInsertionPointInInlineText*/,

      TBool /*aCursorVisibility*/,

      const MFormCustomDraw*,

      MFepInlineTextFormatRetriever&,

      MFepPointerEventHandlerDuringInlineEdit& /*aPointerEventHandlerDuringInlineEdit*/)

{    

    CCoeEnv::Static()->ForEachFepObserverCall(FepObserverHandleStartOfTransactionL);              

    ClearInlineText();        

    UpdateInlineText(aInitialInlineText);       

}

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

// UpdateFepInlineTextL

// 

// 

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

void CWebFepTextEditor::UpdateFepInlineTextL( const TDesC& aNewInlineText,

								TInt /*aPositionOfInsertionPointInInlineText*/ )

{        

    ClearInlineText();        

    UpdateInlineText(aNewInlineText);       

}

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

// SetInlineEditingCursorVisibilityL

// 

// 

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

void CWebFepTextEditor::SetInlineEditingCursorVisibilityL(TBool /*aCursorVisibility*/)

{

}

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

// CancelFepInlineEdit

// 

// 

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

void CWebFepTextEditor::CancelFepInlineEdit()

{

}

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

// DocumentLengthForFep

// 

// 

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

TInt CWebFepTextEditor::DocumentLengthForFep() const

{

    TInt length = 0;

    Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();

    if (frame &&

        frame->document() &&

        frame->document()->focusedNode()) {

        if (frame->document()->focusedNode()->hasTagName(HTMLNames::inputTag)) {

            HTMLInputElement* ie = static_cast<HTMLInputElement*>(frame->document()->focusedNode());

            length = ie->value().length();

        }

        else if (frame->document()->focusedNode()->hasTagName(HTMLNames::textareaTag)) {

            HTMLTextAreaElement* ie = static_cast<HTMLTextAreaElement*>(frame->document()->focusedNode());

            length = ie->value().length();

        }

    }

    return length;    

}

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

// DocumentMaximumLengthForFep

// 

// 

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

TInt CWebFepTextEditor::DocumentMaximumLengthForFep() const

{       

    TInt length = KMaxTInt;       

    Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();

    if (frame &&

        frame->document() &&

        frame->document()->focusedNode() &&

        frame->document()->focusedNode()->hasTagName(HTMLNames::inputTag) ) {                   

        length = static_cast<HTMLInputElement*>(frame->document()->focusedNode())->maxLength();

    }

	// Override the length if a text format mask is set

	if ( m_textFormatMask && m_textFormatMask->getMultitude() > 0 )

        length = m_textFormatMask->getMultitude();

    // TextArea node has no member function maxLength(), so return KMaxTInt

    return length;

}

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

// SetCursorSelectionForFepL

// 

// 

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

void CWebFepTextEditor::SetCursorSelectionForFepL(const TCursorSelection& aCursorSelection)

{    

    // The other part of the rather hackish way to check if we are at the end of the editing field

    // see WebEditorClient::handleKeypress

    Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();

    if ( frame ) {           

        SelectionController* sc = frame->selectionController();

        Node* editNode = sc->base().node();

        if ( IsTextAreaFocused() ) {

			TInt position( aCursorSelection.iAnchorPos );

			TInt offset( 0 );

			if ( editNode ) {

				editNode = findTextNodeForCurPos( editNode, position );

				if ( aCursorSelection.iAnchorPos > position ) {

					offset = aCursorSelection.iAnchorPos - position;

				}

				Position base( editNode, offset );

				Position extent( editNode, offset );

				sc->moveTo( base, extent, DOWNSTREAM );

			}

		}

		else if ( editNode && editNode->isTextNode() ) { 

			Position base( sc->baseNode(), aCursorSelection.iAnchorPos );

			Position extent( sc->baseNode(), aCursorSelection.iCursorPos );

			sc->moveTo( base, extent, DOWNSTREAM );   

		}

		HandleUpdateCursor();

    }

}

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

// GetCursorSelectionForFep

// 

// 

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

void CWebFepTextEditor::GetCursorSelectionForFep(TCursorSelection& aCursorSelection) const

{

    aCursorSelection.SetSelection(0,0);

    Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();

    if ( frame ) {           

        SelectionController* sc = frame->selectionController();

        Node* editNode = sc->base().node();

		if ( frame && frame->document()->focusedNode() ) {

			if ( IsTextAreaFocused() ) {

				TInt len( 0 );

				if ( editNode ) {

					findPrevSiblingTextLen( editNode, len );  

				}

				aCursorSelection.SetSelection( sc->baseOffset() + len,

											   sc->extentOffset() + len );

			}

			else {

				aCursorSelection.SetSelection(sc->baseOffset(), sc->extentOffset());       

			}

		}

	}

}

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

// GetEditorContentForFep

// 

// 

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

void CWebFepTextEditor::GetEditorContentForFep( TDes& aEditorContent,

												TInt aDocumentPosition,

												TInt aLengthToRetrieve ) const

{    

    aEditorContent = KNullDesC;   	   // KNullDesC has length 0

    if (aLengthToRetrieve == 0) {

        return;

    }

    Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();

    if (frame &&

        frame->document() &&

        frame->document()->focusedNode()) {

        if (frame->document()->focusedNode()->hasTagName(HTMLNames::inputTag)) {

            HTMLInputElement* ie = static_cast<HTMLInputElement*>(frame->document()->focusedNode());

            aEditorContent = ie->value().substring(aDocumentPosition, aLengthToRetrieve);

        }

        else if (frame->document()->focusedNode()->hasTagName(HTMLNames::textareaTag)) {

            HTMLTextAreaElement* ie = static_cast<HTMLTextAreaElement*>(frame->document()->focusedNode());

            // Convert the newline to paragraph separator, because the FEP

            // input editors (vkb, etc) ignore newline

            String str(ie->value().substring(aDocumentPosition, aLengthToRetrieve));

            str.replace(EKeyLineFeed, CEditableText::EParagraphDelimiter);  

            aEditorContent = str;        

        }

    }

}

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

// GetFormatForFep

// 

// 

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

void CWebFepTextEditor::GetFormatForFep(TCharFormat& /*aFormat*/,TInt /*aDocumentPosition*/) const

{         

}

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

// GetScreenCoordinatesForFepL

// 

// 

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

void CWebFepTextEditor::GetScreenCoordinatesForFepL(TPoint& /*aLeftSideOfBaseLine*/,

                                                    TInt& /*aHeight*/,

                                                    TInt& /*aAscent*/,

                                                    TInt /*aDocumentPosition*/) const

{    

}

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

// DoCommitFepInlineEditL

// 

// 

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

void CWebFepTextEditor::DoCommitFepInlineEditL()

{                    

    ClearInlineText();     

    if (m_inlineEditText && DocumentLengthForFep() < DocumentMaximumLengthForFep()) {

        Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();

        if (frame){

            frame->editor()->insertTextWithoutSendingTextEvent(String(*m_inlineEditText), false);

        }

    }

    //delete the m_inlineEditText since text is commited

    delete m_inlineEditText;    

    m_inlineEditText = NULL;    

    HandleUpdateCursor();

    UpdateEditingMode();

}