2 * Copyright (c) 2015 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <dali-toolkit/internal/text/text-controller.h>
24 #include <dali/public-api/adaptor-framework/key.h>
25 #include <dali/public-api/text-abstraction/font-client.h>
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>
46 const float MAX_FLOAT = std::numeric_limits<float>::max();
47 const std::string EMPTY_STRING;
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
73 struct Controller::TextInput
75 // Used to queue input events until DoRelayout()
78 KEYBOARD_FOCUS_GAIN_EVENT,
79 KEYBOARD_FOCUS_LOST_EVENT,
94 Event( EventType eventType )
114 TextInput( LogicalModelPtr logicalModel,
115 VisualModelPtr visualModel,
116 DecoratorPtr decorator )
117 : mLogicalModel( logicalModel ),
118 mVisualModel( visualModel ),
119 mDecorator( decorator ),
121 mPrimaryCursorPosition( 0u ),
122 mSecondaryCursorPosition( 0u ),
123 mDecoratorUpdated( false ),
124 mCursorBlinkEnabled( true )
129 * @brief Helper to move the cursor, grab handle etc.
131 bool ProcessInputEvents()
133 mDecoratorUpdated = false;
137 for( vector<TextInput::Event>::iterator iter = mEventQueue.begin(); iter != mEventQueue.end(); ++iter )
141 case KEYBOARD_FOCUS_GAIN_EVENT:
143 OnKeyboardFocus( true );
146 case KEYBOARD_FOCUS_LOST_EVENT:
148 OnKeyboardFocus( false );
151 case CURSOR_KEY_EVENT:
153 OnCursorKeyEvent( *iter );
161 case GRAB_HANDLE_EVENT:
163 OnGrabHandleEvent( *iter );
172 return mDecoratorUpdated;
175 void OnKeyboardFocus( bool hasFocus )
179 ChangeState( INACTIVE );
183 ChangeState( EDITING );
187 void OnCursorKeyEvent( const Event& event )
189 int keyCode = event.p1.mInt;
191 if( Dali::DALI_KEY_CURSOR_LEFT == keyCode )
195 else if( Dali::DALI_KEY_CURSOR_RIGHT == keyCode )
199 else if( Dali::DALI_KEY_CURSOR_UP == keyCode )
203 else if( Dali::DALI_KEY_CURSOR_DOWN == keyCode )
209 void HandleBackspaceKey()
214 void HandleCursorKey( int keyCode )
219 void HandleKeyString( const char* keyString )
224 void OnTapEvent( const Event& event )
226 unsigned int tapCount = event.p1.mUint;
230 ChangeState( EDITING );
232 float xPosition = event.p2.mFloat;
233 float yPosition = event.p3.mFloat;
235 GetClosestCursorPosition( xPosition, yPosition, height );
236 mDecorator->SetPosition( PRIMARY_CURSOR, xPosition, yPosition, height );
238 mDecoratorUpdated = true;
240 else if( 2u == tapCount )
242 ChangeState( SELECTING );
246 void OnGrabHandleEvent( const Event& event )
248 unsigned int state = event.p1.mUint;
250 if( GRAB_HANDLE_PRESSED == state )
252 float xPosition = event.p2.mFloat;
253 float yPosition = event.p3.mFloat;
256 GetClosestCursorPosition( xPosition, yPosition, height );
258 mDecorator->SetPosition( PRIMARY_CURSOR, xPosition, yPosition, height );
259 mDecorator->HidePopup();
260 mDecoratorUpdated = true;
262 else if ( GRAB_HANDLE_RELEASED == state )
264 mDecorator->ShowPopup();
269 void ChangeState( State newState )
271 if( mState != newState )
275 if( INACTIVE == mState )
277 mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
278 mDecorator->StopCursorBlink();
279 mDecorator->SetGrabHandleActive( false );
280 mDecorator->SetSelectionActive( false );
281 mDecorator->HidePopup();
282 mDecoratorUpdated = true;
284 else if ( SELECTING == mState )
286 mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
287 mDecorator->StopCursorBlink();
288 mDecorator->SetGrabHandleActive( false );
289 mDecorator->SetSelectionActive( true );
290 mDecoratorUpdated = true;
292 else if( EDITING == mState )
294 mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
295 if( mCursorBlinkEnabled )
297 mDecorator->StartCursorBlink();
299 mDecorator->SetGrabHandleActive( true );
300 mDecorator->SetSelectionActive( false );
301 mDecoratorUpdated = true;
306 void GetClosestCursorPosition( float& x, float& y, float& height )
308 // TODO - Look at LineRuns first
310 Text::Length numberOfGlyphs = mVisualModel->GetNumberOfGlyphs();
311 if( 0 == numberOfGlyphs )
316 Vector<GlyphInfo>& glyphs = mVisualModel->mGlyphs;
317 const GlyphInfo* const glyphsBuffer = glyphs.Begin();
319 Vector<Vector2>& positions = mVisualModel->mGlyphPositions;
320 const Vector2* const positionsBuffer = positions.Begin();
322 unsigned int closestGlyph = 0;
323 float closestDistance = MAX_FLOAT;
325 for( unsigned int i = 0, numberOfGLyphs = glyphs.Count(); i < numberOfGLyphs; ++i )
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;
332 float distanceToGlyph = fabsf( glyphX - x ) + fabsf( glyphY - y );
334 if( distanceToGlyph < closestDistance )
336 closestDistance = distanceToGlyph;
341 // TODO - Consider RTL languages
342 x = positions[closestGlyph].x + glyphs[closestGlyph].width;
346 TextAbstraction::FontClient::Get().GetFontMetrics( glyphs[closestGlyph].fontId, metrics );
347 height = metrics.height; // TODO - Fix for multi-line
350 LogicalModelPtr mLogicalModel;
351 VisualModelPtr mVisualModel;
352 DecoratorPtr mDecorator;
354 std::string mPlaceholderText;
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.
360 vector<Event> mEventQueue; ///< The queue of touch events etc.
362 State mState; ///< Selection mode, edit mode etc.
364 CharacterIndex mPrimaryCursorPosition; ///< Index into logical model for primary cursor
365 CharacterIndex mSecondaryCursorPosition; ///< Index into logical model for secondary cursor
367 bool mDecoratorUpdated : 1; ///< True if the decorator was updated during event processing
368 bool mCursorBlinkEnabled : 1; ///< True if cursor should blink when active
371 struct Controller::FontDefaults
374 : mDefaultPointSize(0.0f),
379 FontId GetFontId( TextAbstraction::FontClient& fontClient )
383 Dali::TextAbstraction::PointSize26Dot6 pointSize = mDefaultPointSize*64;
384 mFontId = fontClient.GetFontId( mDefaultFontFamily, mDefaultFontStyle, pointSize );
390 std::string mDefaultFontFamily;
391 std::string mDefaultFontStyle;
392 float mDefaultPointSize;
396 struct Controller::Impl
398 Impl( ControlInterface& controlInterface )
399 : mControlInterface( controlInterface ),
402 mFontDefaults( NULL ),
409 mOperationsPending( NO_OPERATION ),
410 mRecalculateNaturalSize( true )
412 mLogicalModel = LogicalModel::New();
413 mVisualModel = VisualModel::New();
415 mFontClient = TextAbstraction::FontClient::Get();
417 mView.SetVisualModel( mVisualModel );
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.
439 ControllerPtr Controller::New( ControlInterface& controlInterface )
441 return ControllerPtr( new Controller( controlInterface ) );
444 void Controller::SetText( const std::string& text )
446 // Cancel previously queued inserts etc.
447 mImpl->mModifyEvents.clear();
449 // Keep until size negotiation
451 event.type = REPLACE_TEXT;
453 mImpl->mModifyEvents.push_back( event );
455 if( mImpl->mTextInput )
457 // Cancel previously queued events
458 mImpl->mTextInput->mEventQueue.clear();
460 // TODO - Hide selection decorations
464 void Controller::GetText( std::string& text ) const
466 if( !mImpl->mModifyEvents.empty() &&
467 REPLACE_TEXT == mImpl->mModifyEvents[0].type )
469 text = mImpl->mModifyEvents[0].text;
473 // TODO - Convert from UTF-32
477 void Controller::SetPlaceholderText( const std::string& text )
479 if( !mImpl->mTextInput )
481 mImpl->mTextInput->mPlaceholderText = text;
485 void Controller::GetPlaceholderText( std::string& text ) const
487 if( !mImpl->mTextInput )
489 text = mImpl->mTextInput->mPlaceholderText;
493 void Controller::SetDefaultFontFamily( const std::string& defaultFontFamily )
495 if( !mImpl->mFontDefaults )
497 mImpl->mFontDefaults = new Controller::FontDefaults();
500 mImpl->mFontDefaults->mDefaultFontFamily = defaultFontFamily;
501 mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
502 mImpl->mOperationsPending = ALL_OPERATIONS;
503 mImpl->mRecalculateNaturalSize = true;
506 const std::string& Controller::GetDefaultFontFamily() const
508 if( mImpl->mFontDefaults )
510 return mImpl->mFontDefaults->mDefaultFontFamily;
516 void Controller::SetDefaultFontStyle( const std::string& defaultFontStyle )
518 if( !mImpl->mFontDefaults )
520 mImpl->mFontDefaults = new Controller::FontDefaults();
523 mImpl->mFontDefaults->mDefaultFontStyle = defaultFontStyle;
524 mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
525 mImpl->mOperationsPending = ALL_OPERATIONS;
526 mImpl->mRecalculateNaturalSize = true;
529 const std::string& Controller::GetDefaultFontStyle() const
531 if( mImpl->mFontDefaults )
533 return mImpl->mFontDefaults->mDefaultFontStyle;
539 void Controller::SetDefaultPointSize( float pointSize )
541 if( !mImpl->mFontDefaults )
543 mImpl->mFontDefaults = new Controller::FontDefaults();
546 mImpl->mFontDefaults->mDefaultPointSize = pointSize;
547 mImpl->mFontDefaults->mFontId = 0u; // Remove old font ID
548 mImpl->mOperationsPending = ALL_OPERATIONS;
549 mImpl->mRecalculateNaturalSize = true;
552 float Controller::GetDefaultPointSize() const
554 if( mImpl->mFontDefaults )
556 return mImpl->mFontDefaults->mDefaultPointSize;
562 void Controller::GetDefaultFonts( Vector<FontRun>& fonts, Length numberOfCharacters )
564 if( mImpl->mFontDefaults )
567 fontRun.characterRun.characterIndex = 0;
568 fontRun.characterRun.numberOfCharacters = numberOfCharacters;
569 fontRun.fontId = mImpl->mFontDefaults->GetFontId( mImpl->mFontClient );
570 fontRun.isDefault = true;
572 fonts.PushBack( fontRun );
576 void Controller::EnableTextInput( DecoratorPtr decorator )
578 if( !mImpl->mTextInput )
580 mImpl->mTextInput = new TextInput( mImpl->mLogicalModel, mImpl->mVisualModel, decorator );
584 void Controller::SetEnableCursorBlink( bool enable )
586 DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "TextInput disabled" );
588 if( mImpl->mTextInput )
590 mImpl->mTextInput->mCursorBlinkEnabled = enable;
593 mImpl->mTextInput->mDecorator )
595 mImpl->mTextInput->mDecorator->StopCursorBlink();
600 bool Controller::GetEnableCursorBlink() const
602 if( mImpl->mTextInput )
604 return mImpl->mTextInput->mCursorBlinkEnabled;
610 Vector3 Controller::GetNaturalSize()
614 // Make sure the model is up-to-date before layouting
615 ProcessModifyEvents();
617 if( mImpl->mRecalculateNaturalSize )
619 // Operations that can be done only once until the text changes.
620 const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32 |
627 // Make sure the model is up-to-date before layouting
628 UpdateModel( onlyOnceOperations );
630 // Operations that need to be done if the size changes.
631 const OperationsMask sizeOperations = static_cast<OperationsMask>( LAYOUT |
634 DoRelayout( Size( MAX_FLOAT, MAX_FLOAT ),
635 static_cast<OperationsMask>( onlyOnceOperations |
637 naturalSize.GetVectorXY() );
639 // Do not do again the only once operations.
640 mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
642 // Do the size related operations again.
643 mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
645 // Stores the natural size to avoid recalculate it again
646 // unless the text/style changes.
647 mImpl->mVisualModel->SetNaturalSize( naturalSize.GetVectorXY() );
649 mImpl->mRecalculateNaturalSize = false;
653 naturalSize = mImpl->mVisualModel->GetNaturalSize();
659 float Controller::GetHeightForWidth( float width )
661 // Make sure the model is up-to-date before layouting
662 ProcessModifyEvents();
665 if( width != mImpl->mControlSize.width )
667 // Operations that can be done only once until the text changes.
668 const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32 |
675 // Make sure the model is up-to-date before layouting
676 UpdateModel( onlyOnceOperations );
678 // Operations that need to be done if the size changes.
679 const OperationsMask sizeOperations = static_cast<OperationsMask>( LAYOUT |
682 DoRelayout( Size( width, MAX_FLOAT ),
683 static_cast<OperationsMask>( onlyOnceOperations |
687 // Do not do again the only once operations.
688 mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
690 // Do the size related operations again.
691 mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
695 layoutSize = mImpl->mVisualModel->GetActualSize();
698 return layoutSize.height;
701 bool Controller::Relayout( const Vector2& size )
703 if( ( size.width < Math::MACHINE_EPSILON_1000 ) || ( size.height < Math::MACHINE_EPSILON_1000 ) )
705 bool glyphsRemoved( false );
706 if( 0u != mImpl->mVisualModel->GetNumberOfGlyphPositions() )
708 mImpl->mVisualModel->SetGlyphPositions( NULL, 0u );
709 glyphsRemoved = true;
712 // Not worth to relayout if width or height is equal to zero.
713 return glyphsRemoved;
716 if( size != mImpl->mControlSize )
718 // Operations that need to be done if the size changes.
719 mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
724 mImpl->mControlSize = size;
727 // Make sure the model is up-to-date before layouting
728 ProcessModifyEvents();
729 UpdateModel( mImpl->mOperationsPending );
732 bool updated = DoRelayout( mImpl->mControlSize,
733 mImpl->mOperationsPending,
736 // Do not re-do any operation until something changes.
737 mImpl->mOperationsPending = NO_OPERATION;
739 if( mImpl->mTextInput )
741 // Move the cursor, grab handle etc.
742 updated = mImpl->mTextInput->ProcessInputEvents() || updated;
748 void Controller::ProcessModifyEvents()
750 std::vector<ModifyEvent>& events = mImpl->mModifyEvents;
752 for( unsigned int i=0; i<events.size(); ++i )
754 if( REPLACE_TEXT == events[0].type )
756 // A (single) replace event should come first, otherwise we wasted time processing NOOP events
757 DALI_ASSERT_DEBUG( 0 == i && "Unexpected REPLACE event" );
759 ReplaceTextEvent( events[0].text );
761 else if( INSERT_TEXT == events[0].type )
763 InsertTextEvent( events[0].text );
765 else if( DELETE_TEXT == events[0].type )
771 // Discard temporary text
775 void Controller::ReplaceTextEvent( const std::string& text )
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();
785 // Convert text into UTF-32
786 Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
787 utf32Characters.Resize( text.size() );
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() );
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 );
797 // Reset the cursor position
798 if( mImpl->mTextInput )
800 mImpl->mTextInput->mPrimaryCursorPosition = characterCount;
801 // TODO - handle secondary cursor
804 // The natural size needs to be re-calculated.
805 mImpl->mRecalculateNaturalSize = true;
807 // Apply modifications to the model
808 mImpl->mOperationsPending = ALL_OPERATIONS;
809 UpdateModel( ALL_OPERATIONS );
810 mImpl->mOperationsPending = static_cast<OperationsMask>( LAYOUT |
815 void Controller::InsertTextEvent( const std::string& text )
817 DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "Unexpected InsertTextEvent" );
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();
827 // Convert text into UTF-32
828 Vector<Character> utf32Characters;
829 utf32Characters.Resize( text.size() );
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() );
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 );
839 // Insert at current cursor position
840 Vector<Character>& modifyText = mImpl->mLogicalModel->mText;
841 CharacterIndex& cursorIndex = mImpl->mTextInput->mPrimaryCursorPosition;
843 if( cursorIndex < modifyText.Count() )
845 modifyText.Insert( modifyText.Begin() + cursorIndex, utf32Characters.Begin(), utf32Characters.End() );
849 modifyText.Insert( modifyText.End(), utf32Characters.Begin(), utf32Characters.End() );
852 // Advance the cursor position
855 // The natural size needs to be re-calculated.
856 mImpl->mRecalculateNaturalSize = true;
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 |
866 void Controller::DeleteTextEvent()
868 DALI_ASSERT_DEBUG( NULL != mImpl->mTextInput && "Unexpected InsertTextEvent" );
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();
878 // Delte at current cursor position
879 Vector<Character>& modifyText = mImpl->mLogicalModel->mText;
880 CharacterIndex& cursorIndex = mImpl->mTextInput->mPrimaryCursorPosition;
882 if( cursorIndex > 0 &&
883 cursorIndex-1 < modifyText.Count() )
885 modifyText.Remove( modifyText.Begin() + cursorIndex - 1 );
887 // Cursor position retreat
891 // The natural size needs to be re-calculated.
892 mImpl->mRecalculateNaturalSize = true;
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 |
902 void Controller::UpdateModel( OperationsMask operationsRequired )
904 // Calculate the operations to be done.
905 const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
907 Vector<Character>& utf32Characters = mImpl->mLogicalModel->mText;
909 const Length numberOfCharacters = mImpl->mLogicalModel->GetNumberOfCharacters();
911 Vector<LineBreakInfo>& lineBreakInfo = mImpl->mLogicalModel->mLineBreakInfo;
912 if( GET_LINE_BREAKS & operations )
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 );
920 SetLineBreakInfo( utf32Characters,
924 Vector<WordBreakInfo>& wordBreakInfo = mImpl->mLogicalModel->mWordBreakInfo;
925 if( GET_WORD_BREAKS & operations )
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 );
930 SetWordBreakInfo( utf32Characters,
934 const bool getScripts = GET_SCRIPTS & operations;
935 const bool validateFonts = VALIDATE_FONTS & operations;
937 Vector<ScriptRun>& scripts = mImpl->mLogicalModel->mScriptRuns;
938 Vector<FontRun>& validFonts = mImpl->mLogicalModel->mFontRuns;
940 if( getScripts || validateFonts )
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();
948 // Retrieves the scripts used in the text.
949 multilanguageSupport.SetScripts( utf32Characters,
956 if( 0u == validFonts.Count() )
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 );
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,
971 if( BIDI_INFO & operations )
973 // Count the number of LINE_NO_BREAK to reserve some space for the vector of paragraph's
974 // bidirectional info.
976 Length numberOfParagraphs = 0u;
978 const TextAbstraction::LineBreakInfo* lineBreakInfoBuffer = lineBreakInfo.Begin();
979 for( Length index = 0u; index < numberOfCharacters; ++index )
981 if( TextAbstraction::LINE_NO_BREAK == *( lineBreakInfoBuffer + index ) )
983 ++numberOfParagraphs;
987 Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mImpl->mLogicalModel->mBidirectionalParagraphInfo;
988 bidirectionalInfo.Reserve( numberOfParagraphs );
990 // Calculates the bidirectional info for the whole paragraph if it contains right to left scripts.
991 SetBidirectionalInfo( utf32Characters,
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 )
1003 ShapeText( utf32Characters,
1008 glyphsToCharactersMap,
1009 charactersPerGlyph );
1012 const Length numberOfGlyphs = glyphs.Count();
1014 if( GET_GLYPH_METRICS & operations )
1016 mImpl->mFontClient.GetGlyphMetrics( glyphs.Begin(), numberOfGlyphs );
1019 if( 0u != numberOfGlyphs )
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 );
1027 bool Controller::DoRelayout( const Vector2& size,
1028 OperationsMask operationsRequired,
1031 bool viewUpdated( false );
1033 // Calculate the operations to be done.
1034 const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
1036 if( LAYOUT & operations )
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.
1042 const Length numberOfCharacters = mImpl->mLogicalModel->GetNumberOfCharacters();
1043 Length numberOfGlyphs = mImpl->mVisualModel->GetNumberOfGlyphs();
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;
1051 // Set the layout parameters.
1052 LayoutParameters layoutParameters( size,
1053 lineBreakInfo.Begin(),
1054 wordBreakInfo.Begin(),
1057 glyphsToCharactersMap.Begin(),
1058 charactersPerGlyph.Begin() );
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;
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 );
1070 BidirectionalRunIndex firstBidiRunIndex = 0u;
1071 Length numberOfBidiRuns = 0u;
1072 mImpl->mLogicalModel->GetNumberOfBidirectionalInfoRuns( 0u, numberOfCharacters, firstBidiRunIndex, numberOfBidiRuns );
1074 // Delete any previous laid out lines before setting the new ones.
1076 lines.Reserve( numberOfBidiRuns );
1078 // Update the visual model.
1079 viewUpdated = mImpl->mLayoutEngine.LayoutText( layoutParameters,
1086 // Reorder the lines
1087 if( REORDER & operations )
1089 Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mImpl->mLogicalModel->mBidirectionalParagraphInfo;
1091 // Check first if there are paragraphs with bidirectional info.
1092 if( 0u != bidirectionalInfo.Count() )
1095 const Length numberOfLines = mImpl->mVisualModel->GetNumberOfLines();
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,
1102 lineBidirectionalInfoRuns );
1104 // Set the bidirectional info into the model.
1105 const Length numberOfBidirectionalInfoRuns = lineBidirectionalInfoRuns.Count();
1106 mImpl->mLogicalModel->SetVisualToLogicalMap( lineBidirectionalInfoRuns.Begin(),
1107 numberOfBidirectionalInfoRuns );
1109 // Set the bidirectional info per line into the layout parameters.
1110 layoutParameters.lineBidirectionalInfoRunsBuffer = lineBidirectionalInfoRuns.Begin();
1111 layoutParameters.numberOfBidirectionalInfoRuns = numberOfBidirectionalInfoRuns;
1113 // Get the character to glyph conversion table and set into the layout.
1114 layoutParameters.charactersToGlyphsBuffer = mImpl->mVisualModel->mCharactersToGlyph.Begin();
1116 // Get the glyphs per character table and set into the layout.
1117 layoutParameters.glyphsPerCharacterBuffer = mImpl->mVisualModel->mGlyphsPerCharacter.Begin();
1119 // Re-layout the text. Reorder those lines with right to left characters.
1120 mImpl->mLayoutEngine.ReLayoutRightToLeftLines( layoutParameters,
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();
1129 BidirectionalLineInfoRun& bidiLineInfo = *it;
1131 free( bidiLineInfo.visualToLogicalMap );
1136 // Sets the actual size.
1137 if( UPDATE_ACTUAL_SIZE & operations )
1139 mImpl->mVisualModel->SetActualSize( layoutSize );
1145 layoutSize = mImpl->mVisualModel->GetActualSize();
1151 View& Controller::GetView()
1153 return mImpl->mView;
1156 LayoutEngine& Controller::GetLayoutEngine()
1158 return mImpl->mLayoutEngine;
1161 void Controller::RequestRelayout()
1163 mImpl->mControlInterface.RequestTextRelayout();
1166 void Controller::KeyboardFocusGainEvent()
1168 DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyboardFocusGainEvent" );
1170 if( mImpl->mTextInput )
1172 TextInput::Event event( TextInput::KEYBOARD_FOCUS_GAIN_EVENT );
1173 mImpl->mTextInput->mEventQueue.push_back( event );
1179 void Controller::KeyboardFocusLostEvent()
1181 DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyboardFocusLostEvent" );
1183 if( mImpl->mTextInput )
1185 TextInput::Event event( TextInput::KEYBOARD_FOCUS_LOST_EVENT );
1186 mImpl->mTextInput->mEventQueue.push_back( event );
1192 bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent )
1194 DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected KeyEvent" );
1196 if( mImpl->mTextInput &&
1197 keyEvent.state == KeyEvent::Down )
1199 int keyCode = keyEvent.keyCode;
1200 const std::string& keyString = keyEvent.keyPressed;
1202 // Pre-process to separate modifying events from non-modifying input events.
1203 if( Dali::DALI_KEY_ESCAPE == keyCode )
1205 // Escape key is a special case which causes focus loss
1206 KeyboardFocusLostEvent();
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 )
1213 TextInput::Event event( TextInput::CURSOR_KEY_EVENT );
1214 event.p1.mInt = keyCode;
1215 mImpl->mTextInput->mEventQueue.push_back( event );
1217 else if( Dali::DALI_KEY_BACKSPACE == keyCode )
1219 // Queue a delete event
1221 event.type = DELETE_TEXT;
1222 mImpl->mModifyEvents.push_back( event );
1224 else if( !keyString.empty() )
1226 // Queue an insert event
1228 event.type = INSERT_TEXT;
1229 event.text = keyString;
1230 mImpl->mModifyEvents.push_back( event );
1239 void Controller::TapEvent( unsigned int tapCount, float x, float y )
1241 DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected TapEvent" );
1243 if( mImpl->mTextInput )
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 );
1255 void Controller::GrabHandleEvent( GrabHandleState state, float x, float y )
1257 DALI_ASSERT_DEBUG( mImpl->mTextInput && "Unexpected GrabHandleEvent" );
1259 if( mImpl->mTextInput )
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 );
1271 Controller::~Controller()
1276 Controller::Controller( ControlInterface& controlInterface )
1279 mImpl = new Controller::Impl( controlInterface );
1284 } // namespace Toolkit