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

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