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();
 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(keyCode == Dali::DevelKey::DALI_KEY_DELETE)
 603   {
 604     // Remove the character after the current cursor position
 605     removed = controller.RemoveText(0,
 606                                     1,
 607                                     UPDATE_INPUT_STYLE);
 608   }
 609
 610   if(removed)
 611   {
 612     if((0u != controller.mImpl->mModel->mLogicalModel->mText.Count()) ||
 613        !controller.mImpl->IsPlaceholderAvailable())
 614     {
 615       controller.mImpl->QueueModifyEvent(ModifyEvent::TEXT_DELETED);
 616     }
 617     else
 618     {
 619       controller.ShowPlaceholderText();
 620     }
 621     controller.mImpl->mEventData->mUpdateCursorPosition = true;
 622     controller.mImpl->mEventData->mScrollAfterDelete    = true;
 623   }
 624
 625   return removed;
 626 }
 627
 628 InputMethodContext::CallbackData Controller::EventHandler::OnInputMethodContextEvent(Controller& controller, InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
 629 {
 630   // Whether the text needs to be relaid-out.
 631   bool requestRelayout = false;
 632
 633   // Whether to retrieve the text and cursor position to be sent to the InputMethodContext.
 634   bool retrieveText   = false;
 635   bool retrieveCursor = false;
 636
 637   switch(inputMethodContextEvent.eventName)
 638   {
 639     case InputMethodContext::COMMIT:
 640     {
 641       controller.InsertText(inputMethodContextEvent.predictiveString, Text::Controller::COMMIT);
 642       requestRelayout = true;
 643       retrieveCursor  = true;
 644       break;
 645     }
 646     case InputMethodContext::PRE_EDIT:
 647     {
 648       controller.InsertText(inputMethodContextEvent.predictiveString, Text::Controller::PRE_EDIT);
 649       requestRelayout = true;
 650       retrieveCursor  = true;
 651       break;
 652     }
 653     case InputMethodContext::DELETE_SURROUNDING:
 654     {
 655       const bool textDeleted = controller.RemoveText(inputMethodContextEvent.cursorOffset,
 656                                                      inputMethodContextEvent.numberOfChars,
 657                                                      DONT_UPDATE_INPUT_STYLE);
 658
 659       if(textDeleted)
 660       {
 661         if((0u != controller.mImpl->mModel->mLogicalModel->mText.Count()) ||
 662            !controller.mImpl->IsPlaceholderAvailable())
 663         {
 664           controller.mImpl->QueueModifyEvent(ModifyEvent::TEXT_DELETED);
 665         }
 666         else
 667         {
 668           controller.ShowPlaceholderText();
 669         }
 670         controller.mImpl->mEventData->mUpdateCursorPosition = true;
 671         controller.mImpl->mEventData->mScrollAfterDelete    = true;
 672
 673         requestRelayout = true;
 674       }
 675       break;
 676     }
 677     case InputMethodContext::GET_SURROUNDING:
 678     {
 679       retrieveText   = true;
 680       retrieveCursor = true;
 681       break;
 682     }
 683     case InputMethodContext::PRIVATE_COMMAND:
 684     {
 685       // PRIVATECOMMAND event is just for getting the private command message
 686       retrieveText   = true;
 687       retrieveCursor = true;
 688       break;
 689     }
 690     case InputMethodContext::VOID:
 691     {
 692       // do nothing
 693       break;
 694     }
 695   } // end switch
 696
 697   if(requestRelayout)
 698   {
 699     controller.mImpl->mOperationsPending = ALL_OPERATIONS;
 700     controller.mImpl->RequestRelayout();
 701   }
 702
 703   std::string    text;
 704   CharacterIndex cursorPosition      = 0u;
 705   Length         numberOfWhiteSpaces = 0u;
 706
 707   if(retrieveCursor)
 708   {
 709     numberOfWhiteSpaces = controller.mImpl->GetNumberOfWhiteSpaces(0u);
 710
 711     cursorPosition = controller.mImpl->GetLogicalCursorPosition();
 712
 713     if(cursorPosition < numberOfWhiteSpaces)
 714     {
 715       cursorPosition = 0u;
 716     }
 717     else
 718     {
 719       cursorPosition -= numberOfWhiteSpaces;
 720     }
 721   }
 722
 723   if(retrieveText)
 724   {
 725     if(!controller.mImpl->IsShowingPlaceholderText())
 726     {
 727       // Retrieves the normal text string.
 728       controller.mImpl->GetText(numberOfWhiteSpaces, text);
 729     }
 730     else
 731     {
 732       // When the current text is Placeholder Text, the surrounding text should be empty string.
 733       // It means DALi should send empty string ("") to IME.
 734       text = "";
 735     }
 736   }
 737
 738   InputMethodContext::CallbackData callbackData((retrieveText || retrieveCursor), cursorPosition, text, false);
 739
 740   if(requestRelayout &&
 741      (NULL != controller.mImpl->mEditableControlInterface))
 742   {
 743     // Do this last since it provides callbacks into application code
 744     controller.mImpl->mEditableControlInterface->TextChanged();
 745   }
 746
 747   return callbackData;
 748 }
 749
 750 void Controller::EventHandler::PasteClipboardItemEvent(Controller& controller)
 751 {
 752   // Retrieve the clipboard contents first
 753   ClipboardEventNotifier notifier(ClipboardEventNotifier::Get());
 754   std::string            stringToPaste(notifier.GetContent());
 755
 756   // Commit the current pre-edit text; the contents of the clipboard should be appended
 757   controller.mImpl->ResetInputMethodContext();
 758
 759   // Temporary disable hiding clipboard
 760   controller.mImpl->SetClipboardHideEnable(false);
 761
 762   // Paste
 763   controller.PasteText(stringToPaste);
 764
 765   controller.mImpl->SetClipboardHideEnable(true);
 766 }
 767
 768 void Controller::EventHandler::DecorationEvent(Controller& controller, HandleType handleType, HandleState state, float x, float y)
 769 {
 770   DALI_ASSERT_DEBUG(controller.mImpl->mEventData && "Unexpected DecorationEvent");
 771
 772   if(NULL != controller.mImpl->mEventData)
 773   {
 774     switch(handleType)
 775     {
 776       case GRAB_HANDLE:
 777       {
 778         Event event(Event::GRAB_HANDLE_EVENT);
 779         event.p1.mUint  = state;
 780         event.p2.mFloat = x;
 781         event.p3.mFloat = y;
 782
 783         controller.mImpl->mEventData->mEventQueue.push_back(event);
 784         break;
 785       }
 786       case LEFT_SELECTION_HANDLE:
 787       {
 788         Event event(Event::LEFT_SELECTION_HANDLE_EVENT);
 789         event.p1.mUint  = state;
 790         event.p2.mFloat = x;
 791         event.p3.mFloat = y;
 792
 793         controller.mImpl->mEventData->mEventQueue.push_back(event);
 794         break;
 795       }
 796       case RIGHT_SELECTION_HANDLE:
 797       {
 798         Event event(Event::RIGHT_SELECTION_HANDLE_EVENT);
 799         event.p1.mUint  = state;
 800         event.p2.mFloat = x;
 801         event.p3.mFloat = y;
 802
 803         controller.mImpl->mEventData->mEventQueue.push_back(event);
 804         break;
 805       }
 806       case LEFT_SELECTION_HANDLE_MARKER:
 807       case RIGHT_SELECTION_HANDLE_MARKER:
 808       {
 809         // Markers do not move the handles.
 810         break;
 811       }
 812       case HANDLE_TYPE_COUNT:
 813       {
 814         DALI_ASSERT_DEBUG(!"Controller::HandleEvent. Unexpected handle type");
 815       }
 816     }
 817
 818     controller.mImpl->RequestRelayout();
 819   }
 820 }
 821
 822 void Controller::EventHandler::TextPopupButtonTouched(Controller& controller, Dali::Toolkit::TextSelectionPopup::Buttons button)
 823 {
 824   if(NULL == controller.mImpl->mEventData)
 825   {
 826     return;
 827   }
 828
 829   switch(button)
 830   {
 831     case Toolkit::TextSelectionPopup::CUT:
 832     {
 833       if(!controller.IsEditable()) return;
 834       controller.mImpl->SendSelectionToClipboard(true); // Synchronous call to modify text
 835       controller.mImpl->mOperationsPending = ALL_OPERATIONS;
 836
 837       if((0u != controller.mImpl->mModel->mLogicalModel->mText.Count()) ||
 838          !controller.mImpl->IsPlaceholderAvailable())
 839       {
 840         controller.mImpl->QueueModifyEvent(ModifyEvent::TEXT_DELETED);
 841       }
 842       else
 843       {
 844         controller.ShowPlaceholderText();
 845       }
 846
 847       controller.mImpl->mEventData->mUpdateCursorPosition = true;
 848       controller.mImpl->mEventData->mScrollAfterDelete    = true;
 849
 850       controller.mImpl->RequestRelayout();
 851
 852       if(NULL != controller.mImpl->mEditableControlInterface)
 853       {
 854         controller.mImpl->mEditableControlInterface->TextChanged();
 855       }
 856       break;
 857     }
 858     case Toolkit::TextSelectionPopup::COPY:
 859     {
 860       controller.mImpl->SendSelectionToClipboard(false); // Text not modified
 861
 862       controller.mImpl->mEventData->mUpdateCursorPosition = true;
 863
 864       controller.mImpl->RequestRelayout(); // Cursor, Handles, Selection Highlight, Popup
 865       break;
 866     }
 867     case Toolkit::TextSelectionPopup::PASTE:
 868     {
 869       controller.mImpl->RequestGetTextFromClipboard(); // Request clipboard service to retrieve an item
 870       break;
 871     }
 872     case Toolkit::TextSelectionPopup::SELECT:
 873     {
 874       const Vector2& currentCursorPosition = controller.mImpl->mEventData->mDecorator->GetPosition(PRIMARY_CURSOR);
 875
 876       if(controller.mImpl->mEventData->mSelectionEnabled)
 877       {
 878         // Creates a SELECT event.
 879         controller.SelectEvent(currentCursorPosition.x, currentCursorPosition.y, SelectionType::INTERACTIVE);
 880       }
 881       break;
 882     }
 883     case Toolkit::TextSelectionPopup::SELECT_ALL:
 884     {
 885       // Creates a SELECT_ALL event
 886       controller.SelectEvent(0.f, 0.f, SelectionType::ALL);
 887       break;
 888     }
 889     case Toolkit::TextSelectionPopup::CLIPBOARD:
 890     {
 891       controller.mImpl->ShowClipboard();
 892       break;
 893     }
 894     case Toolkit::TextSelectionPopup::NONE:
 895     {
 896       // Nothing to do.
 897       break;
 898     }
 899   }
 900 }
 901
 902 } // namespace Text
 903
 904 } // namespace Toolkit
 905
 906 } // namespace Dali