dali-toolkit/internal/text/text-controller-event-handler.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/text/text-controller-event-handler.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dali/devel-api/adaptor-framework/clipboard-event-notifier.h>
  24 #include <dali/devel-api/adaptor-framework/key-devel.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/internal/text/text-controller-impl.h>
  28 #include <dali-toolkit/internal/text/text-editable-control-interface.h>
  29
  30 namespace
  31 {
  32
  33 #if defined(DEBUG_ENABLED)
  34 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
  35 #endif
  36
  37 const std::string KEY_C_NAME = "c";
  38 const std::string KEY_V_NAME = "v";
  39 const std::string KEY_X_NAME = "x";
  40 const std::string KEY_A_NAME = "a";
  41 const std::string KEY_INSERT_NAME = "Insert";
  42
  43 } // namespace
  44
  45 namespace Dali
  46 {
  47
  48 namespace Toolkit
  49 {
  50
  51 namespace Text
  52 {
  53
  54 void Controller::EventHandler::KeyboardFocusGainEvent(Controller& controller)
  55 {
  56   DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected KeyboardFocusGainEvent" );
  57
  58   if( NULL != controller.mImpl->mEventData )
  59   {
  60     if( ( EventData::INACTIVE == controller.mImpl->mEventData->mState ) ||
  61         ( EventData::INTERRUPTED == controller.mImpl->mEventData->mState ) )
  62     {
  63       controller.mImpl->ChangeState( EventData::EDITING );
  64       controller.mImpl->mEventData->mUpdateCursorPosition = true; //If editing started without tap event, cursor update must be triggered.
  65       controller.mImpl->mEventData->mUpdateInputStyle = true;
  66       controller.mImpl->mEventData->mScrollAfterUpdatePosition = true;
  67     }
  68     controller.mImpl->NotifyInputMethodContextMultiLineStatus();
  69     if( controller.mImpl->IsShowingPlaceholderText() )
  70     {
  71       // Show alternative placeholder-text when editing
  72       controller.ShowPlaceholderText();
  73     }
  74
  75     controller.mImpl->RequestRelayout();
  76   }
  77 }
  78
  79 void Controller::EventHandler::KeyboardFocusLostEvent(Controller& controller)
  80 {
  81   DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected KeyboardFocusLostEvent" );
  82
  83   if( NULL != controller.mImpl->mEventData )
  84   {
  85     if( EventData::INTERRUPTED != controller.mImpl->mEventData->mState )
  86     {
  87       controller.mImpl->ChangeState( EventData::INACTIVE );
  88
  89       if( !controller.mImpl->IsShowingRealText() )
  90       {
  91         // Revert to regular placeholder-text when not editing
  92         controller.ShowPlaceholderText();
  93       }
  94     }
  95   }
  96   controller.mImpl->RequestRelayout();
  97 }
  98
  99 bool Controller::EventHandler::KeyEvent(Controller& controller, const Dali::KeyEvent& keyEvent)
 100 {
 101   DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected KeyEvent" );
 102
 103   bool textChanged = false;
 104   bool relayoutNeeded = false;
 105
 106   if( ( NULL != controller.mImpl->mEventData ) &&
 107       ( keyEvent.GetState() == KeyEvent::DOWN ) )
 108   {
 109     int keyCode = keyEvent.GetKeyCode();
 110     const std::string& keyString = keyEvent.GetKeyString();
 111     const std::string keyName = keyEvent.GetKeyName();
 112     // Key will produce same logical-key value when ctrl
 113     // is down, regardless of language layout
 114     const std::string logicalKey = keyEvent.GetLogicalKey();
 115
 116     const bool isNullKey = ( 0 == keyCode ) && ( keyString.empty() );
 117
 118     // Pre-process to separate modifying events from non-modifying input events.
 119     if( isNullKey )
 120     {
 121       // In some platforms arrive key events with no key code.
 122       // Do nothing.
 123       return false;
 124     }
 125     else if( Dali::DALI_KEY_ESCAPE == keyCode || Dali::DALI_KEY_BACK == keyCode  || Dali::DALI_KEY_SEARCH == keyCode )
 126     {
 127       // Do nothing
 128       return false;
 129     }
 130     else if( ( Dali::DALI_KEY_CURSOR_LEFT  == keyCode ) ||
 131              ( Dali::DALI_KEY_CURSOR_RIGHT == keyCode ) ||
 132              ( Dali::DALI_KEY_CURSOR_UP    == keyCode ) ||
 133              ( Dali::DALI_KEY_CURSOR_DOWN  == keyCode ) )
 134     {
 135       // If don't have any text, do nothing.
 136       if( !controller.mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters )
 137       {
 138         return false;
 139       }
 140
 141       uint32_t cursorPosition = controller.mImpl->mEventData->mPrimaryCursorPosition;
 142       uint32_t numberOfCharacters = controller.mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
 143       uint32_t cursorLine = controller.mImpl->mModel->mVisualModel->GetLineOfCharacter( cursorPosition );
 144       uint32_t numberOfLines = controller.mImpl->mModel->GetNumberOfLines();
 145
 146       // Logic to determine whether this text control will lose focus or not.
 147       if( ( Dali::DALI_KEY_CURSOR_LEFT == keyCode && 0 == cursorPosition && !keyEvent.IsShiftModifier() ) ||
 148           ( Dali::DALI_KEY_CURSOR_RIGHT == keyCode && numberOfCharacters == cursorPosition && !keyEvent.IsShiftModifier() ) ||
 149           ( Dali::DALI_KEY_CURSOR_DOWN == keyCode && cursorLine == numberOfLines -1 ) ||
 150           ( Dali::DALI_KEY_CURSOR_DOWN == keyCode && numberOfCharacters == cursorPosition && cursorLine -1 == numberOfLines -1 ) ||
 151           ( Dali::DALI_KEY_CURSOR_UP == keyCode && cursorLine == 0 ) ||
 152           ( Dali::DALI_KEY_CURSOR_UP == keyCode && numberOfCharacters == cursorPosition && cursorLine == 1 ) )
 153       {
 154         // Release the active highlight.
 155         if( controller.mImpl->mEventData->mState == EventData::SELECTING )
 156         {
 157           controller.mImpl->ChangeState( EventData::EDITING );
 158
 159           // Update selection position.
 160           controller.mImpl->mEventData->mLeftSelectionPosition = controller.mImpl->mEventData->mPrimaryCursorPosition;
 161           controller.mImpl->mEventData->mRightSelectionPosition = controller.mImpl->mEventData->mPrimaryCursorPosition;
 162           controller.mImpl->mEventData->mUpdateCursorPosition = true;
 163           controller.mImpl->RequestRelayout();
 164         }
 165         return false;
 166       }
 167
 168       controller.mImpl->mEventData->mCheckScrollAmount = true;
 169       Event event( Event::CURSOR_KEY_EVENT );
 170       event.p1.mInt = keyCode;
 171       event.p2.mBool = keyEvent.IsShiftModifier();
 172       controller.mImpl->mEventData->mEventQueue.push_back( event );
 173
 174       // Will request for relayout.
 175       relayoutNeeded = true;
 176     }
 177     else if ( Dali::DevelKey::DALI_KEY_CONTROL_LEFT == keyCode || Dali::DevelKey::DALI_KEY_CONTROL_RIGHT == keyCode )
 178     {
 179       // Left or Right Control key event is received before Ctrl-C/V/X key event is received
 180       // If not handle it here, any selected text will be deleted
 181
 182       // Do nothing
 183       return false;
 184     }
 185     else if ( keyEvent.IsCtrlModifier() && !keyEvent.IsShiftModifier())
 186     {
 187       bool consumed = false;
 188       if (keyName == KEY_C_NAME || keyName == KEY_INSERT_NAME || logicalKey == KEY_C_NAME || logicalKey == KEY_INSERT_NAME)
 189       {
 190         // Ctrl-C or Ctrl+Insert to copy the selected text
 191         controller.TextPopupButtonTouched( Toolkit::TextSelectionPopup::COPY );
 192         consumed = true;
 193       }
 194       else if (keyName == KEY_V_NAME || logicalKey == KEY_V_NAME)
 195       {
 196         // Ctrl-V to paste the copied text
 197         controller.TextPopupButtonTouched( Toolkit::TextSelectionPopup::PASTE );
 198         consumed = true;
 199       }
 200       else if (keyName == KEY_X_NAME || logicalKey == KEY_X_NAME)
 201       {
 202         // Ctrl-X to cut the selected text
 203         controller.TextPopupButtonTouched( Toolkit::TextSelectionPopup::CUT );
 204         consumed = true;
 205       }
 206       else if (keyName == KEY_A_NAME || logicalKey == KEY_A_NAME)
 207       {
 208         // Ctrl-A to select All the text
 209         controller.TextPopupButtonTouched( Toolkit::TextSelectionPopup::SELECT_ALL );
 210         consumed = true;
 211       }
 212       return consumed;
 213     }
 214     else if( ( Dali::DALI_KEY_BACKSPACE == keyCode ) ||
 215              ( Dali::DevelKey::DALI_KEY_DELETE == keyCode ) )
 216     {
 217       textChanged = controller.DeleteEvent( keyCode );
 218
 219       // Will request for relayout.
 220       relayoutNeeded = true;
 221     }
 222     else if( IsKey( keyEvent, Dali::DALI_KEY_POWER ) ||
 223              IsKey( keyEvent, Dali::DALI_KEY_MENU ) ||
 224              IsKey( keyEvent, Dali::DALI_KEY_HOME ) )
 225     {
 226       // Power key/Menu/Home key behaviour does not allow edit mode to resume.
 227       controller.mImpl->ChangeState( EventData::INACTIVE );
 228
 229       // Will request for relayout.
 230       relayoutNeeded = true;
 231
 232       // This branch avoids calling the InsertText() method of the 'else' branch which can delete selected text.
 233     }
 234     else if( ( Dali::DALI_KEY_SHIFT_LEFT == keyCode ) || ( Dali::DALI_KEY_SHIFT_RIGHT == keyCode ) )
 235     {
 236       // DALI_KEY_SHIFT_LEFT or DALI_KEY_SHIFT_RIGHT is the key code for Shift. It's sent (by the InputMethodContext?) when the predictive text is enabled
 237       // and a character is typed after the type of a upper case latin character.
 238
 239       // Do nothing.
 240       return false;
 241     }
 242     else if( ( Dali::DALI_KEY_VOLUME_UP == keyCode ) || ( Dali::DALI_KEY_VOLUME_DOWN == keyCode ) )
 243     {
 244       // This branch avoids calling the InsertText() method of the 'else' branch which can delete selected text.
 245       // Do nothing.
 246       return false;
 247     }
 248     else
 249     {
 250       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p keyString %s\n", &controller, keyString.c_str() );
 251       if (!controller.IsEditable()) return false;
 252
 253       if( !keyString.empty() )
 254       {
 255         // InputMethodContext is no longer handling key-events
 256         controller.mImpl->ClearPreEditFlag();
 257
 258         controller.InsertText( keyString, COMMIT );
 259
 260         textChanged = true;
 261
 262         // Will request for relayout.
 263         relayoutNeeded = true;
 264       }
 265
 266     }
 267
 268     if ( ( controller.mImpl->mEventData->mState != EventData::INTERRUPTED ) &&
 269          ( controller.mImpl->mEventData->mState != EventData::INACTIVE ) &&
 270          ( !isNullKey ) &&
 271          ( Dali::DALI_KEY_SHIFT_LEFT != keyCode ) &&
 272          ( Dali::DALI_KEY_SHIFT_RIGHT != keyCode ) &&
 273          ( Dali::DALI_KEY_VOLUME_UP != keyCode ) &&
 274          ( Dali::DALI_KEY_VOLUME_DOWN != keyCode ) )
 275     {
 276       // Should not change the state if the key is the shift send by the InputMethodContext.
 277       // Otherwise, when the state is SELECTING the text controller can't send the right
 278       // surrounding info to the InputMethodContext.
 279       controller.mImpl->ChangeState( EventData::EDITING );
 280
 281       // Will request for relayout.
 282       relayoutNeeded = true;
 283     }
 284
 285     if( relayoutNeeded )
 286     {
 287       controller.mImpl->RequestRelayout();
 288     }
 289   }
 290
 291   if( textChanged &&
 292       ( NULL != controller.mImpl->mEditableControlInterface ) )
 293   {
 294     // Do this last since it provides callbacks into application code
 295     controller.mImpl->mEditableControlInterface->TextChanged();
 296   }
 297
 298   return true;
 299 }
 300
 301 void Controller::EventHandler::TapEvent(Controller& controller, unsigned int tapCount, float x, float y)
 302 {
 303   DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected TapEvent" );
 304
 305   if( NULL != controller.mImpl->mEventData )
 306   {
 307     DALI_LOG_INFO( gLogFilter, Debug::Concise, "TapEvent state:%d \n", controller.mImpl->mEventData->mState );
 308     EventData::State state( controller.mImpl->mEventData->mState );
 309     bool relayoutNeeded( false );   // to avoid unnecessary relayouts when tapping an empty text-field
 310
 311     if( controller.mImpl->IsClipboardVisible() )
 312     {
 313       if( EventData::INACTIVE == state || EventData::EDITING == state)
 314       {
 315         controller.mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );
 316       }
 317       relayoutNeeded = true;
 318     }
 319     else if( 1u == tapCount )
 320     {
 321       if( EventData::EDITING_WITH_POPUP == state || EventData::EDITING_WITH_PASTE_POPUP == state )
 322       {
 323         controller.mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );  // If Popup shown hide it here so can be shown again if required.
 324       }
 325
 326       if( controller.mImpl->IsShowingRealText() && ( EventData::INACTIVE != state ) )
 327       {
 328         controller.mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );
 329         relayoutNeeded = true;
 330       }
 331       else
 332       {
 333         if( controller.mImpl->IsShowingPlaceholderText() && !controller.mImpl->IsFocusedPlaceholderAvailable() )
 334         {
 335           // Hide placeholder text
 336           controller.ResetText();
 337         }
 338
 339         if( EventData::INACTIVE == state )
 340         {
 341           controller.mImpl->ChangeState( EventData::EDITING );
 342         }
 343         else if( !controller.mImpl->IsClipboardEmpty() )
 344         {
 345           controller.mImpl->ChangeState( EventData::EDITING_WITH_POPUP );
 346         }
 347         relayoutNeeded = true;
 348       }
 349     }
 350     else if( 2u == tapCount )
 351     {
 352       if( controller.mImpl->mEventData->mSelectionEnabled &&
 353           controller.mImpl->IsShowingRealText() )
 354       {
 355         relayoutNeeded = true;
 356         controller.mImpl->mEventData->mIsLeftHandleSelected = true;
 357         controller.mImpl->mEventData->mIsRightHandleSelected = true;
 358       }
 359     }
 360
 361     // Handles & cursors must be repositioned after Relayout() i.e. after the Model has been updated
 362     if( relayoutNeeded )
 363     {
 364       Event event( Event::TAP_EVENT );
 365       event.p1.mUint = tapCount;
 366       event.p2.mFloat = x;
 367       event.p3.mFloat = y;
 368       controller.mImpl->mEventData->mEventQueue.push_back( event );
 369
 370       controller.mImpl->RequestRelayout();
 371     }
 372   }
 373
 374   // Reset keyboard as tap event has occurred.
 375   controller.mImpl->ResetInputMethodContext();
 376 }
 377
 378 void Controller::EventHandler::PanEvent(Controller& controller, GestureState state, const Vector2& displacement)
 379 {
 380   DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected PanEvent" );
 381
 382   if( NULL != controller.mImpl->mEventData )
 383   {
 384     Event event( Event::PAN_EVENT );
 385     event.p1.mInt = static_cast<int>( state );
 386     event.p2.mFloat = displacement.x;
 387     event.p3.mFloat = displacement.y;
 388     controller.mImpl->mEventData->mEventQueue.push_back( event );
 389
 390     controller.mImpl->RequestRelayout();
 391   }
 392 }
 393
 394 void Controller::EventHandler::LongPressEvent(Controller& controller, GestureState state, float x, float y)
 395 {
 396   DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected LongPressEvent" );
 397
 398   if( ( state == GestureState::STARTED ) &&
 399       ( NULL != controller.mImpl->mEventData ) )
 400   {
 401     // The 1st long-press on inactive text-field is treated as tap
 402     if( EventData::INACTIVE == controller.mImpl->mEventData->mState )
 403     {
 404       controller.mImpl->ChangeState( EventData::EDITING );
 405
 406       Event event( Event::TAP_EVENT );
 407       event.p1.mUint = 1;
 408       event.p2.mFloat = x;
 409       event.p3.mFloat = y;
 410       controller.mImpl->mEventData->mEventQueue.push_back( event );
 411
 412       controller.mImpl->RequestRelayout();
 413     }
 414     else if( !controller.mImpl->IsShowingRealText() )
 415     {
 416       Event event( Event::LONG_PRESS_EVENT );
 417       event.p1.mInt = static_cast<int>( state );
 418       event.p2.mFloat = x;
 419       event.p3.mFloat = y;
 420       controller.mImpl->mEventData->mEventQueue.push_back( event );
 421       controller.mImpl->RequestRelayout();
 422     }
 423     else if( !controller.mImpl->IsClipboardVisible() )
 424     {
 425       // Reset the InputMethodContext to commit the pre-edit before selecting the text.
 426       controller.mImpl->ResetInputMethodContext();
 427
 428       Event event( Event::LONG_PRESS_EVENT );
 429       event.p1.mInt = static_cast<int>( state );
 430       event.p2.mFloat = x;
 431       event.p3.mFloat = y;
 432       controller.mImpl->mEventData->mEventQueue.push_back( event );
 433       controller.mImpl->RequestRelayout();
 434
 435       controller.mImpl->mEventData->mIsLeftHandleSelected = true;
 436       controller.mImpl->mEventData->mIsRightHandleSelected = true;
 437     }
 438   }
 439 }
 440
 441 void Controller::EventHandler::SelectEvent(Controller& controller, float x, float y, SelectionType selectType)
 442 {
 443   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::SelectEvent\n" );
 444
 445   if( NULL != controller.mImpl->mEventData )
 446   {
 447     if( selectType == SelectionType::ALL )
 448     {
 449       Event event( Event::SELECT_ALL );
 450       controller.mImpl->mEventData->mEventQueue.push_back( event );
 451     }
 452     else if( selectType == SelectionType::NONE )
 453     {
 454       Event event( Event::SELECT_NONE );
 455       controller.mImpl->mEventData->mEventQueue.push_back( event );
 456     }
 457     else
 458     {
 459       Event event( Event::SELECT );
 460       event.p2.mFloat = x;
 461       event.p3.mFloat = y;
 462       controller.mImpl->mEventData->mEventQueue.push_back( event );
 463     }
 464
 465     controller.mImpl->mEventData->mCheckScrollAmount = true;
 466     controller.mImpl->mEventData->mIsLeftHandleSelected = true;
 467     controller.mImpl->mEventData->mIsRightHandleSelected = true;
 468     controller.mImpl->RequestRelayout();
 469   }
 470 }
 471
 472 void Controller::EventHandler::ProcessModifyEvents(Controller& controller)
 473 {
 474   Vector<ModifyEvent>& events = controller.mImpl->mModifyEvents;
 475
 476   if( 0u == events.Count() )
 477   {
 478     // Nothing to do.
 479     return;
 480   }
 481
 482   for( Vector<ModifyEvent>::ConstIterator it = events.Begin(),
 483          endIt = events.End();
 484        it != endIt;
 485        ++it )
 486   {
 487     const ModifyEvent& event = *it;
 488
 489     if( ModifyEvent::TEXT_REPLACED == event.type )
 490     {
 491       // A (single) replace event should come first, otherwise we wasted time processing NOOP events
 492       DALI_ASSERT_DEBUG( it == events.Begin() && "Unexpected TEXT_REPLACED event" );
 493
 494       controller.TextReplacedEvent();
 495     }
 496     else if( ModifyEvent::TEXT_INSERTED == event.type )
 497     {
 498       controller.TextInsertedEvent();
 499     }
 500     else if( ModifyEvent::TEXT_DELETED == event.type )
 501     {
 502       // Placeholder-text cannot be deleted
 503       if( !controller.mImpl->IsShowingPlaceholderText() )
 504       {
 505         controller.TextDeletedEvent();
 506       }
 507     }
 508   }
 509
 510   if( NULL != controller.mImpl->mEventData )
 511   {
 512     // When the text is being modified, delay cursor blinking
 513     controller.mImpl->mEventData->mDecorator->DelayCursorBlink();
 514
 515     // Update selection position after modifying the text
 516     controller.mImpl->mEventData->mLeftSelectionPosition = controller.mImpl->mEventData->mPrimaryCursorPosition;
 517     controller.mImpl->mEventData->mRightSelectionPosition = controller.mImpl->mEventData->mPrimaryCursorPosition;
 518   }
 519
 520   // DISCARD temporary text
 521   events.Clear();
 522 }
 523
 524 void Controller::EventHandler::TextReplacedEvent(Controller& controller)
 525 {
 526   // The natural size needs to be re-calculated.
 527   controller.mImpl->mRecalculateNaturalSize = true;
 528
 529   // The text direction needs to be updated.
 530   controller.mImpl->mUpdateTextDirection = true;
 531
 532   // Apply modifications to the model
 533   controller.mImpl->mOperationsPending = ALL_OPERATIONS;
 534 }
 535
 536 void Controller::EventHandler::TextInsertedEvent(Controller& controller)
 537 {
 538   DALI_ASSERT_DEBUG( NULL != controller.mImpl->mEventData && "Unexpected TextInsertedEvent" );
 539
 540   if( NULL == controller.mImpl->mEventData )
 541   {
 542     return;
 543   }
 544
 545   controller.mImpl->mEventData->mCheckScrollAmount = true;
 546
 547   // The natural size needs to be re-calculated.
 548   controller.mImpl->mRecalculateNaturalSize = true;
 549
 550   // The text direction needs to be updated.
 551   controller.mImpl->mUpdateTextDirection = true;
 552
 553   // Apply modifications to the model; TODO - Optimize this
 554   controller.mImpl->mOperationsPending = ALL_OPERATIONS;
 555 }
 556
 557 void Controller::EventHandler::TextDeletedEvent(Controller& controller)
 558 {
 559   DALI_ASSERT_DEBUG( NULL != controller.mImpl->mEventData && "Unexpected TextDeletedEvent" );
 560
 561   if( NULL == controller.mImpl->mEventData )
 562   {
 563     return;
 564   }
 565
 566   if (!controller.IsEditable()) return;
 567
 568   controller.mImpl->mEventData->mCheckScrollAmount = true;
 569
 570   // The natural size needs to be re-calculated.
 571   controller.mImpl->mRecalculateNaturalSize = true;
 572
 573   // The text direction needs to be updated.
 574   controller.mImpl->mUpdateTextDirection = true;
 575
 576   // Apply modifications to the model; TODO - Optimize this
 577   controller.mImpl->mOperationsPending = ALL_OPERATIONS;
 578 }
 579
 580 bool Controller::EventHandler::DeleteEvent(Controller& controller, int keyCode)
 581 {
 582   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p KeyCode : %d \n", &controller, keyCode );
 583
 584   bool removed = false;
 585
 586   if( NULL == controller.mImpl->mEventData )
 587   {
 588     return removed;
 589   }
 590
 591   if (!controller.IsEditable()) return false;
 592
 593   // InputMethodContext is no longer handling key-events
 594   controller.mImpl->ClearPreEditFlag();
 595
 596   if( EventData::SELECTING == controller.mImpl->mEventData->mState )
 597   {
 598     removed = controller.RemoveSelectedText();
 599   }
 600   else if( ( controller.mImpl->mEventData->mPrimaryCursorPosition > 0 ) && ( keyCode == Dali::DALI_KEY_BACKSPACE) )
 601   {
 602     // Remove the character before the current cursor position
 603     removed = controller.RemoveText( -1,
 604                           1,
 605                           UPDATE_INPUT_STYLE );
 606   }
 607   else if( keyCode == Dali::DevelKey::DALI_KEY_DELETE )
 608   {
 609     // Remove the character after the current cursor position
 610     removed = controller.RemoveText( 0,
 611                           1,
 612                           UPDATE_INPUT_STYLE );
 613   }
 614
 615   if( removed )
 616   {
 617     if( ( 0u != controller.mImpl->mModel->mLogicalModel->mText.Count() ) ||
 618         !controller.mImpl->IsPlaceholderAvailable() )
 619     {
 620       controller.mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
 621     }
 622     else
 623     {
 624       controller.ShowPlaceholderText();
 625     }
 626     controller.mImpl->mEventData->mUpdateCursorPosition = true;
 627     controller.mImpl->mEventData->mScrollAfterDelete = true;
 628   }
 629
 630   return removed;
 631 }
 632
 633 InputMethodContext::CallbackData Controller::EventHandler::OnInputMethodContextEvent(Controller& controller, InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
 634 {
 635   // Whether the text needs to be relaid-out.
 636   bool requestRelayout = false;
 637
 638   // Whether to retrieve the text and cursor position to be sent to the InputMethodContext.
 639   bool retrieveText = false;
 640   bool retrieveCursor = false;
 641
 642   switch( inputMethodContextEvent.eventName )
 643   {
 644     case InputMethodContext::COMMIT:
 645     {
 646       controller.InsertText( inputMethodContextEvent.predictiveString, Text::Controller::COMMIT );
 647       requestRelayout = true;
 648       retrieveCursor = true;
 649       break;
 650     }
 651     case InputMethodContext::PRE_EDIT:
 652     {
 653       controller.InsertText( inputMethodContextEvent.predictiveString, Text::Controller::PRE_EDIT );
 654       requestRelayout = true;
 655       retrieveCursor = true;
 656       break;
 657     }
 658     case InputMethodContext::DELETE_SURROUNDING:
 659     {
 660       const bool textDeleted = controller.RemoveText( inputMethodContextEvent.cursorOffset,
 661                                                       inputMethodContextEvent.numberOfChars,
 662                                                       DONT_UPDATE_INPUT_STYLE );
 663
 664       if( textDeleted )
 665       {
 666         if( ( 0u != controller.mImpl->mModel->mLogicalModel->mText.Count() ) ||
 667             !controller.mImpl->IsPlaceholderAvailable() )
 668         {
 669           controller.mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
 670         }
 671         else
 672         {
 673           controller.ShowPlaceholderText();
 674         }
 675         controller.mImpl->mEventData->mUpdateCursorPosition = true;
 676         controller.mImpl->mEventData->mScrollAfterDelete = true;
 677
 678         requestRelayout = true;
 679       }
 680       break;
 681     }
 682     case InputMethodContext::GET_SURROUNDING:
 683     {
 684       retrieveText = true;
 685       retrieveCursor = true;
 686       break;
 687     }
 688     case InputMethodContext::PRIVATE_COMMAND:
 689     {
 690       // PRIVATECOMMAND event is just for getting the private command message
 691       retrieveText = true;
 692       retrieveCursor = true;
 693       break;
 694     }
 695     case InputMethodContext::VOID:
 696     {
 697       // do nothing
 698       break;
 699     }
 700   } // end switch
 701
 702   if( requestRelayout )
 703   {
 704     controller.mImpl->mOperationsPending = ALL_OPERATIONS;
 705     controller.mImpl->RequestRelayout();
 706   }
 707
 708   std::string text;
 709   CharacterIndex cursorPosition = 0u;
 710   Length numberOfWhiteSpaces = 0u;
 711
 712   if( retrieveCursor )
 713   {
 714     numberOfWhiteSpaces = controller.mImpl->GetNumberOfWhiteSpaces( 0u );
 715
 716     cursorPosition = controller.mImpl->GetLogicalCursorPosition();
 717
 718     if( cursorPosition < numberOfWhiteSpaces )
 719     {
 720       cursorPosition = 0u;
 721     }
 722     else
 723     {
 724       cursorPosition -= numberOfWhiteSpaces;
 725     }
 726   }
 727
 728   if( retrieveText )
 729   {
 730     if( !controller.mImpl->IsShowingPlaceholderText() )
 731     {
 732       // Retrieves the normal text string.
 733       controller.mImpl->GetText( numberOfWhiteSpaces, text );
 734     }
 735     else
 736     {
 737       // When the current text is Placeholder Text, the surrounding text should be empty string.
 738       // It means DALi should send empty string ("") to IME.
 739       text = "";
 740     }
 741   }
 742
 743   InputMethodContext::CallbackData callbackData( ( retrieveText || retrieveCursor ), cursorPosition, text, false );
 744
 745   if( requestRelayout &&
 746       ( NULL != controller.mImpl->mEditableControlInterface ) )
 747   {
 748     // Do this last since it provides callbacks into application code
 749     controller.mImpl->mEditableControlInterface->TextChanged();
 750   }
 751
 752   return callbackData;
 753 }
 754
 755 void Controller::EventHandler::PasteClipboardItemEvent(Controller& controller)
 756 {
 757   // Retrieve the clipboard contents first
 758   ClipboardEventNotifier notifier( ClipboardEventNotifier::Get() );
 759   std::string stringToPaste( notifier.GetContent() );
 760
 761   // Commit the current pre-edit text; the contents of the clipboard should be appended
 762   controller.mImpl->ResetInputMethodContext();
 763
 764   // Temporary disable hiding clipboard
 765   controller.mImpl->SetClipboardHideEnable( false );
 766
 767   // Paste
 768   controller.PasteText( stringToPaste );
 769
 770   controller.mImpl->SetClipboardHideEnable( true );
 771 }
 772
 773 void Controller::EventHandler::DecorationEvent(Controller& controller, HandleType handleType, HandleState state, float x, float y)
 774 {
 775   DALI_ASSERT_DEBUG( controller.mImpl->mEventData && "Unexpected DecorationEvent" );
 776
 777   if( NULL != controller.mImpl->mEventData )
 778   {
 779     switch( handleType )
 780     {
 781       case GRAB_HANDLE:
 782       {
 783         Event event( Event::GRAB_HANDLE_EVENT );
 784         event.p1.mUint  = state;
 785         event.p2.mFloat = x;
 786         event.p3.mFloat = y;
 787
 788         controller.mImpl->mEventData->mEventQueue.push_back( event );
 789         break;
 790       }
 791       case LEFT_SELECTION_HANDLE:
 792       {
 793         Event event( Event::LEFT_SELECTION_HANDLE_EVENT );
 794         event.p1.mUint  = state;
 795         event.p2.mFloat = x;
 796         event.p3.mFloat = y;
 797
 798         controller.mImpl->mEventData->mEventQueue.push_back( event );
 799         break;
 800       }
 801       case RIGHT_SELECTION_HANDLE:
 802       {
 803         Event event( Event::RIGHT_SELECTION_HANDLE_EVENT );
 804         event.p1.mUint  = state;
 805         event.p2.mFloat = x;
 806         event.p3.mFloat = y;
 807
 808         controller.mImpl->mEventData->mEventQueue.push_back( event );
 809         break;
 810       }
 811       case LEFT_SELECTION_HANDLE_MARKER:
 812       case RIGHT_SELECTION_HANDLE_MARKER:
 813       {
 814         // Markers do not move the handles.
 815         break;
 816       }
 817       case HANDLE_TYPE_COUNT:
 818       {
 819         DALI_ASSERT_DEBUG( !"Controller::HandleEvent. Unexpected handle type" );
 820       }
 821     }
 822
 823     controller.mImpl->RequestRelayout();
 824   }
 825 }
 826
 827 void Controller::EventHandler::TextPopupButtonTouched(Controller& controller, Dali::Toolkit::TextSelectionPopup::Buttons button)
 828 {
 829   if( NULL == controller.mImpl->mEventData )
 830   {
 831     return;
 832   }
 833
 834   switch( button )
 835   {
 836     case Toolkit::TextSelectionPopup::CUT:
 837     {
 838       if (!controller.IsEditable()) return;
 839       controller.mImpl->SendSelectionToClipboard( true ); // Synchronous call to modify text
 840       controller.mImpl->mOperationsPending = ALL_OPERATIONS;
 841
 842       if( ( 0u != controller.mImpl->mModel->mLogicalModel->mText.Count() ) ||
 843           !controller.mImpl->IsPlaceholderAvailable() )
 844       {
 845         controller.mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
 846       }
 847       else
 848       {
 849         controller.ShowPlaceholderText();
 850       }
 851
 852       controller.mImpl->mEventData->mUpdateCursorPosition = true;
 853       controller.mImpl->mEventData->mScrollAfterDelete = true;
 854
 855       controller.mImpl->RequestRelayout();
 856
 857       if( NULL != controller.mImpl->mEditableControlInterface )
 858       {
 859         controller.mImpl->mEditableControlInterface->TextChanged();
 860       }
 861       break;
 862     }
 863     case Toolkit::TextSelectionPopup::COPY:
 864     {
 865       controller.mImpl->SendSelectionToClipboard( false ); // Text not modified
 866
 867       controller.mImpl->mEventData->mUpdateCursorPosition = true;
 868
 869       controller.mImpl->RequestRelayout(); // Cursor, Handles, Selection Highlight, Popup
 870       break;
 871     }
 872     case Toolkit::TextSelectionPopup::PASTE:
 873     {
 874       controller.mImpl->RequestGetTextFromClipboard(); // Request clipboard service to retrieve an item
 875       break;
 876     }
 877     case Toolkit::TextSelectionPopup::SELECT:
 878     {
 879       const Vector2& currentCursorPosition = controller.mImpl->mEventData->mDecorator->GetPosition( PRIMARY_CURSOR );
 880
 881       if( controller.mImpl->mEventData->mSelectionEnabled )
 882       {
 883         // Creates a SELECT event.
 884         controller.SelectEvent( currentCursorPosition.x, currentCursorPosition.y, SelectionType::INTERACTIVE );
 885       }
 886       break;
 887     }
 888     case Toolkit::TextSelectionPopup::SELECT_ALL:
 889     {
 890       // Creates a SELECT_ALL event
 891       controller.SelectEvent( 0.f, 0.f, SelectionType::ALL );
 892       break;
 893     }
 894     case Toolkit::TextSelectionPopup::CLIPBOARD:
 895     {
 896       controller.mImpl->ShowClipboard();
 897       break;
 898     }
 899     case Toolkit::TextSelectionPopup::NONE:
 900     {
 901       // Nothing to do.
 902       break;
 903     }
 904   }
 905 }
 906
 907 } // namespace Text
 908
 909 } // namespace Toolkit
 910
 911 } // namespace Dali