MCL/sf/mw/web: comparison webengine/osswebengine/WebKit/s60/webview/WebFepTextEditor.cpp

equal deleted inserted replaced

-:79859ed3eea9
+:919f36ff910f
 *
 * Description:   WebFepTextEditor.cpp
 *
 */
 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
 #include <txtetext_internal.h>
 #include <txtclipboard.h>
 #include <txtetext_internal.h>
 #endif
 #include "FocusController.h"
 #include "WebFrameView.h"
 #include "Frame.h"
 #include "Editor.h"
-#include "HTMLNames.h"
+#include "HtmlNames.h"
 #include "EventHandler.h"
-#include "HTMLInputElement.h"
+#include "HtmlInputElement.h"
-#include "HTMLTextAreaElement.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 <aknutils.h>
 #include "Text.h"
+#include <e32const.h>
+#define KLineEnterChar 0x21b2
 using namespace WebCore;
 static const int kInfinite = -1;
 _LIT(KBlankDesC," ");
 //
 // -----------------------------------------------------------------------------
 CWebFepTextEditor::CWebFepTextEditor(WebView* aView)
 : m_webView(aView),
 m_textFormatMask(NULL),
-m_inlineEditText(NULL)
+m_inlineEditText(NULL),
+m_longKeyPress(EFalse),
+m_inlineTextEditingStarted(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
-	EnableCcpu(ETrue);
+TRAP_IGNORE( EnableCcpuL() );
 }
 // -----------------------------------------------------------------------------
 // ~CWebFepTextEditor
 //
 {
 delete m_state;
 delete m_inlineEditText;
 delete m_textFormatMask;
 	delete m_ExtendedInputCapabilities;
+	delete m_CcpuSupport;
 }
 // -----------------------------------------------------------------------------
 // CreateTextFormatMask
 //
 // -----------------------------------------------------------------------------
 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 );
+EAknEditorFlagUseSCTNumericCharmap |
+EAknEditorFlagNoLRNavigation);
 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);
