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

   1 /*
   2  * Copyright (c) 2015 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.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <limits>
  23 #include <dali/public-api/adaptor-framework/key.h>
  24 #include <dali/integration-api/debug.h>
  25 #include <dali/devel-api/adaptor-framework/clipboard-event-notifier.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-toolkit/internal/text/bidirectional-support.h>
  29 #include <dali-toolkit/internal/text/character-set-conversion.h>
  30 #include <dali-toolkit/internal/text/layouts/layout-parameters.h>
  31 #include <dali-toolkit/internal/text/text-controller-impl.h>
  32
  33 namespace
  34 {
  35
  36 #if defined(DEBUG_ENABLED)
  37   Debug::Filter* gLogFilter = Debug::Filter::New(Debug::Verbose, true, "LOG_TEXT_CONTROLS");
  38 #endif
  39
  40 const float MAX_FLOAT = std::numeric_limits<float>::max();
  41
  42 const std::string EMPTY_STRING("");
  43
  44 float ConvertToEven( float value )
  45 {
  46   int intValue(static_cast<int>( value ));
  47   return static_cast<float>(intValue % 2 == 0) ? intValue : (intValue + 1);
  48 }
  49
  50 } // namespace
  51
  52 namespace Dali
  53 {
  54
  55 namespace Toolkit
  56 {
  57
  58 namespace Text
  59 {
  60
  61 ControllerPtr Controller::New( ControlInterface& controlInterface )
  62 {
  63   return ControllerPtr( new Controller( controlInterface ) );
  64 }
  65
  66 void Controller::EnableTextInput( DecoratorPtr decorator )
  67 {
  68   if( !mImpl->mEventData )
  69   {
  70     mImpl->mEventData = new EventData( decorator );
  71   }
  72 }
  73
  74 void Controller::SetText( const std::string& text )
  75 {
  76   // Remove the previously set text
  77   ResetText();
  78
  79   CharacterIndex lastCursorIndex = 0u;
  80
  81   if( mImpl->mEventData )
  82   {
  83     // If popup shown then hide it by switching to Editing state
  84     if ( EventData::SELECTING == mImpl->mEventData->mState ||
  85          EventData::SELECTION_CHANGED == mImpl->mEventData->mState ||
  86          EventData::EDITING_WITH_POPUP == mImpl->mEventData->mState )
  87     {
  88       mImpl->ChangeState( EventData::EDITING );
  89     }
  90   }
  91
  92   if( !text.empty() )
  93   {
  94     //  Convert text into UTF-32
  95     Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
  96     utf32Characters.Resize( text.size() );
  97
  98     // This is a bit horrible but std::string returns a (signed) char*
  99     const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
 100
 101     // Transform a text array encoded in utf8 into an array encoded in utf32.
 102     // It returns the actual number of characters.
 103     Length characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
 104     utf32Characters.Resize( characterCount );
 105
 106     DALI_ASSERT_DEBUG( text.size() >= characterCount && "Invalid UTF32 conversion length" );
 107     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::SetText %p UTF8 size %d, UTF32 size %d\n", this, text.size(), mImpl->mLogicalModel->mText.Count() );
 108
 109     // To reset the cursor position
 110     lastCursorIndex = characterCount;
 111
 112     // Update the rest of the model during size negotiation
 113     mImpl->QueueModifyEvent( ModifyEvent::TEXT_REPLACED );
 114
 115     // The natural size needs to be re-calculated.
 116     mImpl->mRecalculateNaturalSize = true;
 117
 118     // Apply modifications to the model
 119     mImpl->mOperationsPending = ALL_OPERATIONS;
 120   }
 121   else
 122   {
 123     ShowPlaceholderText();
 124   }
 125
 126   // Resets the cursor position.
 127   ResetCursorPosition( lastCursorIndex );
 128
 129   // Scrolls the text to make the cursor visible.
 130   ResetScrollPosition();
 131
 132   mImpl->RequestRelayout();
 133
 134   if( mImpl->mEventData )
 135   {
 136     // Cancel previously queued events
 137     mImpl->mEventData->mEventQueue.clear();
 138   }
 139
 140   // Reset keyboard as text changed
 141   mImpl->ResetImfManager();
 142
 143   // Do this last since it provides callbacks into application code
 144   mImpl->mControlInterface.TextChanged();
 145 }
 146
 147 void Controller::GetText( std::string& text ) const
 148 {
 149   if( ! mImpl->IsShowingPlaceholderText() )
 150   {
 151     Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
 152
 153     if( 0u != utf32Characters.Count() )
 154     {
 155       Utf32ToUtf8( &utf32Characters[0], utf32Characters.Count(), text );
 156     }
 157   }
 158   else
 159   {
 160     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::GetText %p empty (but showing placeholder)\n", this );
 161   }
 162 }
 163
 164 unsigned int Controller::GetLogicalCursorPosition() const
 165 {
 166   if( mImpl->mEventData )
 167   {
 168     return mImpl->mEventData->mPrimaryCursorPosition;
 169   }
 170
 171   return 0u;
 172 }
 173
 174 void Controller::SetPlaceholderText( PlaceholderType type, const std::string& text )
 175 {
 176   if( mImpl->mEventData )
 177   {
 178     if( PLACEHOLDER_TYPE_INACTIVE == type )
 179     {
 180       mImpl->mEventData->mPlaceholderTextInactive = text;
 181     }
 182     else
 183     {
 184       mImpl->mEventData->mPlaceholderTextActive = text;
 185     }
 186
 187     // Update placeholder if there is no text
 188     if( mImpl->IsShowingPlaceholderText() ||
 189         0u == mImpl->mLogicalModel->mText.Count() )
 190     {
 191       ShowPlaceholderText();
 192     }
 193   }
 194 }
 195
 196 void Controller::GetPlaceholderText( PlaceholderType type, std::string& text ) const
 197 {
 198   if( mImpl->mEventData )
 199   {
 200     if( PLACEHOLDER_TYPE_INACTIVE == type )
 201     {
 202       text = mImpl->mEventData->mPlaceholderTextInactive;
 203     }
 204     else
 205     {
 206       text = mImpl->mEventData->mPlaceholderTextActive;
 207     }
 208   }
 209 }
 210
 211 void Controller::SetMaximumNumberOfCharacters( int maxCharacters )
 212 {
 213   if ( maxCharacters >= 0 )
 214   {
 215     mImpl->mMaximumNumberOfCharacters = maxCharacters;
 216   }
 217 }
 218
 219 int Controller::GetMaximumNumberOfCharacters()
 220 {
 221   return mImpl->mMaximumNumberOfCharacters;
 222 }
 223
 224 void Controller::SetDefaultFontFamily( const std::string& defaultFontFamily )
 225 {
 226   if( !mImpl->mFontDefaults )
 227   {
 228     mImpl->mFontDefaults = new FontDefaults();
 229   }
 230
 231   mImpl->mFontDefaults->mDefaultFontFamily = defaultFontFamily;
 232
 233   // Clear the font-specific data
 234   ClearFontData();
 235
 236   mImpl->mOperationsPending = ALL_OPERATIONS;
 237   mImpl->mRecalculateNaturalSize = true;
 238
 239   mImpl->RequestRelayout();
 240 }
 241
 242 const std::string& Controller::GetDefaultFontFamily() const
 243 {
 244   if( mImpl->mFontDefaults )
 245   {
 246     return mImpl->mFontDefaults->mDefaultFontFamily;
 247   }
 248
 249   return EMPTY_STRING;
 250 }
 251
 252 void Controller::SetDefaultFontStyle( const std::string& defaultFontStyle )
 253 {
 254   if( !mImpl->mFontDefaults )
 255   {
 256     mImpl->mFontDefaults = new FontDefaults();
 257   }
 258
 259   mImpl->mFontDefaults->mDefaultFontStyle = defaultFontStyle;
 260
 261   // Clear the font-specific data
 262   ClearFontData();
 263
 264   mImpl->mOperationsPending = ALL_OPERATIONS;
 265   mImpl->mRecalculateNaturalSize = true;
 266
 267   mImpl->RequestRelayout();
 268 }
 269
 270 const std::string& Controller::GetDefaultFontStyle() const
 271 {
 272   if( mImpl->mFontDefaults )
 273   {
 274     return mImpl->mFontDefaults->mDefaultFontStyle;
 275   }
 276
 277   return EMPTY_STRING;
 278 }
 279
 280 void Controller::SetDefaultPointSize( float pointSize )
 281 {
 282   if( !mImpl->mFontDefaults )
 283   {
 284     mImpl->mFontDefaults = new FontDefaults();
 285   }
 286
 287   mImpl->mFontDefaults->mDefaultPointSize = pointSize;
 288
 289   // Clear the font-specific data
 290   ClearFontData();
 291
 292   mImpl->mOperationsPending = ALL_OPERATIONS;
 293   mImpl->mRecalculateNaturalSize = true;
 294
 295   mImpl->RequestRelayout();
 296 }
 297
 298 float Controller::GetDefaultPointSize() const
 299 {
 300   if( mImpl->mFontDefaults )
 301   {
 302     return mImpl->mFontDefaults->mDefaultPointSize;
 303   }
 304
 305   return 0.0f;
 306 }
 307
 308 void Controller::SetTextColor( const Vector4& textColor )
 309 {
 310   mImpl->mTextColor = textColor;
 311
 312   if( !mImpl->IsShowingPlaceholderText() )
 313   {
 314     mImpl->mVisualModel->SetTextColor( textColor );
 315
 316     mImpl->RequestRelayout();
 317   }
 318 }
 319
 320 const Vector4& Controller::GetTextColor() const
 321 {
 322   return mImpl->mTextColor;
 323 }
 324
 325 bool Controller::RemoveText( int cursorOffset, int numberOfChars )
 326 {
 327   bool removed( false );
 328
 329   DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::RemoveText %p mText.Count() %d cursor %d cursorOffset %d numberOfChars %d\n",
 330                  this, mImpl->mLogicalModel->mText.Count(), mImpl->mEventData->mPrimaryCursorPosition, cursorOffset, numberOfChars );
 331
 332   if( !mImpl->IsShowingPlaceholderText() )
 333   {
 334     // Delete at current cursor position
 335     Vector<Character>& currentText = mImpl->mLogicalModel->mText;
 336     CharacterIndex& oldCursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
 337
 338     CharacterIndex cursorIndex = oldCursorIndex;
 339
 340     // Validate the cursor position & number of characters
 341     if( static_cast< CharacterIndex >( std::abs( cursorOffset ) ) <= cursorIndex )
 342     {
 343       cursorIndex = oldCursorIndex + cursorOffset;
 344     }
 345
 346     if( (cursorIndex + numberOfChars) > currentText.Count() )
 347     {
 348       numberOfChars = currentText.Count() - cursorIndex;
 349     }
 350
 351     if( (cursorIndex + numberOfChars) <= currentText.Count() )
 352     {
 353       Vector<Character>::Iterator first = currentText.Begin() + cursorIndex;
 354       Vector<Character>::Iterator last  = first + numberOfChars;
 355
 356       currentText.Erase( first, last );
 357
 358       // Cursor position retreat
 359       oldCursorIndex = cursorIndex;
 360
 361       DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::RemoveText %p removed %d\n", this, numberOfChars );
 362       removed = true;
 363     }
 364   }
 365
 366   return removed;
 367 }
 368
 369 void Controller::SetPlaceholderTextColor( const Vector4& textColor )
 370 {
 371   if( mImpl->mEventData )
 372   {
 373     mImpl->mEventData->mPlaceholderTextColor = textColor;
 374   }
 375
 376   if( mImpl->IsShowingPlaceholderText() )
 377   {
 378     mImpl->mVisualModel->SetTextColor( textColor );
 379     mImpl->RequestRelayout();
 380   }
 381 }
 382
 383 const Vector4& Controller::GetPlaceholderTextColor() const
 384 {
 385   if( mImpl->mEventData )
 386   {
 387     return mImpl->mEventData->mPlaceholderTextColor;
 388   }
 389
 390   return Color::BLACK;
 391 }
 392
 393 void Controller::SetShadowOffset( const Vector2& shadowOffset )
 394 {
 395   mImpl->mVisualModel->SetShadowOffset( shadowOffset );
 396
 397   mImpl->RequestRelayout();
 398 }
 399
 400 const Vector2& Controller::GetShadowOffset() const
 401 {
 402   return mImpl->mVisualModel->GetShadowOffset();
 403 }
 404
 405 void Controller::SetShadowColor( const Vector4& shadowColor )
 406 {
 407   mImpl->mVisualModel->SetShadowColor( shadowColor );
 408
 409   mImpl->RequestRelayout();
 410 }
 411
 412 const Vector4& Controller::GetShadowColor() const
 413 {
 414   return mImpl->mVisualModel->GetShadowColor();
 415 }
 416
 417 void Controller::SetUnderlineColor( const Vector4& color )
 418 {
 419   mImpl->mVisualModel->SetUnderlineColor( color );
 420
 421   mImpl->RequestRelayout();
 422 }
 423
 424 const Vector4& Controller::GetUnderlineColor() const
 425 {
 426   return mImpl->mVisualModel->GetUnderlineColor();
 427 }
 428
 429 void Controller::SetUnderlineEnabled( bool enabled )
 430 {
 431   mImpl->mVisualModel->SetUnderlineEnabled( enabled );
 432
 433   mImpl->RequestRelayout();
 434 }
 435
 436 bool Controller::IsUnderlineEnabled() const
 437 {
 438   return mImpl->mVisualModel->IsUnderlineEnabled();
 439 }
 440
 441 void Controller::SetUnderlineHeight( float height )
 442 {
 443   mImpl->mVisualModel->SetUnderlineHeight( height );
 444
 445   mImpl->RequestRelayout();
 446 }
 447
 448 float Controller::GetUnderlineHeight() const
 449 {
 450   return mImpl->mVisualModel->GetUnderlineHeight();
 451 }
 452
 453 void Controller::SetEnableCursorBlink( bool enable )
 454 {
 455   DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "TextInput disabled" );
 456
 457   if( mImpl->mEventData )
 458   {
 459     mImpl->mEventData->mCursorBlinkEnabled = enable;
 460
 461     if( !enable &&
 462         mImpl->mEventData->mDecorator )
 463     {
 464       mImpl->mEventData->mDecorator->StopCursorBlink();
 465     }
 466   }
 467 }
 468
 469 bool Controller::GetEnableCursorBlink() const
 470 {
 471   if( mImpl->mEventData )
 472   {
 473     return mImpl->mEventData->mCursorBlinkEnabled;
 474   }
 475
 476   return false;
 477 }
 478
 479 const Vector2& Controller::GetScrollPosition() const
 480 {
 481   if( mImpl->mEventData )
 482   {
 483     return mImpl->mEventData->mScrollPosition;
 484   }
 485
 486   return Vector2::ZERO;
 487 }
 488
 489 const Vector2& Controller::GetAlignmentOffset() const
 490 {
 491   return mImpl->mAlignmentOffset;
 492 }
 493
 494 Vector3 Controller::GetNaturalSize()
 495 {
 496   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::GetNaturalSize\n" );
 497   Vector3 naturalSize;
 498
 499   // Make sure the model is up-to-date before layouting
 500   ProcessModifyEvents();
 501
 502   if( mImpl->mRecalculateNaturalSize )
 503   {
 504     // Operations that can be done only once until the text changes.
 505     const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32  |
 506                                                                            GET_SCRIPTS       |
 507                                                                            VALIDATE_FONTS    |
 508                                                                            GET_LINE_BREAKS   |
 509                                                                            GET_WORD_BREAKS   |
 510                                                                            BIDI_INFO         |
 511                                                                            SHAPE_TEXT        |
 512                                                                            GET_GLYPH_METRICS );
 513     // Make sure the model is up-to-date before layouting
 514     mImpl->UpdateModel( onlyOnceOperations );
 515
 516     // Operations that need to be done if the size changes.
 517     const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
 518                                                                         ALIGN  |
 519                                                                         REORDER );
 520
 521     DoRelayout( Size( MAX_FLOAT, MAX_FLOAT ),
 522                 static_cast<OperationsMask>( onlyOnceOperations |
 523                                              sizeOperations ),
 524                 naturalSize.GetVectorXY() );
 525
 526     // Do not do again the only once operations.
 527     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
 528
 529     // Do the size related operations again.
 530     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
 531
 532     // Stores the natural size to avoid recalculate it again
 533     // unless the text/style changes.
 534     mImpl->mVisualModel->SetNaturalSize( naturalSize.GetVectorXY() );
 535
 536     mImpl->mRecalculateNaturalSize = false;
 537
 538     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize calculated %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z );
 539   }
 540   else
 541   {
 542     naturalSize = mImpl->mVisualModel->GetNaturalSize();
 543
 544     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize cached %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z );
 545   }
 546
 547   naturalSize.x = ConvertToEven( naturalSize.x );
 548   naturalSize.y = ConvertToEven( naturalSize.y );
 549
 550   return naturalSize;
 551 }
 552
 553 float Controller::GetHeightForWidth( float width )
 554 {
 555   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::GetHeightForWidth %p width %f\n", this, width );
 556   // Make sure the model is up-to-date before layouting
 557   ProcessModifyEvents();
 558
 559   Size layoutSize;
 560   if( width != mImpl->mVisualModel->mControlSize.width )
 561   {
 562     // Operations that can be done only once until the text changes.
 563     const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32  |
 564                                                                            GET_SCRIPTS       |
 565                                                                            VALIDATE_FONTS    |
 566                                                                            GET_LINE_BREAKS   |
 567                                                                            GET_WORD_BREAKS   |
 568                                                                            BIDI_INFO         |
 569                                                                            SHAPE_TEXT        |
 570                                                                            GET_GLYPH_METRICS );
 571     // Make sure the model is up-to-date before layouting
 572     mImpl->UpdateModel( onlyOnceOperations );
 573
 574     // Operations that need to be done if the size changes.
 575     const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
 576                                                                         ALIGN  |
 577                                                                         REORDER );
 578
 579     DoRelayout( Size( width, MAX_FLOAT ),
 580                 static_cast<OperationsMask>( onlyOnceOperations |
 581                                              sizeOperations ),
 582                 layoutSize );
 583
 584     // Do not do again the only once operations.
 585     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
 586
 587     // Do the size related operations again.
 588     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
 589     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth calculated %f\n", layoutSize.height );
 590   }
 591   else
 592   {
 593     layoutSize = mImpl->mVisualModel->GetActualSize();
 594     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth cached %f\n", layoutSize.height );
 595   }
 596
 597   return layoutSize.height;
 598 }
 599
 600 bool Controller::Relayout( const Size& size )
 601 {
 602   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::Relayout %p size %f,%f\n", this, size.width, size.height );
 603
 604   if( ( size.width < Math::MACHINE_EPSILON_1000 ) || ( size.height < Math::MACHINE_EPSILON_1000 ) )
 605   {
 606     bool glyphsRemoved( false );
 607     if( 0u != mImpl->mVisualModel->mGlyphPositions.Count() )
 608     {
 609       mImpl->mVisualModel->mGlyphPositions.Clear();
 610       glyphsRemoved = true;
 611     }
 612     // Not worth to relayout if width or height is equal to zero.
 613     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout (skipped)\n" );
 614     return glyphsRemoved;
 615   }
 616
 617   if( size != mImpl->mVisualModel->mControlSize )
 618   {
 619     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "new size (previous size %f,%f)\n", mImpl->mVisualModel->mControlSize.width, mImpl->mVisualModel->mControlSize.height );
 620
 621     // Operations that need to be done if the size changes.
 622     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
 623                                                              LAYOUT                    |
 624                                                              ALIGN                     |
 625                                                              UPDATE_ACTUAL_SIZE        |
 626                                                              REORDER );
 627
 628     mImpl->mVisualModel->mControlSize = size;
 629   }
 630
 631   // Make sure the model is up-to-date before layouting
 632   ProcessModifyEvents();
 633   mImpl->UpdateModel( mImpl->mOperationsPending );
 634
 635   Size layoutSize;
 636   bool updated = DoRelayout( mImpl->mVisualModel->mControlSize,
 637                              mImpl->mOperationsPending,
 638                              layoutSize );
 639
 640   // Do not re-do any operation until something changes.
 641   mImpl->mOperationsPending = NO_OPERATION;
 642
 643   // After doing the text layout, the alignment offset to place the actor in the desired position can be calculated.
 644   CalculateTextAlignment( size );
 645
 646   if( mImpl->mEventData )
 647   {
 648     // Move the cursor, grab handle etc.
 649     updated = mImpl->ProcessInputEvents() || updated;
 650   }
 651
 652   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout\n" );
 653   return updated;
 654 }
 655
 656 void Controller::ProcessModifyEvents()
 657 {
 658   std::vector<ModifyEvent>& events = mImpl->mModifyEvents;
 659
 660   for( unsigned int i=0; i<events.size(); ++i )
 661   {
 662     if( ModifyEvent::TEXT_REPLACED == events[0].type )
 663     {
 664       // A (single) replace event should come first, otherwise we wasted time processing NOOP events
 665       DALI_ASSERT_DEBUG( 0 == i && "Unexpected TEXT_REPLACED event" );
 666
 667       TextReplacedEvent();
 668     }
 669     else if( ModifyEvent::TEXT_INSERTED == events[0].type )
 670     {
 671       TextInsertedEvent();
 672     }
 673     else if( ModifyEvent::TEXT_DELETED == events[0].type )
 674     {
 675       // Placeholder-text cannot be deleted
 676       if( !mImpl->IsShowingPlaceholderText() )
 677       {
 678         TextDeletedEvent();
 679       }
 680     }
 681   }
 682
 683   // Discard temporary text
 684   events.clear();
 685 }
 686
 687 void Controller::ResetText()
 688 {
 689   // Reset buffers.
 690   mImpl->mLogicalModel->mText.Clear();
 691   ClearModelData();
 692
 693   // We have cleared everything including the placeholder-text
 694   mImpl->PlaceholderCleared();
 695
 696   // The natural size needs to be re-calculated.
 697   mImpl->mRecalculateNaturalSize = true;
 698
 699   // Apply modifications to the model
 700   mImpl->mOperationsPending = ALL_OPERATIONS;
 701 }
 702
 703 void Controller::ResetCursorPosition( CharacterIndex cursorIndex )
 704 {
 705   // Reset the cursor position
 706   if( NULL != mImpl->mEventData )
 707   {
 708     mImpl->mEventData->mPrimaryCursorPosition = cursorIndex;
 709
 710     // Update the cursor if it's in editing mode.
 711     if( ( EventData::EDITING == mImpl->mEventData->mState ) ||
 712         ( EventData::EDITING_WITH_POPUP == mImpl->mEventData->mState ) )
 713     {
 714       mImpl->mEventData->mUpdateCursorPosition = true;
 715     }
 716   }
 717 }
 718
 719 void Controller::ResetScrollPosition()
 720 {
 721   if( NULL != mImpl->mEventData )
 722   {
 723     // Reset the scroll position.
 724     mImpl->mEventData->mScrollPosition = Vector2::ZERO;
 725     mImpl->mEventData->mScrollAfterUpdatePosition = true;
 726   }
 727 }
 728
 729 void Controller::TextReplacedEvent()
 730 {
 731   // Reset buffers.
 732   ClearModelData();
 733
 734   // The natural size needs to be re-calculated.
 735   mImpl->mRecalculateNaturalSize = true;
 736
 737   // Apply modifications to the model
 738   mImpl->mOperationsPending = ALL_OPERATIONS;
 739   mImpl->UpdateModel( ALL_OPERATIONS );
 740   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT             |
 741                                                            ALIGN              |
 742                                                            UPDATE_ACTUAL_SIZE |
 743                                                            REORDER );
 744 }
 745
 746 void Controller::TextInsertedEvent()
 747 {
 748   DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected TextInsertedEvent" );
 749
 750   // TODO - Optimize this
 751   ClearModelData();
 752
 753   // The natural size needs to be re-calculated.
 754   mImpl->mRecalculateNaturalSize = true;
 755
 756   // Apply modifications to the model; TODO - Optimize this
 757   mImpl->mOperationsPending = ALL_OPERATIONS;
 758   mImpl->UpdateModel( ALL_OPERATIONS );
 759   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT             |
 760                                                            ALIGN              |
 761                                                            UPDATE_ACTUAL_SIZE |
 762                                                            REORDER );
 763
 764   // Queue a cursor reposition event; this must wait until after DoRelayout()
 765   mImpl->mEventData->mUpdateCursorPosition = true;
 766   mImpl->mEventData->mScrollAfterUpdatePosition = true;
 767 }
 768
 769 void Controller::TextDeletedEvent()
 770 {
 771   DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected TextDeletedEvent" );
 772
 773   // TODO - Optimize this
 774   ClearModelData();
 775
 776   // The natural size needs to be re-calculated.
 777   mImpl->mRecalculateNaturalSize = true;
 778
 779   // Apply modifications to the model; TODO - Optimize this
 780   mImpl->mOperationsPending = ALL_OPERATIONS;
 781   mImpl->UpdateModel( ALL_OPERATIONS );
 782   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT             |
 783                                                            ALIGN              |
 784                                                            UPDATE_ACTUAL_SIZE |
 785                                                            REORDER );
 786
 787   // Queue a cursor reposition event; this must wait until after DoRelayout()
 788   if( 0u == mImpl->mLogicalModel->mText.Count() )
 789   {
 790     mImpl->mEventData->mUpdateCursorPosition = true;
 791   }
 792   else
 793   {
 794     mImpl->mEventData->mScrollAfterDelete = true;
 795   }
 796 }
 797
 798 bool Controller::DoRelayout( const Size& size,
 799                              OperationsMask operationsRequired,
 800                              Size& layoutSize )
 801 {
 802   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::DoRelayout %p size %f,%f\n", this, size.width, size.height );
 803   bool viewUpdated( false );
 804
 805   // Calculate the operations to be done.
 806   const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
 807
 808   if( LAYOUT & operations )
 809   {
 810     // Some vectors with data needed to layout and reorder may be void
 811     // after the first time the text has been laid out.
 812     // Fill the vectors again.
 813
 814     const Length numberOfGlyphs = mImpl->mVisualModel->mGlyphs.Count();
 815
 816     if( 0u == numberOfGlyphs )
 817     {
 818       // Nothing else to do if there is no glyphs.
 819       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::DoRelayout no glyphs, view updated true\n" );
 820       return true;
 821     }
 822
 823     const Vector<LineBreakInfo>& lineBreakInfo = mImpl->mLogicalModel->mLineBreakInfo;
 824     const Vector<WordBreakInfo>& wordBreakInfo = mImpl->mLogicalModel->mWordBreakInfo;
 825     const Vector<CharacterDirection>& characterDirection = mImpl->mLogicalModel->mCharacterDirections;
 826     const Vector<GlyphInfo>& glyphs = mImpl->mVisualModel->mGlyphs;
 827     const Vector<CharacterIndex>& glyphsToCharactersMap = mImpl->mVisualModel->mGlyphsToCharacters;
 828     const Vector<Length>& charactersPerGlyph = mImpl->mVisualModel->mCharactersPerGlyph;
 829     const Character* const textBuffer = mImpl->mLogicalModel->mText.Begin();
 830
 831     // Set the layout parameters.
 832     LayoutParameters layoutParameters( size,
 833                                        textBuffer,
 834                                        lineBreakInfo.Begin(),
 835                                        wordBreakInfo.Begin(),
 836                                        ( 0u != characterDirection.Count() ) ? characterDirection.Begin() : NULL,
 837                                        numberOfGlyphs,
 838                                        glyphs.Begin(),
 839                                        glyphsToCharactersMap.Begin(),
 840                                        charactersPerGlyph.Begin() );
 841
 842     // The laid-out lines.
 843     // It's not possible to know in how many lines the text is going to be laid-out,
 844     // but it can be resized at least with the number of 'paragraphs' to avoid
 845     // some re-allocations.
 846     Vector<LineRun>& lines = mImpl->mVisualModel->mLines;
 847
 848     // Delete any previous laid out lines before setting the new ones.
 849     lines.Clear();
 850
 851     // The capacity of the bidirectional paragraph info is the number of paragraphs.
 852     lines.Reserve( mImpl->mLogicalModel->mBidirectionalParagraphInfo.Capacity() );
 853
 854     // Resize the vector of positions to have the same size than the vector of glyphs.
 855     Vector<Vector2>& glyphPositions = mImpl->mVisualModel->mGlyphPositions;
 856     glyphPositions.Resize( numberOfGlyphs );
 857
 858     // Whether the last character is a new paragraph character.
 859     layoutParameters.isLastNewParagraph = TextAbstraction::IsNewParagraph( *( textBuffer + ( mImpl->mLogicalModel->mText.Count() - 1u ) ) );
 860
 861     // Update the visual model.
 862     viewUpdated = mImpl->mLayoutEngine.LayoutText( layoutParameters,
 863                                                    glyphPositions,
 864                                                    lines,
 865                                                    layoutSize );
 866
 867     if( viewUpdated )
 868     {
 869       // Reorder the lines
 870       if( REORDER & operations )
 871       {
 872         Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mImpl->mLogicalModel->mBidirectionalParagraphInfo;
 873
 874         // Check first if there are paragraphs with bidirectional info.
 875         if( 0u != bidirectionalInfo.Count() )
 876         {
 877           // Get the lines
 878           const Length numberOfLines = mImpl->mVisualModel->mLines.Count();
 879
 880           // Reorder the lines.
 881           Vector<BidirectionalLineInfoRun> lineBidirectionalInfoRuns;
 882           lineBidirectionalInfoRuns.Reserve( numberOfLines ); // Reserve because is not known yet how many lines have right to left characters.
 883           ReorderLines( bidirectionalInfo,
 884                         lines,
 885                         lineBidirectionalInfoRuns );
 886
 887           // Set the bidirectional info into the model.
 888           const Length numberOfBidirectionalInfoRuns = lineBidirectionalInfoRuns.Count();
 889           mImpl->mLogicalModel->SetVisualToLogicalMap( lineBidirectionalInfoRuns.Begin(),
 890                                                        numberOfBidirectionalInfoRuns );
 891
 892           // Set the bidirectional info per line into the layout parameters.
 893           layoutParameters.lineBidirectionalInfoRunsBuffer = lineBidirectionalInfoRuns.Begin();
 894           layoutParameters.numberOfBidirectionalInfoRuns = numberOfBidirectionalInfoRuns;
 895
 896           // Get the character to glyph conversion table and set into the layout.
 897           layoutParameters.charactersToGlyphsBuffer = mImpl->mVisualModel->mCharactersToGlyph.Begin();
 898
 899           // Get the glyphs per character table and set into the layout.
 900           layoutParameters.glyphsPerCharacterBuffer = mImpl->mVisualModel->mGlyphsPerCharacter.Begin();
 901
 902           // Re-layout the text. Reorder those lines with right to left characters.
 903           mImpl->mLayoutEngine.ReLayoutRightToLeftLines( layoutParameters,
 904                                                          glyphPositions );
 905
 906           // Free the allocated memory used to store the conversion table in the bidirectional line info run.
 907           for( Vector<BidirectionalLineInfoRun>::Iterator it = lineBidirectionalInfoRuns.Begin(),
 908                  endIt = lineBidirectionalInfoRuns.End();
 909                it != endIt;
 910                ++it )
 911           {
 912             BidirectionalLineInfoRun& bidiLineInfo = *it;
 913
 914             free( bidiLineInfo.visualToLogicalMap );
 915           }
 916         }
 917       } // REORDER
 918
 919       // Sets the actual size.
 920       if( UPDATE_ACTUAL_SIZE & operations )
 921       {
 922         mImpl->mVisualModel->SetActualSize( layoutSize );
 923       }
 924     } // view updated
 925   }
 926   else
 927   {
 928     layoutSize = mImpl->mVisualModel->GetActualSize();
 929   }
 930
 931   if( ALIGN & operations )
 932   {
 933     // The laid-out lines.
 934     Vector<LineRun>& lines = mImpl->mVisualModel->mLines;
 935
 936     mImpl->mLayoutEngine.Align( layoutSize,
 937                                 lines );
 938
 939     viewUpdated = true;
 940   }
 941
 942   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::DoRelayout, view updated %s\n", ( viewUpdated ? "true" : "false" ) );
 943   return viewUpdated;
 944 }
 945
 946 void Controller::SetMultiLineEnabled( bool enable )
 947 {
 948   const LayoutEngine::Layout layout = enable ? LayoutEngine::MULTI_LINE_BOX : LayoutEngine::SINGLE_LINE_BOX;
 949
 950   if( layout != mImpl->mLayoutEngine.GetLayout() )
 951   {
 952     // Set the layout type.
 953     mImpl->mLayoutEngine.SetLayout( layout );
 954
 955     // Set the flags to redo the layout operations
 956     const OperationsMask layoutOperations =  static_cast<OperationsMask>( LAYOUT             |
 957                                                                           UPDATE_ACTUAL_SIZE |
 958                                                                           ALIGN              |
 959                                                                           REORDER );
 960
 961     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | layoutOperations );
 962
 963     mImpl->RequestRelayout();
 964   }
 965 }
 966
 967 bool Controller::IsMultiLineEnabled() const
 968 {
 969   return LayoutEngine::MULTI_LINE_BOX == mImpl->mLayoutEngine.GetLayout();
 970 }
 971
 972 void Controller::SetHorizontalAlignment( LayoutEngine::HorizontalAlignment alignment )
 973 {
 974   if( alignment != mImpl->mLayoutEngine.GetHorizontalAlignment() )
 975   {
 976     // Set the alignment.
 977     mImpl->mLayoutEngine.SetHorizontalAlignment( alignment );
 978
 979     // Set the flag to redo the alignment operation.
 980     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | ALIGN );
 981
 982     mImpl->RequestRelayout();
 983   }
 984 }
 985
 986 LayoutEngine::HorizontalAlignment Controller::GetHorizontalAlignment() const
 987 {
 988   return mImpl->mLayoutEngine.GetHorizontalAlignment();
 989 }
 990
 991 void Controller::SetVerticalAlignment( LayoutEngine::VerticalAlignment alignment )
 992 {
 993   if( alignment != mImpl->mLayoutEngine.GetVerticalAlignment() )
 994   {
 995     // Set the alignment.
 996     mImpl->mLayoutEngine.SetVerticalAlignment( alignment );
 997
 998     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | ALIGN );
 999
1000     mImpl->RequestRelayout();
1001   }
1002 }
1003
1004 LayoutEngine::VerticalAlignment Controller::GetVerticalAlignment() const
1005 {
1006   return mImpl->mLayoutEngine.GetVerticalAlignment();
1007 }
1008
1009 void Controller::CalculateTextAlignment( const Size& size )
1010 {
1011   // Get the direction of the first character.
1012   const CharacterDirection firstParagraphDirection = mImpl->mLogicalModel->GetCharacterDirection( 0u );
1013
1014   Size actualSize = mImpl->mVisualModel->GetActualSize();
1015   if( fabsf( actualSize.height ) < Math::MACHINE_EPSILON_1000 )
1016   {
1017     // Get the line height of the default font.
1018     actualSize.height = mImpl->GetDefaultFontLineHeight();
1019   }
1020
1021   // If the first paragraph is right to left swap ALIGN_BEGIN and ALIGN_END;
1022   LayoutEngine::HorizontalAlignment horizontalAlignment = mImpl->mLayoutEngine.GetHorizontalAlignment();
1023   if( firstParagraphDirection &&
1024       ( LayoutEngine::HORIZONTAL_ALIGN_CENTER != horizontalAlignment ) )
1025   {
1026     if( LayoutEngine::HORIZONTAL_ALIGN_BEGIN == horizontalAlignment )
1027     {
1028       horizontalAlignment = LayoutEngine::HORIZONTAL_ALIGN_END;
1029     }
1030     else
1031     {
1032       horizontalAlignment = LayoutEngine::HORIZONTAL_ALIGN_BEGIN;
1033     }
1034   }
1035
1036   switch( horizontalAlignment )
1037   {
1038     case LayoutEngine::HORIZONTAL_ALIGN_BEGIN:
1039     {
1040       mImpl->mAlignmentOffset.x = 0.f;
1041       break;
1042     }
1043     case LayoutEngine::HORIZONTAL_ALIGN_CENTER:
1044     {
1045       const int intOffset = static_cast<int>( 0.5f * ( size.width - actualSize.width ) ); // try to avoid pixel alignment.
1046       mImpl->mAlignmentOffset.x = static_cast<float>( intOffset );
1047       break;
1048     }
1049     case LayoutEngine::HORIZONTAL_ALIGN_END:
1050     {
1051       mImpl->mAlignmentOffset.x = size.width - actualSize.width;
1052       break;
1053     }
1054   }
1055
1056   const LayoutEngine::VerticalAlignment verticalAlignment = mImpl->mLayoutEngine.GetVerticalAlignment();
1057   switch( verticalAlignment )
1058   {
1059     case LayoutEngine::VERTICAL_ALIGN_TOP:
1060     {
1061       mImpl->mAlignmentOffset.y = 0.f;
1062       break;
1063     }
1064     case LayoutEngine::VERTICAL_ALIGN_CENTER:
1065     {
1066       const int intOffset = static_cast<int>( 0.5f * ( size.height - actualSize.height ) ); // try to avoid pixel alignment.
1067       mImpl->mAlignmentOffset.y = static_cast<float>( intOffset );
1068       break;
1069     }
1070     case LayoutEngine::VERTICAL_ALIGN_BOTTOM:
1071     {
1072       mImpl->mAlignmentOffset.y = size.height - actualSize.height;
1073       break;
1074     }
1075   }
1076 }
1077
1078 LayoutEngine& Controller::GetLayoutEngine()
1079 {
1080   return mImpl->mLayoutEngine;
1081 }
1082
1083 View& Controller::GetView()
1084 {
1085   return mImpl->mView;
1086 }
1087
1088 void Controller::KeyboardFocusGainEvent()
1089 {
1090   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyboardFocusGainEvent" );
1091
1092   if( mImpl->mEventData )
1093   {
1094     mImpl->ChangeState( EventData::EDITING );
1095
1096     if( mImpl->IsShowingPlaceholderText() )
1097     {
1098       // Show alternative placeholder-text when editing
1099       ShowPlaceholderText();
1100     }
1101
1102     mImpl->mEventData->mUpdateCursorPosition = true; //If editing started without tap event, cursor update must be triggered.
1103     mImpl->RequestRelayout();
1104   }
1105 }
1106
1107 void Controller::KeyboardFocusLostEvent()
1108 {
1109   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyboardFocusLostEvent" );
1110
1111   if( mImpl->mEventData )
1112   {
1113     if ( EventData::INTERRUPTED != mImpl->mEventData->mState )
1114     {
1115       mImpl->ChangeState( EventData::INACTIVE );
1116
1117       if( mImpl->IsShowingPlaceholderText() )
1118       {
1119         // Revert to regular placeholder-text when not editing
1120         ShowPlaceholderText();
1121       }
1122     }
1123   }
1124   mImpl->RequestRelayout();
1125 }
1126
1127 bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent )
1128 {
1129   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyEvent" );
1130
1131   bool textChanged( false );
1132
1133   if( mImpl->mEventData &&
1134       keyEvent.state == KeyEvent::Down )
1135   {
1136     int keyCode = keyEvent.keyCode;
1137     const std::string& keyString = keyEvent.keyPressed;
1138
1139     // Pre-process to separate modifying events from non-modifying input events.
1140     if( Dali::DALI_KEY_ESCAPE == keyCode )
1141     {
1142       // Escape key is a special case which causes focus loss
1143       KeyboardFocusLostEvent();
1144     }
1145     else if( Dali::DALI_KEY_CURSOR_LEFT  == keyCode ||
1146              Dali::DALI_KEY_CURSOR_RIGHT == keyCode ||
1147              Dali::DALI_KEY_CURSOR_UP    == keyCode ||
1148              Dali::DALI_KEY_CURSOR_DOWN  == keyCode )
1149     {
1150       Event event( Event::CURSOR_KEY_EVENT );
1151       event.p1.mInt = keyCode;
1152       mImpl->mEventData->mEventQueue.push_back( event );
1153     }
1154     else if( Dali::DALI_KEY_BACKSPACE == keyCode )
1155     {
1156       textChanged = BackspaceKeyEvent();
1157     }
1158     else if ( IsKey( keyEvent,  Dali::DALI_KEY_POWER ) )
1159     {
1160       mImpl->ChangeState( EventData::INTERRUPTED ); // State is not INACTIVE as expect to return to edit mode.
1161       // Avoids calling the InsertText() method which can delete selected text
1162     }
1163     else if ( IsKey( keyEvent, Dali::DALI_KEY_MENU ) ||
1164               IsKey( keyEvent, Dali::DALI_KEY_HOME ) )
1165     {
1166       mImpl->ChangeState( EventData::INACTIVE );
1167       // Menu/Home key behaviour does not allow edit mode to resume like Power key
1168       // Avoids calling the InsertText() method which can delete selected text
1169     }
1170     else if( Dali::DALI_KEY_SHIFT_LEFT == keyCode )
1171     {
1172       // DALI_KEY_SHIFT_LEFT is the key code for the Left Shift. It's sent (by the imf?) when the predictive text is enabled
1173       // and a character is typed after the type of a upper case latin character.
1174
1175       // Do nothing.
1176     }
1177     else
1178     {
1179       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p keyString %s\n", this, keyString.c_str() );
1180
1181       // IMF manager is no longer handling key-events
1182       mImpl->ClearPreEditFlag();
1183
1184       InsertText( keyString, COMMIT );
1185       textChanged = true;
1186     }
1187
1188     if ( mImpl->mEventData->mState != EventData::INTERRUPTED &&  mImpl->mEventData->mState != EventData::INACTIVE )
1189     {
1190       mImpl->ChangeState( EventData::EDITING );
1191     }
1192
1193     mImpl->RequestRelayout();
1194   }
1195
1196   if( textChanged )
1197   {
1198     // Do this last since it provides callbacks into application code
1199     mImpl->mControlInterface.TextChanged();
1200   }
1201
1202   return false;
1203 }
1204
1205 void Controller::InsertText( const std::string& text, Controller::InsertType type )
1206 {
1207   bool removedPrevious( false );
1208   bool maxLengthReached( false );
1209
1210   DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected InsertText" )
1211   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::InsertText %p %s (%s) mPrimaryCursorPosition %d mPreEditFlag %d mPreEditStartPosition %d mPreEditLength %d\n",
1212                  this, text.c_str(), (COMMIT == type ? "COMMIT" : "PRE_EDIT"),
1213                  mImpl->mEventData->mPrimaryCursorPosition, mImpl->mEventData->mPreEditFlag, mImpl->mEventData->mPreEditStartPosition, mImpl->mEventData->mPreEditLength );
1214
1215   // TODO: At the moment the underline runs are only for pre-edit.
1216   mImpl->mVisualModel->mUnderlineRuns.Clear();
1217
1218   Vector<Character> utf32Characters;
1219   Length characterCount( 0u );
1220
1221   // Remove the previous IMF pre-edit (predicitive text)
1222   if( mImpl->mEventData &&
1223       mImpl->mEventData->mPreEditFlag &&
1224       0 != mImpl->mEventData->mPreEditLength )
1225   {
1226     CharacterIndex offset = mImpl->mEventData->mPrimaryCursorPosition - mImpl->mEventData->mPreEditStartPosition;
1227
1228     removedPrevious = RemoveText( -static_cast<int>(offset), mImpl->mEventData->mPreEditLength );
1229
1230     mImpl->mEventData->mPrimaryCursorPosition = mImpl->mEventData->mPreEditStartPosition;
1231     mImpl->mEventData->mPreEditLength = 0;
1232   }
1233   else
1234   {
1235     // Remove the previous Selection
1236     removedPrevious = RemoveSelectedText();
1237   }
1238
1239   if( !text.empty() )
1240   {
1241     //  Convert text into UTF-32
1242     utf32Characters.Resize( text.size() );
1243
1244     // This is a bit horrible but std::string returns a (signed) char*
1245     const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
1246
1247     // Transform a text array encoded in utf8 into an array encoded in utf32.
1248     // It returns the actual number of characters.
1249     characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
1250     utf32Characters.Resize( characterCount );
1251
1252     DALI_ASSERT_DEBUG( text.size() >= utf32Characters.Count() && "Invalid UTF32 conversion length" );
1253     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "UTF8 size %d, UTF32 size %d\n", text.size(), utf32Characters.Count() );
1254   }
1255
1256   if( 0u != utf32Characters.Count() ) // Check if Utf8ToUtf32 conversion succeeded
1257   {
1258     // The placeholder text is no longer needed
1259     if( mImpl->IsShowingPlaceholderText() )
1260     {
1261       ResetText();
1262     }
1263
1264     mImpl->ChangeState( EventData::EDITING );
1265
1266     // Handle the IMF (predicitive text) state changes
1267     if( mImpl->mEventData )
1268     {
1269       if( COMMIT == type )
1270       {
1271         // IMF manager is no longer handling key-events
1272         mImpl->ClearPreEditFlag();
1273       }
1274       else // PRE_EDIT
1275       {
1276         if( !mImpl->mEventData->mPreEditFlag )
1277         {
1278           DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Entered PreEdit state" );
1279
1280           // Record the start of the pre-edit text
1281           mImpl->mEventData->mPreEditStartPosition = mImpl->mEventData->mPrimaryCursorPosition;
1282         }
1283
1284         mImpl->mEventData->mPreEditLength = utf32Characters.Count();
1285         mImpl->mEventData->mPreEditFlag = true;
1286
1287         if( 0u != mImpl->mVisualModel->mCharactersToGlyph.Count() )
1288         {
1289           // Add the underline for the pre-edit text.
1290           const GlyphIndex* const charactersToGlyphBuffer = mImpl->mVisualModel->mCharactersToGlyph.Begin();
1291           const Length* const glyphsPerCharacterBuffer = mImpl->mVisualModel->mGlyphsPerCharacter.Begin();
1292
1293           const GlyphIndex glyphStart = *( charactersToGlyphBuffer + mImpl->mEventData->mPreEditStartPosition );
1294           const CharacterIndex lastPreEditCharacter = mImpl->mEventData->mPreEditStartPosition + ( ( mImpl->mEventData->mPreEditLength > 0u ) ? mImpl->mEventData->mPreEditLength - 1u : 0u );
1295           const Length numberOfGlyphsLastCharacter = *( glyphsPerCharacterBuffer + lastPreEditCharacter );
1296           const GlyphIndex glyphEnd = *( charactersToGlyphBuffer + lastPreEditCharacter ) + ( numberOfGlyphsLastCharacter > 1u ? numberOfGlyphsLastCharacter - 1u : 0u );
1297
1298           GlyphRun underlineRun;
1299           underlineRun.glyphIndex = glyphStart;
1300           underlineRun.numberOfGlyphs = 1u + glyphEnd - glyphStart;
1301
1302           // TODO: At the moment the underline runs are only for pre-edit.
1303           mImpl->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
1304         }
1305         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "mPreEditStartPosition %d mPreEditLength %d\n", mImpl->mEventData->mPreEditStartPosition, mImpl->mEventData->mPreEditLength );
1306       }
1307     }
1308
1309     const Length numberOfCharactersInModel = mImpl->mLogicalModel->mText.Count();
1310
1311     // Restrict new text to fit within Maximum characters setting
1312     Length maxSizeOfNewText = std::min ( ( mImpl->mMaximumNumberOfCharacters - numberOfCharactersInModel ), characterCount );
1313     maxLengthReached = ( characterCount > maxSizeOfNewText );
1314
1315     // Insert at current cursor position
1316     CharacterIndex& cursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
1317
1318     Vector<Character>& modifyText = mImpl->mLogicalModel->mText;
1319
1320     if( cursorIndex < numberOfCharactersInModel )
1321     {
1322       modifyText.Insert( modifyText.Begin() + cursorIndex, utf32Characters.Begin(), utf32Characters.Begin() + maxSizeOfNewText );
1323     }
1324     else
1325     {
1326       modifyText.Insert( modifyText.End(), utf32Characters.Begin(), utf32Characters.Begin() + maxSizeOfNewText );
1327     }
1328
1329     cursorIndex += maxSizeOfNewText;
1330
1331     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Inserted %d characters, new size %d new cursor %d\n", maxSizeOfNewText, mImpl->mLogicalModel->mText.Count(), mImpl->mEventData->mPrimaryCursorPosition );
1332   }
1333
1334   if( 0u == mImpl->mLogicalModel->mText.Count() &&
1335       mImpl->IsPlaceholderAvailable() )
1336   {
1337     // Show place-holder if empty after removing the pre-edit text
1338     ShowPlaceholderText();
1339     mImpl->mEventData->mUpdateCursorPosition = true;
1340     mImpl->ClearPreEditFlag();
1341   }
1342   else if( removedPrevious ||
1343            0 != utf32Characters.Count() )
1344   {
1345     // Queue an inserted event
1346     mImpl->QueueModifyEvent( ModifyEvent::TEXT_INSERTED );
1347   }
1348
1349   if( maxLengthReached )
1350   {
1351     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "MaxLengthReached (%d)\n", mImpl->mLogicalModel->mText.Count() );
1352
1353     mImpl->ResetImfManager();
1354
1355     // Do this last since it provides callbacks into application code
1356     mImpl->mControlInterface.MaxLengthReached();
1357   }
1358 }
1359
1360 bool Controller::RemoveSelectedText()
1361 {
1362   bool textRemoved( false );
1363
1364   if ( EventData::SELECTING         == mImpl->mEventData->mState ||
1365        EventData::SELECTION_CHANGED == mImpl->mEventData->mState )
1366   {
1367     std::string removedString;
1368     mImpl->RetrieveSelection( removedString, true );
1369
1370     if( !removedString.empty() )
1371     {
1372       textRemoved = true;
1373       mImpl->ChangeState( EventData::EDITING );
1374     }
1375   }
1376
1377   return textRemoved;
1378 }
1379
1380 void Controller::TapEvent( unsigned int tapCount, float x, float y )
1381 {
1382   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected TapEvent" );
1383
1384   if( NULL != mImpl->mEventData )
1385   {
1386     if( 1u == tapCount )
1387     {
1388       if( mImpl->IsShowingRealText() &&
1389           EventData::EDITING == mImpl->mEventData->mState )
1390       {
1391         mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );
1392       }
1393       else if( EventData::EDITING_WITH_GRAB_HANDLE != mImpl->mEventData->mState  )
1394       {
1395         // Handles & cursors must be repositioned after Relayout() i.e. after the Model has been updated
1396         mImpl->ChangeState( EventData::EDITING );
1397       }
1398
1399       Event event( Event::TAP_EVENT );
1400       event.p1.mUint = tapCount;
1401       event.p2.mFloat = x;
1402       event.p3.mFloat = y;
1403       mImpl->mEventData->mEventQueue.push_back( event );
1404
1405       mImpl->RequestRelayout();
1406     }
1407     else if( 2u == tapCount )
1408     {
1409       if( mImpl->mEventData->mSelectionEnabled &&
1410           mImpl->IsShowingRealText() )
1411       {
1412         SelectEvent( x, y, false );
1413       }
1414     }
1415   }
1416
1417   // Reset keyboard as tap event has occurred.
1418   mImpl->ResetImfManager();
1419 }
1420
1421 void Controller::PanEvent( Gesture::State state, const Vector2& displacement )
1422 {
1423   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected PanEvent" );
1424
1425   if( mImpl->mEventData )
1426   {
1427     Event event( Event::PAN_EVENT );
1428     event.p1.mInt = state;
1429     event.p2.mFloat = displacement.x;
1430     event.p3.mFloat = displacement.y;
1431     mImpl->mEventData->mEventQueue.push_back( event );
1432
1433     mImpl->RequestRelayout();
1434   }
1435 }
1436
1437 void Controller::LongPressEvent( Gesture::State state, float x, float y  )
1438 {
1439   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected PanEvent" );
1440
1441   if  ( mImpl->IsShowingPlaceholderText() || mImpl->mLogicalModel->mText.Count() == 0u )
1442   {
1443     if ( mImpl->mEventData )
1444     {
1445       Event event( Event::LONG_PRESS_EVENT );
1446       event.p1.mInt = state;
1447       mImpl->mEventData->mEventQueue.push_back( event );
1448       mImpl->RequestRelayout();
1449     }
1450   }
1451   else if( mImpl->mEventData )
1452   {
1453     SelectEvent( x, y, false );
1454   }
1455 }
1456
1457 void Controller::SelectEvent( float x, float y, bool selectAll )
1458 {
1459   if( mImpl->mEventData )
1460   {
1461     if ( mImpl->mEventData->mState == EventData::SELECTING )
1462     {
1463       mImpl->ChangeState( EventData::SELECTION_CHANGED );
1464     }
1465     else
1466     {
1467       mImpl->ChangeState( EventData::SELECTING );
1468     }
1469
1470     if( selectAll )
1471     {
1472       Event event( Event::SELECT_ALL );
1473       mImpl->mEventData->mEventQueue.push_back( event );
1474     }
1475     else
1476     {
1477       Event event( Event::SELECT );
1478       event.p2.mFloat = x;
1479       event.p3.mFloat = y;
1480       mImpl->mEventData->mEventQueue.push_back( event );
1481     }
1482
1483     mImpl->RequestRelayout();
1484   }
1485 }
1486
1487 void Controller::GetTargetSize( Vector2& targetSize )
1488 {
1489   targetSize = mImpl->mVisualModel->mControlSize;
1490 }
1491
1492 void Controller::AddDecoration( Actor& actor, bool needsClipping )
1493 {
1494   mImpl->mControlInterface.AddDecoration( actor, needsClipping );
1495 }
1496
1497 void Controller::DecorationEvent( HandleType handleType, HandleState state, float x, float y )
1498 {
1499   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected DecorationEvent" );
1500
1501   if( mImpl->mEventData )
1502   {
1503     switch( handleType )
1504     {
1505       case GRAB_HANDLE:
1506       {
1507         Event event( Event::GRAB_HANDLE_EVENT );
1508         event.p1.mUint  = state;
1509         event.p2.mFloat = x;
1510         event.p3.mFloat = y;
1511
1512         mImpl->mEventData->mEventQueue.push_back( event );
1513         break;
1514       }
1515       case LEFT_SELECTION_HANDLE:
1516       {
1517         Event event( Event::LEFT_SELECTION_HANDLE_EVENT );
1518         event.p1.mUint  = state;
1519         event.p2.mFloat = x;
1520         event.p3.mFloat = y;
1521
1522         mImpl->mEventData->mEventQueue.push_back( event );
1523         break;
1524       }
1525       case RIGHT_SELECTION_HANDLE:
1526       {
1527         Event event( Event::RIGHT_SELECTION_HANDLE_EVENT );
1528         event.p1.mUint  = state;
1529         event.p2.mFloat = x;
1530         event.p3.mFloat = y;
1531
1532         mImpl->mEventData->mEventQueue.push_back( event );
1533         break;
1534       }
1535       case LEFT_SELECTION_HANDLE_MARKER:
1536       case RIGHT_SELECTION_HANDLE_MARKER:
1537       {
1538         // Markers do not move the handles.
1539         break;
1540       }
1541       case HANDLE_TYPE_COUNT:
1542       {
1543         DALI_ASSERT_DEBUG( !"Controller::HandleEvent. Unexpected handle type" );
1544       }
1545     }
1546
1547     mImpl->RequestRelayout();
1548   }
1549 }
1550
1551 void Controller::PasteText( const std::string& stringToPaste )
1552 {
1553   InsertText( stringToPaste, Text::Controller::COMMIT );
1554   mImpl->ChangeState( EventData::EDITING );
1555   mImpl->RequestRelayout();
1556 }
1557
1558 void Controller::PasteClipboardItemEvent()
1559 {
1560   ClipboardEventNotifier notifier( ClipboardEventNotifier::Get() );
1561   std::string stringToPaste( notifier.GetContent() );
1562   PasteText( stringToPaste );
1563 }
1564
1565 void Controller::TextPopupButtonTouched( Dali::Toolkit::TextSelectionPopup::Buttons button )
1566 {
1567   if( NULL == mImpl->mEventData )
1568   {
1569     return;
1570   }
1571
1572   switch( button )
1573   {
1574     case Toolkit::TextSelectionPopup::CUT:
1575     {
1576       mImpl->SendSelectionToClipboard( true ); // Synchronous call to modify text
1577       mImpl->mOperationsPending = ALL_OPERATIONS;
1578       if( 0u != mImpl->mLogicalModel->mText.Count() ||
1579           !mImpl->IsPlaceholderAvailable() )
1580       {
1581         mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
1582       }
1583       else
1584       {
1585         ShowPlaceholderText();
1586         mImpl->mEventData->mUpdateCursorPosition = true;
1587       }
1588       mImpl->RequestRelayout();
1589       mImpl->mControlInterface.TextChanged();
1590       break;
1591     }
1592     case Toolkit::TextSelectionPopup::COPY:
1593     {
1594       mImpl->SendSelectionToClipboard( false ); // Text not modified
1595       mImpl->RequestRelayout(); // Handles, Selection Highlight, Popup
1596       break;
1597     }
1598     case Toolkit::TextSelectionPopup::PASTE:
1599     {
1600       std::string stringToPaste("");
1601       mImpl->GetTextFromClipboard( 0, stringToPaste ); // Paste latest item from system clipboard
1602       PasteText( stringToPaste );
1603       break;
1604     }
1605     case Toolkit::TextSelectionPopup::SELECT:
1606     {
1607       const Vector2& currentCursorPosition = mImpl->mEventData->mDecorator->GetPosition( PRIMARY_CURSOR );
1608
1609       if( mImpl->mEventData->mSelectionEnabled  )
1610       {
1611         // Creates a SELECT event.
1612         SelectEvent( currentCursorPosition.x, currentCursorPosition.y, false );
1613       }
1614       break;
1615     }
1616     case Toolkit::TextSelectionPopup::SELECT_ALL:
1617     {
1618       // Creates a SELECT_ALL event
1619       SelectEvent( 0.f, 0.f, true );
1620       break;
1621     }
1622     case Toolkit::TextSelectionPopup::CLIPBOARD:
1623     {
1624       mImpl->ShowClipboard();
1625       break;
1626     }
1627     case Toolkit::TextSelectionPopup::NONE:
1628     {
1629       // Nothing to do.
1630       break;
1631     }
1632   }
1633 }
1634
1635 ImfManager::ImfCallbackData Controller::OnImfEvent( ImfManager& imfManager, const ImfManager::ImfEventData& imfEvent )
1636 {
1637   bool update( false );
1638   bool requestRelayout = false;
1639
1640   std::string text;
1641   unsigned int cursorPosition( 0 );
1642
1643   switch ( imfEvent.eventName )
1644   {
1645     case ImfManager::COMMIT:
1646     {
1647       InsertText( imfEvent.predictiveString, Text::Controller::COMMIT );
1648       requestRelayout = true;
1649       break;
1650     }
1651     case ImfManager::PREEDIT:
1652     {
1653       InsertText( imfEvent.predictiveString, Text::Controller::PRE_EDIT );
1654       update = true;
1655       requestRelayout = true;
1656       break;
1657     }
1658     case ImfManager::DELETESURROUNDING:
1659     {
1660       update = RemoveText( imfEvent.cursorOffset, imfEvent.numberOfChars );
1661
1662       if( update )
1663       {
1664         if( 0u != mImpl->mLogicalModel->mText.Count() ||
1665             !mImpl->IsPlaceholderAvailable() )
1666         {
1667           mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
1668         }
1669         else
1670         {
1671           ShowPlaceholderText();
1672           mImpl->mEventData->mUpdateCursorPosition = true;
1673         }
1674       }
1675       requestRelayout = true;
1676       break;
1677     }
1678     case ImfManager::GETSURROUNDING:
1679     {
1680       GetText( text );
1681       cursorPosition = GetLogicalCursorPosition();
1682
1683       imfManager.SetSurroundingText( text );
1684       imfManager.SetCursorPosition( cursorPosition );
1685       break;
1686     }
1687     case ImfManager::VOID:
1688     {
1689       // do nothing
1690       break;
1691     }
1692   } // end switch
1693
1694   if( ImfManager::GETSURROUNDING != imfEvent.eventName )
1695   {
1696     GetText( text );
1697     cursorPosition = GetLogicalCursorPosition();
1698   }
1699
1700   if( requestRelayout )
1701   {
1702     mImpl->mOperationsPending = ALL_OPERATIONS;
1703     mImpl->RequestRelayout();
1704
1705     // Do this last since it provides callbacks into application code
1706     mImpl->mControlInterface.TextChanged();
1707   }
1708
1709   ImfManager::ImfCallbackData callbackData( update, cursorPosition, text, false );
1710
1711   return callbackData;
1712 }
1713
1714 Controller::~Controller()
1715 {
1716   delete mImpl;
1717 }
1718
1719 bool Controller::BackspaceKeyEvent()
1720 {
1721   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p DALI_KEY_BACKSPACE\n", this );
1722
1723   // IMF manager is no longer handling key-events
1724   mImpl->ClearPreEditFlag();
1725
1726   bool removed( false );
1727
1728   if ( EventData::SELECTING         == mImpl->mEventData->mState ||
1729        EventData::SELECTION_CHANGED == mImpl->mEventData->mState )
1730   {
1731     removed = RemoveSelectedText();
1732   }
1733   else if( mImpl->mEventData->mPrimaryCursorPosition > 0 )
1734   {
1735     // Remove the character before the current cursor position
1736     removed = RemoveText( -1, 1 );
1737   }
1738
1739   if( removed )
1740   {
1741     if( 0u != mImpl->mLogicalModel->mText.Count() ||
1742         !mImpl->IsPlaceholderAvailable() )
1743     {
1744       mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
1745     }
1746     else
1747     {
1748       ShowPlaceholderText();
1749       mImpl->mEventData->mUpdateCursorPosition = true;
1750     }
1751   }
1752
1753   return removed;
1754 }
1755
1756 void Controller::ShowPlaceholderText()
1757 {
1758   if( mImpl->IsPlaceholderAvailable() )
1759   {
1760     DALI_ASSERT_DEBUG( mImpl->mEventData && "No placeholder text available" );
1761
1762     mImpl->mEventData->mIsShowingPlaceholderText = true;
1763
1764     // Disable handles when showing place-holder text
1765     mImpl->mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
1766     mImpl->mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
1767     mImpl->mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
1768
1769     const char* text( NULL );
1770     size_t size( 0 );
1771
1772     // TODO - Switch placeholder text styles when changing state
1773     if( EventData::INACTIVE != mImpl->mEventData->mState &&
1774         0u != mImpl->mEventData->mPlaceholderTextActive.c_str() )
1775     {
1776       text = mImpl->mEventData->mPlaceholderTextActive.c_str();
1777       size = mImpl->mEventData->mPlaceholderTextActive.size();
1778     }
1779     else
1780     {
1781       text = mImpl->mEventData->mPlaceholderTextInactive.c_str();
1782       size = mImpl->mEventData->mPlaceholderTextInactive.size();
1783     }
1784
1785     // Reset model for showing placeholder.
1786     mImpl->mLogicalModel->mText.Clear();
1787     ClearModelData();
1788     mImpl->mVisualModel->SetTextColor( mImpl->mEventData->mPlaceholderTextColor );
1789
1790     // Convert text into UTF-32
1791     Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
1792     utf32Characters.Resize( size );
1793
1794     // This is a bit horrible but std::string returns a (signed) char*
1795     const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text );
1796
1797     // Transform a text array encoded in utf8 into an array encoded in utf32.
1798     // It returns the actual number of characters.
1799     Length characterCount = Utf8ToUtf32( utf8, size, utf32Characters.Begin() );
1800     utf32Characters.Resize( characterCount );
1801
1802     // Reset the cursor position
1803     mImpl->mEventData->mPrimaryCursorPosition = 0;
1804
1805     // The natural size needs to be re-calculated.
1806     mImpl->mRecalculateNaturalSize = true;
1807
1808     // Apply modifications to the model
1809     mImpl->mOperationsPending = ALL_OPERATIONS;
1810
1811     // Update the rest of the model during size negotiation
1812     mImpl->QueueModifyEvent( ModifyEvent::TEXT_REPLACED );
1813   }
1814 }
1815
1816 void Controller::ClearModelData()
1817 {
1818   // n.b. This does not Clear the mText from mLogicalModel
1819   mImpl->mLogicalModel->mScriptRuns.Clear();
1820   mImpl->mLogicalModel->mFontRuns.Clear();
1821   mImpl->mLogicalModel->mLineBreakInfo.Clear();
1822   mImpl->mLogicalModel->mWordBreakInfo.Clear();
1823   mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
1824   mImpl->mLogicalModel->mCharacterDirections.Clear();
1825   mImpl->mLogicalModel->mBidirectionalLineInfo.Clear();
1826   mImpl->mLogicalModel->mLogicalToVisualMap.Clear();
1827   mImpl->mLogicalModel->mVisualToLogicalMap.Clear();
1828   mImpl->mVisualModel->mGlyphs.Clear();
1829   mImpl->mVisualModel->mGlyphsToCharacters.Clear();
1830   mImpl->mVisualModel->mCharactersToGlyph.Clear();
1831   mImpl->mVisualModel->mCharactersPerGlyph.Clear();
1832   mImpl->mVisualModel->mGlyphsPerCharacter.Clear();
1833   mImpl->mVisualModel->mGlyphPositions.Clear();
1834   mImpl->mVisualModel->mLines.Clear();
1835   mImpl->mVisualModel->ClearCaches();
1836 }
1837
1838 void Controller::ClearFontData()
1839 {
1840   mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
1841   mImpl->mLogicalModel->mFontRuns.Clear();
1842   mImpl->mVisualModel->mGlyphs.Clear();
1843   mImpl->mVisualModel->mGlyphsToCharacters.Clear();
1844   mImpl->mVisualModel->mCharactersToGlyph.Clear();
1845   mImpl->mVisualModel->mCharactersPerGlyph.Clear();
1846   mImpl->mVisualModel->mGlyphsPerCharacter.Clear();
1847   mImpl->mVisualModel->mGlyphPositions.Clear();
1848   mImpl->mVisualModel->mLines.Clear();
1849   mImpl->mVisualModel->ClearCaches();
1850 }
1851
1852 Controller::Controller( ControlInterface& controlInterface )
1853 : mImpl( NULL )
1854 {
1855   mImpl = new Controller::Impl( controlInterface );
1856 }
1857
1858 } // namespace Text
1859
1860 } // namespace Toolkit
1861
1862 } // namespace Dali