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 <vector>
  24 #include <dali/public-api/adaptor-framework/key.h>
  25 #include <dali/public-api/text-abstraction/font-client.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-engine.h>
  31 #include <dali-toolkit/internal/text/layouts/layout-parameters.h>
  32 #include <dali-toolkit/internal/text/logical-model-impl.h>
  33 #include <dali-toolkit/internal/text/multi-language-support.h>
  34 #include <dali-toolkit/internal/text/script-run.h>
  35 #include <dali-toolkit/internal/text/segmentation.h>
  36 #include <dali-toolkit/internal/text/shaper.h>
  37 #include <dali-toolkit/internal/text/text-io.h>
  38 #include <dali-toolkit/internal/text/text-view.h>
  39 #include <dali-toolkit/internal/text/visual-model-impl.h>
  40
  41 using std::vector;
  42
  43 namespace
  44 {
  45
  46 const float MAX_FLOAT = std::numeric_limits<float>::max();
  47 const std::string EMPTY_STRING;
  48
  49 enum ModifyType
  50 {
  51   REPLACE_TEXT, ///< Replace the entire text
  52   INSERT_TEXT,  ///< Insert characters at the current cursor position
  53   DELETE_TEXT   ///< Delete a character at the current cursor position
  54 };
  55
  56 struct ModifyEvent
  57 {
  58   ModifyType type;
  59   std::string text;
  60 };
  61
  62 } // namespace
  63
  64 namespace Dali
  65 {
  66
  67 namespace Toolkit
  68 {
  69
  70 namespace Text
  71 {
  72
  73 struct Controller::TextInput
  74 {
  75   // Used to queue input events until DoRelayout()
  76   enum EventType
  77   {
  78     KEYBOARD_FOCUS_GAIN_EVENT,
  79     KEYBOARD_FOCUS_LOST_EVENT,
  80     CURSOR_KEY_EVENT,
  81     TAP_EVENT,
  82     GRAB_HANDLE_EVENT
  83   };
  84
  85   union Param
  86   {
  87     int mInt;
  88     unsigned int mUint;
  89     float mFloat;
  90   };
  91
  92   struct Event
  93   {
  94     Event( EventType eventType )
  95     : type( eventType )
  96     {
  97       p1.mInt = 0;
  98       p2.mInt = 0;
  99     }
 100
 101     EventType type;
 102     Param p1;
 103     Param p2;
 104     Param p3;
 105   };
 106
 107   enum State
 108   {
 109     INACTIVE,
 110     SELECTING,
 111     EDITING
 112   };
 113
 114   TextInput( LogicalModelPtr logicalModel,
 115              VisualModelPtr visualModel,
 116              DecoratorPtr decorator )
 117   : mLogicalModel( logicalModel ),
 118     mVisualModel( visualModel ),
 119     mDecorator( decorator ),
 120     mState( INACTIVE ),
 121     mPrimaryCursorPosition( 0u ),
 122     mSecondaryCursorPosition( 0u ),
 123     mDecoratorUpdated( false ),
 124     mCursorBlinkEnabled( true )
 125   {
 126   }
 127
 128   /**
 129    * @brief Helper to move the cursor, grab handle etc.
 130    */
 131   bool ProcessInputEvents()
 132   {
 133     mDecoratorUpdated = false;
 134
 135     if( mDecorator )
 136     {
 137       for( vector<TextInput::Event>::iterator iter = mEventQueue.begin(); iter != mEventQueue.end(); ++iter )
 138       {
 139         switch( iter->type )
 140         {
 141           case KEYBOARD_FOCUS_GAIN_EVENT:
 142           {
 143             OnKeyboardFocus( true );
 144             break;
 145           }
 146           case KEYBOARD_FOCUS_LOST_EVENT:
 147           {
 148             OnKeyboardFocus( false );
 149             break;
 150           }
 151           case CURSOR_KEY_EVENT:
 152           {
 153             OnCursorKeyEvent( *iter );
 154             break;
 155           }
 156           case TAP_EVENT:
 157           {
 158             OnTapEvent( *iter );
 159             break;
 160           }
 161           case GRAB_HANDLE_EVENT:
 162           {
 163             OnGrabHandleEvent( *iter );
 164             break;
 165           }
 166         }
 167       }
 168     }
 169
 170     mEventQueue.clear();
 171
 172     return mDecoratorUpdated;
 173   }
 174
 175   void OnKeyboardFocus( bool hasFocus )
 176   {
 177     if( !hasFocus )
 178     {
 179       ChangeState( INACTIVE );
 180     }
 181     else
 182     {
 183       ChangeState( EDITING );
 184     }
 185   }
 186
 187   void OnCursorKeyEvent( const Event& event )
 188   {
 189     int keyCode = event.p1.mInt;
 190
 191     if( Dali::DALI_KEY_CURSOR_LEFT == keyCode )
 192     {
 193       // TODO
 194     }
 195     else if( Dali::DALI_KEY_CURSOR_RIGHT == keyCode )
 196     {
 197       // TODO
 198     }
 199     else if( Dali::DALI_KEY_CURSOR_UP == keyCode )
 200     {
 201       // TODO
 202     }
 203     else if(   Dali::DALI_KEY_CURSOR_DOWN == keyCode )
 204     {
 205       // TODO
 206     }
 207   }
 208
 209   void HandleBackspaceKey()
 210   {
 211     // TODO
 212   }
 213
 214   void HandleCursorKey( int keyCode )
 215   {
 216     // TODO
 217   }
 218
 219   void HandleKeyString( const char* keyString )
 220   {
 221     // TODO
 222   }
 223
 224   void OnTapEvent( const Event& event )
 225   {
 226     unsigned int tapCount = event.p1.mUint;
 227
 228     if( 1u == tapCount )
 229     {
 230       ChangeState( EDITING );
 231
 232       float xPosition = event.p2.mFloat;
 233       float yPosition = event.p3.mFloat;
 234       float height(0.0f);
 235       GetClosestCursorPosition( xPosition, yPosition, height );
 236       mDecorator->SetPosition( PRIMARY_CURSOR, xPosition, yPosition, height );
 237
 238       mDecoratorUpdated = true;
 239     }
 240     else if( 2u == tapCount )
 241     {
 242       ChangeState( SELECTING );
 243     }
 244   }
 245
 246   void OnGrabHandleEvent( const Event& event )
 247   {
 248     unsigned int state = event.p1.mUint;
 249
 250     if( GRAB_HANDLE_PRESSED == state )
 251     {
 252       float xPosition = event.p2.mFloat;
 253       float yPosition = event.p3.mFloat;
 254       float height(0.0f);
 255
 256       GetClosestCursorPosition( xPosition, yPosition, height );
 257
 258       mDecorator->SetPosition( PRIMARY_CURSOR, xPosition, yPosition, height );
 259       mDecorator->HidePopup();
 260       mDecoratorUpdated = true;
 261     }
 262     else if ( GRAB_HANDLE_RELEASED == state )
 263     {
 264       mDecorator->ShowPopup();
 265     }
 266
 267   }
 268
 269   void ChangeState( State newState )
 270   {
 271     if( mState != newState )
 272     {
 273       mState = newState;
 274
 275       if( INACTIVE == mState )
 276       {
 277         mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
 278         mDecorator->StopCursorBlink();
 279         mDecorator->SetGrabHandleActive( false );
 280         mDecorator->SetSelectionActive( false );
 281         mDecorator->HidePopup();
 282         mDecoratorUpdated = true;
 283       }
 284       else if ( SELECTING == mState )
 285       {
 286         mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
 287         mDecorator->StopCursorBlink();
 288         mDecorator->SetGrabHandleActive( false );
 289         mDecorator->SetSelectionActive( true );
 290         mDecoratorUpdated = true;
 291       }
 292       else if( EDITING == mState )
 293       {
 294         mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
 295         if( mCursorBlinkEnabled )
 296         {
 297           mDecorator->StartCursorBlink();
 298         }
 299         mDecorator->SetGrabHandleActive( true );
 300         mDecorator->SetSelectionActive( false );
 301         mDecoratorUpdated = true;
 302       }
 303     }
 304   }
 305
 306   void GetClosestCursorPosition( float& x, float& y, float& height )
 307   {
 308     // TODO - Look at LineRuns first
 309
 310     Text::Length numberOfGlyphs = mVisualModel->GetNumberOfGlyphs();
 311     if( 0 == numberOfGlyphs )
 312     {
 313       return;
 314     }
 315
 316     Vector<GlyphInfo>& glyphs = mVisualModel->mGlyphs;
 317     const GlyphInfo* const glyphsBuffer = glyphs.Begin();
 318
 319     Vector<Vector2>& positions = mVisualModel->mGlyphPositions;
 320     const Vector2* const positionsBuffer = positions.Begin();
 321
 322     unsigned int closestGlyph = 0;
 323     float closestDistance = MAX_FLOAT;
 324
 325     for( unsigned int i = 0, numberOfGLyphs = glyphs.Count(); i < numberOfGLyphs; ++i )
 326     {
 327       const GlyphInfo& glyphInfo = *( glyphsBuffer + i );
 328       const Vector2& position = *( positionsBuffer + i );
 329       float glyphX = position.x + glyphInfo.width*0.5f;
 330       float glyphY = position.y + glyphInfo.height*0.5f;
 331
 332       float distanceToGlyph = fabsf( glyphX - x ) + fabsf( glyphY - y );
 333
 334       if( distanceToGlyph < closestDistance )
 335       {
 336         closestDistance = distanceToGlyph;
 337         closestGlyph = i;
 338       }
 339     }
 340
 341     // TODO - Consider RTL languages
 342     x = positions[closestGlyph].x + glyphs[closestGlyph].width;
 343     y = 0.0f;
 344
 345     FontMetrics metrics;
 346     TextAbstraction::FontClient::Get().GetFontMetrics( glyphs[closestGlyph].fontId, metrics );
 347     height = metrics.height; // TODO - Fix for multi-line
 348   }
 349
 350   LogicalModelPtr mLogicalModel;
 351   VisualModelPtr  mVisualModel;
 352   DecoratorPtr    mDecorator;
 353
 354   std::string mPlaceholderText;
 355
 356   /**
 357    * This is used to delay handling events until after the model has been updated.
 358    * The number of updates to the model is minimized to improve performance.
 359    */
 360   vector<Event> mEventQueue; ///< The queue of touch events etc.
 361
 362   State mState; ///< Selection mode, edit mode etc.
 363
 364   CharacterIndex mPrimaryCursorPosition;   ///< Index into logical model for primary cursor
 365   CharacterIndex mSecondaryCursorPosition; ///< Index into logical model for secondary cursor
 366
 367   bool mDecoratorUpdated   : 1; ///< True if the decorator was updated during event processing
 368   bool mCursorBlinkEnabled : 1; ///< True if cursor should blink when active
 369 };
 370
 371 struct Controller::FontDefaults
 372 {
 373   FontDefaults()
 374   : mDefaultPointSize(0.0f),
 375     mFontId(0u)
 376   {
 377   }
 378
 379   FontId GetFontId( TextAbstraction::FontClient& fontClient )
 380   {
 381     if( !mFontId )
 382     {
 383       Dali::TextAbstraction::PointSize26Dot6 pointSize = mDefaultPointSize*64;
 384       mFontId = fontClient.GetFontId( mDefaultFontFamily, mDefaultFontStyle, pointSize );
 385     }
 386
 387     return mFontId;
 388   }
 389
 390   std::string mDefaultFontFamily;
 391   std::string mDefaultFontStyle;
 392   float mDefaultPointSize;
 393   FontId mFontId;
 394 };
 395
 396 struct Controller::Impl
 397 {
 398   Impl( ControlInterface& controlInterface )
 399   : mControlInterface( controlInterface ),
 400     mLogicalModel(),
 401     mVisualModel(),
 402     mFontDefaults( NULL ),
 403     mTextInput( NULL ),
 404     mFontClient(),
 405     mView(),
 406     mLayoutEngine(),
 407     mModifyEvents(),
 408     mControlSize(),
 409     mOperationsPending( NO_OPERATION ),
 410     mRecalculateNaturalSize( true )
 411   {
 412     mLogicalModel = LogicalModel::New();
 413     mVisualModel  = VisualModel::New();
 414
 415     mFontClient = TextAbstraction::FontClient::Get();
 416
 417     mView.SetVisualModel( mVisualModel );
 418   }
 419
 420   ~Impl()
 421   {
 422     delete mTextInput;
 423   }
 424
 425   ControlInterface& mControlInterface;     ///< Reference to the text controller.
 426   LogicalModelPtr mLogicalModel;           ///< Pointer to the logical model.
 427   VisualModelPtr  mVisualModel;            ///< Pointer to the visual model.
 428   FontDefaults* mFontDefaults;             ///< Avoid allocating this when the user does not specify a font.
 429   Controller::TextInput* mTextInput;       ///< Avoid allocating everything for text input until EnableTextInput().
 430   TextAbstraction::FontClient mFontClient; ///< Handle to the font client.
 431   View mView;                              ///< The view interface to the rendering back-end.
 432   LayoutEngine mLayoutEngine;              ///< The layout engine.
 433   std::vector<ModifyEvent> mModifyEvents;  ///< Temporary stores the text set until the next relayout.
 434   Size mControlSize;                       ///< The size of the control.
 435   OperationsMask mOperationsPending;       ///< Operations pending to be done to layout the text.
 436   bool mRecalculateNaturalSize:1;          ///< Whether the natural size needs to be recalculated.
 437 };
 438
 439 ControllerPtr Controller::New( ControlInterface& controlInterface )
 440 {
 441   return ControllerPtr( new Controller( controlInterface ) );
 442 }
 443
 444 void Controller::SetText( const std::string& text )
 445 {
 446   // Cancel previously queued inserts etc.
 447   mImpl->mModifyEvents.clear();
 448
 449   // Keep until size negotiation
 450   ModifyEvent event;
 451   event.type = REPLACE_TEXT;
 452   event.text = text;
 453   mImpl->mModifyEvents.push_back( event );
 454
 455   if( mImpl->mTextInput )
 456   {
 457     // Cancel previously queued events
 458     mImpl->mTextInput->mEventQueue.clear();
 459
 460     // TODO - Hide selection decorations
 461   }
 462 }
 463
 464 void Controller::GetText( std::string& text ) const
 465 {
 466   if( !mImpl->mModifyEvents.empty() &&
 467        REPLACE_TEXT == mImpl->mModifyEvents[0].type )
 468   {
 469     text = mImpl->mModifyEvents[0].text;
 470   }
 471   else
 472   {
 473     // TODO - Convert from UTF-32
 474   }
 475 }
 476
 477 void Controller::SetPlaceholderText( const std::string& text )
 478 {
 479   if( !mImpl->mTextInput )
 480   {
 481     mImpl->mTextInput->mPlaceholderText = text;
 482   }
 483 }
 484
 485 void Controller::GetPlaceholderText( std::string& text ) const
 486 {
 487   if( !mImpl->mTextInput )
 488   {
 489     text = mImpl->mTextInput->mPlaceholderText;
 490   }
 491 }
 492
 493 void Controller::SetDefaultFontFamily( const std::string& defaultFontFamily )
 494 {
 495   if( !mImpl->mFontDefaults )
 496   {
 497     mImpl->mFontDefaults = new Controller::FontDefaults();
 498   }
 499
 500   mImpl->mFontDefaults->mDefaultFontFamily = defaultFontFamily;
 501   mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
 502   mImpl->mOperationsPending = ALL_OPERATIONS;
 503   mImpl->mRecalculateNaturalSize = true;
 504 }
 505
 506 const std::string& Controller::GetDefaultFontFamily() const
 507 {
 508   if( mImpl->mFontDefaults )
 509   {
 510     return mImpl->mFontDefaults->mDefaultFontFamily;
 511   }
 512
 513   return EMPTY_STRING;
 514 }
 515
 516 void Controller::SetDefaultFontStyle( const std::string& defaultFontStyle )
 517 {
 518   if( !mImpl->mFontDefaults )
 519   {
 520     mImpl->mFontDefaults = new Controller::FontDefaults();
 521   }
 522
 523   mImpl->mFontDefaults->mDefaultFontStyle = defaultFontStyle;
 524   mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
 525   mImpl->mOperationsPending = ALL_OPERATIONS;
 526   mImpl->mRecalculateNaturalSize = true;
 527 }
 528
 529 const std::string& Controller::GetDefaultFontStyle() const
 530 {
 531   if( mImpl->mFontDefaults )
 532   {
 533     return mImpl->mFontDefaults->mDefaultFontStyle;
 534   }
 535
 536   return EMPTY_STRING;
 537 }
 538
 539 void Controller::SetDefaultPointSize( float pointSize )
 540 {
 541   if( !mImpl->mFontDefaults )
 542   {
 543     mImpl->mFontDefaults = new Controller::FontDefaults();
 544   }
 545
 546   mImpl->mFontDefaults->mDefaultPointSize = pointSize;
 547   mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
 548   mImpl->mOperationsPending = ALL_OPERATIONS;
 549   mImpl->mRecalculateNaturalSize = true;
 550 }
 551
 552 float Controller::GetDefaultPointSize() const
 553 {
 554   if( mImpl->mFontDefaults )
 555   {
 556     return mImpl->mFontDefaults->mDefaultPointSize;
 557   }
 558
 559   return 0.0f;
 560 }
 561
 562 void Controller::GetDefaultFonts( Vector<FontRun>& fonts, Length numberOfCharacters )
 563 {
 564   if( mImpl->mFontDefaults )
 565   {
 566     FontRun fontRun;
 567     fontRun.characterRun.characterIndex = 0;
 568     fontRun.characterRun.numberOfCharacters = numberOfCharacters;
 569     fontRun.fontId = mImpl->mFontDefaults->GetFontId( mImpl->mFontClient );
 570     fontRun.isDefault = true;
 571
 572     fonts.PushBack( fontRun );
 573   }
 574 }
 575
 576 void Controller::EnableTextInput( DecoratorPtr decorator )
 577 {
 578   if( !mImpl->mTextInput )
 579   {
 580     mImpl->mTextInput = new TextInput( mImpl->mLogicalModel, mImpl->mVisualModel, decorator );
 581   }
 582 }
 583
 584 void Controller::SetEnableCursorBlink( bool enable )
 585 {
 586   DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "TextInput disabled" );
 587
 588   if( mImpl->mTextInput )
 589   {
 590     mImpl->mTextInput->mCursorBlinkEnabled = enable;
 591
 592     if( !enable &&
 593         mImpl->mTextInput->mDecorator )
 594     {
 595       mImpl->mTextInput->mDecorator->StopCursorBlink();
 596     }
 597   }
 598 }
 599
 600 bool Controller::GetEnableCursorBlink() const
 601 {
 602   if( mImpl->mTextInput )
 603   {
 604     return mImpl->mTextInput->mCursorBlinkEnabled;
 605   }
 606
 607   return false;
 608 }
 609
 610 Vector3 Controller::GetNaturalSize()
 611 {
 612   Vector3 naturalSize;
 613
 614   // Make sure the model is up-to-date before layouting
 615   ProcessModifyEvents();
 616
 617   if( mImpl->mRecalculateNaturalSize )
 618   {
 619     // Operations that can be done only once until the text changes.
 620     const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32  |
 621                                                                            GET_SCRIPTS       |
 622                                                                            VALIDATE_FONTS    |
 623                                                                            GET_LINE_BREAKS   |
 624                                                                            GET_WORD_BREAKS   |
 625                                                                            SHAPE_TEXT        |
 626                                                                            GET_GLYPH_METRICS );
 627     // Make sure the model is up-to-date before layouting
 628     UpdateModel( onlyOnceOperations );
 629
 630     // Operations that need to be done if the size changes.
 631     const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
 632                                                                         REORDER );
 633
 634     DoRelayout( Size( MAX_FLOAT, MAX_FLOAT ),
 635                 static_cast<OperationsMask>( onlyOnceOperations |
 636                                              sizeOperations ),
 637                 naturalSize.GetVectorXY() );
 638
 639     // Do not do again the only once operations.
 640     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
 641
 642     // Do the size related operations again.
 643     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
 644
 645     // Stores the natural size to avoid recalculate it again
 646     // unless the text/style changes.
 647     mImpl->mVisualModel->SetNaturalSize( naturalSize.GetVectorXY() );
 648
 649     mImpl->mRecalculateNaturalSize = false;
 650   }
 651   else
 652   {
 653     naturalSize = mImpl->mVisualModel->GetNaturalSize();
 654   }
 655
 656   return naturalSize;
 657 }
 658
 659 float Controller::GetHeightForWidth( float width )
 660 {
 661   // Make sure the model is up-to-date before layouting
 662   ProcessModifyEvents();
 663
 664   Size layoutSize;
 665   if( width != mImpl->mControlSize.width )
 666   {
 667     // Operations that can be done only once until the text changes.
 668     const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32  |
 669                                                                            GET_SCRIPTS       |
 670                                                                            VALIDATE_FONTS    |
 671                                                                            GET_LINE_BREAKS   |
 672                                                                            GET_WORD_BREAKS   |
 673                                                                            SHAPE_TEXT        |
 674                                                                            GET_GLYPH_METRICS );
 675     // Make sure the model is up-to-date before layouting
 676     UpdateModel( onlyOnceOperations );
 677
 678     // Operations that need to be done if the size changes.
 679     const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
 680                                                                         REORDER );
 681
 682     DoRelayout( Size( width, MAX_FLOAT ),
 683                 static_cast<OperationsMask>( onlyOnceOperations |
 684                                              sizeOperations ),
 685                 layoutSize );
 686
 687     // Do not do again the only once operations.
 688     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
 689
 690     // Do the size related operations again.
 691     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
 692   }
 693   else
 694   {
 695     layoutSize = mImpl->mVisualModel->GetActualSize();
 696   }
 697
 698   return layoutSize.height;
 699 }
 700
 701 bool Controller::Relayout( const Vector2& size )
 702 {
 703   if( ( size.width < Math::MACHINE_EPSILON_1000 ) || ( size.height < Math::MACHINE_EPSILON_1000 ) )
 704   {
 705     bool glyphsRemoved( false );
 706     if( 0u != mImpl->mVisualModel->GetNumberOfGlyphPositions() )
 707     {
 708       mImpl->mVisualModel->SetGlyphPositions( NULL, 0u );
 709       glyphsRemoved = true;
 710     }
 711
 712     // Not worth to relayout if width or height is equal to zero.
 713     return glyphsRemoved;
 714   }
 715
 716   if( size != mImpl->mControlSize )
 717   {
 718     // Operations that need to be done if the size changes.
 719     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
 720                                                              LAYOUT                    |
 721                                                              UPDATE_ACTUAL_SIZE        |
 722                                                              REORDER );
 723
 724     mImpl->mControlSize = size;
 725   }
 726
 727   // Make sure the model is up-to-date before layouting
 728   ProcessModifyEvents();
 729   UpdateModel( mImpl->mOperationsPending );
 730
 731   Size layoutSize;
 732   bool updated = DoRelayout( mImpl->mControlSize,
 733                              mImpl->mOperationsPending,
 734                              layoutSize );
 735
 736   // Do not re-do any operation until something changes.
 737   mImpl->mOperationsPending = NO_OPERATION;
 738
 739   if( mImpl->mTextInput )
 740   {
 741     // Move the cursor, grab handle etc.
 742     updated = mImpl->mTextInput->ProcessInputEvents() || updated;
 743   }
 744
 745   return updated;
 746 }
 747
 748 void Controller::ProcessModifyEvents()
 749 {
 750   std::vector<ModifyEvent>& events = mImpl->mModifyEvents;
 751
 752   for( unsigned int i=0; i<events.size(); ++i )
 753   {
 754     if( REPLACE_TEXT == events[0].type )
 755     {
 756       // A (single) replace event should come first, otherwise we wasted time processing NOOP events
 757       DALI_ASSERT_DEBUG( 0 == i && "Unexpected REPLACE event" );
 758
 759       ReplaceTextEvent( events[0].text );
 760     }
 761     else if( INSERT_TEXT == events[0].type )
 762     {
 763       InsertTextEvent( events[0].text );
 764     }
 765     else if( DELETE_TEXT == events[0].type )
 766     {
 767       DeleteTextEvent();
 768     }
 769   }
 770
 771   // Discard temporary text
 772   events.clear();
 773 }
 774
 775 void Controller::ReplaceTextEvent( const std::string& text )
 776 {
 777   // Reset buffers.
 778   mImpl->mLogicalModel->mScriptRuns.Clear();
 779   mImpl->mLogicalModel->mFontRuns.Clear();
 780   mImpl->mLogicalModel->mLineBreakInfo.Clear();
 781   mImpl->mLogicalModel->mWordBreakInfo.Clear();
 782   mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
 783   mImpl->mVisualModel->mGlyphs.Clear();
 784
 785   //  Convert text into UTF-32
 786   Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
 787   utf32Characters.Resize( text.size() );
 788
 789   // This is a bit horrible but std::string returns a (signed) char*
 790   const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
 791
 792   // Transform a text array encoded in utf8 into an array encoded in utf32.
 793   // It returns the actual number of characters.
 794   Length characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
 795   utf32Characters.Resize( characterCount );
 796
 797   // Reset the cursor position
 798   if( mImpl->mTextInput )
 799   {
 800     mImpl->mTextInput->mPrimaryCursorPosition = characterCount;
 801     // TODO - handle secondary cursor
 802   }
 803
 804   // The natural size needs to be re-calculated.
 805   mImpl->mRecalculateNaturalSize = true;
 806
 807   // Apply modifications to the model
 808   mImpl->mOperationsPending = ALL_OPERATIONS;
 809   UpdateModel( ALL_OPERATIONS );
 810   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT |
 811                                                            UPDATE_ACTUAL_SIZE |
 812                                                            REORDER );
 813 }
 814
 815 void Controller::InsertTextEvent( const std::string& text )
 816 {
 817   DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "Unexpected InsertTextEvent" );
 818
 819   // TODO - Optimize this
 820   mImpl->mLogicalModel->mScriptRuns.Clear();
 821   mImpl->mLogicalModel->mFontRuns.Clear();
 822   mImpl->mLogicalModel->mLineBreakInfo.Clear();
 823   mImpl->mLogicalModel->mWordBreakInfo.Clear();
 824   mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
 825   mImpl->mVisualModel->mGlyphs.Clear();
 826
 827   //  Convert text into UTF-32
 828   Vector<Character> utf32Characters;
 829   utf32Characters.Resize( text.size() );
 830
 831   // This is a bit horrible but std::string returns a (signed) char*
 832   const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
 833
 834   // Transform a text array encoded in utf8 into an array encoded in utf32.
 835   // It returns the actual number of characters.
 836   Length characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
 837   utf32Characters.Resize( characterCount );
 838
 839   // Insert at current cursor position
 840   Vector<Character>& modifyText = mImpl->mLogicalModel->mText;
 841   CharacterIndex& cursorIndex = mImpl->mTextInput->mPrimaryCursorPosition;
 842
 843   if( cursorIndex < modifyText.Count() )
 844   {
 845     modifyText.Insert( modifyText.Begin() + cursorIndex, utf32Characters.Begin(), utf32Characters.End() );
 846   }
 847   else
 848   {
 849     modifyText.Insert( modifyText.End(), utf32Characters.Begin(), utf32Characters.End() );
 850   }
 851
 852   // Advance the cursor position
 853   ++cursorIndex;
 854
 855   // The natural size needs to be re-calculated.
 856   mImpl->mRecalculateNaturalSize = true;
 857
 858   // Apply modifications to the model; TODO - Optimize this
 859   mImpl->mOperationsPending = ALL_OPERATIONS;
 860   UpdateModel( ALL_OPERATIONS );
 861   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT |
 862                                                            UPDATE_ACTUAL_SIZE |
 863                                                            REORDER );
 864 }
 865
 866 void Controller::DeleteTextEvent()
 867 {
 868   DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "Unexpected InsertTextEvent" );
 869
 870   // TODO - Optimize this
 871   mImpl->mLogicalModel->mScriptRuns.Clear();
 872   mImpl->mLogicalModel->mFontRuns.Clear();
 873   mImpl->mLogicalModel->mLineBreakInfo.Clear();
 874   mImpl->mLogicalModel->mWordBreakInfo.Clear();
 875   mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
 876   mImpl->mVisualModel->mGlyphs.Clear();
 877
 878   // Delte at current cursor position
 879   Vector<Character>& modifyText = mImpl->mLogicalModel->mText;
 880   CharacterIndex& cursorIndex = mImpl->mTextInput->mPrimaryCursorPosition;
 881
 882   if( cursorIndex > 0 &&
 883       cursorIndex-1 < modifyText.Count() )
 884   {
 885     modifyText.Remove( modifyText.Begin() + cursorIndex - 1 );
 886
 887     // Cursor position retreat
 888     --cursorIndex;
 889   }
 890
 891   // The natural size needs to be re-calculated.
 892   mImpl->mRecalculateNaturalSize = true;
 893
 894   // Apply modifications to the model; TODO - Optimize this
 895   mImpl->mOperationsPending = ALL_OPERATIONS;
 896   UpdateModel( ALL_OPERATIONS );
 897   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT |
 898                                                            UPDATE_ACTUAL_SIZE |
 899                                                            REORDER );
 900 }
 901
 902 void Controller::UpdateModel( OperationsMask operationsRequired )
 903 {
 904   // Calculate the operations to be done.
 905   const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
 906
 907   Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
 908
 909   const Length numberOfCharacters = mImpl->mLogicalModel->GetNumberOfCharacters();
 910
 911   Vector<LineBreakInfo>& lineBreakInfo = mImpl->mLogicalModel->mLineBreakInfo;
 912   if( GET_LINE_BREAKS & operations )
 913   {
 914     // Retrieves the line break info. The line break info is used to split the text in 'paragraphs' to
 915     // calculate the bidirectional info for each 'paragraph'.
 916     // It's also used to layout the text (where it should be a new line) or to shape the text (text in different lines
 917     // is not shaped together).
 918     lineBreakInfo.Resize( numberOfCharacters, TextAbstraction::LINE_NO_BREAK );
 919
 920     SetLineBreakInfo( utf32Characters,
 921                       lineBreakInfo );
 922   }
 923
 924   Vector<WordBreakInfo>& wordBreakInfo = mImpl->mLogicalModel->mWordBreakInfo;
 925   if( GET_WORD_BREAKS & operations )
 926   {
 927     // Retrieves the word break info. The word break info is used to layout the text (where to wrap the text in lines).
 928     wordBreakInfo.Resize( numberOfCharacters, TextAbstraction::WORD_NO_BREAK );
 929
 930     SetWordBreakInfo( utf32Characters,
 931                       wordBreakInfo );
 932   }
 933
 934   const bool getScripts = GET_SCRIPTS & operations;
 935   const bool validateFonts = VALIDATE_FONTS & operations;
 936
 937   Vector<ScriptRun>& scripts = mImpl->mLogicalModel->mScriptRuns;
 938   Vector<FontRun>& validFonts = mImpl->mLogicalModel->mFontRuns;
 939
 940   if( getScripts || validateFonts )
 941   {
 942     // Validates the fonts assigned by the application or assigns default ones.
 943     // It makes sure all the characters are going to be rendered by the correct font.
 944     MultilanguageSupport multilanguageSupport = MultilanguageSupport::Get();
 945
 946     if( getScripts )
 947     {
 948       // Retrieves the scripts used in the text.
 949       multilanguageSupport.SetScripts( utf32Characters,
 950                                        lineBreakInfo,
 951                                        scripts );
 952     }
 953
 954     if( validateFonts )
 955     {
 956       if( 0u == validFonts.Count() )
 957       {
 958         // Copy the requested font defaults received via the property system.
 959         // These may not be valid i.e. may not contain glyphs for the necessary scripts.
 960         GetDefaultFonts( validFonts, numberOfCharacters );
 961       }
 962
 963       // Validates the fonts. If there is a character with no assigned font it sets a default one.
 964       // After this call, fonts are validated.
 965       multilanguageSupport.ValidateFonts( utf32Characters,
 966                                           scripts,
 967                                           validFonts );
 968     }
 969   }
 970
 971   if( BIDI_INFO & operations )
 972   {
 973     // Count the number of LINE_NO_BREAK to reserve some space for the vector of paragraph's
 974     // bidirectional info.
 975
 976     Length numberOfParagraphs = 0u;
 977
 978     const TextAbstraction::LineBreakInfo* lineBreakInfoBuffer = lineBreakInfo.Begin();
 979     for( Length index = 0u; index < numberOfCharacters; ++index )
 980     {
 981       if( TextAbstraction::LINE_NO_BREAK == *( lineBreakInfoBuffer + index ) )
 982       {
 983         ++numberOfParagraphs;
 984       }
 985     }
 986
 987     Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mImpl->mLogicalModel->mBidirectionalParagraphInfo;
 988     bidirectionalInfo.Reserve( numberOfParagraphs );
 989
 990     // Calculates the bidirectional info for the whole paragraph if it contains right to left scripts.
 991     SetBidirectionalInfo( utf32Characters,
 992                           scripts,
 993                           lineBreakInfo,
 994                           bidirectionalInfo );
 995   }
 996
 997   Vector<GlyphInfo>& glyphs = mImpl->mVisualModel->mGlyphs;
 998   Vector<CharacterIndex>& glyphsToCharactersMap = mImpl->mVisualModel->mGlyphsToCharacters;
 999   Vector<Length>& charactersPerGlyph = mImpl->mVisualModel->mCharactersPerGlyph;
1000   if( SHAPE_TEXT & operations )
1001   {
1002     // Shapes the text.
1003     ShapeText( utf32Characters,
1004                lineBreakInfo,
1005                scripts,
1006                validFonts,
1007                glyphs,
1008                glyphsToCharactersMap,
1009                charactersPerGlyph );
1010   }
1011
1012   const Length numberOfGlyphs = glyphs.Count();
1013
1014   if( GET_GLYPH_METRICS & operations )
1015   {
1016     mImpl->mFontClient.GetGlyphMetrics( glyphs.Begin(), numberOfGlyphs );
1017   }
1018
1019   if( 0u != numberOfGlyphs )
1020   {
1021     // Create the glyph to character conversion table and the 'number of glyphs' per character.
1022     mImpl->mVisualModel->CreateCharacterToGlyphTable(numberOfCharacters );
1023     mImpl->mVisualModel->CreateGlyphsPerCharacterTable( numberOfCharacters );
1024   }
1025 }
1026
1027 bool Controller::DoRelayout( const Vector2& size,
1028                              OperationsMask operationsRequired,
1029                              Size& layoutSize )
1030 {
1031   bool viewUpdated( false );
1032
1033   // Calculate the operations to be done.
1034   const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
1035
1036   if( LAYOUT & operations )
1037   {
1038     // Some vectors with data needed to layout and reorder may be void
1039     // after the first time the text has been laid out.
1040     // Fill the vectors again.
1041
1042     const Length numberOfCharacters = mImpl->mLogicalModel->GetNumberOfCharacters();
1043     Length numberOfGlyphs = mImpl->mVisualModel->GetNumberOfGlyphs();
1044
1045     Vector<LineBreakInfo>& lineBreakInfo = mImpl->mLogicalModel->mLineBreakInfo;
1046     Vector<WordBreakInfo>& wordBreakInfo = mImpl->mLogicalModel->mWordBreakInfo;
1047     Vector<GlyphInfo>& glyphs = mImpl->mVisualModel->mGlyphs;
1048     Vector<CharacterIndex>& glyphsToCharactersMap = mImpl->mVisualModel->mGlyphsToCharacters;
1049     Vector<Length>& charactersPerGlyph = mImpl->mVisualModel->mCharactersPerGlyph;
1050
1051     // Set the layout parameters.
1052     LayoutParameters layoutParameters( size,
1053                                        lineBreakInfo.Begin(),
1054                                        wordBreakInfo.Begin(),
1055                                        numberOfGlyphs,
1056                                        glyphs.Begin(),
1057                                        glyphsToCharactersMap.Begin(),
1058                                        charactersPerGlyph.Begin() );
1059
1060     // The laid-out lines.
1061     // It's not possible to know in how many lines the text is going to be laid-out,
1062     // but it can be resized at least with the number of 'paragraphs' to avoid
1063     // some re-allocations.
1064     Vector<LineRun>& lines = mImpl->mVisualModel->mLines;
1065
1066     // Resize the vector of positions to have the same size than the vector of glyphs.
1067     Vector<Vector2>& glyphPositions = mImpl->mVisualModel->mGlyphPositions;
1068     glyphPositions.Resize( numberOfGlyphs );
1069
1070     BidirectionalRunIndex firstBidiRunIndex = 0u;
1071     Length numberOfBidiRuns = 0u;
1072     mImpl->mLogicalModel->GetNumberOfBidirectionalInfoRuns( 0u, numberOfCharacters, firstBidiRunIndex, numberOfBidiRuns );
1073
1074     // Delete any previous laid out lines before setting the new ones.
1075     lines.Clear();
1076     lines.Reserve( numberOfBidiRuns );
1077
1078     // Update the visual model.
1079     viewUpdated = mImpl->mLayoutEngine.LayoutText( layoutParameters,
1080                                                    glyphPositions,
1081                                                    lines,
1082                                                    layoutSize );
1083
1084     if( viewUpdated )
1085     {
1086       // Reorder the lines
1087       if( REORDER & operations )
1088       {
1089         Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mImpl->mLogicalModel->mBidirectionalParagraphInfo;
1090
1091         // Check first if there are paragraphs with bidirectional info.
1092         if( 0u != bidirectionalInfo.Count() )
1093         {
1094           // Get the lines
1095           const Length numberOfLines = mImpl->mVisualModel->GetNumberOfLines();
1096
1097           // Reorder the lines.
1098           Vector<BidirectionalLineInfoRun> lineBidirectionalInfoRuns;
1099           lineBidirectionalInfoRuns.Reserve( numberOfLines ); // Reserve because is not known yet how many lines have right to left characters.
1100           ReorderLines( bidirectionalInfo,
1101                         lines,
1102                         lineBidirectionalInfoRuns );
1103
1104           // Set the bidirectional info into the model.
1105           const Length numberOfBidirectionalInfoRuns = lineBidirectionalInfoRuns.Count();
1106           mImpl->mLogicalModel->SetVisualToLogicalMap( lineBidirectionalInfoRuns.Begin(),
1107                                                        numberOfBidirectionalInfoRuns );
1108
1109           // Set the bidirectional info per line into the layout parameters.
1110           layoutParameters.lineBidirectionalInfoRunsBuffer = lineBidirectionalInfoRuns.Begin();
1111           layoutParameters.numberOfBidirectionalInfoRuns = numberOfBidirectionalInfoRuns;
1112
1113           // Get the character to glyph conversion table and set into the layout.
1114           layoutParameters.charactersToGlyphsBuffer = mImpl->mVisualModel->mCharactersToGlyph.Begin();
1115
1116           // Get the glyphs per character table and set into the layout.
1117           layoutParameters.glyphsPerCharacterBuffer = mImpl->mVisualModel->mGlyphsPerCharacter.Begin();
1118
1119           // Re-layout the text. Reorder those lines with right to left characters.
1120           mImpl->mLayoutEngine.ReLayoutRightToLeftLines( layoutParameters,
1121                                                          glyphPositions );
1122
1123           // Free the allocated memory used to store the conversion table in the bidirectional line info run.
1124           for( Vector<BidirectionalLineInfoRun>::Iterator it = lineBidirectionalInfoRuns.Begin(),
1125                  endIt = lineBidirectionalInfoRuns.End();
1126                it != endIt;
1127                ++it )
1128           {
1129             BidirectionalLineInfoRun& bidiLineInfo = *it;
1130
1131             free( bidiLineInfo.visualToLogicalMap );
1132           }
1133         }
1134       }
1135
1136       // Sets the actual size.
1137       if( UPDATE_ACTUAL_SIZE & operations )
1138       {
1139         mImpl->mVisualModel->SetActualSize( layoutSize );
1140       }
1141     }
1142   }
1143   else
1144   {
1145     layoutSize = mImpl->mVisualModel->GetActualSize();
1146   }
1147
1148   return viewUpdated;
1149 }
1150
1151 View& Controller::GetView()
1152 {
1153   return mImpl->mView;
1154 }
1155
1156 LayoutEngine& Controller::GetLayoutEngine()
1157 {
1158   return mImpl->mLayoutEngine;
1159 }
1160
1161 void Controller::RequestRelayout()
1162 {
1163   mImpl->mControlInterface.RequestTextRelayout();
1164 }
1165
1166 void Controller::KeyboardFocusGainEvent()
1167 {
1168   DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyboardFocusGainEvent" );
1169
1170   if( mImpl->mTextInput )
1171   {
1172     TextInput::Event event( TextInput::KEYBOARD_FOCUS_GAIN_EVENT );
1173     mImpl->mTextInput->mEventQueue.push_back( event );
1174
1175     RequestRelayout();
1176   }
1177 }
1178
1179 void Controller::KeyboardFocusLostEvent()
1180 {
1181   DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyboardFocusLostEvent" );
1182
1183   if( mImpl->mTextInput )
1184   {
1185     TextInput::Event event( TextInput::KEYBOARD_FOCUS_LOST_EVENT );
1186     mImpl->mTextInput->mEventQueue.push_back( event );
1187
1188     RequestRelayout();
1189   }
1190 }
1191
1192 bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent )
1193 {
1194   DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyEvent" );
1195
1196   if( mImpl->mTextInput &&
1197       keyEvent.state == KeyEvent::Down )
1198   {
1199     int keyCode = keyEvent.keyCode;
1200     const std::string& keyString = keyEvent.keyPressed;
1201
1202     // Pre-process to separate modifying events from non-modifying input events.
1203     if( Dali::DALI_KEY_ESCAPE == keyCode )
1204     {
1205       // Escape key is a special case which causes focus loss
1206       KeyboardFocusLostEvent();
1207     }
1208     else if( Dali::DALI_KEY_CURSOR_LEFT  == keyCode ||
1209              Dali::DALI_KEY_CURSOR_RIGHT == keyCode ||
1210              Dali::DALI_KEY_CURSOR_UP    == keyCode ||
1211              Dali::DALI_KEY_CURSOR_DOWN  == keyCode )
1212     {
1213       TextInput::Event event( TextInput::CURSOR_KEY_EVENT );
1214       event.p1.mInt = keyCode;
1215       mImpl->mTextInput->mEventQueue.push_back( event );
1216     }
1217     else if( Dali::DALI_KEY_BACKSPACE == keyCode )
1218     {
1219       // Queue a delete event
1220       ModifyEvent event;
1221       event.type = DELETE_TEXT;
1222       mImpl->mModifyEvents.push_back( event );
1223     }
1224     else if( !keyString.empty() )
1225     {
1226       // Queue an insert event
1227       ModifyEvent event;
1228       event.type = INSERT_TEXT;
1229       event.text = keyString;
1230       mImpl->mModifyEvents.push_back( event );
1231     }
1232
1233     RequestRelayout();
1234   }
1235
1236   return false;
1237 }
1238
1239 void Controller::TapEvent( unsigned int tapCount, float x, float y )
1240 {
1241   DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected TapEvent" );
1242
1243   if( mImpl->mTextInput )
1244   {
1245     TextInput::Event event( TextInput::TAP_EVENT );
1246     event.p1.mUint = tapCount;
1247     event.p2.mFloat = x;
1248     event.p3.mFloat = y;
1249     mImpl->mTextInput->mEventQueue.push_back( event );
1250
1251     RequestRelayout();
1252   }
1253 }
1254
1255 void Controller::GrabHandleEvent( GrabHandleState state, float x, float y )
1256 {
1257   DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected GrabHandleEvent" );
1258
1259   if( mImpl->mTextInput )
1260   {
1261     TextInput::Event event( TextInput::GRAB_HANDLE_EVENT );
1262     event.p1.mUint  = state;
1263     event.p2.mFloat = x;
1264     event.p3.mFloat = y;
1265     mImpl->mTextInput->mEventQueue.push_back( event );
1266
1267     RequestRelayout();
1268   }
1269 }
1270
1271 Controller::~Controller()
1272 {
1273   delete mImpl;
1274 }
1275
1276 Controller::Controller( ControlInterface& controlInterface )
1277 : mImpl( NULL )
1278 {
1279   mImpl = new Controller::Impl( controlInterface );
1280 }
1281
1282 } // namespace Text
1283
1284 } // namespace Toolkit
1285
1286 } // namespace Dali