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