-#ifndef __DALI_TOOLKIT_TEXT_CONTROLLER_IMPL_H__
-#define __DALI_TOOLKIT_TEXT_CONTROLLER_IMPL_H__
+#ifndef DALI_TOOLKIT_TEXT_CONTROLLER_IMPL_H
+#define DALI_TOOLKIT_TEXT_CONTROLLER_IMPL_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// EXTERNAL INCLUDES
#include <dali/devel-api/adaptor-framework/clipboard.h>
#include <dali/devel-api/text-abstraction/font-client.h>
+#include <dali/public-api/rendering/shader.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/text/input-style.h>
-#include <dali-toolkit/internal/text/layouts/layout-engine.h>
-#include <dali-toolkit/internal/text/logical-model-impl.h>
#include <dali-toolkit/internal/text/text-controller.h>
+#include <dali-toolkit/internal/text/text-model.h>
#include <dali-toolkit/internal/text/text-view.h>
-#include <dali-toolkit/internal/text/visual-model-impl.h>
+#include <dali-toolkit/public-api/styling/style-manager.h>
+#include <dali-toolkit/devel-api/styling/style-manager-devel.h>
namespace Dali
{
namespace Text
{
+const float DEFAULT_TEXTFIT_MIN = 10.f;
+const float DEFAULT_TEXTFIT_MAX = 100.f;
+const float DEFAULT_TEXTFIT_STEP = 1.f;
+
//Forward declarations
struct CursorInfo;
+struct FontDefaults;
struct Event
{
int mInt;
unsigned int mUint;
float mFloat;
+ bool mBool;
};
Event( Type eventType )
EDITING_WITH_GRAB_HANDLE,
EDITING_WITH_PASTE_POPUP,
GRAB_HANDLE_PANNING,
- SELECTION_HANDLE_PANNING
+ SELECTION_HANDLE_PANNING,
+ TEXT_PANNING
};
- EventData( DecoratorPtr decorator );
+ EventData( DecoratorPtr decorator, InputMethodContext& inputMethodContext );
~EventData();
}
DecoratorPtr mDecorator; ///< Pointer to the decorator.
- ImfManager mImfManager; ///< The Input Method Framework Manager.
+ InputMethodContext mInputMethodContext; ///< The Input Method Framework Manager.
+ FontDefaults* mPlaceholderFont; ///< The placeholder default font.
std::string mPlaceholderTextActive; ///< The text to display when the TextField is empty with key-input focus.
std::string mPlaceholderTextInactive; ///< The text to display when the TextField is empty and inactive.
Vector4 mPlaceholderTextColor; ///< The in/active placeholder text color.
*/
std::vector<Event> mEventQueue; ///< The queue of touch events etc.
- InputStyle mInputStyle; ///< The style to be set to the new inputed text.
+ Vector<InputStyle::Mask> mInputStyleChangedQueue; ///< Queue of changes in the input style. Used to emit the signal in the iddle callback.
- /**
- * 0,0 means that the top-left corner of the layout matches the top-left corner of the UI control.
- * Typically this will have a negative value with scrolling occurs.
- */
- Vector2 mScrollPosition; ///< The text is offset by this position when scrolling.
+ InputStyle mInputStyle; ///< The style to be set to the new inputed text.
+ State mPreviousState; ///< Stores the current state before it's updated with the new one.
State mState; ///< Selection mode, edit mode etc.
CharacterIndex mPrimaryCursorPosition; ///< Index into logical model for primary cursor.
CharacterIndex mPreEditStartPosition; ///< Used to remove the pre-edit text if necessary.
Length mPreEditLength; ///< Used to remove the pre-edit text if necessary.
+ float mCursorHookPositionX; ///< Used to move the cursor with the keys or when scrolling the text vertically with the handles.
+
+ Controller::NoTextTap::Action mDoubleTapAction; ///< Action to be done when there is a double tap on top of 'no text'
+ Controller::NoTextTap::Action mLongPressAction; ///< Action to be done when there is a long press on top of 'no text'
+
bool mIsShowingPlaceholderText : 1; ///< True if the place-holder text is being displayed.
bool mPreEditFlag : 1; ///< True if the model contains text in pre-edit state.
bool mDecoratorUpdated : 1; ///< True if the decorator was updated during event processing.
bool mGrabHandleEnabled : 1; ///< True if grab handle is enabled.
bool mGrabHandlePopupEnabled : 1; ///< True if the grab handle popu-up should be shown.
bool mSelectionEnabled : 1; ///< True if selection handles, highlight etc. are enabled.
- bool mHorizontalScrollingEnabled : 1; ///< True if horizontal scrolling is enabled.
- bool mVerticalScrollingEnabled : 1; ///< True if vertical scrolling is enabled.
+ bool mUpdateCursorHookPosition : 1; ///< True if the cursor hook position must be updated. Used to move the cursor with the keys 'up' and 'down'.
bool mUpdateCursorPosition : 1; ///< True if the visual position of the cursor must be recalculated.
+ bool mUpdateGrabHandlePosition : 1; ///< True if the visual position of the grab handle must be recalculated.
bool mUpdateLeftSelectionPosition : 1; ///< True if the visual position of the left selection handle must be recalculated.
bool mUpdateRightSelectionPosition : 1; ///< True if the visual position of the right selection handle must be recalculated.
+ bool mIsLeftHandleSelected : 1; ///< Whether is the left handle the one which is selected.
+ bool mIsRightHandleSelected : 1; ///< Whether is the right handle the one which is selected.
+ bool mUpdateHighlightBox : 1; ///< True if the text selection high light box must be updated.
bool mScrollAfterUpdatePosition : 1; ///< Whether to scroll after the cursor position is updated.
bool mScrollAfterDelete : 1; ///< Whether to scroll after delete characters.
bool mAllTextSelected : 1; ///< True if the selection handles are selecting all the text.
bool mUpdateInputStyle : 1; ///< Whether to update the input style after moving the cursor.
+ bool mPasswordInput : 1; ///< True if password input is enabled.
+ bool mCheckScrollAmount : 1; ///< Whether to check scrolled amount after updating the position
+ bool mIsPlaceholderPixelSize : 1; ///< True if the placeholder font size is set as pixel size.
+ bool mIsPlaceholderElideEnabled : 1; ///< True if the placeholder text's elide is enabled.
+ bool mPlaceholderEllipsisFlag : 1; ///< True if the text controller sets the placeholder ellipsis.
+ bool mShiftSelectionFlag : 1; ///< True if the text selection using Shift key is enabled.
+ bool mUpdateAlignment : 1; ///< True if the whole text needs to be full aligned..
};
struct ModifyEvent
{
FontDefaults()
: mFontDescription(),
- mFontStyle(),
mDefaultPointSize( 0.f ),
+ mFitPointSize( 0.f ),
mFontId( 0u ),
familyDefined( false ),
weightDefined( false ),
}
TextAbstraction::FontDescription mFontDescription; ///< The default font's description.
- std::string mFontStyle; ///< The font's style string set through the property system.
float mDefaultPointSize; ///< The default font's point size.
+ float mFitPointSize; ///< The fit font's point size.
FontId mFontId; ///< The font's id of the default font.
bool familyDefined:1; ///< Whether the default font's family name is defined.
bool weightDefined:1; ///< Whether the default font's weight is defined.
}
};
+struct UnderlineDefaults
+{
+ std::string properties;
+ // TODO: complete with underline parameters.
+};
+
+struct ShadowDefaults
+{
+ std::string properties;
+ // TODO: complete with shadow parameters.
+};
+
+struct EmbossDefaults
+{
+ std::string properties;
+ // TODO: complete with emboss parameters.
+};
+
+struct OutlineDefaults
+{
+ std::string properties;
+ // TODO: complete with outline parameters.
+};
+
struct Controller::Impl
{
- Impl( ControlInterface& controlInterface )
+ Impl( ControlInterface* controlInterface,
+ EditableControlInterface* editableControlInterface )
: mControlInterface( controlInterface ),
- mLogicalModel(),
- mVisualModel(),
+ mEditableControlInterface( editableControlInterface ),
+ mModel(),
mFontDefaults( NULL ),
+ mUnderlineDefaults( NULL ),
+ mShadowDefaults( NULL ),
+ mEmbossDefaults( NULL ),
+ mOutlineDefaults( NULL ),
mEventData( NULL ),
mFontClient(),
mClipboard(),
mView(),
mMetrics(),
- mLayoutEngine(),
mModifyEvents(),
mTextColor( Color::BLACK ),
- mAlignmentOffset(),
mTextUpdateInfo(),
mOperationsPending( NO_OPERATION ),
mMaximumNumberOfCharacters( 50u ),
+ mHiddenInput( NULL ),
mRecalculateNaturalSize( true ),
mMarkupProcessorEnabled( false ),
mClipboardHideEnabled( true ),
- mAutoScrollEnabled( false ),
- mAutoScrollDirectionRTL( false )
+ mIsAutoScrollEnabled( false ),
+ mUpdateTextDirection( true ),
+ mIsTextDirectionRTL( false ),
+ mUnderlineSetByString( false ),
+ mShadowSetByString( false ),
+ mOutlineSetByString( false ),
+ mFontStyleSetByString( false ),
+ mShouldClearFocusOnEscape( true ),
+ mLayoutDirection( LayoutDirection::LEFT_TO_RIGHT ),
+ mTextFitMinSize( DEFAULT_TEXTFIT_MIN ),
+ mTextFitMaxSize( DEFAULT_TEXTFIT_MAX ),
+ mTextFitStepSize( DEFAULT_TEXTFIT_STEP ),
+ mTextFitEnabled( false )
{
- mLogicalModel = LogicalModel::New();
- mVisualModel = VisualModel::New();
+ mModel = Model::New();
mFontClient = TextAbstraction::FontClient::Get();
mClipboard = Clipboard::Get();
- mView.SetVisualModel( mVisualModel );
+ mView.SetVisualModel( mModel->mVisualModel );
// Use this to access FontClient i.e. to get down-scaled Emoji metrics.
mMetrics = Metrics::New( mFontClient );
mLayoutEngine.SetMetrics( mMetrics );
// Set the text properties to default
- mVisualModel->SetUnderlineEnabled( false );
- mVisualModel->SetUnderlineHeight( 0.0f );
+ mModel->mVisualModel->SetUnderlineEnabled( false );
+ mModel->mVisualModel->SetUnderlineHeight( 0.0f );
+
+ Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
+ if( styleManager )
+ {
+ bool temp;
+ Property::Map config = Toolkit::DevelStyleManager::GetConfigurations( styleManager );
+ if( config["clearFocusOnEscape"].Get( temp ) )
+ {
+ mShouldClearFocusOnEscape = temp;
+ }
+ }
}
~Impl()
{
+ delete mHiddenInput;
+
delete mFontDefaults;
+ delete mUnderlineDefaults;
+ delete mShadowDefaults;
+ delete mEmbossDefaults;
+ delete mOutlineDefaults;
delete mEventData;
}
+ // Text Controller Implementation.
+
/**
- * @brief Request a relayout using the ControlInterface.
+ * @copydoc Text::Controller::RequestRelayout()
*/
void RequestRelayout();
bool IsShowingRealText() const
{
return ( !IsShowingPlaceholderText() &&
- 0u != mLogicalModel->mText.Count() );
+ 0u != mModel->mLogicalModel->mText.Count() );
}
/**
mEventData->mIsShowingPlaceholderText = false;
// Remove mPlaceholderTextColor
- mVisualModel->SetTextColor( mTextColor );
+ mModel->mVisualModel->SetTextColor( mTextColor );
}
}
}
}
- void ResetImfManager()
+ void ResetInputMethodContext()
{
if( mEventData )
{
// Reset incase we are in a pre-edit state.
- if( mEventData->mImfManager )
+ if( mEventData->mInputMethodContext )
{
- mEventData->mImfManager.Reset(); // Will trigger a message ( commit, get surrounding )
+ mEventData->mInputMethodContext.Reset(); // Will trigger a message ( commit, get surrounding )
}
ClearPreEditFlag();
}
}
+ /**
+ * @brief Helper to notify InputMethodContext with surrounding text & cursor changes.
+ */
+ void NotifyInputMethodContext();
+
+ /**
+ * @brief Helper to notify InputMethodContext with multi line status.
+ */
+ void NotifyInputMethodContextMultiLineStatus();
+
+ /**
+ * @brief Retrieve the current cursor position.
+ *
+ * @return The cursor position.
+ */
+ CharacterIndex GetLogicalCursorPosition() const;
+
+ /**
+ * @brief Retrieves the number of consecutive white spaces starting from the given @p index.
+ *
+ * @param[in] index The character index from where to count the number of consecutive white spaces.
+ *
+ * @return The number of consecutive white spaces.
+ */
+ Length GetNumberOfWhiteSpaces( CharacterIndex index ) const;
+
+ /**
+ * @brief Retrieve any text previously set starting from the given @p index.
+ *
+ * @param[in] index The character index from where to retrieve the text.
+ * @param[out] text A string of UTF-8 characters.
+ *
+ * @see Dali::Toolkit::Text::Controller::GetText()
+ */
+ void GetText( CharacterIndex index, std::string& text ) const;
+
bool IsClipboardEmpty()
{
bool result( mClipboard && mClipboard.NumberOfItems() );
return !result; // If NumberOfItems greater than 0, return false
}
+ bool IsClipboardVisible()
+ {
+ bool result( mClipboard && mClipboard.IsVisible() );
+ return result;
+ }
+
/**
* @brief Calculates the start character index of the first paragraph to be updated and
* the end character index of the last paragraph to be updated.
void OnSelectAllEvent();
+ /**
+ * @brief Retrieves the selected text. It removes the text if the @p deleteAfterRetrieval parameter is @e true.
+ *
+ * @param[out] selectedText The selected text encoded in utf8.
+ * @param[in] deleteAfterRetrieval Whether the text should be deleted after retrieval.
+ */
void RetrieveSelection( std::string& selectedText, bool deleteAfterRetrieval );
void ShowClipboard();
void SendSelectionToClipboard( bool deleteAfterSending );
- void GetTextFromClipboard( unsigned int itemIndex, std::string& retrievedString );
+ void RequestGetTextFromClipboard();
void RepositionSelectionHandles();
- void RepositionSelectionHandles( float visualX, float visualY );
+ void RepositionSelectionHandles( float visualX, float visualY, Controller::NoTextTap::Action action );
void SetPopupButtons();
/**
* @biref Clamps the horizontal scrolling to get the control always filled with text.
*
- * @param[in] actualSize The size of the laid out text.
+ * @param[in] layoutSize The size of the laid out text.
*/
- void ClampHorizontalScroll( const Vector2& actualSize );
+ void ClampHorizontalScroll( const Vector2& layoutSize );
/**
* @biref Clamps the vertical scrolling to get the control always filled with text.
*
- * @param[in] actualSize The size of the laid out text.
+ * @param[in] layoutSize The size of the laid out text.
*/
- void ClampVerticalScroll( const Vector2& actualSize );
+ void ClampVerticalScroll( const Vector2& layoutSize );
/**
* @brief Scrolls the text to make a position visible.
* @pre mEventData must not be NULL. (there is a text-input or selection capabilities).
*
* @param[in] position A position in text coords.
+ * @param[in] lineHeight The line height for the given position.
*
* This method is called after inserting text, moving the cursor with the grab handle or the keypad,
* or moving the selection handles.
*/
- void ScrollToMakePositionVisible( const Vector2& position );
+ void ScrollToMakePositionVisible( const Vector2& position, float lineHeight );
/**
* @brief Scrolls the text to make the cursor visible.
*/
void ScrollTextToMatchCursor( const CursorInfo& cursorInfo );
+ /**
+ * @brief Create an actor that renders the text background color
+ *
+ * @return the created actor or an empty handle if no background color needs to be rendered.
+ */
+ Actor CreateBackgroundActor();
+
+public:
+
+ /**
+ * @brief Gets implementation from the controller handle.
+ * @param controller The text controller
+ * @return The implementation of the Controller
+ */
+ static Impl& GetImplementation( Text::Controller& controller )
+ {
+ return *controller.mImpl;
+ }
+
private:
// Declared private and left undefined to avoid copies.
Impl( const Impl& );
public:
- ControlInterface& mControlInterface; ///< Reference to the text controller.
- LogicalModelPtr mLogicalModel; ///< Pointer to the logical model.
- VisualModelPtr mVisualModel; ///< Pointer to the visual model.
+ ControlInterface* mControlInterface; ///< Reference to the text controller.
+ EditableControlInterface* mEditableControlInterface; ///< Reference to the editable text controller.
+ ModelPtr mModel; ///< Pointer to the text's model.
FontDefaults* mFontDefaults; ///< Avoid allocating this when the user does not specify a font.
+ UnderlineDefaults* mUnderlineDefaults; ///< Avoid allocating this when the user does not specify underline parameters.
+ ShadowDefaults* mShadowDefaults; ///< Avoid allocating this when the user does not specify shadow parameters.
+ EmbossDefaults* mEmbossDefaults; ///< Avoid allocating this when the user does not specify emboss parameters.
+ OutlineDefaults* mOutlineDefaults; ///< Avoid allocating this when the user does not specify outline parameters.
EventData* mEventData; ///< Avoid allocating everything for text input until EnableTextInput().
TextAbstraction::FontClient mFontClient; ///< Handle to the font client.
Clipboard mClipboard; ///< Handle to the system clipboard
View mView; ///< The view interface to the rendering back-end.
MetricsPtr mMetrics; ///< A wrapper around FontClient used to get metrics & potentially down-scaled Emoji metrics.
- LayoutEngine mLayoutEngine; ///< The layout engine.
+ Layout::Engine mLayoutEngine; ///< The layout engine.
Vector<ModifyEvent> mModifyEvents; ///< Temporary stores the text set until the next relayout.
Vector4 mTextColor; ///< The regular text color
- Vector2 mAlignmentOffset; ///< Vertical and horizontal offset of the whole text inside the control due to alignment.
TextUpdateInfo mTextUpdateInfo; ///< Info of the characters updated.
OperationsMask mOperationsPending; ///< Operations pending to be done to layout the text.
Length mMaximumNumberOfCharacters; ///< Maximum number of characters that can be inserted.
+ HiddenText* mHiddenInput; ///< Avoid allocating this when the user does not specify hidden input mode.
+ Vector2 mTextFitContentSize; ///< Size of Text fit content
bool mRecalculateNaturalSize:1; ///< Whether the natural size needs to be recalculated.
bool mMarkupProcessorEnabled:1; ///< Whether the mark-up procesor is enabled.
bool mClipboardHideEnabled:1; ///< Whether the ClipboardHide function work or not
- bool mAutoScrollEnabled:1; ///< Whether auto text scrolling is enabled.
- CharacterDirection mAutoScrollDirectionRTL:1; ///< Direction of auto scrolling, true if rtl
-
+ bool mIsAutoScrollEnabled:1; ///< Whether auto text scrolling is enabled.
+ bool mUpdateTextDirection:1; ///< Whether the text direction needs to be updated.
+ CharacterDirection mIsTextDirectionRTL:1; ///< Whether the text direction is right to left or not
+
+ bool mUnderlineSetByString:1; ///< Set when underline is set by string (legacy) instead of map
+ bool mShadowSetByString:1; ///< Set when shadow is set by string (legacy) instead of map
+ 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
+
+ Shader mShaderBackground; ///< The shader for text background.
+
+ float mTextFitMinSize; ///< Minimum Font Size for text fit. Default 10
+ float mTextFitMaxSize; ///< Maximum Font Size for text fit. Default 100
+ float mTextFitStepSize; ///< Step Size for font intervalse. Default 1
+ bool mTextFitEnabled : 1; ///< Whether the text's fit is enabled.
};
} // namespace Text
} // namespace Dali
-#endif // __DALI_TOOLKIT_TEXT_CONTROLLER_H__
+#endif // DALI_TOOLKIT_TEXT_CONTROLLER_H