Text::HorizontalAlignment::BEGIN,
Text::LineWrap::WORD,
outlineWidth,
- true );
+ true,
+ false );
Vector<LineRun>& lines = visualModel->mLines;
characterCount,
Text::HorizontalAlignment::BEGIN,
lines,
- alignmentOffset );
+ alignmentOffset,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false );
}
}
Text::HorizontalAlignment::BEGIN,
Text::LineWrap::WORD,
outlineWidth,
- true );
+ true,
+ false );
layoutParameters.isLastNewParagraph = isLastNewParagraph;
Text::HorizontalAlignment::BEGIN,
Text::LineWrap::WORD,
outlineWidth,
- true );
+ true,
+ false );
layoutParameters.numberOfBidirectionalInfoRuns = logicalModel->mBidirectionalLineInfo.Count();
layoutParameters.lineBidirectionalInfoRunsBuffer = logicalModel->mBidirectionalLineInfo.Begin();
unsigned int numberOfCharacters;
unsigned int numberOfLines;
float* lineOffsets;
+ Dali::LayoutDirection::Type layoutDirection;
+ bool matchSystemLanguageDirection;
};
bool AlignTest( const AlignData& data )
data.numberOfCharacters,
data.horizontalAlignment,
visualModel->mLines,
- alignmentOffset );
+ alignmentOffset,
+ data.layoutDirection,
+ data.matchSystemLanguageDirection );
// Compare results.
if( data.numberOfLines != visualModel->mLines.Count() )
return false;
}
}
-
return true;
}
0u,
22u,
6u,
- positions
+ positions,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false
};
if( !AlignTest( data ) )
22u,
26u,
6u,
- positions
+ positions,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false
};
if( !AlignTest( data ) )
48u,
26u,
6u,
- positions
+ positions,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false
};
if( !AlignTest( data ) )
0u,
22u,
6u,
- positions
+ positions,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false
};
if( !AlignTest( data ) )
22u,
26u,
6u,
- positions
+ positions,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false
};
if( !AlignTest( data ) )
48u,
26u,
6u,
- positions
+ positions,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false
};
if( !AlignTest( data ) )
0u,
22u,
6u,
- positions
+ positions,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false
};
if( !AlignTest( data ) )
22u,
26u,
6u,
- positions
+ positions,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false
};
if( !AlignTest( data ) )
48u,
26u,
6u,
- positions
+ positions,
+ Dali::LayoutDirection::LEFT_TO_RIGHT,
+ false
+ };
+
+ if( !AlignTest( data ) )
+ {
+ tet_result(TET_FAIL);
+ }
+
+ tet_result(TET_PASS);
+ END_TEST;
+}
+
+int UtcDaliTextAlign10(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline(" UtcDaliTextAlign10");
+
+ // Calculate text alignment.
+
+ const std::string fontLatin( "TizenSans" );
+ const std::string fontHebrew( "TizenSansHebrew" );
+ const std::string fontArabic( "TizenSansArabic" );
+
+ // Set a known font description
+ FontDescriptionRun fontDescriptionRun01;
+ fontDescriptionRun01.characterRun.characterIndex = 0u;
+ fontDescriptionRun01.characterRun.numberOfCharacters = 12u;
+ fontDescriptionRun01.familyLength = fontLatin.size();
+ fontDescriptionRun01.familyName = new char[fontDescriptionRun01.familyLength];
+ memcpy( fontDescriptionRun01.familyName, fontLatin.c_str(), fontDescriptionRun01.familyLength );
+ fontDescriptionRun01.familyDefined = true;
+ fontDescriptionRun01.weightDefined = false;
+ fontDescriptionRun01.widthDefined = false;
+ fontDescriptionRun01.slantDefined = false;
+ fontDescriptionRun01.sizeDefined = false;
+
+ FontDescriptionRun fontDescriptionRun02;
+ fontDescriptionRun02.characterRun.characterIndex = 12u;
+ fontDescriptionRun02.characterRun.numberOfCharacters = 10u;
+ fontDescriptionRun02.familyLength = fontHebrew.size();
+ fontDescriptionRun02.familyName = new char[fontDescriptionRun02.familyLength];
+ memcpy( fontDescriptionRun02.familyName, fontHebrew.c_str(), fontDescriptionRun02.familyLength );
+ fontDescriptionRun02.familyDefined = true;
+ fontDescriptionRun02.weightDefined = false;
+ fontDescriptionRun02.widthDefined = false;
+ fontDescriptionRun02.slantDefined = false;
+ fontDescriptionRun02.sizeDefined = false;
+
+ FontDescriptionRun fontDescriptionRun03;
+ fontDescriptionRun03.characterRun.characterIndex = 22u;
+ fontDescriptionRun03.characterRun.numberOfCharacters = 14u;
+ fontDescriptionRun03.familyLength = fontArabic.size();
+ fontDescriptionRun03.familyName = new char[fontDescriptionRun03.familyLength];
+ memcpy( fontDescriptionRun03.familyName, fontArabic.c_str(), fontDescriptionRun03.familyLength );
+ fontDescriptionRun03.familyDefined = true;
+ fontDescriptionRun03.weightDefined = false;
+ fontDescriptionRun03.widthDefined = false;
+ fontDescriptionRun03.slantDefined = false;
+ fontDescriptionRun03.sizeDefined = false;
+
+ FontDescriptionRun fontDescriptionRun04;
+ fontDescriptionRun04.characterRun.characterIndex = 36u;
+ fontDescriptionRun04.characterRun.numberOfCharacters = 12u;
+ fontDescriptionRun04.familyLength = fontLatin.size();
+ fontDescriptionRun04.familyName = new char[fontDescriptionRun04.familyLength];
+ memcpy( fontDescriptionRun04.familyName, fontLatin.c_str(), fontDescriptionRun04.familyLength );
+ fontDescriptionRun04.familyDefined = true;
+ fontDescriptionRun04.weightDefined = false;
+ fontDescriptionRun04.widthDefined = false;
+ fontDescriptionRun04.slantDefined = false;
+ fontDescriptionRun04.sizeDefined = false;
+
+ FontDescriptionRun fontDescriptionRun05;
+ fontDescriptionRun05.characterRun.characterIndex = 48u;
+ fontDescriptionRun05.characterRun.numberOfCharacters = 12u;
+ fontDescriptionRun05.familyLength = fontLatin.size();
+ fontDescriptionRun05.familyName = new char[fontDescriptionRun05.familyLength];
+ memcpy( fontDescriptionRun05.familyName, fontLatin.c_str(), fontDescriptionRun05.familyLength );
+ fontDescriptionRun05.familyDefined = true;
+ fontDescriptionRun05.weightDefined = false;
+ fontDescriptionRun05.widthDefined = false;
+ fontDescriptionRun05.slantDefined = false;
+ fontDescriptionRun05.sizeDefined = false;
+
+ FontDescriptionRun fontDescriptionRun06;
+ fontDescriptionRun06.characterRun.characterIndex = 60u;
+ fontDescriptionRun06.characterRun.numberOfCharacters = 14u;
+ fontDescriptionRun06.familyLength = fontArabic.size();
+ fontDescriptionRun06.familyName = new char[fontDescriptionRun06.familyLength];
+ memcpy( fontDescriptionRun06.familyName, fontArabic.c_str(), fontDescriptionRun06.familyLength );
+ fontDescriptionRun06.familyDefined = true;
+ fontDescriptionRun06.weightDefined = false;
+ fontDescriptionRun06.widthDefined = false;
+ fontDescriptionRun06.slantDefined = false;
+ fontDescriptionRun06.sizeDefined = false;
+
+ Vector<FontDescriptionRun> fontDescriptionRuns;
+ fontDescriptionRuns.PushBack( fontDescriptionRun01 );
+ fontDescriptionRuns.PushBack( fontDescriptionRun02 );
+ fontDescriptionRuns.PushBack( fontDescriptionRun03 );
+ fontDescriptionRuns.PushBack( fontDescriptionRun04 );
+ fontDescriptionRuns.PushBack( fontDescriptionRun05 );
+ fontDescriptionRuns.PushBack( fontDescriptionRun06 );
+
+ float positions[] = { -4.f, 0.f, 0.f, 0.f, 0.f, 0.f };
+
+ Size textArea( 100.f, 300.f );
+ AlignData data =
+ {
+ "Begin alignment for the first paragraph.",
+ "Hello world שלום עולם\nمرحبا بالعالم Hello world\nHello world مرحبا بالعالم.",
+ textArea,
+ 6u,
+ fontDescriptionRuns.Begin(),
+ Text::HorizontalAlignment::END,
+ Text::VerticalAlignment::TOP,
+ 0u,
+ 22u,
+ 6u,
+ positions,
+ Dali::LayoutDirection::RIGHT_TO_LEFT,
+ true
};
if( !AlignTest( data ) )
DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::RIGHT);
+ // Clear the focus again
+ manager.ClearFocus();
+
+ // Send the up event for line coverage, but nothing was focued so focus manager will try the initial focus
+ preFocusChangeCallback.Reset();
+ application.ProcessEvent(upEvent);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+ DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
+
+ // Clear the focus again
+ manager.ClearFocus();
+
+ // Send the down event for line coverage, but nothing was focued so focus manager will try the initial focus
+ preFocusChangeCallback.Reset();
+ application.ProcessEvent(downEvent);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+ DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
+
END_TEST;
}
+int UtcDaliKeyboardFocusManagerSignalChangedBySpaceKeyEvent(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline(" UtcDaliKeyboardFocusManagerSignalChangedBySpaceKeyEvent");
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ bool preFocusChangeSignalVerified = false;
+ PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
+ manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+
+ Integration::KeyEvent spaceEvent( "space", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
+
+ // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
+ // It makes mIsFocusIndicatorEnabled true
+ application.ProcessEvent(spaceEvent);
+
+ // Send the space event
+ application.ProcessEvent(spaceEvent);
+ DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+ DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
+
+ // Clear the focus again
+ manager.ClearFocus();
+
+ // Send the space event again for line coverage
+ preFocusChangeCallback.Reset();
+ application.ProcessEvent(spaceEvent);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+ DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
+ DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
+ END_TEST;
+}
tet_result(TET_FAIL);
}
+
+ label.SetProperty( TextLabel::Property::TEXT, "Hello world" );
+ label.SetProperty( DevelTextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION, true );
+ label.SetSize( 400.0f, 10.f );
+
+ try
+ {
+ // Render the text.
+ application.SendNotification();
+ application.Render();
+ }
+ catch( ... )
+ {
+ tet_result(TET_FAIL);
+ }
+
END_TEST;
}
DALI_TEST_EQUALS( label.GetProperty< int >( DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT ), static_cast< int >( Toolkit::DevelText::VerticalLineAlignment::BOTTOM ), TEST_LOCATION );
END_TEST;
-}
\ No newline at end of file
+}
* @note The default value is true
*/
IGNORE_SPACES_AFTER_TEXT,
+
+ /**
+ * @brief Modifies the default text alignment to match the direction of the system language.
+ * @details Name "matchSystemLanguageDirection", type (Property::BOLEAN), Read/Write
+ * @note The default value is false
+ *
+ * If MATCH_SYSTEM_LANGUAGE_DIRECTION property set true, the default text alignment to match the direction of the system language.
+ *
+ * ex) Current system language direction LTR.
+ * TextLabel::New("Hello world \n ﻡﺮﺤﺑﺍ. ");
+ * TextLabel::Property::HORIZONTAL_ALIGNMENT, "END"
+ *
+ * | TextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION |
+ * |-----------------------------------------------------------------------
+ * | false (default) | true |
+ * |-----------------------------------|----------------------------------|
+ * | Hello world | Hello world |
+ * | ﻡﺮﺤﺑﺍ. | ﻡﺮﺤﺑﺍ. |
+ *
+ */
+ MATCH_SYSTEM_LANGUAGE_DIRECTION,
};
} // namespace Property
mActiveLayer.SetPosition( padding.start, padding.top );
}
- const Text::Controller::UpdateTextType updateTextType = mController->Relayout( contentSize );
+ const Text::Controller::UpdateTextType updateTextType = mController->Relayout( contentSize, layoutDirection );
if( ( Text::Controller::NONE_UPDATED != updateTextType ) ||
!mRenderer )
mActiveLayer.SetPosition( padding.start, padding.top );
}
- const Text::Controller::UpdateTextType updateTextType = mController->Relayout( contentSize );
+ const Text::Controller::UpdateTextType updateTextType = mController->Relayout( contentSize, layoutDirection );
if( ( Text::Controller::NONE_UPDATED != updateTextType ) ||
!mRenderer )
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextLabel, "verticalLineAlignment", INTEGER, VERTICAL_LINE_ALIGNMENT )
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextLabel, "textBackground", MAP, BACKGROUND )
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextLabel, "ignoreSpacesAfterText", BOOLEAN, IGNORE_SPACES_AFTER_TEXT )
+DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextLabel, "matchSystemLanguageDirection", BOOLEAN, MATCH_SYSTEM_LANGUAGE_DIRECTION )
DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT( Toolkit, TextLabel, "textColor", Color::BLACK, TEXT_COLOR )
DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, TextLabel, "textColorRed", TEXT_COLOR_RED, TEXT_COLOR, 0 )
DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, TextLabel, "textColorGreen", TEXT_COLOR_GREEN, TEXT_COLOR, 1 )
impl.mController->SetIgnoreSpacesAfterText(value.Get< bool >());
break;
}
+ case Toolkit::DevelTextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION:
+ {
+ impl.mController->SetMatchSystemLanguageDirection(value.Get< bool >());
+ break;
+ }
}
// Request relayout when text update is needed. It's necessary to call it
value = impl.mController->IsIgnoreSpacesAfterText();
break;
}
+ case Toolkit::DevelTextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION:
+ {
+ value = impl.mController->IsMatchSystemLanguageDirection();
+ break;
+ }
}
}
Vector2 contentSize( size.x - ( padding.start + padding.end ), size.y - ( padding.top + padding.bottom ) );
- const Text::Controller::UpdateTextType updateTextType = mController->Relayout( contentSize );
+ // Support Right-To-Left
+ Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>( Self().GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
+
+ const Text::Controller::UpdateTextType updateTextType = mController->Relayout( contentSize, layoutDirection );
if( ( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType ) )
|| mTextUpdateNeeded )
TextVisual::EnableRendererUpdate( mVisual );
// Support Right-To-Left of padding
- Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>( Self().GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
if( Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection )
{
std::swap( padding.start, padding.end );
mFocusedActorEnterKeySignal(),
mCurrentFocusActor(),
mFocusIndicatorActor(),
- mIsFocusIndicatorEnabled( -1 ),
+ mIsFocusIndicatorShown( -1 ),
mFocusGroupLoopEnabled( false ),
mIsWaitingKeyboardFocusChangeCommit( false ),
mClearFocusOnTouch( true ),
mEnableFocusIndicator( true ),
+ mAlwaysShowIndicator( true ),
mFocusHistory(),
mSlotDelegate( this ),
mCustomAlgorithmInterface(NULL)
{
- // TODO: Get FocusIndicatorEnable constant from stylesheet to set mIsFocusIndicatorEnabled.
+ // TODO: Get FocusIndicatorEnable constant from stylesheet to set mIsFocusIndicatorShown.
Stage::GetCurrent().KeyEventSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnKeyEvent);
Stage::GetCurrent().TouchSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
}
if( styleManager )
{
Property::Map config = Toolkit::DevelStyleManager::GetConfigurations( styleManager );
- mIsFocusIndicatorEnabled = static_cast<int>(config["alwaysShowFocus"].Get<bool>());
- mClearFocusOnTouch = mIsFocusIndicatorEnabled ? false : true;
+ mAlwaysShowIndicator = config["alwaysShowFocus"].Get<bool>();
+ mIsFocusIndicatorShown = static_cast<int>(mAlwaysShowIndicator);
+ mClearFocusOnTouch = mIsFocusIndicatorShown ? false : true;
}
}
{
DALI_ASSERT_DEBUG( !mIsWaitingKeyboardFocusChangeCommit && "Calling this function in the PreFocusChangeSignal callback?" );
- if( mIsFocusIndicatorEnabled == -1 )
+ if( mIsFocusIndicatorShown == -1 )
{
GetConfigurationFromStyleManger();
}
// Check whether the actor is in the stage and is keyboard focusable.
if( actor && actor.IsKeyboardFocusable() && actor.OnStage() )
{
- if( mIsFocusIndicatorEnabled && mEnableFocusIndicator )
+ if( mIsFocusIndicatorShown && mEnableFocusIndicator )
{
actor.Add( GetFocusIndicatorActor() );
}
}
mCurrentFocusActor.Reset();
- mIsFocusIndicatorEnabled = 0;
+ mIsFocusIndicatorShown = static_cast<int>(mAlwaysShowIndicator);
}
void KeyboardFocusManager::SetFocusGroupLoop(bool enabled)
std::string keyName = event.keyPressedName;
- if( mIsFocusIndicatorEnabled == -1 )
+ if( mIsFocusIndicatorShown == -1 )
{
GetConfigurationFromStyleManger();
}
{
if(!isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = 1;
+ mIsFocusIndicatorShown = 1;
}
else
{
{
if(!isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = 1;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "Up" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = 1;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "Down" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = 1;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "Prior" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = 1;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "Next" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = 1;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "Tab" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = 1;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "space" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = 1;
+ mIsFocusIndicatorShown = 1;
}
isFocusStartableKey = true;
else if (keyName == "" && !isAccessibilityEnabled)
{
// Check the fake key event for evas-plugin case
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = 1;
+ mIsFocusIndicatorShown = 1;
}
isFocusStartableKey = true;
{
if (keyName == "Return")
{
- if(!mIsFocusIndicatorEnabled && !isAccessibilityEnabled)
+ if(!mIsFocusIndicatorShown && !isAccessibilityEnabled)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = 1;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
}
- if(isFocusStartableKey && mIsFocusIndicatorEnabled && !isAccessibilityEnabled)
+ if(isFocusStartableKey && mIsFocusIndicatorShown && !isAccessibilityEnabled)
{
Actor actor = GetCurrentFocusActor();
if( actor )
void KeyboardFocusManager::OnTouch(const TouchData& touch)
{
- // if mIsFocusIndicatorEnabled is -1, it means Configuration is not loaded.
+ // if mIsFocusIndicatorShown is -1, it means Configuration is not loaded.
// Try to load configuration.
- if( mIsFocusIndicatorEnabled == -1 )
+ if( mIsFocusIndicatorShown == -1 )
{
GetConfigurationFromStyleManger();
}
Actor mFocusIndicatorActor; ///< The focus indicator actor shared by all the keyboard focusable actors for highlight
- int mIsFocusIndicatorEnabled; ///< Whether indicator should be shown / hidden when getting focus. It could be enabled when keyboard focus feature is enabled and navigation keys or 'Tab' key are pressed.
+ int mIsFocusIndicatorShown; ///< Whether indicator should be shown / hidden when getting focus. It could be enabled when keyboard focus feature is enabled and navigation keys or 'Tab' key are pressed.
bool mFocusGroupLoopEnabled:1; ///< Whether the focus movement is looped within the same focus group
bool mEnableFocusIndicator; ///< Whether use focus indicator
+ bool mAlwaysShowIndicator; ///< Whether always show indicator. If true, the indicator would be directly shown when focused.
+
FocusStack mFocusHistory; ///< Stack to contain pre-focused actor's BaseObject*
SlotDelegate< KeyboardFocusManager > mSlotDelegate;
Length numberOfCharacters,
Text::HorizontalAlignment::Type horizontalAlignment,
Vector<LineRun>& lines,
- float& alignmentOffset )
+ float& alignmentOffset,
+ Dali::LayoutDirection::Type layoutDirection,
+ bool matchSystemLanguageDirection )
{
const CharacterIndex lastCharacterPlusOne = startIndex + numberOfCharacters;
// the box width, line length, and the paragraph's direction.
CalculateHorizontalAlignment( size.width,
horizontalAlignment,
- line );
+ line,
+ layoutDirection,
+ matchSystemLanguageDirection );
// Updates the alignment offset.
alignmentOffset = std::min( alignmentOffset, line.alignmentOffset );
void CalculateHorizontalAlignment( float boxWidth,
HorizontalAlignment::Type horizontalAlignment,
- LineRun& line )
+ LineRun& line,
+ Dali::LayoutDirection::Type layoutDirection,
+ bool matchSystemLanguageDirection )
{
line.alignmentOffset = 0.f;
- const bool isRTL = RTL == line.direction;
+ bool isRTL = RTL == line.direction;
float lineLength = line.width;
-
HorizontalAlignment::Type alignment = horizontalAlignment;
+
+ // match align for system language direction
+ if( matchSystemLanguageDirection )
+ {
+ isRTL = layoutDirection == LayoutDirection::RIGHT_TO_LEFT;
+ }
+
+ // Swap the alignment type if the line is right to left.
if( isRTL )
{
- // Swap the alignment type if the line is right to left.
switch( alignment )
{
case HorizontalAlignment::BEGIN:
break;
}
}
+
}
// Calculate the horizontal line offset.
Length numberOfCharacters,
Text::HorizontalAlignment::Type horizontalAlignment,
Vector<LineRun>& lines,
- float& alignmentOffset )
+ float& alignmentOffset,
+ Dali::LayoutDirection::Type layoutDirection,
+ bool matchSystemLanguageDirection )
{
mImpl->Align( size,
startIndex,
numberOfCharacters,
horizontalAlignment,
lines,
- alignmentOffset );
+ alignmentOffset,
+ layoutDirection,
+ matchSystemLanguageDirection );
}
void Engine::SetDefaultLineSpacing( float lineSpacing )
// EXTERNAL INCLUDE
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/math/vector2.h>
+#include <dali/public-api/actors/actor-enumerations.h>
// INTERNAL INCLUDE
#include <dali-toolkit/public-api/text/text-enumerations.h>
* @param[in] horizontalAlignment The horizontal alignment.
* @param[in,out] lines The laid-out lines.
* @param[out] alignmentOffset The alignment offset.
+ * @param[in] layoutDirection The direction of the system language.
+ * @param[in] matchSystemLanguageDirection Whether match align for system language direction or not.
*/
void Align( const Size& size,
CharacterIndex startIndex,
Length numberOfCharacters,
Text::HorizontalAlignment::Type horizontalAlignment,
Vector<LineRun>& lines,
- float& alignmentOffset );
+ float& alignmentOffset,
+ Dali::LayoutDirection::Type layoutDirection,
+ bool matchSystemLanguageDirection );
/**
* @brief Sets the default line spacing.
* @param[in] totalNumberOfGlyphs The number of glyphs.
* @param[in] horizontalAlignment The horizontal alignment.
* @param[in] lineWrapMode The text wrap mode.
+ * @param[in] outlineWidth The outline width.
+ * @param[in] ignoreSpaceAfterText Whether ignoring spaces after text or not.
+ * @param[in] matchSystemLanguageDirection Whether match align for system language direction or not..
*/
Parameters( const Vector2& boundingBox,
const Character* const textBuffer,
Text::HorizontalAlignment::Type horizontalAlignment,
Text::LineWrap::Mode lineWrapMode,
float outlineWidth,
- bool ignoreSpaceAfterText )
+ bool ignoreSpaceAfterText,
+ bool matchSystemLanguageDirection )
: boundingBox( boundingBox ),
textBuffer( textBuffer ),
lineBreakInfoBuffer( lineBreakInfoBuffer ),
lineWrapMode( lineWrapMode ),
outlineWidth( outlineWidth ),
isLastNewParagraph( false ),
- ignoreSpaceAfterText( ignoreSpaceAfterText )
+ ignoreSpaceAfterText( ignoreSpaceAfterText ),
+ matchSystemLanguageDirection ( matchSystemLanguageDirection )
{}
Vector2 boundingBox; ///< The size of the box containing the text.
float outlineWidth; ///< The outline width.
bool isLastNewParagraph:1; ///< Whether the last character is a new paragraph character.
bool ignoreSpaceAfterText:1; ///< Whether ignoring spaces after text or not. Default is true.
+ bool matchSystemLanguageDirection:1; ///< Whether match align for system language direction or not. Default is false.
};
} // namespace Layout
mShadowSetByString( false ),
mOutlineSetByString( false ),
mFontStyleSetByString( false ),
- mShouldClearFocusOnEscape( true )
+ mShouldClearFocusOnEscape( true ),
+ mLayoutDirection( LayoutDirection::LEFT_TO_RIGHT )
{
mModel = Model::New();
bool mOutlineSetByString:1; ///< Set when outline is set by string (legacy) instead of map
bool mFontStyleSetByString:1; ///< Set when font style is set by string (legacy) instead of map
bool mShouldClearFocusOnEscape:1; ///< Whether text control should clear key input focus
+ LayoutDirection::Type mLayoutDirection; ///< Current system language direction
};
} // namespace Text
mImpl->mModel->mIgnoreSpacesAfterText = ignore;
}
+bool Controller::IsMatchSystemLanguageDirection() const
+{
+ return mImpl->mModel->mMatchSystemLanguageDirection;
+}
+
+void Controller::SetMatchSystemLanguageDirection( bool match )
+{
+ mImpl->mModel->mMatchSystemLanguageDirection = match;
+}
+
+
void Controller::SetLineWrapMode( Text::LineWrap::Mode lineWrapMode )
{
if( lineWrapMode != mImpl->mModel->mLineWrapMode )
// public : Relayout.
-Controller::UpdateTextType Controller::Relayout( const Size& size )
+Controller::UpdateTextType Controller::Relayout( const Size& size, Dali::LayoutDirection::Type layoutDirection )
{
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::Relayout %p size %f,%f, autoScroll[%s]\n", this, size.width, size.height, mImpl->mIsAutoScrollEnabled ?"true":"false" );
UpdateTextType updateTextType = NONE_UPDATED;
+ mImpl->mLayoutDirection = layoutDirection;
if( ( size.width < Math::MACHINE_EPSILON_1000 ) || ( size.height < Math::MACHINE_EPSILON_1000 ) )
{
if( 0u != mImpl->mModel->mVisualModel->mGlyphPositions.Count() )
mImpl->mModel->mHorizontalAlignment,
mImpl->mModel->mLineWrapMode,
outlineWidth,
- mImpl->mModel->mIgnoreSpacesAfterText );
+ mImpl->mModel->mIgnoreSpacesAfterText,
+ mImpl->mModel->mMatchSystemLanguageDirection );
// Resize the vector of positions to have the same size than the vector of glyphs.
Vector<Vector2>& glyphPositions = mImpl->mModel->mVisualModel->mGlyphPositions;
requestedNumberOfCharacters,
mImpl->mModel->mHorizontalAlignment,
lines,
- mImpl->mModel->mAlignmentOffset );
+ mImpl->mModel->mAlignmentOffset,
+ mImpl->mLayoutDirection,
+ mImpl->mModel->mMatchSystemLanguageDirection );
viewUpdated = true;
}
*/
void SetIgnoreSpacesAfterText( bool ignore );
+ /**
+ * @brief Retrieves matchSystemLanguageDirection value from model
+ * @return The value of matchSystemLanguageDirection
+ */
+ bool IsMatchSystemLanguageDirection() const;
+
+ /**
+ * @brief Sets matchSystemLanguageDirection value to model
+ * @param[in] match The value of matchSystemLanguageDirection for the text
+ */
+ void SetMatchSystemLanguageDirection( bool match );
+
public: // Relayout.
/**
*
* @note UI Controls are expected to minimize calls to this method e.g. call once after size negotiation.
* @param[in] size A the size of a bounding box to layout text within.
+ * @param[in] layoutDirection The direction of the system language.
*
* @return Whether the text model or decorations were updated.
*/
- UpdateTextType Relayout( const Size& size );
+ UpdateTextType Relayout( const Size& size, Dali::LayoutDirection::Type layoutDirection = Dali::LayoutDirection::LEFT_TO_RIGHT );
/**
* @brief Request a relayout using the ControlInterface.
mLineWrapMode( Text::LineWrap::WORD ),
mAlignmentOffset( 0.0f ),
mElideEnabled( false ),
- mIgnoreSpacesAfterText( true )
+ mIgnoreSpacesAfterText( true ),
+ mMatchSystemLanguageDirection( false )
{
mLogicalModel = LogicalModel::New();
mVisualModel = VisualModel::New();
float mAlignmentOffset; ///< The alignment offset.
bool mElideEnabled:1; ///< Whether the text's elide is enabled.
bool mIgnoreSpacesAfterText:1; ///< Whether ignoring spaces after text or not. Default is true.
+ bool mMatchSystemLanguageDirection:1; ///< Whether match align for system language direction or not. Default is false.
};
} // namespace Text
return;
}
- const Text::Controller::UpdateTextType updateTextType = mController->Relayout( relayoutSize );
+ Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>( control.GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
+
+ const Text::Controller::UpdateTextType updateTextType = mController->Relayout( relayoutSize, layoutDirection );
if( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType )
|| mRendererUpdateNeeded )
"autoScrollLoopCount":2,
"autoScrollGap":50,
"autoScrollSpeed":80,
- "ignoreSpacesAfterText":false
+ "ignoreSpacesAfterText":false,
+ "matchSystemLanguageDirection":true
},
"TextLabelFontSize0":
|   |   |
+
+The text's alignment can be modified to match the direction of the system language.
+
+If the MATCH_SYSTEM_LANGUAGE_DIRECTION property is set to true then the direction of the text is ignored, instead the text is aligned as the system default language.
+
+~~~{.cpp}
+// C++
+
+label.SetProperty( TextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION, true );
+~~~
+
+~~~{.js}
+// JavaScript
+
+label.matchSystemLanguageDirection = true;
+~~~
+
+| | |
+|--|--|
+| Current system language direction left-to-right | |
+| END alignment and MATCH_SYSTEM_LANGUAGE_DIRECTION set to TRUE. | END alignment and MATCH_SYSTEM_LANGUAGE_DIRECTION set to FALSE (default). |
+|  |  |
+
+
The examples above assume that the TextLabel size greater than the minimum required.
The next section provides details about the other size related options.
projects / platform / core / uifw / dali-toolkit.git / commitdiff
