/*

* 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

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <txtetext_internal.h>

#include <txtclipboard.h>

#include <txtetext_internal.h>

#endif

#include "config.h"

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

#include "StaticObjectsContainer.h"

#include "AtomicString.h"

#include "PlatformFontCache.h"

#include "BrCtl.h"

#include "WebFepTextEditor.h"

#include "WebEditorClient.h"

#include "WebTextFormatMask.h"

#include "WebView.h"

#include "WebFrame.h"

#include "Page.h"

#include "FocusController.h"

#include "WebFrameView.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"

#define KLineEnterChar 0x21b2

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),

      m_longKeyPress(EFalse)

{

    // 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

    TRAP_IGNORE( EnableCcpuL() );

}

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

// ~CWebFepTextEditor

//

//

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

CWebFepTextEditor::~CWebFepTextEditor()

    {

    delete m_state;

    delete m_inlineEditText;

    delete m_textFormatMask;

	delete m_ExtendedInputCapabilities;

	delete m_CcpuSupport;

    }

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

// 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) {

        Node *node = frame->document()->focusedNode(); 

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

            if (node->hasTagName(HTMLNames::inputTag) 

                    && (static_cast<HTMLInputElement*>(node)->inputType() == HTMLInputElement::PASSWORD) 

                        && !static_cast<HTMLInputElement*>(node)->readOnly()) {            

                // 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->SetDefaultCase(EAknEditorLowerCase);

                            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;

    m_longKeyPress = EFalse ;

    UpdateInputModeState(EAknEditorNullInputMode, EAknEditorAllInputModes,EAknEditorStandardNumberModeKeymap);

    UpdateFlagsState(EAknEditorFlagDefault);        

    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;

                UpdateFlagsState(EAknEditorFlagNoT9);

            }

            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()

{

    if (IsTextAreaFocused()) {

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

            HBufC* tempBuf = HBufC::NewLC(DocumentLengthForFep());

            TPtr ptr(tempBuf->Des());

            GetEditorContentForFep(ptr, 0, DocumentLengthForFep());

            TInt position = ptr.Locate(KLineEnterChar);

            if(position != KErrNotFound){

                TRAP_IGNORE(m_webView->fepTextEditor()->DoCommitFepInlineEditL());

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

				if(frame){

                	frame->editor()->execCommand("BackwardDelete");

				}

            }

            CleanupStack::PopAndDestroy();

        }

    }

}

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

// 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();

    if (IsLongKeyPress() && 

        (KMaxTInt != length))

        length += 1 ;

    // 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();

    Node*  focusedNode = frame->document()->focusedNode();

    if ( frame && focusedNode) {

        TInt lowPos = aCursorSelection.LowerPos();

        TInt highPos = aCursorSelection.HigherPos();

        if (focusedNode->hasTagName(HTMLNames::textareaTag)) {

            HTMLTextAreaElement* textArea = static_cast<HTMLTextAreaElement*>(focusedNode);

            textArea->setSelectionRange(lowPos, highPos);

		}

		else if (focusedNode->hasTagName(HTMLNames::inputTag)) {

		    HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(focusedNode);

		    inputElement->setSelectionStart(lowPos);

		    inputElement->setSelectionEnd(highPos);

		}

		HandleUpdateCursor();

    }

}

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

// GetCursorSelectionForFep

//

//

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

void CWebFepTextEditor::GetCursorSelectionForFep(TCursorSelection& aCursorSelection) const

{

    aCursorSelection.SetSelection(0,0);

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

    Node*  focusedNode = frame->document()->focusedNode();

    if (frame && focusedNode) {

        if (focusedNode->hasTagName(HTMLNames::textareaTag)) {

            HTMLTextAreaElement* textArea = static_cast<HTMLTextAreaElement*>(focusedNode);

            TInt anchorPos = textArea->selectionStart();

            TInt cursorPos = textArea->selectionEnd();

            aCursorSelection.SetSelection(cursorPos, anchorPos);

        }

        else if (focusedNode->hasTagName(HTMLNames::inputTag)) {

            HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(focusedNode);

            TInt anchorPos = inputElement->selectionStart();

            TInt cursorPos = inputElement->selectionEnd();

            aCursorSelection.SetSelection(cursorPos, anchorPos);

        }

    }

}

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

// 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;