+state->SetNumericKeymap(EAknEditorStandardNumberModeKeymap);
+state->SetCcpuState(NULL);
+TRAP_IGNORE( state->ReportAknEdStateEventL(MAknEdStateObserver::EAknEdwinStateFlagsUpdate ) );
 }
 }
 else {
 CreateTextFormatMask();
 TUint currentCase ( EAknEditorLowerCase ) ;
 TUint permittedCase ( EAknEditorAllCaseModes ) ;
 TUint inputMode( EAknEditorNullInputMode );
 TUint permittedInputModes( EAknEditorAllInputModes );
+#ifdef BRDO_MULTITOUCH_ENABLED_FF
+TUint flags( EAknEditorFlagDefault | EAknEditorFlagSelectionVisible );
+#else
 TUint flags( EAknEditorFlagDefault );
+#endif
 TUint numericKeyMap( EAknEditorStandardNumberModeKeymap );
 if (GetStateFromFormatMask(currentCase, permittedCase, inputMode, permittedInputModes, flags, numericKeyMap)) {
 UpdateFlagsState(flags);
 UpdateInputModeState(inputMode, permittedInputModes, numericKeyMap);
 UpdateCaseState(currentCase, permittedCase);
 }
 CAknEdwinState* state = static_cast<CAknEdwinState*>(State(KNullUid));
 if (state) {
 state->SetDefaultCase(EAknEditorLowerCase);
 state->SetPermittedInputModes(EAknEditorAllInputModes);
 state->SetPermittedCases(EAknEditorAllCaseModes);//allow everything
+state->SetCcpuState(this);
 }
 }
 }
 }
 }   // End of if (frame)
 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();
 }
 // Set up the input capabilities, based on the <input> box
 TUint caps = TCoeInputCapabilities::ENavigation;
 if ( sc->isInPasswordField() ) {
 caps |= TCoeInputCapabilities::ESecretText;
-UpdateFlagsState(EAknEditorFlagNoT9);
+UpdateFlagsState(EAknEditorFlagNoT9 | EAknEditorFlagLatinInputModesOnly);
 }
 else {
 CAknEdwinState* state = static_cast<CAknEdwinState*>(State(KNullUid));
 if ( state ) {
 MFepInlineTextFormatRetriever&,
 MFepPointerEventHandlerDuringInlineEdit& /*aPointerEventHandlerDuringInlineEdit*/)
 {
 CCoeEnv::Static()->ForEachFepObserverCall(FepObserverHandleStartOfTransactionL);
 ClearInlineText();
+m_inlineTextEditingStarted= ETrue;
 UpdateInlineText(aInitialInlineText);
 }
 // -----------------------------------------------------------------------------
 // UpdateFepInlineTextL
 //
 //
 // -----------------------------------------------------------------------------
 void CWebFepTextEditor::CancelFepInlineEdit()
 {
+if (IsTextAreaFocused()||IsInputElementFocused()) {
+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
 //
 	// 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;
 }
 // -----------------------------------------------------------------------------
 {
 // 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) {
+if ( focusedNode ) {
 TInt lowPos = aCursorSelection.LowerPos();
 TInt highPos = aCursorSelection.HigherPos();
 if (focusedNode->hasTagName(HTMLNames::textareaTag)) {
 HTMLTextAreaElement* textArea = static_cast<HTMLTextAreaElement*>(focusedNode);
 textArea->setSelectionRange(lowPos, highPos);
 {
 aCursorSelection.SetSelection(0,0);
 Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();
 Node*  focusedNode = frame->document()->focusedNode();
-if (frame && focusedNode) {
+if (focusedNode) {
 if (focusedNode->hasTagName(HTMLNames::textareaTag)) {
 HTMLTextAreaElement* textArea = static_cast<HTMLTextAreaElement*>(focusedNode);
 TInt anchorPos = textArea->selectionStart();
 TInt cursorPos = textArea->selectionEnd();
 aCursorSelection.SetSelection(cursorPos, anchorPos);
 		int xPos(0);
 		int yPos(0);
 		if ( sc ){
 			IntRect rect = sc->caretRect();
 			Node* editNode = sc->focusNode();
-			TPoint viewPoint = kit(frame)->frameView()->frameCoordsInViewCoords(editNode->getRect().Rect().iBr);
+			if ( editNode && editNode->isTextNode() ) {
-			xPos = viewPoint.iX;
+TPoint viewPoint = kit(frame)->frameView()->frameCoordsInViewCoords(editNode->getRect().Rect().iBr);
-			yPos = viewPoint.iY;
+	            xPos = viewPoint.iX;
-			String str;
+	            yPos = frame->document()->focusedNode()->getRect().bottomLeft().y() + rect.height();
-			if ( editNode &&
-				 editNode->isTextNode() ) {
+	            String str;
-				WebCore::Text* aText = (WebCore::Text*)editNode;
+	            WebCore::Text* aText = (WebCore::Text*)editNode;
 				str = aText->data();
 				aDocumentPosition =  aText->length();
 				TInt position = aDocumentPosition - ( str.reverseFind(KBlankDesC(), aDocumentPosition )+1);
 				String word(str);
 				if( position > 0 ){
 if (frame){
 if(IsWapMaskedModeInput(frame)) {
 HandleMaskedInsertText(frame, (String(*m_inlineEditText)));
 }
 else {
 frame->editor()->insertTextWithoutSendingTextEvent(String(*m_inlineEditText), false);
 }
 }
 }
 //delete the m_inlineEditText since text is commited
 delete m_inlineEditText;
 m_inlineEditText = NULL;
+m_longKeyPress = EFalse;
+m_inlineTextEditingStarted= EFalse;
 HandleUpdateCursor();
 UpdateEditingMode();
 }
 MFepInlineTextFormatRetriever& aInlineTextFormatRetriever,
 MFepPointerEventHandlerDuringInlineEdit& aPointerEventHandlerDuringInlineEdit)
 {
 aSetToTrue=ETrue;
 SetCursorSelectionForFepL(aCursorSelection);
+m_longKeyPress = ETrue ;
 StartFepInlineEditL(aInitialInlineText, aPositionOfInsertionPointInInlineText, aCursorVisibility, aCustomDraw, aInlineTextFormatRetriever, aPointerEventHandlerDuringInlineEdit);
 }
 // -----------------------------------------------------------------------------
 // SetCursorType
 void CWebFepTextEditor::UpdateFlagsState(TUint flags)
 {
 CAknEdwinState* state = static_cast<CAknEdwinState*>(State(KNullUid));
 if ( IsTextAreaFocused() ) {
+#ifdef BRDO_MULTITOUCH_ENABLED_FF
 	// If in a TextArea, allow "enter" key presses to be newline/paragraph
 	state->SetFlags( flags | EAknEditorFlagUseSCTNumericCharmap
-					 | EAknEditorFlagAllowEntersWithScrollDown );
+| EAknEditorFlagAllowEntersWithScrollDown | EAknEditorFlagSelectionVisible );
+#else
+state->SetFlags( flags | EAknEditorFlagUseSCTNumericCharmap
+| EAknEditorFlagAllowEntersWithScrollDown );
+#endif
 	}
 else {
-state->SetFlags(flags | EAknEditorFlagUseSCTNumericCharmap);
+#ifdef BRDO_MULTITOUCH_ENABLED_FF
+state->SetFlags(flags | EAknEditorFlagUseSCTNumericCharmap | EAknEditorFlagSelectionVisible);
+#else
+state->SetFlags(flags | EAknEditorFlagUseSCTNumericCharmap );
+#endif
 	}
 state->ReportAknEdStateEventL(MAknEdStateObserver::EAknEdwinStateFlagsUpdate);
+if (m_CcpuSupport)
+{
+TRAP_IGNORE(m_CcpuSupport->HandleFocusChangeL());
+}
 }
 // -----------------------------------------------------------------------------
 // UpdateInputModeState
 //
 state->SetDefaultInputMode(inputMode);
 state->SetCurrentInputMode(inputMode);
 state->SetPermittedInputModes(permittedInputModes);
 state->SetNumericKeymap(static_cast<TAknEditorNumericKeymap>(numericKeyMap));
-state->ReportAknEdStateEventL(MAknEdStateObserver::EAknSyncEdwinState);
 state->ReportAknEdStateEventL(MAknEdStateObserver::EAknEdwinStateInputModeUpdate);
 }
 // -----------------------------------------------------------------------------
 // UpdateCaseState
 // MAknEdStateObserver::EAknCursorPositionChanged
 CAknEdwinState* state = static_cast<CAknEdwinState*>(State(KNullUid));
 if ( state ) {
 TRAP_IGNORE( state->ReportAknEdStateEventL( MAknEdStateObserver::EAknCursorPositionChanged ) );
+		if (m_CcpuSupport)
+		{
+			TRAP_IGNORE(m_CcpuSupport->HandleSelectionChangeL());
+		}
 }
 }
 // -----------------------------------------------------------------------------
 // GetStateFromFormatMask
 TInt cursorpos = DocumentLengthForFep();
 TInputFormatMaskType fm = m_textFormatMask->getInputFormatMaskType(frame, cursorpos);
 if (!cursorpos) {
 while(fm == EStatic) {
 fm = m_textFormatMask->getInputFormatMaskType(frame, ++cursorpos);
 }
 }
 setSCTAvailability(true);
+CAknEdwinState* state = static_cast<CAknEdwinState*>(State(KNullUid));
 switch( fm ) {
 case ELeUpSymPuc:       //A any upper case letter or symbolic
 flags = EAknEditorFlagNoT9 | EAknEditorFlagFixedCase;
 currentCase = EAknEditorUpperCase;
 permittedCase = EAknEditorUpperCase;
 break;
 case ELeUpNumSymPuc:    //X any upper case, number or symbolic
 flags = EAknEditorFlagNoT9 | EAknEditorFlagFixedCase;
 currentCase = EAknEditorUpperCase;
 permittedCase= EAknEditorUpperCase;
-inputMode = EAknEditorTextInputMode;
+inputMode = state->CurrentInputMode();
 permittedInputModes= EAknEditorTextInputMode;
 break;
 case ELeLoNumSymPuc:    //x any lower case, number or symbolic
 flags = EAknEditorFlagNoT9 | EAknEditorFlagFixedCase;
 currentCase = EAknEditorLowerCase;
 permittedCase= EAknEditorLowerCase;
-inputMode = EAknEditorTextInputMode;
+inputMode = state->CurrentInputMode();
 permittedInputModes= EAknEditorTextInputMode | EAknEditorNumericInputMode;
 break;
 case EAnyLow:           //m any lower character can be changed to upper
 flags = EAknEditorFlagNoT9;
 currentCase = EAknEditorLowerCase;
 return EFalse;
 }
 return ETrue;
 }
+	else {
+setSCTAvailability(true);
+}
 return EFalse;
 }
 // -----------------------------------------------------------------------------
 if (!m_textFormatMask->checkText(input->value(), eb)) {
 style->setProperty(CSS_PROP_COLOR, "red", false, ec);
 return false;
 }
+else if ( m_textFormatMask->acceptAll() )
+{
+return true;
+}
 else
 {
 style->setProperty(CSS_PROP_COLOR, m_inputTextColor, false, ec);
-CancelEditingMode();
+UpdateEditingMode();
 return true;
 }
 }
 else if ( n->hasTagName(HTMLNames::textareaTag)) {
 CancelEditingMode();
 //
 //
 // -----------------------------------------------------------------------------
 TBool CWebFepTextEditor::CcpuIsFocused() const
 {
-return ETrue;
+return (IsTextAreaFocused() || IsInputElementFocused());
 }
 // -----------------------------------------------------------------------------
 // CcpuCanCut
 //
 // -----------------------------------------------------------------------------
 TBool CWebFepTextEditor::CcpuCanCut() const
 {
 TCursorSelection selection;
 GetCursorSelectionForFep(selection);
-return selection.Length();
+return m_CcpuSupport && selection.Length();
 }
 // -----------------------------------------------------------------------------
 // CcpuCutL
 //
 void CWebFepTextEditor::CcpuCutL()
 {
 PlaceDataOnClipboardL();
 TCursorSelection selection;
 GetCursorSelectionForFep(selection);
+Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();
+if (frame) {
+frame->editor()->deleteWithDirection(SelectionController::BACKWARD,
+CharacterGranularity, false, true);
+}
+HandleUpdateCursor();
 }
 // -----------------------------------------------------------------------------
 // CcpuCanCopy
 //
 // -----------------------------------------------------------------------------
 TBool CWebFepTextEditor::CcpuCanCopy() const
 {
 TCursorSelection selection;
 GetCursorSelectionForFep(selection);
-return selection.Length();
+return m_CcpuSupport && selection.Length();
 }
 // -----------------------------------------------------------------------------
 // CcpuCopyL
 //
 //
 // -----------------------------------------------------------------------------
 void CWebFepTextEditor::CcpuCopyL()
 {
 PlaceDataOnClipboardL();
+if (m_CcpuSupport)
+m_CcpuSupport->HandleSelectionChangeL();
 }
 // -----------------------------------------------------------------------------
 // CcpuCanPaste
 //
 //
 // -----------------------------------------------------------------------------
 TBool CWebFepTextEditor::CcpuCanPaste() const
 {
 TRAPD(err, DoCcpuCanPasteL());
-return err == KErrNone;
+return (err == KErrNone) && m_CcpuSupport;
 }
 // -----------------------------------------------------------------------------
 // CcpuPasteL
 //
 // DoCcpuCanPasteL
 //
 //
 // -----------------------------------------------------------------------------
 void  CWebFepTextEditor::DoCcpuCanPasteL() const
 {
 CClipboard* cb=CClipboard::NewForReadingL(CCoeEnv::Static()->FsSession());
 CleanupStack::PushL(cb);
 TStreamId streamId=cb->StreamDictionary().At(KClipboardUidTypePlainText);
 if (streamId==KNullStreamId)
 User::Leave(KErrNotFound);
 CleanupStack::PopAndDestroy();
 }
 // -----------------------------------------------------------------------------
 // HandleMaskedInsertText
 //
 //
 // -----------------------------------------------------------------------------
 void CWebFepTextEditor::HandleMaskedInsertText(WebCore::Frame *frame, const String& text)
 {
 TInt pos = DocumentLengthForFep();
 if (!pos) {
 }
 // -----------------------------------------------------------------------------
 // HandleMaskedDeleteText
 //
 //
 // -----------------------------------------------------------------------------
 void CWebFepTextEditor::HandleMaskedDeleteText(WebCore::Frame* frame)
 {
 TCursorSelection selection;
 GetCursorSelectionForFep(selection);
 }
 // -----------------------------------------------------------------------------
 // IsWapMaskedModeInput
 //
 //
 // -----------------------------------------------------------------------------
 bool CWebFepTextEditor::IsWapMaskedModeInput(WebCore::Frame* frame)
 {
 bool maskedInput(false);
 if (m_textFormatMask && frame->document() && frame->document()->focusedNode()) {
 RenderStyle* s = frame->document()->focusedNode()->renderStyle();
 if (s && (!s->wapInputFormat().isEmpty() || s->wapInputRequired())){
 maskedInput = true;
 }
 }
 return maskedInput;
 }
 // -----------------------------------------------------------------------------
 // EnableCcpu
 //
 //
 // -----------------------------------------------------------------------------
-void CWebFepTextEditor::EnableCcpu(TBool aSupport)
+void CWebFepTextEditor::EnableCcpuL()
 {
+CAknCcpuSupport* ccpu = NULL;
 CAknEdwinState* edwinState = static_cast<CAknEdwinState*>(this->State(KNullUid));
-if(aSupport)
+if ( edwinState && edwinState->MenuBar() && edwinState->MenuBar()->IsDisplayed() )
 {
-edwinState->SetCcpuState(this);
+return;
 }
-else
+ccpu = new(ELeave) CAknCcpuSupport(this);
+ccpu->SetMopParent(this);
+CleanupStack::PushL(ccpu);
+ccpu->ConstructL();
+CleanupStack::Pop(ccpu);
+delete m_CcpuSupport;
+m_CcpuSupport = ccpu;
+if (edwinState)
 {
-edwinState->SetCcpuState(NULL);
+edwinState->SetCcpuState(this);
-}
+edwinState->SetMenu();
+if (edwinState->MenuBar())
+edwinState->MenuBar()->SetEditMenuObserver( m_CcpuSupport );
+}
 }
 // -----------------------------------------------------------------------------
 // findPrevSiblingTextLen
 //
 }
 // -----------------------------------------------------------------------------
 // SetSCTAvailability
 //
 // Set availibility of the special character table.
 // -----------------------------------------------------------------------------
 void CWebFepTextEditor::setSCTAvailability(bool aAvailable)
 {
 if (m_ExtendedInputCapabilities) {
 TUint capabilities = m_ExtendedInputCapabilities->Capabilities();
 }
 m_ExtendedInputCapabilities->SetCapabilities(capabilities);
 }
 }
+// -----------------------------------------------------------------------------
+// IsLongKeyPress
+//
+// Called to know the status of the key pressed
+// -----------------------------------------------------------------------------
+TBool CWebFepTextEditor::IsLongKeyPress() const
+{
+return m_longKeyPress ;
+}
+TBool CWebFepTextEditor::IsInputElementFocused() const
+{
+Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();
+return ( frame && frame->document()->focusedNode() &&
+frame->document()->focusedNode()->hasTagName(HTMLNames::inputTag));
+}
+void CWebFepTextEditor::ReportEventL()
+{
+m_ExtendedInputCapabilities->ReportEventL(CAknExtendedInputCapabilities::
+MAknEventObserver::EPointerEventReceived, NULL );
+}
+TBool CWebFepTextEditor::inlineTextEditingStarted()
+{
+return m_inlineTextEditingStarted;
+}

branch	RCL_3
changeset 49	919f36ff910f
parent 48	79859ed3eea9
child 50	d96eed154187