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                                                                            BIDI_INFO         |
 626                                                                            SHAPE_TEXT        |
 627                                                                            GET_GLYPH_METRICS );
 628     // Make sure the model is up-to-date before layouting
 629     UpdateModel( onlyOnceOperations );
 630
 631     // Operations that need to be done if the size changes.
 632     const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
 633                                                                         REORDER );
 634
 635     DoRelayout( Size( MAX_FLOAT, MAX_FLOAT ),
 636                 static_cast<OperationsMask>( onlyOnceOperations |
 637                                              sizeOperations ),
 638                 naturalSize.GetVectorXY() );
 639
 640     // Do not do again the only once operations.
 641     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
 642
 643     // Do the size related operations again.
 644     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
 645
 646     // Stores the natural size to avoid recalculate it again
 647     // unless the text/style changes.
 648     mImpl->mVisualModel->SetNaturalSize( naturalSize.GetVectorXY() );
 649
 650     mImpl->mRecalculateNaturalSize = false;
 651   }
 652   else
 653   {
 654     naturalSize = mImpl->mVisualModel->GetNaturalSize();
 655   }
 656
 657   return naturalSize;
 658 }
 659
 660 float Controller::GetHeightForWidth( float width )
 661 {
 662   // Make sure the model is up-to-date before layouting
 663   ProcessModifyEvents();
 664
 665   Size layoutSize;
 666   if( width != mImpl->mControlSize.width )
 667   {
 668     // Operations that can be done only once until the text changes.
 669     const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32  |
 670                                                                            GET_SCRIPTS       |
 671                                                                            VALIDATE_FONTS    |
 672                                                                            GET_LINE_BREAKS   |
 673                                                                            GET_WORD_BREAKS   |
 674                                                                            BIDI_INFO         |
 675                                                                            SHAPE_TEXT        |
 676                                                                            GET_GLYPH_METRICS );
 677     // Make sure the model is up-to-date before layouting
 678     UpdateModel( onlyOnceOperations );
 679
 680     // Operations that need to be done if the size changes.
 681     const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
 682                                                                         REORDER );
 683
 684     DoRelayout( Size( width, MAX_FLOAT ),
 685                 static_cast<OperationsMask>( onlyOnceOperations |
 686                                              sizeOperations ),
 687                 layoutSize );
 688
 689     // Do not do again the only once operations.
 690     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
 691
 692     // Do the size related operations again.
 693     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
 694   }
 695   else
 696   {
 697     layoutSize = mImpl->mVisualModel->GetActualSize();
 698   }
 699
 700   return layoutSize.height;
 701 }
 702
 703 bool Controller::Relayout( const Vector2& size )
 704 {
 705   if( ( size.width < Math::MACHINE_EPSILON_1000 ) || ( size.height < Math::MACHINE_EPSILON_1000 ) )
 706   {
 707     bool glyphsRemoved( false );
 708     if( 0u != mImpl->mVisualModel->GetNumberOfGlyphPositions() )
 709     {
 710       mImpl->mVisualModel->SetGlyphPositions( NULL, 0u );
 711       glyphsRemoved = true;
 712     }
 713
 714     // Not worth to relayout if width or height is equal to zero.
 715     return glyphsRemoved;
 716   }
 717
 718   if( size != mImpl->mControlSize )
 719   {
 720     // Operations that need to be done if the size changes.
 721     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
 722                                                              LAYOUT                    |
 723                                                              UPDATE_ACTUAL_SIZE        |
 724                                                              REORDER );
 725
 726     mImpl->mControlSize = size;
 727   }
 728
 729   // Make sure the model is up-to-date before layouting
 730   ProcessModifyEvents();
 731   UpdateModel( mImpl->mOperationsPending );
 732
 733   Size layoutSize;
 734   bool updated = DoRelayout( mImpl->mControlSize,
 735                              mImpl->mOperationsPending,
 736                              layoutSize );
 737
 738   // Do not re-do any operation until something changes.
 739   mImpl->mOperationsPending = NO_OPERATION;
 740
 741   if( mImpl->mTextInput )
 742   {
 743     // Move the cursor, grab handle etc.
 744     updated = mImpl->mTextInput->ProcessInputEvents() || updated;
 745   }
 746
 747   return updated;
 748 }
 749
 750 void Controller::ProcessModifyEvents()
 751 {
 752   std::vector<ModifyEvent>& events = mImpl->mModifyEvents;
 753
 754   for( unsigned int i=0; i<events.size(); ++i )
 755   {
 756     if( REPLACE_TEXT == events[0].type )
 757     {
 758       // A (single) replace event should come first, otherwise we wasted time processing NOOP events
 759       DALI_ASSERT_DEBUG( 0 == i && "Unexpected REPLACE event" );
 760
 761       ReplaceTextEvent( events[0].text );
 762     }
 763     else if( INSERT_TEXT == events[0].type )
 764     {
 765       InsertTextEvent( events[0].text );
 766     }
 767     else if( DELETE_TEXT == events[0].type )
 768     {
 769       DeleteTextEvent();
 770     }
 771   }
 772
 773   // Discard temporary text
 774   events.clear();
 775 }
 776
 777 void Controller::ReplaceTextEvent( const std::string& text )
 778 {
 779   // Reset buffers.
 780   mImpl->mLogicalModel->mScriptRuns.Clear();
 781   mImpl->mLogicalModel->mFontRuns.Clear();
 782   mImpl->mLogicalModel->mLineBreakInfo.Clear();
 783   mImpl->mLogicalModel->mWordBreakInfo.Clear();
 784   mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
 785   mImpl->mVisualModel->mGlyphs.Clear();
 786
 787   //  Convert text into UTF-32
 788   Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
 789   utf32Characters.Resize( text.size() );
 790
 791   // This is a bit horrible but std::string returns a (signed) char*
 792   const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
 793
 794   // Transform a text array encoded in utf8 into an array encoded in utf32.
 795   // It returns the actual number of characters.
 796   Length characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
 797   utf32Characters.Resize( characterCount );
 798
 799   // Reset the cursor position
 800   if( mImpl->mTextInput )
 801   {
 802     mImpl->mTextInput->mPrimaryCursorPosition = characterCount;
 803     // TODO - handle secondary cursor
 804   }
 805
 806   // The natural size needs to be re-calculated.
 807   mImpl->mRecalculateNaturalSize = true;
 808
 809   // Apply modifications to the model
 810   mImpl->mOperationsPending = ALL_OPERATIONS;
 811   UpdateModel( ALL_OPERATIONS );
 812   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT |
 813                                                            UPDATE_ACTUAL_SIZE |
 814                                                            REORDER );
 815 }
 816
 817 void Controller::InsertTextEvent( const std::string& text )
 818 {
 819   DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "Unexpected InsertTextEvent" );
 820
 821   // TODO - Optimize this
 822   mImpl->mLogicalModel->mScriptRuns.Clear();
 823   mImpl->mLogicalModel->mFontRuns.Clear();
 824   mImpl->mLogicalModel->mLineBreakInfo.Clear();
 825   mImpl->mLogicalModel->mWordBreakInfo.Clear();
 826   mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
 827   mImpl->mVisualModel->mGlyphs.Clear();
 828
 829   //  Convert text into UTF-32
 830   Vector<Character> utf32Characters;
 831   utf32Characters.Resize( text.size() );
 832
 833   // This is a bit horrible but std::string returns a (signed) char*
 834   const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
 835
 836   // Transform a text array encoded in utf8 into an array encoded in utf32.
 837   // It returns the actual number of characters.
 838   Length characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
 839   utf32Characters.Resize( characterCount );
 840
 841   // Insert at current cursor position
 842   Vector<Character>& modifyText = mImpl->mLogicalModel->mText;
 843   CharacterIndex& cursorIndex = mImpl->mTextInput->mPrimaryCursorPosition;
 844
 845   if( cursorIndex < modifyText.Count() )
 846   {
 847     modifyText.Insert( modifyText.Begin() + cursorIndex, utf32Characters.Begin(), utf32Characters.End() );
 848   }
 849   else
 850   {
 851     modifyText.Insert( modifyText.End(), utf32Characters.Begin(), utf32Characters.End() );
 852   }
 853
 854   // Advance the cursor position
 855   ++cursorIndex;
 856
 857   // The natural size needs to be re-calculated.
 858   mImpl->mRecalculateNaturalSize = true;
 859
 860   // Apply modifications to the model; TODO - Optimize this
 861   mImpl->mOperationsPending = ALL_OPERATIONS;
 862   UpdateModel( ALL_OPERATIONS );
 863   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT |
 864                                                            UPDATE_ACTUAL_SIZE |
 865                                                            REORDER );
 866 }
 867
 868 void Controller::DeleteTextEvent()
 869 {
 870   DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "Unexpected InsertTextEvent" );
 871
 872   // TODO - Optimize this
 873   mImpl->mLogicalModel->mScriptRuns.Clear();
 874   mImpl->mLogicalModel->mFontRuns.Clear();
 875   mImpl->mLogicalModel->mLineBreakInfo.Clear();
 876   mImpl->mLogicalModel->mWordBreakInfo.Clear();
 877   mImpl->mLogicalModel->mBidirectionalParagraphInfo.Clear();
 878   mImpl->mVisualModel->mGlyphs.Clear();
 879
 880   // Delte at current cursor position
 881   Vector<Character>& modifyText = mImpl->mLogicalModel->mText;
 882   CharacterIndex& cursorIndex = mImpl->mTextInput->mPrimaryCursorPosition;
 883
 884   if( cursorIndex > 0 &&
 885       cursorIndex-1 < modifyText.Count() )
 886   {
 887     modifyText.Remove( modifyText.Begin() + cursorIndex - 1 );
 888
 889     // Cursor position retreat
 890     --cursorIndex;
 891   }
 892
 893   // The natural size needs to be re-calculated.
 894   mImpl->mRecalculateNaturalSize = true;
 895
 896   // Apply modifications to the model; TODO - Optimize this
 897   mImpl->mOperationsPending = ALL_OPERATIONS;
 898   UpdateModel( ALL_OPERATIONS );
 899   mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT |
 900                                                            UPDATE_ACTUAL_SIZE |
 901                                                            REORDER );
 902 }
 903
 904 void Controller::UpdateModel( OperationsMask operationsRequired )
 905 {
 906   // Calculate the operations to be done.
 907   const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
 908
 909   Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
 910
 911   const Length numberOfCharacters = mImpl->mLogicalModel->GetNumberOfCharacters();
 912
 913   Vector<LineBreakInfo>& lineBreakInfo = mImpl->mLogicalModel->mLineBreakInfo;
 914   if( GET_LINE_BREAKS & operations )
 915   {
 916     // Retrieves the line break info. The line break info is used to split the text in 'paragraphs' to
 917     // calculate the bidirectional info for each 'paragraph'.
 918     // It's also used to layout the text (where it should be a new line) or to shape the text (text in different lines
 919     // is not shaped together).
 920     lineBreakInfo.Resize( numberOfCharacters, TextAbstraction::LINE_NO_BREAK );
 921
 922     SetLineBreakInfo( utf32Characters,
 923                       lineBreakInfo );
 924   }
 925
 926   Vector<WordBreakInfo>& wordBreakInfo = mImpl->mLogicalModel->mWordBreakInfo;
 927   if( GET_WORD_BREAKS & operations )
 928   {
 929     // Retrieves the word break info. The word break info is used to layout the text (where to wrap the text in lines).
 930     wordBreakInfo.Resize( numberOfCharacters, TextAbstraction::WORD_NO_BREAK );
 931
 932     SetWordBreakInfo( utf32Characters,
 933                       wordBreakInfo );
 934   }
 935
 936   const bool getScripts = GET_SCRIPTS & operations;
 937   const bool validateFonts = VALIDATE_FONTS & operations;
 938
 939   Vector<ScriptRun>& scripts = mImpl->mLogicalModel->mScriptRuns;
 940   Vector<FontRun>& validFonts = mImpl->mLogicalModel->mFontRuns;
 941
 942   if( getScripts || validateFonts )
 943   {
 944     // Validates the fonts assigned by the application or assigns default ones.
 945     // It makes sure all the characters are going to be rendered by the correct font.
 946     MultilanguageSupport multilanguageSupport = MultilanguageSupport::Get();
 947
 948     if( getScripts )
 949     {
 950       // Retrieves the scripts used in the text.
 951       multilanguageSupport.SetScripts( utf32Characters,
 952                                        lineBreakInfo,
 953                                        scripts );
 954     }
 955
 956     if( validateFonts )
 957     {
 958       if( 0u == validFonts.Count() )
 959       {
 960         // Copy the requested font defaults received via the property system.
 961         // These may not be valid i.e. may not contain glyphs for the necessary scripts.
 962         GetDefaultFonts( validFonts, numberOfCharacters );
 963       }
 964
 965       // Validates the fonts. If there is a character with no assigned font it sets a default one.
 966       // After this call, fonts are validated.
 967       multilanguageSupport.ValidateFonts( utf32Characters,
 968                                           scripts,
 969                                           validFonts );
 970     }
 971   }
 972
 973   Vector<Character> mirroredUtf32Characters;
 974   bool textMirrored = false;
 975   if( BIDI_INFO & operations )
 976   {
 977     // Count the number of LINE_NO_BREAK to reserve some space for the vector of paragraph's
 978     // bidirectional info.
 979
 980     Length numberOfParagraphs = 0u;
 981
 982     const TextAbstraction::LineBreakInfo* lineBreakInfoBuffer = lineBreakInfo.Begin();
 983     for( Length index = 0u; index < numberOfCharacters; ++index )
 984     {
 985       if( TextAbstraction::LINE_NO_BREAK == *( lineBreakInfoBuffer + index ) )
 986       {
 987         ++numberOfParagraphs;
 988       }
 989     }
 990
 991     Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mImpl->mLogicalModel->mBidirectionalParagraphInfo;
 992     bidirectionalInfo.Reserve( numberOfParagraphs );
 993
 994     // Calculates the bidirectional info for the whole paragraph if it contains right to left scripts.
 995     SetBidirectionalInfo( utf32Characters,
 996                           scripts,
 997                           lineBreakInfo,
 998                           bidirectionalInfo );
 999
1000     if( 0u != bidirectionalInfo.Count() )
1001     {
1002       // This paragraph has right to left text. Some characters may need to be mirrored.
1003       // TODO: consider if the mirrored string can be stored as well.
1004
1005       textMirrored = GetMirroredText( utf32Characters, mirroredUtf32Characters );
1006     }
1007   }
1008
1009   Vector<GlyphInfo>& glyphs = mImpl->mVisualModel->mGlyphs;
1010   Vector<CharacterIndex>& glyphsToCharactersMap = mImpl->mVisualModel->mGlyphsToCharacters;
1011   Vector<Length>& charactersPerGlyph = mImpl->mVisualModel->mCharactersPerGlyph;
1012   if( SHAPE_TEXT & operations )
1013   {
1014     const Vector<Character>& textToShape = textMirrored ? mirroredUtf32Characters : utf32Characters;
1015     // Shapes the text.
1016     ShapeText( textToShape,
1017                lineBreakInfo,
1018                scripts,
1019                validFonts,
1020                glyphs,
1021                glyphsToCharactersMap,
1022                charactersPerGlyph );
1023   }
1024
1025   const Length numberOfGlyphs = glyphs.Count();
1026
1027   if( GET_GLYPH_METRICS & operations )
1028   {
1029     mImpl->mFontClient.GetGlyphMetrics( glyphs.Begin(), numberOfGlyphs );
1030   }
1031
1032   if( 0u != numberOfGlyphs )
1033   {
1034     // Create the glyph to character conversion table and the 'number of glyphs' per character.
1035     mImpl->mVisualModel->CreateCharacterToGlyphTable(numberOfCharacters );
1036     mImpl->mVisualModel->CreateGlyphsPerCharacterTable( numberOfCharacters );
1037   }
1038 }
1039
1040 bool Controller::DoRelayout( const Vector2& size,
1041                              OperationsMask operationsRequired,
1042                              Size& layoutSize )
1043 {
1044   bool viewUpdated( false );
1045
1046   // Calculate the operations to be done.
1047   const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
1048
1049   if( LAYOUT & operations )
1050   {
1051     // Some vectors with data needed to layout and reorder may be void
1052     // after the first time the text has been laid out.
1053     // Fill the vectors again.
1054
1055     const Length numberOfCharacters = mImpl->mLogicalModel->GetNumberOfCharacters();
1056     Length numberOfGlyphs = mImpl->mVisualModel->GetNumberOfGlyphs();
1057
1058     Vector<LineBreakInfo>& lineBreakInfo = mImpl->mLogicalModel->mLineBreakInfo;
1059     Vector<WordBreakInfo>& wordBreakInfo = mImpl->mLogicalModel->mWordBreakInfo;
1060     Vector<GlyphInfo>& glyphs = mImpl->mVisualModel->mGlyphs;
1061     Vector<CharacterIndex>& glyphsToCharactersMap = mImpl->mVisualModel->mGlyphsToCharacters;
1062     Vector<Length>& charactersPerGlyph = mImpl->mVisualModel->mCharactersPerGlyph;
1063
1064     // Set the layout parameters.
1065     LayoutParameters layoutParameters( size,
1066                                        lineBreakInfo.Begin(),
1067                                        wordBreakInfo.Begin(),
1068                                        numberOfGlyphs,
1069                                        glyphs.Begin(),
1070                                        glyphsToCharactersMap.Begin(),
1071                                        charactersPerGlyph.Begin() );
1072
1073     // The laid-out lines.
1074     // It's not possible to know in how many lines the text is going to be laid-out,
1075     // but it can be resized at least with the number of 'paragraphs' to avoid
1076     // some re-allocations.
1077     Vector<LineRun>& lines = mImpl->mVisualModel->mLines;
1078
1079     // Resize the vector of positions to have the same size than the vector of glyphs.
1080     Vector<Vector2>& glyphPositions = mImpl->mVisualModel->mGlyphPositions;
1081     glyphPositions.Resize( numberOfGlyphs );
1082
1083     BidirectionalRunIndex firstBidiRunIndex = 0u;
1084     Length numberOfBidiRuns = 0u;
1085     mImpl->mLogicalModel->GetNumberOfBidirectionalInfoRuns( 0u, numberOfCharacters, firstBidiRunIndex, numberOfBidiRuns );
1086
1087     // Delete any previous laid out lines before setting the new ones.
1088     lines.Clear();
1089     lines.Reserve( numberOfBidiRuns );
1090
1091     // Update the visual model.
1092     viewUpdated = mImpl->mLayoutEngine.LayoutText( layoutParameters,
1093                                                    glyphPositions,
1094                                                    lines,
1095                                                    layoutSize );
1096
1097     if( viewUpdated )
1098     {
1099       // Reorder the lines
1100       if( REORDER & operations )
1101       {
1102         Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mImpl->mLogicalModel->mBidirectionalParagraphInfo;
1103
1104         // Check first if there are paragraphs with bidirectional info.
1105         if( 0u != bidirectionalInfo.Count() )
1106         {
1107           // Get the lines
1108           const Length numberOfLines = mImpl->mVisualModel->GetNumberOfLines();
1109
1110           // Reorder the lines.
1111           Vector<BidirectionalLineInfoRun> lineBidirectionalInfoRuns;
1112           lineBidirectionalInfoRuns.Reserve( numberOfLines ); // Reserve because is not known yet how many lines have right to left characters.
1113           ReorderLines( bidirectionalInfo,
1114                         lines,
1115                         lineBidirectionalInfoRuns );
1116
1117           // Set the bidirectional info into the model.
1118           const Length numberOfBidirectionalInfoRuns = lineBidirectionalInfoRuns.Count();
1119           mImpl->mLogicalModel->SetVisualToLogicalMap( lineBidirectionalInfoRuns.Begin(),
1120                                                        numberOfBidirectionalInfoRuns );
1121
1122           // Set the bidirectional info per line into the layout parameters.
1123           layoutParameters.lineBidirectionalInfoRunsBuffer = lineBidirectionalInfoRuns.Begin();
1124           layoutParameters.numberOfBidirectionalInfoRuns = numberOfBidirectionalInfoRuns;
1125
1126           // Get the character to glyph conversion table and set into the layout.
1127           layoutParameters.charactersToGlyphsBuffer = mImpl->mVisualModel->mCharactersToGlyph.Begin();
1128
1129           // Get the glyphs per character table and set into the layout.
1130           layoutParameters.glyphsPerCharacterBuffer = mImpl->mVisualModel->mGlyphsPerCharacter.Begin();
1131
1132           // Re-layout the text. Reorder those lines with right to left characters.
1133           mImpl->mLayoutEngine.ReLayoutRightToLeftLines( layoutParameters,
1134                                                          glyphPositions );
1135
1136           // Free the allocated memory used to store the conversion table in the bidirectional line info run.
1137           for( Vector<BidirectionalLineInfoRun>::Iterator it = lineBidirectionalInfoRuns.Begin(),
1138                  endIt = lineBidirectionalInfoRuns.End();
1139                it != endIt;
1140                ++it )
1141           {
1142             BidirectionalLineInfoRun& bidiLineInfo = *it;
1143
1144             free( bidiLineInfo.visualToLogicalMap );
1145           }
1146         }
1147       }
1148
1149       // Sets the actual size.
1150       if( UPDATE_ACTUAL_SIZE & operations )
1151       {
1152         mImpl->mVisualModel->SetActualSize( layoutSize );
1153       }
1154     }
1155   }
1156   else
1157   {
1158     layoutSize = mImpl->mVisualModel->GetActualSize();
1159   }
1160
1161   return viewUpdated;
1162 }
1163
1164 View& Controller::GetView()
1165 {
1166   return mImpl->mView;
1167 }
1168
1169 LayoutEngine& Controller::GetLayoutEngine()
1170 {
1171   return mImpl->mLayoutEngine;
1172 }
1173
1174 void Controller::RequestRelayout()
1175 {
1176   mImpl->mControlInterface.RequestTextRelayout();
1177 }
1178
1179 void Controller::KeyboardFocusGainEvent()
1180 {
1181   DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyboardFocusGainEvent" );
1182
1183   if( mImpl->mTextInput )
1184   {
1185     TextInput::Event event( TextInput::KEYBOARD_FOCUS_GAIN_EVENT );
1186     mImpl->mTextInput->mEventQueue.push_back( event );
1187
1188     RequestRelayout();
1189   }
1190 }
1191
1192 void Controller::KeyboardFocusLostEvent()
1193 {
1194   DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyboardFocusLostEvent" );
1195
1196   if( mImpl->mTextInput )
1197   {
1198     TextInput::Event event( TextInput::KEYBOARD_FOCUS_LOST_EVENT );
1199     mImpl->mTextInput->mEventQueue.push_back( event );
1200
1201     RequestRelayout();
1202   }
1203 }
1204
1205 bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent )
1206 {
1207   DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyEvent" );
1208
1209   if( mImpl->mTextInput &&
1210       keyEvent.state == KeyEvent::Down )
1211   {
1212     int keyCode = keyEvent.keyCode;
1213     const std::string& keyString = keyEvent.keyPressed;
1214
1215     // Pre-process to separate modifying events from non-modifying input events.
1216     if( Dali::DALI_KEY_ESCAPE == keyCode )
1217     {
1218       // Escape key is a special case which causes focus loss
1219       KeyboardFocusLostEvent();
1220     }
1221     else if( Dali::DALI_KEY_CURSOR_LEFT  == keyCode ||
1222              Dali::DALI_KEY_CURSOR_RIGHT == keyCode ||
1223              Dali::DALI_KEY_CURSOR_UP    == keyCode ||
1224              Dali::DALI_KEY_CURSOR_DOWN  == keyCode )
1225     {
1226       TextInput::Event event( TextInput::CURSOR_KEY_EVENT );
1227       event.p1.mInt = keyCode;
1228       mImpl->mTextInput->mEventQueue.push_back( event );
1229     }
1230     else if( Dali::DALI_KEY_BACKSPACE == keyCode )
1231     {
1232       // Queue a delete event
1233       ModifyEvent event;
1234       event.type = DELETE_TEXT;
1235       mImpl->mModifyEvents.push_back( event );
1236     }
1237     else if( !keyString.empty() )
1238     {
1239       // Queue an insert event
1240       ModifyEvent event;
1241       event.type = INSERT_TEXT;
1242       event.text = keyString;
1243       mImpl->mModifyEvents.push_back( event );
1244     }
1245
1246     RequestRelayout();
1247   }
1248
1249   return false;
1250 }
1251
1252 void Controller::TapEvent( unsigned int tapCount, float x, float y )
1253 {
1254   DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected TapEvent" );
1255
1256   if( mImpl->mTextInput )
1257   {
1258     TextInput::Event event( TextInput::TAP_EVENT );
1259     event.p1.mUint = tapCount;
1260     event.p2.mFloat = x;
1261     event.p3.mFloat = y;
1262     mImpl->mTextInput->mEventQueue.push_back( event );
1263
1264     RequestRelayout();
1265   }
1266 }
1267
1268 void Controller::GrabHandleEvent( GrabHandleState state, float x, float y )
1269 {
1270   DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected GrabHandleEvent" );
1271
1272   if( mImpl->mTextInput )
1273   {
1274     TextInput::Event event( TextInput::GRAB_HANDLE_EVENT );
1275     event.p1.mUint  = state;
1276     event.p2.mFloat = x;
1277     event.p3.mFloat = y;
1278     mImpl->mTextInput->mEventQueue.push_back( event );
1279
1280     RequestRelayout();
1281   }
1282 }
1283
1284 Controller::~Controller()
1285 {
1286   delete mImpl;
1287 }
1288
1289 Controller::Controller( ControlInterface& controlInterface )
1290 : mImpl( NULL )
1291 {
1292   mImpl = new Controller::Impl( controlInterface );
1293 }
1294
1295 } // namespace Text
1296
1297 } // namespace Toolkit
1298
1299 } // namespace Dali