Dali::Accessibility::TestEnableSC( true );
auto rel = Accessibility::RelationType::FLOWS_TO;
- auto number = static_cast< size_t >( rel );
auto control = Control::New();
auto destination1 = Control::New();
auto destination2 = Control::New();
DevelControl::AppendAccessibilityRelation( control, destination1, rel );
auto relations = DevelControl::GetAccessibilityRelations(control);
- DALI_TEST_CHECK( relations[ number ].size() == 1 );
+ DALI_TEST_EQUALS(relations.size(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(relations[0].mRelationType, rel, TEST_LOCATION);
+ DALI_TEST_EQUALS(relations[0].mTargets.size(), 1u, TEST_LOCATION);
DevelControl::AppendAccessibilityRelation( control, destination2, rel );
relations = DevelControl::GetAccessibilityRelations(control);
- DALI_TEST_CHECK( relations[ number ].size() == 2 );
+ DALI_TEST_EQUALS(relations.size(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(relations[0].mRelationType, rel, TEST_LOCATION);
+ DALI_TEST_EQUALS(relations[0].mTargets.size(), 2u, TEST_LOCATION);
auto accessible = Dali::Accessibility::Accessible::Get( control );
auto accessible_destination1 = Dali::Accessibility::Accessible::Get( destination1 );
auto accessible_destination2 = Dali::Accessibility::Accessible::Get( destination2 );
auto relationset = accessible->GetRelationSet();
- DALI_TEST_CHECK( relationset[0].relationType == rel );
- DALI_TEST_CHECK( relationset[0].targets[0] == accessible_destination1->GetAddress() || relationset[0].targets[1] == accessible_destination1->GetAddress() );
- DALI_TEST_CHECK( relationset[0].targets[0] == accessible_destination2->GetAddress() || relationset[0].targets[1] == accessible_destination2->GetAddress() );
+ DALI_TEST_CHECK( relationset[0].mRelationType == rel );
+ DALI_TEST_CHECK( relationset[0].mTargets[0] == accessible_destination1 || relationset[0].mTargets[1] == accessible_destination1 );
+ DALI_TEST_CHECK( relationset[0].mTargets[0] == accessible_destination2 || relationset[0].mTargets[1] == accessible_destination2 );
auto relationset_bridge = TestGetRelationSet( accessible -> GetAddress() );
- DALI_TEST_CHECK( static_cast< uint32_t >( relationset[0].relationType ) == std::get<0>( relationset_bridge[0] ) );
+ DALI_TEST_CHECK( static_cast< uint32_t >( relationset[0].mRelationType ) == std::get<0>( relationset_bridge[0] ) );
- DALI_TEST_CHECK( relationset[0].targets[0] == std::get<1>( relationset_bridge[0] )[0] || relationset[0].targets[1] == std::get<1>( relationset_bridge[0] )[0] );
- DALI_TEST_CHECK( relationset[0].targets[0] == std::get<1>( relationset_bridge[0] )[1] || relationset[0].targets[1] == std::get<1>( relationset_bridge[0] )[1] );
+ DALI_TEST_CHECK( relationset[0].mTargets[0]->GetAddress() == std::get<1>( relationset_bridge[0] )[0] || relationset[0].mTargets[1]->GetAddress() == std::get<1>( relationset_bridge[0] )[0] );
+ DALI_TEST_CHECK( relationset[0].mTargets[0]->GetAddress() == std::get<1>( relationset_bridge[0] )[1] || relationset[0].mTargets[1]->GetAddress() == std::get<1>( relationset_bridge[0] )[1] );
- DevelControl::RemoveAccessibilityRelation(control,destination2,rel);
+ DevelControl::RemoveAccessibilityRelation(control, destination2, rel);
relations = DevelControl::GetAccessibilityRelations(control);
- DALI_TEST_CHECK( relations[ number ].size() == 1 );
+ DALI_TEST_EQUALS(relations.size(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(relations[0].mTargets.size(), 1u, TEST_LOCATION);
DevelControl::ClearAccessibilityRelations(control);
relations = DevelControl::GetAccessibilityRelations(control);
- DALI_TEST_CHECK( relations[ number ].size() == 0 );
+ DALI_TEST_EQUALS(relations.size(), 0u, TEST_LOCATION);
Dali::Accessibility::TestEnableSC( false );
{
mRasterizeSuccess = false;
}
+ mLoadSuccess = true;
return true;
}
bool IsLoaded() const
{
- return mLoadCount > 0 ? true : false;
+ return mLoadSuccess;
}
Dali::Devel::PixelBuffer Rasterize(uint32_t width, uint32_t height)
uint32_t mWidth{0};
uint32_t mHeight{0};
uint32_t mLoadCount{0};
+ bool mLoadSuccess{false};
bool mRasterizeSuccess{true};
};
// Note that we only re-load 0 frame.
DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
- tet_infoline("Test that we don't try to re-load new image cause it cached");
- DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1, 1), false, TEST_LOCATION);
+ // To do: we need to fix caching bug in animated-visual
+ //tet_infoline("Test that we don't try to re-load new image cause it cached");
+ //DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1, 1), false, TEST_LOCATION);
// Batch 2 frames. Now visual frame 1, 2, 3 cached and visual2 frame 0, 1 cached.
application.SendNotification();
application.SendNotification();
- DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+ // Wait for loading & rasterization
+ DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
application.SendNotification();
application.Render();
application.SendNotification();
- DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+ // Wait for loading & rasterization
+ DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
application.SendNotification();
application.Render();
application.SendNotification();
- // Wait for rasterization
+ // Wait for loading
DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
application.SendNotification();
application.SendNotification();
- // Wait for rasterization
+ // Wait for loading
DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
application.SendNotification();
int UtcDaliImageViewSvgLoadingFailure(void)
{
- ToolkitTestApplication application;
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
- TraceCallStack& textureTrace = gl.GetTextureTrace();
- textureTrace.Enable(true);
-
// Local svg file - invalid file path
{
+ ToolkitTestApplication application;
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
gResourceReadySignalFired = false;
ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/foo.svg");
application.SendNotification();
- // loading started, this waits for the loader thread
+ // loading started, this waits for the loader thread - load
DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
application.SendNotification();
// Local svg file - invalid file path without size set
{
+ ToolkitTestApplication application;
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
gResourceReadySignalFired = false;
textureTrace.Reset();
application.SendNotification();
- // loading started, this waits for the loader thread
+ // loading started, this waits for the loader thread - load & rasterize
DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
application.SendNotification();
// Local svg file - invalid file
{
+ ToolkitTestApplication application;
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
gResourceReadySignalFired = false;
textureTrace.Reset();
application.SendNotification();
- // loading started, this waits for the loader thread
+ // loading started, this waits for the loader thread - load & rasterize
DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
application.SendNotification();
// Remote svg file
{
+ ToolkitTestApplication application;
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
gResourceReadySignalFired = false;
textureTrace.Reset();
application.SendNotification();
- // loading started, this waits for the loader thread
+ // loading started, this waits for the loader thread - load & rasterize
DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
application.SendNotification();
// Remote svg file without size set
{
+ ToolkitTestApplication application;
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
gResourceReadySignalFired = false;
textureTrace.Reset();
application.SendNotification();
- // loading started, this waits for the loader thread
+ // loading started, this waits for the loader thread - load & rasterize
DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
application.SendNotification();
application.SendNotification();
- // loading started, this waits for the loader thread
- DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+ // Wait for loading & rasterization
+ DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
application.SendNotification();
application.Render(16);
application.SendNotification();
- // loading started, this waits for the loader thread
- DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+ // Wait for loading & rasterization
+ DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
application.SendNotification();
application.Render(16);
application.SendNotification();
- // loading started, this waits for the loader thread
+ // Wait for rasterization
DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
application.SendNotification();
END_TEST;
}
+int UtcDaliImageViewSvgAtlasing(void)
+{
+ ToolkitTestApplication application;
+
+ TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
+ callStack.Reset();
+ callStack.Enable(true);
+
+ Property::Map propertyMap;
+ propertyMap["url"] = TEST_SVG_FILE_NAME;
+ propertyMap["atlasing"] = true;
+
+ ImageView imageView = ImageView::New();
+ imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
+ imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
+ application.GetScene().Add(imageView);
+
+ application.SendNotification();
+
+ // Wait for loading & rasterization
+ DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(16);
+
+ // use atlas
+ TraceCallStack::NamedParams params1;
+ params1["width"] << 100;
+ params1["height"] << 100;
+ DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexSubImage2D", params1), true, TEST_LOCATION);
+
+ imageView.SetProperty(Actor::Property::SIZE, Vector2(600.f, 600.f));
+
+ application.SendNotification();
+
+ // Wait for rasterization
+ DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+
+ callStack.Reset();
+
+ application.SendNotification();
+ application.Render(16);
+
+ // not use atlas
+ TraceCallStack::NamedParams params2;
+ params2["width"] << 600;
+ params2["height"] << 600;
+ DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexImage2D", params2), true, TEST_LOCATION);
+
+ END_TEST;
+}
+
int UtcDaliImageViewTVGLoading(void)
{
ToolkitTestApplication application;
// Test normal case
TestResourceReadyUrl(1, 0, 1, gImage_600_RGB, "", TEST_LOCATION);
- TestResourceReadyUrl(1, 0, 1, TEST_SVG_FILE_NAME, "", TEST_LOCATION); // 1 rasterize
+ TestResourceReadyUrl(2, 0, 1, TEST_SVG_FILE_NAME, "", TEST_LOCATION); // load & rasterize
TestResourceReadyUrl(1, 0, 1, TEST_BROKEN_IMAGE_L, "", TEST_LOCATION);
TestResourceReadyUrl(2, 0, 1, TEST_GIF_FILE_NAME, "", TEST_LOCATION); // 2 image loading - batch size
#include <dali-toolkit/devel-api/controls/text-controls/text-editor-devel.h>
#include <dali-toolkit/devel-api/text/rendering-backend.h>
#include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
+#include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup.h>
#include <dali/devel-api/actors/actor-devel.h>
#include <dali/devel-api/adaptor-framework/clipboard.h>
const char* const PROPERTY_NAME_CURSOR_WIDTH = "cursorWidth";
const char* const PROPERTY_NAME_GRAB_HANDLE_IMAGE = "grabHandleImage";
const char* const PROPERTY_NAME_GRAB_HANDLE_PRESSED_IMAGE = "grabHandlePressedImage";
+const char* const PROPERTY_NAME_SELECTION_POPUP_STYLE = "selectionPopupStyle";
const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_LEFT = "selectionHandleImageLeft";
const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_RIGHT = "selectionHandleImageRight";
const char* const PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_LEFT = "selectionHandlePressedImageLeft";
DALI_TEST_CHECK(editor.GetPropertyIndex(PROPERTY_NAME_INPUT_FILTER) == DevelTextEditor::Property::INPUT_FILTER);
DALI_TEST_CHECK(editor.GetPropertyIndex(PROPERTY_NAME_STRIKETHROUGH) == DevelTextEditor::Property::STRIKETHROUGH);
DALI_TEST_CHECK(editor.GetPropertyIndex(PROPERTY_NAME_INPUT_STRIKETHROUGH) == DevelTextEditor::Property::INPUT_STRIKETHROUGH);
+ DALI_TEST_CHECK(editor.GetPropertyIndex(PROPERTY_NAME_SELECTION_POPUP_STYLE) == DevelTextEditor::Property::SELECTION_POPUP_STYLE);
END_TEST;
}
DALI_TEST_CHECK(SetPropertyMapRetrieved(editor, TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT, "filename", "leftHandleMarkerImage"));
DALI_TEST_CHECK(SetPropertyMapRetrieved(editor, TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT, "filename", "rightHandleMarkerImage"));
+ // Check the selection popup style
+ const Vector2 popupMaxSize(200.0f, 300.0f);
+ const Vector2 optionDividerSize(30.0f, 5.0f);
+ const Vector4 optionDividerPadding(20.0f, 20.0f, 10.0f, 10.0f);
+ const Vector4 labelPadding(5.0f, 5.0f, 50.0f, 25.0f);
+
+ Property::Map selectionPopupStyle;
+ selectionPopupStyle.Insert(TextSelectionPopup::Property::POPUP_MAX_SIZE, popupMaxSize);
+ selectionPopupStyle.Insert(TextSelectionPopup::Property::OPTION_DIVIDER_SIZE, optionDividerSize);
+ selectionPopupStyle.Insert(TextSelectionPopup::Property::OPTION_DIVIDER_PADDING, optionDividerPadding);
+ selectionPopupStyle.Insert(TextSelectionPopup::Property::LABEL_PADDING, labelPadding);
+
+ editor.SetProperty(DevelTextEditor::Property::SELECTION_POPUP_STYLE, selectionPopupStyle);
+
+ Property::Map selectionPopupStyleGet;
+ selectionPopupStyleGet = editor.GetProperty<Property::Map>(DevelTextEditor::Property::SELECTION_POPUP_STYLE);
+
+ Property::Value* popupValue;
+ popupValue = selectionPopupStyleGet.Find(TextSelectionPopup::Property::POPUP_MAX_SIZE);
+ DALI_TEST_CHECK(NULL != popupValue);
+ if(popupValue)
+ {
+ Vector2 popupMaxSizeGet;
+ popupValue->Get(popupMaxSizeGet);
+ DALI_TEST_EQUALS(popupMaxSizeGet, popupMaxSize, TEST_LOCATION);
+ }
+
+ popupValue = selectionPopupStyleGet.Find(TextSelectionPopup::Property::OPTION_DIVIDER_SIZE);
+ DALI_TEST_CHECK(NULL != popupValue);
+ if(popupValue)
+ {
+ Vector2 optionDividerSizeGet;
+ popupValue->Get(optionDividerSizeGet);
+ DALI_TEST_EQUALS(optionDividerSizeGet, optionDividerSize, TEST_LOCATION);
+ }
+
+ popupValue = selectionPopupStyleGet.Find(TextSelectionPopup::Property::OPTION_DIVIDER_PADDING);
+ DALI_TEST_CHECK(NULL != popupValue);
+ if(popupValue)
+ {
+ Vector4 optionDividerPaddingGet;
+ popupValue->Get(optionDividerPaddingGet);
+ DALI_TEST_EQUALS(optionDividerPaddingGet, optionDividerPadding, TEST_LOCATION);
+ }
+
+ popupValue = selectionPopupStyleGet.Find(TextSelectionPopup::Property::LABEL_PADDING);
+ DALI_TEST_CHECK(NULL != popupValue);
+ if(popupValue)
+ {
+ Vector4 labelPaddingGet;
+ popupValue->Get(labelPaddingGet);
+ DALI_TEST_EQUALS(labelPaddingGet, labelPadding, TEST_LOCATION);
+ }
+
+ // Reset selection popup style
+ selectionPopupStyle.Clear();
+ editor.SetProperty(DevelTextEditor::Property::SELECTION_POPUP_STYLE, selectionPopupStyle);
+
// Check the highlight color
editor.SetProperty(TextEditor::Property::SELECTION_HIGHLIGHT_COLOR, Color::GREEN);
DALI_TEST_EQUALS(editor.GetProperty<Vector4>(TextEditor::Property::SELECTION_HIGHLIGHT_COLOR), Color::GREEN, TEST_LOCATION);
#include <dali-toolkit-test-suite-utils.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/devel-api/controls/text-controls/text-field-devel.h>
+#include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup.h>
#include <dali-toolkit/devel-api/text/rendering-backend.h>
#include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
#include <dali/devel-api/adaptor-framework/key-devel.h>
const char* const PROPERTY_NAME_GRAB_HANDLE_PRESSED_IMAGE = "grabHandlePressedImage";
const char* const PROPERTY_NAME_SCROLL_THRESHOLD = "scrollThreshold";
const char* const PROPERTY_NAME_SCROLL_SPEED = "scrollSpeed";
+const char* const PROPERTY_NAME_SELECTION_POPUP_STYLE = "selectionPopupStyle";
const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_LEFT = "selectionHandleImageLeft";
const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_RIGHT = "selectionHandleImageRight";
const char* const PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_LEFT = "selectionHandlePressedImageLeft";
DALI_TEST_CHECK(field.GetPropertyIndex(PROPERTY_NAME_INPUT_FILTER) == DevelTextField::Property::INPUT_FILTER);
DALI_TEST_CHECK(field.GetPropertyIndex(PROPERTY_NAME_STRIKETHROUGH) == DevelTextField::Property::STRIKETHROUGH);
DALI_TEST_CHECK(field.GetPropertyIndex(PROPERTY_NAME_INPUT_STRIKETHROUGH) == DevelTextField::Property::INPUT_STRIKETHROUGH);
+ DALI_TEST_CHECK(field.GetPropertyIndex(PROPERTY_NAME_SELECTION_POPUP_STYLE) == DevelTextField::Property::SELECTION_POPUP_STYLE);
END_TEST;
}
DALI_TEST_CHECK(SetPropertyMapRetrieved(field, TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT, "filename", "leftHandleMarkerImage"));
DALI_TEST_CHECK(SetPropertyMapRetrieved(field, TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT, "filename", "rightHandleMarkerImage"));
+ // Check the selection popup style
+ const Vector2 popupMaxSize(200.0f, 300.0f);
+ const Vector2 optionDividerSize(30.0f, 5.0f);
+ const Vector4 optionDividerPadding(20.0f, 20.0f, 10.0f, 10.0f);
+ const Vector4 labelPadding(5.0f, 5.0f, 50.0f, 25.0f);
+
+ Property::Map selectionPopupStyle;
+ selectionPopupStyle.Insert(TextSelectionPopup::Property::POPUP_MAX_SIZE, popupMaxSize);
+ selectionPopupStyle.Insert(TextSelectionPopup::Property::OPTION_DIVIDER_SIZE, optionDividerSize);
+ selectionPopupStyle.Insert(TextSelectionPopup::Property::OPTION_DIVIDER_PADDING, optionDividerPadding);
+ selectionPopupStyle.Insert(TextSelectionPopup::Property::LABEL_PADDING, labelPadding);
+
+ field.SetProperty(DevelTextField::Property::SELECTION_POPUP_STYLE, selectionPopupStyle);
+
+ Property::Map selectionPopupStyleGet;
+ selectionPopupStyleGet = field.GetProperty<Property::Map>(DevelTextField::Property::SELECTION_POPUP_STYLE);
+
+ Property::Value* popupValue;
+ popupValue = selectionPopupStyleGet.Find(TextSelectionPopup::Property::POPUP_MAX_SIZE);
+ DALI_TEST_CHECK(NULL != popupValue);
+ if(popupValue)
+ {
+ Vector2 popupMaxSizeGet;
+ popupValue->Get(popupMaxSizeGet);
+ DALI_TEST_EQUALS(popupMaxSizeGet, popupMaxSize, TEST_LOCATION);
+ }
+
+ popupValue = selectionPopupStyleGet.Find(TextSelectionPopup::Property::OPTION_DIVIDER_SIZE);
+ DALI_TEST_CHECK(NULL != popupValue);
+ if(popupValue)
+ {
+ Vector2 optionDividerSizeGet;
+ popupValue->Get(optionDividerSizeGet);
+ DALI_TEST_EQUALS(optionDividerSizeGet, optionDividerSize, TEST_LOCATION);
+ }
+
+ popupValue = selectionPopupStyleGet.Find(TextSelectionPopup::Property::OPTION_DIVIDER_PADDING);
+ DALI_TEST_CHECK(NULL != popupValue);
+ if(popupValue)
+ {
+ Vector4 optionDividerPaddingGet;
+ popupValue->Get(optionDividerPaddingGet);
+ DALI_TEST_EQUALS(optionDividerPaddingGet, optionDividerPadding, TEST_LOCATION);
+ }
+
+ popupValue = selectionPopupStyleGet.Find(TextSelectionPopup::Property::LABEL_PADDING);
+ DALI_TEST_CHECK(NULL != popupValue);
+ if(popupValue)
+ {
+ Vector4 labelPaddingGet;
+ popupValue->Get(labelPaddingGet);
+ DALI_TEST_EQUALS(labelPaddingGet, labelPadding, TEST_LOCATION);
+ }
+
+ // Reset selection popup style
+ selectionPopupStyle.Clear();
+ field.SetProperty(DevelTextField::Property::SELECTION_POPUP_STYLE, selectionPopupStyle);
+
// Check the highlight color
field.SetProperty(TextField::Property::SELECTION_HIGHLIGHT_COLOR, Color::GREEN);
DALI_TEST_EQUALS(field.GetProperty<Vector4>(TextField::Property::SELECTION_HIGHLIGHT_COLOR), Color::GREEN, TEST_LOCATION);
application.SendNotification();
application.Render();
+ // Generate a Back key event. Nothing happens to the text field.
+ application.ProcessEvent(GenerateKey("XF86Back", "", "XF86Back", DALI_KEY_BACK, 0, 0, Integration::KeyEvent::DOWN, "XF86Back", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
+ application.ProcessEvent(GenerateKey("XF86Back", "", "XF86Back", DALI_KEY_BACK, 0, 0, Integration::KeyEvent::UP, "XF86Back", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
+
+ // Render and notify
+ application.SendNotification();
+ application.Render();
+
// The text shouldn't be deleted.
DALI_TEST_EQUALS(field.GetProperty<std::string>(TextField::Property::TEXT), longText, TEST_LOCATION);
namespace
{
const char* TEST_IMAGE_FILE_NAME = "selection-popup-border.9.png";
-
+const char* TEST_FONT_FAMILY = "BreezeSans";
}
void dali_textselectionpopup_startup(void)
END_TEST;
}
+int UtcDaliToolkitTextSelectionPopupBackgroundP(void)
+{
+ ToolkitTestApplication application;
+ TextSelectionPopup textSelectionPopup;
+ textSelectionPopup = TextSelectionPopup::New(NULL);
+
+ textSelectionPopup.SetProperty(TextSelectionPopup::Property::BACKGROUND,
+ Property::Map().Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
+
+ Property::Value value = textSelectionPopup.GetProperty(TextSelectionPopup::Property::BACKGROUND);
+
+ Property::Map map;
+ value.Get(map);
+
+ Property::Value* returnValue = map.Find(Dali::Toolkit::ImageVisual::Property::URL);
+ DALI_TEST_CHECK(NULL != returnValue);
+
+ if(returnValue)
+ {
+ std::string url;
+ returnValue->Get(url);
+ DALI_TEST_EQUALS(TEST_IMAGE_FILE_NAME, url, TEST_LOCATION);
+ }
+
+ END_TEST;
+}
+
// TextSelectionToolBar is used TextSelectionPopup, below tests it individually
int UtcDaliToolkitTextSelectionToolBarP(void)
END_TEST;
}
-int UtcDaliToolkitTextSelectionPopupDurationProperties(void)
+int UtcDaliToolkitTextSelectionPopupFloatProperties(void)
{
ToolkitTestApplication application;
TextSelectionPopup popup = TextSelectionPopup::New(nullptr);
const float popupFadeInDuration = 5.0f;
const float popupFadeOutDuration = 10.0f;
+ const float popupPressedCornerRadius = 15.0f;
popup.SetProperty(TextSelectionPopup::Property::POPUP_FADE_IN_DURATION, popupFadeInDuration);
popup.SetProperty(TextSelectionPopup::Property::POPUP_FADE_OUT_DURATION, popupFadeOutDuration);
+ popup.SetProperty(TextSelectionPopup::Property::POPUP_PRESSED_CORNER_RADIUS, popupPressedCornerRadius);
DALI_TEST_EQUALS(popup.GetProperty(TextSelectionPopup::Property::POPUP_FADE_IN_DURATION).Get<float>(), popupFadeInDuration, TEST_LOCATION);
DALI_TEST_EQUALS(popup.GetProperty(TextSelectionPopup::Property::POPUP_FADE_OUT_DURATION).Get<float>(), popupFadeOutDuration, TEST_LOCATION);
+ DALI_TEST_EQUALS(popup.GetProperty(TextSelectionPopup::Property::POPUP_PRESSED_CORNER_RADIUS).Get<float>(), popupPressedCornerRadius, TEST_LOCATION);
END_TEST;
}
DALI_TEST_EQUALS(popup.GetProperty(TextSelectionPopup::Property::POPUP_PRESSED_COLOR).Get<Vector4>(), Color::BLACK, TEST_LOCATION);
END_TEST;
+}
+
+int UtcDaliToolkitTextSelectionPopupScrollBarP(void)
+{
+ ToolkitTestApplication application;
+ TextSelectionPopup popup = TextSelectionPopup::New(nullptr);
+ DALI_TEST_CHECK(popup);
+
+ popup.SetProperty(TextSelectionPopup::Property::ENABLE_SCROLL_BAR, true);
+ DALI_TEST_EQUALS(popup.GetProperty(TextSelectionPopup::Property::ENABLE_SCROLL_BAR).Get<bool>(), true, TEST_LOCATION);
+
+ popup.SetProperty(TextSelectionPopup::Property::ENABLE_SCROLL_BAR, false);
+ DALI_TEST_EQUALS(popup.GetProperty(TextSelectionPopup::Property::ENABLE_SCROLL_BAR).Get<bool>(), false, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliToolkitTextSelectionPopupLabelTextVisualP(void)
+{
+ ToolkitTestApplication application;
+ TextSelectionPopup popup = TextSelectionPopup::New(nullptr);
+ DALI_TEST_CHECK(popup);
+
+ Property::Map textVisualMapSet;
+
+ textVisualMapSet.Insert(TextVisual::Property::FONT_FAMILY, TEST_FONT_FAMILY);
+ textVisualMapSet.Insert(TextVisual::Property::POINT_SIZE, 50.f);
+ textVisualMapSet.Insert(TextVisual::Property::TEXT_COLOR, Color::RED);
+
+ popup.SetProperty(TextSelectionPopup::Property::LABEL_TEXT_VISUAL, textVisualMapSet);
+
+ Property::Map textVisualMapGet;
+ Property::Map styleMapGet;
+
+ textVisualMapGet = popup.GetProperty(TextSelectionPopup::Property::LABEL_TEXT_VISUAL).Get<Property::Map>();
+ DALI_TEST_EQUALS(textVisualMapGet.Count(), 3u, TEST_LOCATION);
+
+ Property::Value* returnValue;
+
+ returnValue = textVisualMapGet.Find(TextVisual::Property::FONT_FAMILY);
+ DALI_TEST_CHECK(NULL != returnValue);
+
+ if(returnValue)
+ {
+ std::string fontFamily;
+ returnValue->Get(fontFamily);
+ DALI_TEST_EQUALS(fontFamily, TEST_FONT_FAMILY, TEST_LOCATION);
+ }
+
+ returnValue = textVisualMapGet.Find(TextVisual::Property::POINT_SIZE);
+ DALI_TEST_CHECK(NULL != returnValue);
+
+ if(returnValue)
+ {
+ float pointSize;
+ returnValue->Get(pointSize);
+ DALI_TEST_EQUALS(pointSize, 50.0f, TEST_LOCATION);
+ }
+
+ returnValue = textVisualMapGet.Find(TextVisual::Property::TEXT_COLOR);
+ DALI_TEST_CHECK(NULL != returnValue);
+
+ if(returnValue)
+ {
+ Vector4 textColor;
+ returnValue->Get(textColor);
+ DALI_TEST_EQUALS(textColor, Color::RED, TEST_LOCATION);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliToolkitTextSelectionPopupLabelProperties(void)
+{
+ ToolkitTestApplication application;
+ TextSelectionPopup popup = TextSelectionPopup::New(nullptr);
+ DALI_TEST_CHECK(popup);
+
+ const Vector2 labelMinimumSize(100.0f, 50.0f);
+ const Vector4 labelPadding(10.0f, 20.0f, 30.0f, 40.0f);
+
+ popup.SetProperty(TextSelectionPopup::Property::LABEL_MINIMUM_SIZE, labelMinimumSize);
+ popup.SetProperty(TextSelectionPopup::Property::LABEL_PADDING, labelPadding);
+
+ DALI_TEST_EQUALS(popup.GetProperty(TextSelectionPopup::Property::LABEL_MINIMUM_SIZE).Get<Vector2>(), labelMinimumSize, TEST_LOCATION);
+ DALI_TEST_EQUALS(popup.GetProperty(TextSelectionPopup::Property::LABEL_PADDING).Get<Vector4>(), labelPadding, TEST_LOCATION);
+
+ END_TEST;
}
\ No newline at end of file
{
auto control = Dali::Toolkit::Control::DownCast(Self());
- Internal::Control& internalControl = Toolkit::Internal::GetImplementation(control);
- Internal::Control::Impl& controlImpl = Internal::Control::Impl::Get(internalControl);
-
- std::vector<Dali::Accessibility::Relation> ret;
-
- for(auto& relation : controlImpl.mAccessibilityRelations)
- {
- auto& targets = relation.second;
-
- ret.emplace_back(Accessibility::Relation{relation.first, {}});
-
- // Map every Accessible* to its Address
- std::transform(targets.begin(), targets.end(), std::back_inserter(ret.back().targets), [](auto* x) {
- return x->GetAddress();
- });
- }
-
- return ret;
+ return DevelControl::GetAccessibilityRelations(control);
}
bool ControlAccessible::ScrollToChild(Actor child)
}
}
-std::vector<std::vector<Accessibility::Address>> GetAccessibilityRelations(Toolkit::Control control)
+std::vector<Accessibility::Relation> GetAccessibilityRelations(Toolkit::Control control)
{
- std::vector<std::vector<Accessibility::Address>> result(static_cast<std::size_t>(Accessibility::RelationType::MAX_COUNT));
+ const auto& relations = GetControlImplementation(control).mAccessibilityRelations;
+ std::vector<Accessibility::Relation> result;
- // Map every Accessible* to its Address
- for(auto& relation : GetControlImplementation(control).mAccessibilityRelations)
+ for(auto& relation : relations)
{
- auto index = static_cast<std::size_t>(relation.first);
auto& targets = relation.second;
- std::transform(targets.begin(), targets.end(), std::back_inserter(result[index]), [](auto* x) {
- return x->GetAddress();
- });
+ result.emplace_back(Accessibility::Relation{relation.first, {}});
+ std::copy(targets.begin(), targets.end(), std::back_inserter(result.back().mTargets));
}
return result;
DALI_TOOLKIT_API void RemoveAccessibilityRelation(Toolkit::Control control, Dali::Actor destination, Dali::Accessibility::RelationType relation);
/**
- * @brief The method returns collection accessibility addresses representing objects connected with current object
+ * @brief Returns a collection of Accessible objects related to current object and grouped by relation type.
*
- * @param control object to append attribute to
- * @return std::vector, where index is casted value of Accessibility::RelationType and value is std::vector of type Accessibility::Address
+ * @param control object to query
+ * @return collection of relations
+ *
+ * @see Dali::Accessibility::Accessible::GetRelationSet()
*/
-DALI_TOOLKIT_API std::vector<std::vector<Accessibility::Address>> GetAccessibilityRelations(Toolkit::Control control);
+DALI_TOOLKIT_API std::vector<Accessibility::Relation> GetAccessibilityRelations(Toolkit::Control control);
/**
* @brief The method removes all previously appended relations
* @note Return type is Property::STRING
*/
VERTICAL_ALIGNMENT,
+
+ /**
+ * @brief Sets the selection popup style
+ * @details Name "selectionPopupStyle", type Property::MAP.
+ * @see Dali::Toolkit::TextSelectionPopup::Property
+ */
+ SELECTION_POPUP_STYLE,
};
} // namespace Property
* The default value is 0.f which does nothing.
*/
CHARACTER_SPACING,
+
+ /**
+ * @brief Sets the selection popup style
+ * @details Name "selectionPopupStyle", type Property::MAP.
+ * @see Dali::Toolkit::TextSelectionPopup::Property
+ */
+ SELECTION_POPUP_STYLE,
};
} // namespace Property
GetImpl(*this).HidePopup();
}
+void TextSelectionPopup::SetProperties(const Dali::Property::Map& properties)
+{
+ GetImpl(*this).SetProperties(properties);
+}
+
+void TextSelectionPopup::GetProperties(Dali::Property::Map& properties)
+{
+ GetImpl(*this).GetProperties(properties);
+}
+
TextSelectionPopup::TextSelectionPopup(Internal::TextSelectionPopup& implementation)
: Control(implementation)
{
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
+#include <dali/public-api/object/property-map.h>
namespace Dali
{
POPUP_PRESSED_COLOR,
/**
+ * @brief The corner radius of the option when pressed.
+ * @details Name "popupPressedCornerRadius", type float.
+ */
+ POPUP_PRESSED_CORNER_RADIUS,
+
+ /**
* @brief The image to use for the option when pressed.
* @details Name "popupPressedImage", type string.
*/
* @details Name "backgroundBorder", type Property::Map.
* @note Optional.
*/
- BACKGROUND_BORDER
+ BACKGROUND_BORDER,
+
+ /**
+ * @brief The popup background.
+ * @details Name "background", type Property::Map.
+ * @note Optional.
+ */
+ BACKGROUND,
+
+ /**
+ * @brief The minimum size of popup label.
+ * @details Name "labelMinimumSize", type Vector2.
+ * @note Optional.
+ */
+ LABEL_MINIMUM_SIZE,
+
+ /**
+ * @brief The padding of popup label.
+ * @details Name "labelPadding", type Vector4.
+ * @note Optional.
+ */
+ LABEL_PADDING,
+
+ /**
+ * @brief The text visual map of popup label.
+ * @details Name "labelTextVisual", type Property::Map.
+ * @note Optional.
+ */
+ LABEL_TEXT_VISUAL,
+
+ /**
+ * @brief Whether the scroll-bar is enabled.
+ * @details Name "enableScrollBar", type Property::BOOLEAN.
+ * @note Optional.
+ */
+ ENABLE_SCROLL_BAR
};
};
*/
void HidePopup();
+ /**
+ * @brief Used to set options of text selection popup
+ *
+ * @param[in] properties The text selection popup options
+ */
+ void SetProperties(const Dali::Property::Map& properties);
+
+ /**
+ * @brief Retrieve property map of text selection popup options
+ *
+ * @param[out] properties The text selection popup options
+ */
+ void GetProperties(Dali::Property::Map& properties);
+
public: // Not intended for application developers
/**
* @brief Creates a handle using the Toolkit::Internal implementation.
{
namespace DevelAsyncImageLoader
{
-uint32_t LoadAnimatedImage(AsyncImageLoader asyncImageLoader,
- Dali::AnimatedImageLoading animatedImageLoading,
- uint32_t frameIndex)
+uint32_t LoadAnimatedImage(AsyncImageLoader asyncImageLoader,
+ Dali::AnimatedImageLoading animatedImageLoading,
+ uint32_t frameIndex,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad)
{
- return GetImplementation(asyncImageLoader).LoadAnimatedImage(animatedImageLoading, frameIndex);
+ return GetImplementation(asyncImageLoader).LoadAnimatedImage(animatedImageLoading, frameIndex, preMultiplyOnLoad);
}
uint32_t Load(AsyncImageLoader asyncImageLoader,
* @param[in] asyncImageLoader The ayncImageLoader
* @param[in] animatedImageLoading The AnimatedImageLoading to load animated image
* @param[in] frameIndex The frame index of a frame to be loaded frame
+ * @param[in] preMultiplyOnLoad ON if the image color should be multiplied by it's alpha. Set to OFF if there is no alpha or if the image need to be applied alpha mask.
* @return The loading task id
*/
-DALI_TOOLKIT_API uint32_t LoadAnimatedImage(AsyncImageLoader asyncImageLoader,
- Dali::AnimatedImageLoading animatedImageLoading,
- uint32_t frameIndex);
+DALI_TOOLKIT_API uint32_t LoadAnimatedImage(AsyncImageLoader asyncImageLoader,
+ Dali::AnimatedImageLoading animatedImageLoading,
+ uint32_t frameIndex,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad);
/**
* @brief Starts an image loading task.
DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "characterSpacing", FLOAT, CHARACTER_SPACING )
DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "relativeLineSize", FLOAT, RELATIVE_LINE_SIZE )
DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "verticalAlignment", STRING, VERTICAL_ALIGNMENT )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "selectionPopupStyle", MAP, SELECTION_POPUP_STYLE )
DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "textChanged", SIGNAL_TEXT_CHANGED )
DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "inputStyleChanged", SIGNAL_INPUT_STYLE_CHANGED )
impl.mRenderer.Reset();
break;
}
+ case Toolkit::DevelTextEditor::Property::SELECTION_POPUP_STYLE:
+ {
+ const Property::Map* map = value.GetMap();
+ if(map)
+ {
+ impl.mDecorator->SetSelectionPopupStyle(*map);
+ }
+ break;
+ }
}
}
value = impl.mController->GetRelativeLineSize();
break;
}
+ case Toolkit::DevelTextEditor::Property::SELECTION_POPUP_STYLE:
+ {
+ Property::Map map;
+ impl.mDecorator->GetSelectionPopupStyle(map);
+ value = map;
+ break;
+ }
} //switch
return value;
}
DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextField, "strikethrough", MAP, STRIKETHROUGH )
DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextField, "inputStrikethrough", MAP, INPUT_STRIKETHROUGH )
DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextField, "characterSpacing", FLOAT, CHARACTER_SPACING )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextField, "selectionPopupStyle", MAP, SELECTION_POPUP_STYLE )
DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "textChanged", SIGNAL_TEXT_CHANGED )
DALI_SIGNAL_REGISTRATION(Toolkit, TextField, "maxLengthReached", SIGNAL_MAX_LENGTH_REACHED )
impl.mController->SetCharacterSpacing(characterSpacing);
break;
}
+ case Toolkit::DevelTextField::Property::SELECTION_POPUP_STYLE:
+ {
+ const Property::Map* map = value.GetMap();
+ if(map)
+ {
+ impl.mDecorator->SetSelectionPopupStyle(*map);
+ }
+ break;
+ }
}
}
value = impl.mController->GetCharacterSpacing();
break;
}
+ case Toolkit::DevelTextField::Property::SELECTION_POPUP_STYLE:
+ {
+ Property::Map map;
+ impl.mDecorator->GetSelectionPopupStyle(map);
+ value = map;
+ break;
+ }
} //switch
return value;
}
#include <dali/public-api/animation/animation.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector4.h>
-#include <dali/public-api/object/property-map.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <string.h>
#include <cfloat>
#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup-callback-interface.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
#include <dali-toolkit/internal/controls/control/control-data-impl.h>
#include <dali-toolkit/internal/controls/text-controls/text-selection-popup-property-handler.h>
#include <dali-toolkit/internal/helpers/color-conversion.h>
const std::string TEXT_SELECTION_POPUP_BUTTON_STYLE_NAME("TextSelectionPopupButton");
const Dali::Vector4 DEFAULT_OPTION_PRESSED_COLOR(Dali::Vector4(0.24f, 0.72f, 0.8f, 1.0f));
+const float DEFAULT_OPTION_PRESSED_CORNER_RADIUS = 0.0f;
+const Dali::Vector4 DEFAULT_LABEL_PADDING(Dali::Vector4(24.0f, 24.0f, 14.0f, 14.0f));
#if defined(DEBUG_ENABLED)
Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
DALI_TYPE_REGISTRATION_BEGIN(Toolkit::TextSelectionPopup, Toolkit::Control, Create);
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupMaxSize", VECTOR2, POPUP_MAX_SIZE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupMinSize", VECTOR2, POPUP_MIN_SIZE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionMaxSize", VECTOR2, OPTION_MAX_SIZE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionMinSize", VECTOR2, OPTION_MIN_SIZE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionDividerSize", VECTOR2, OPTION_DIVIDER_SIZE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionDividerPadding", VECTOR4, OPTION_DIVIDER_PADDING)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupClipboardButtonImage", STRING, POPUP_CLIPBOARD_BUTTON_ICON_IMAGE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupCutButtonImage", STRING, POPUP_CUT_BUTTON_ICON_IMAGE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupCopyButtonImage", STRING, POPUP_COPY_BUTTON_ICON_IMAGE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupPasteButtonImage", STRING, POPUP_PASTE_BUTTON_ICON_IMAGE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupSelectButtonImage", STRING, POPUP_SELECT_BUTTON_ICON_IMAGE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupSelectAllButtonImage", STRING, POPUP_SELECT_ALL_BUTTON_ICON_IMAGE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupDividerColor", VECTOR4, POPUP_DIVIDER_COLOR)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupIconColor", VECTOR4, POPUP_ICON_COLOR)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupPressedColor", VECTOR4, POPUP_PRESSED_COLOR)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupPressedImage", STRING, POPUP_PRESSED_IMAGE)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupFadeInDuration", FLOAT, POPUP_FADE_IN_DURATION)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupFadeOutDuration", FLOAT, POPUP_FADE_OUT_DURATION)
-DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "backgroundBorder", MAP, BACKGROUND_BORDER)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupMaxSize", VECTOR2, POPUP_MAX_SIZE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupMinSize", VECTOR2, POPUP_MIN_SIZE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionMaxSize", VECTOR2, OPTION_MAX_SIZE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionMinSize", VECTOR2, OPTION_MIN_SIZE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionDividerSize", VECTOR2, OPTION_DIVIDER_SIZE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionDividerPadding", VECTOR4, OPTION_DIVIDER_PADDING)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupClipboardButtonImage", STRING, POPUP_CLIPBOARD_BUTTON_ICON_IMAGE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupCutButtonImage", STRING, POPUP_CUT_BUTTON_ICON_IMAGE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupCopyButtonImage", STRING, POPUP_COPY_BUTTON_ICON_IMAGE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupPasteButtonImage", STRING, POPUP_PASTE_BUTTON_ICON_IMAGE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupSelectButtonImage", STRING, POPUP_SELECT_BUTTON_ICON_IMAGE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupSelectAllButtonImage", STRING, POPUP_SELECT_ALL_BUTTON_ICON_IMAGE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupDividerColor", VECTOR4, POPUP_DIVIDER_COLOR)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupIconColor", VECTOR4, POPUP_ICON_COLOR)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupPressedColor", VECTOR4, POPUP_PRESSED_COLOR)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupPressedCornerRadius", FLOAT, POPUP_PRESSED_CORNER_RADIUS)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupPressedImage", STRING, POPUP_PRESSED_IMAGE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupFadeInDuration", FLOAT, POPUP_FADE_IN_DURATION)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupFadeOutDuration", FLOAT, POPUP_FADE_OUT_DURATION)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "backgroundBorder", MAP, BACKGROUND_BORDER)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "background", MAP, BACKGROUND)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "labelMinimumSize", VECTOR2, LABEL_MINIMUM_SIZE)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "labelPadding", VECTOR4, LABEL_PADDING)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "labelTextVisual", MAP, LABEL_TEXT_VISUAL)
+DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "enableScrollBar", BOOLEAN, ENABLE_SCROLL_BAR)
DALI_TYPE_REGISTRATION_END()
Property::Value TextSelectionPopup::GetProperty(BaseObject* object, Property::Index index)
{
Property::Value value;
-
Toolkit::TextSelectionPopup selectionPopup = Toolkit::TextSelectionPopup::DownCast(Dali::BaseHandle(object));
if(selectionPopup)
return value;
}
+void TextSelectionPopup::SetProperties(const Property::Map& properties)
+{
+ Toolkit::TextSelectionPopup selectionPopup = Toolkit::TextSelectionPopup::DownCast(Self());
+
+ if(selectionPopup)
+ {
+ const Property::Map::SizeType count = properties.Count();
+ for(Property::Map::SizeType position = 0; position < count; ++position)
+ {
+ KeyValuePair keyValue = properties.GetKeyValue(position);
+ Property::Key& key = keyValue.first;
+ Property::Value& value = keyValue.second;
+ PropertyHandler::SetProperty(selectionPopup, key.indexKey, value);
+ }
+ }
+}
+
+void TextSelectionPopup::GetProperties(Property::Map& properties)
+{
+ Property::Map map;
+
+ map.Insert(Toolkit::TextSelectionPopup::Property::POPUP_MAX_SIZE, GetDimensionToCustomise(POPUP_MAXIMUM_SIZE));
+ map.Insert(Toolkit::TextSelectionPopup::Property::OPTION_DIVIDER_SIZE, GetDimensionToCustomise(OPTION_DIVIDER_SIZE));
+ map.Insert(Toolkit::TextSelectionPopup::Property::OPTION_DIVIDER_PADDING, Vector4(mOptionDividerPadding.left, mOptionDividerPadding.right, mOptionDividerPadding.top, mOptionDividerPadding.bottom));
+ map.Insert(Toolkit::TextSelectionPopup::Property::LABEL_MINIMUM_SIZE, mLabelMinimumSize);
+ map.Insert(Toolkit::TextSelectionPopup::Property::LABEL_PADDING, Vector4(mLabelPadding.left, mLabelPadding.right, mLabelPadding.top, mLabelPadding.bottom));
+ map.Insert(Toolkit::TextSelectionPopup::Property::LABEL_TEXT_VISUAL, mLabelTextVisual);
+ map.Insert(Toolkit::TextSelectionPopup::Property::ENABLE_SCROLL_BAR, mEnableScrollBar);
+ map.Insert(Toolkit::TextSelectionPopup::Property::POPUP_DIVIDER_COLOR, mDividerColor);
+ map.Insert(Toolkit::TextSelectionPopup::Property::POPUP_FADE_IN_DURATION, mFadeInDuration);
+ map.Insert(Toolkit::TextSelectionPopup::Property::POPUP_FADE_OUT_DURATION, mFadeOutDuration);
+ map.Insert(Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_COLOR, mPressedColor);
+ map.Insert(Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_CORNER_RADIUS, mPressedCornerRadius);
+
+ Property::Map backgroundMap;
+ Toolkit::Visual::Base backgroundVisual = DevelControl::GetVisual(*this, Toolkit::Control::Property::BACKGROUND);
+ if(backgroundVisual)
+ {
+ backgroundVisual.CreatePropertyMap(backgroundMap);
+ }
+ map.Insert(Toolkit::TextSelectionPopup::Property::BACKGROUND, backgroundMap);
+
+ Property::Map borderMap;
+ Toolkit::Visual::Base borderVisual = DevelControl::GetVisual(*this, Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER);
+ if(borderVisual)
+ {
+ borderVisual.CreatePropertyMap(borderMap);
+ }
+ map.Insert(Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER, borderMap);
+
+ properties = map;
+}
+
void TextSelectionPopup::EnableButtons(Toolkit::TextSelectionPopup::Buttons buttonsToEnable)
{
mEnabledButtons = buttonsToEnable;
return mOptionDividerPadding;
}
+void TextSelectionPopup::SetLabelPadding(const Padding& padding)
+{
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextSelectionPopup::SetLabelPadding padding(%f,%f,%f,%f)\n", padding.left, padding.right, padding.top, padding.bottom);
+ mLabelPadding = Padding(padding.left, padding.right, padding.top, padding.bottom);
+}
+
+Padding TextSelectionPopup::GetLabelPadding() const
+{
+ return mLabelPadding;
+}
+
void TextSelectionPopup::CreateOrderedListOfPopupOptions()
{
mOrderListOfButtons.clear();
Toolkit::PushButton option = Toolkit::PushButton::New();
option.SetProperty(Dali::Actor::Property::NAME, button.name);
option.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
+ option.SetProperty(Actor::Property::MINIMUM_SIZE, mLabelMinimumSize);
switch(button.id)
{
if(showCaption)
{
// PushButton layout properties.
- option.SetProperty(Toolkit::PushButton::Property::LABEL_PADDING, Vector4(24.0f, 24.0f, 14.0f, 14.0f));
+ const Padding padding(mLabelPadding);
+ option.SetProperty(Toolkit::PushButton::Property::LABEL_PADDING, padding);
// Label properties.
Property::Map buttonLabelProperties;
buttonLabelProperties.Insert(Toolkit::TextVisual::Property::TEXT, button.caption);
+ buttonLabelProperties.Merge(mLabelTextVisual);
+
option.SetProperty(Toolkit::Button::Property::LABEL, buttonLabelProperties);
}
if(showIcons)
{
// The image can be blank, the color can be used in that case.
selectedBackgroundValue = Property::Value{{Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR},
- {Toolkit::ColorVisual::Property::MIX_COLOR, mPressedColor}};
+ {Toolkit::ColorVisual::Property::MIX_COLOR, mPressedColor},
+ {Toolkit::DevelVisual::Property::CORNER_RADIUS, mPressedCornerRadius},
+ {Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE}};
}
option.SetProperty(Toolkit::Button::Property::SELECTED_BACKGROUND_VISUAL, selectedBackgroundValue);
- option.SetProperty(Toolkit::Control::Property::STYLE_NAME, TEXT_SELECTION_POPUP_BUTTON_STYLE_NAME);
+ // The value set by user takes precedence over the theme value.
+ if(mLabelTextVisual.Count() == 0)
+ {
+ option.SetProperty(Toolkit::Control::Property::STYLE_NAME, TEXT_SELECTION_POPUP_BUTTON_STYLE_NAME);
+ }
// 5 Add option to tool bar
mToolbar.AddOption(option);
#ifdef DECORATOR_DEBUG
mToolbar.SetProperty(Dali::Actor::Property::NAME, "TextSelectionToolbar");
#endif
+ mToolbar.SetProperty(Toolkit::TextSelectionToolbar::Property::ENABLE_SCROLL_BAR, mEnableScrollBar);
self.Add(mToolbar);
}
}
}
+void TextSelectionPopup::CreateBackground(Property::Map& propertyMap)
+{
+ // Removes previous image if necessary
+ DevelControl::UnregisterVisual(*this, Toolkit::Control::Property::BACKGROUND);
+
+ if(!propertyMap.Empty())
+ {
+ Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual(propertyMap);
+
+ if(visual)
+ {
+ DevelControl::RegisterVisual(*this, Toolkit::Control::Property::BACKGROUND, visual, DepthIndex::BACKGROUND);
+ }
+ }
+}
+
TextSelectionPopup::TextSelectionPopup(TextSelectionPopupCallbackInterface* callbackInterface)
: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
mToolbar(),
mOptionMinSize(),
mOptionDividerSize(),
mOptionDividerPadding(),
+ mLabelMinimumSize(),
+ mLabelPadding(DEFAULT_LABEL_PADDING),
+ mLabelTextVisual(),
+ mEnableScrollBar(true),
mEnabledButtons(Toolkit::TextSelectionPopup::NONE),
mCallbackInterface(callbackInterface),
mPressedColor(DEFAULT_OPTION_PRESSED_COLOR),
+ mPressedCornerRadius(DEFAULT_OPTION_PRESSED_CORNER_RADIUS),
mDividerColor(Color::WHITE),
mIconColor(Color::WHITE),
mSelectOptionPriority(1),
static Property::Value GetProperty(BaseObject* object, Property::Index index);
/**
+ * @brief Toolkit::TextSelectionPopup::SetProperties()
+ */
+ void SetProperties(const Property::Map& properties);
+
+ /**
+ * @brief Toolkit::TextSelectionPopup::GetProperties()
+ */
+ void GetProperties(Property::Map& properties);
+
+ /**
* @copydoc Toolkit::EnableButtons
*/
void EnableButtons(Toolkit::TextSelectionPopup::Buttons buttonsToEnable);
*/
Padding GetOptionDividerPadding() const;
+ /**
+ * Set label padding
+ * @param[in] padding BEGIN END BOTTOM TOP
+ */
+ void SetLabelPadding(const Padding& padding);
+
+ /**
+ * Get label padding
+ * @return Padding
+ */
+ Padding GetLabelPadding() const;
+
void CreateOrderedListOfPopupOptions();
void AddOption(const ButtonRequirement& button, bool showDivider, bool showIcons, bool showCaption);
void CreateBackgroundBorder(Property::Map& propertyMap);
/**
+ * Creates the background image
+ *
+ * @param[in] propertyMap The properties describing the background
+ */
+ void CreateBackground(Property::Map& propertyMap);
+
+
+ /**
* Construct a new TextField.
*/
TextSelectionPopup(TextSelectionPopupCallbackInterface* callbackInterface);
Size mOptionDividerSize; // Size of divider line
Padding mOptionDividerPadding; // Padding of divider line
+ Vector2 mLabelMinimumSize; // Minimum size of label
+ Padding mLabelPadding; // Padding of label
+ Property::Map mLabelTextVisual; // Text visual map of label
+ bool mEnableScrollBar; // Enable scrollbar
+
std::vector<ButtonRequirement> mOrderListOfButtons; // List of buttons in the order to be displayed and a flag to indicate if needed.
Toolkit::TextSelectionPopup::Buttons mEnabledButtons; // stores enabled buttons
Toolkit::TextSelectionPopupCallbackInterface* mCallbackInterface;
- std::string mPressedImage; // Image used for the popup option when pressed.
- Vector4 mPressedColor; // Color of the popup option when pressed.
- Vector4 mDividerColor; // Color of the divider between buttons
- Vector4 mIconColor; // Color of the popup icon.
+ std::string mPressedImage; // Image used for the popup option when pressed.
+ Vector4 mPressedColor; // Color of the popup option when pressed.
+ float mPressedCornerRadius; // Corner radius of the popup option when pressed.
+ Vector4 mDividerColor; // Color of the divider between buttons
+ Vector4 mIconColor; // Color of the popup icon.
// Priority of Options/Buttons in the Cut and Paste pop-up, higher priority buttons are displayed first, left to right.
std::size_t mSelectOptionPriority; // Position of Select Button
impl.mPressedColor = value.Get<Vector4>();
break;
}
+ case Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_CORNER_RADIUS:
+ {
+ impl.mPressedCornerRadius = value.Get<float>();
+ break;
+ }
case Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_IMAGE:
{
impl.SetPressedImage(value.Get<std::string>());
impl.CreateBackgroundBorder(map);
break;
}
+ case Toolkit::TextSelectionPopup::Property::BACKGROUND:
+ {
+ Property::Map map = value.Get<Property::Map>();
+ impl.CreateBackground(map);
+ break;
+ }
+ case Toolkit::TextSelectionPopup::Property::LABEL_MINIMUM_SIZE:
+ {
+ impl.mLabelMinimumSize = value.Get<Vector2>();
+ break;
+ }
+ case Toolkit::TextSelectionPopup::Property::LABEL_PADDING:
+ {
+ Vector4 padding(value.Get<Vector4>());
+ impl.SetLabelPadding(Padding(padding.x, padding.y, padding.z, padding.w));
+ break;
+ }
+ case Toolkit::TextSelectionPopup::Property::LABEL_TEXT_VISUAL:
+ {
+ impl.mLabelTextVisual = value.Get<Property::Map>();
+ break;
+ }
+ case Toolkit::TextSelectionPopup::Property::ENABLE_SCROLL_BAR:
+ {
+ impl.mEnableScrollBar = value.Get<bool>();
+ break;
+ }
}
}
value = impl.mPressedColor;
break;
}
+ case Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_CORNER_RADIUS:
+ {
+ value = impl.mPressedCornerRadius;
+ break;
+ }
case Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_IMAGE:
{
value = impl.GetPressedImage();
value = map;
break;
}
+ case Toolkit::TextSelectionPopup::Property::BACKGROUND:
+ {
+ Property::Map map;
+ Toolkit::Visual::Base visual = DevelControl::GetVisual(impl, Toolkit::Control::Property::BACKGROUND);
+ if(visual)
+ {
+ visual.CreatePropertyMap(map);
+ }
+ value = map;
+ break;
+ }
+ case Toolkit::TextSelectionPopup::Property::LABEL_MINIMUM_SIZE:
+ {
+ value = impl.mLabelMinimumSize;
+ break;
+ }
+ case Toolkit::TextSelectionPopup::Property::LABEL_PADDING:
+ {
+ Padding padding = impl.GetLabelPadding();
+ value = Vector4(padding.left, padding.right, padding.top, padding.bottom);
+ break;
+ }
+ case Toolkit::TextSelectionPopup::Property::LABEL_TEXT_VISUAL:
+ {
+ value = impl.mLabelTextVisual;
+ break;
+ }
+ case Toolkit::TextSelectionPopup::Property::ENABLE_SCROLL_BAR:
+ {
+ value = impl.mEnableScrollBar;
+ break;
+ }
}
return value;
mCurrentFocusActors.push_back(std::pair<WeakHandle<Layer>, WeakHandle<Actor> >(mCurrentFocusedWindow, actor));
}
+ // Send notification for the change of focus actor
+ if(!mFocusChangedSignal.Empty())
+ {
+ mFocusChangedSignal.Emit(currentFocusedActor, actor);
+ }
+
Toolkit::Control newlyFocusedControl = Toolkit::Control::DownCast(actor);
if(newlyFocusedControl)
{
mFocusHistory.erase(beginPos);
}
- // Send notification for the change of focus actor
- if(!mFocusChangedSignal.Empty())
- {
- mFocusChangedSignal.Emit(currentFocusedActor, actor);
- }
DALI_LOG_INFO(gLogFilter, Debug::General, "[%s:%d] SUCCEED\n", __FUNCTION__, __LINE__);
success = true;
}
return internal;
}
-uint32_t AsyncImageLoader::LoadAnimatedImage(Dali::AnimatedImageLoading animatedImageLoading,
- uint32_t frameIndex)
+uint32_t AsyncImageLoader::LoadAnimatedImage(Dali::AnimatedImageLoading animatedImageLoading,
+ uint32_t frameIndex,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad)
{
if(!mIsLoadThreadStarted)
{
mLoadThread.Start();
mIsLoadThreadStarted = true;
}
- mLoadThread.AddTask(new LoadingTask(++mLoadTaskId, animatedImageLoading, frameIndex));
+ mLoadThread.AddTask(new LoadingTask(++mLoadTaskId, animatedImageLoading, frameIndex, preMultiplyOnLoad));
return mLoadTaskId;
}
static IntrusivePtr<AsyncImageLoader> New();
/**
- * @copydoc Toolkit::AsyncImageLoader::LoadAnimatedImage( Dali::AnimatedImageLoading animatedImageLoading, uint32_t frameIndex )
+ * @copydoc Toolkit::AsyncImageLoader::LoadAnimatedImage( Dali::AnimatedImageLoading animatedImageLoading, uint32_t frameIndex, DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad)
*/
- uint32_t LoadAnimatedImage(Dali::AnimatedImageLoading animatedImageLoading,
- uint32_t frameIndex);
+ uint32_t LoadAnimatedImage(Dali::AnimatedImageLoading animatedImageLoading,
+ uint32_t frameIndex,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad);
/**
* @copydoc Toolkit::AsyncImageLoader::Load( const std::string&, ImageDimensions, FittingMode::Type, SamplingMode::Type, bool , DevelAsyncImageLoader::PreMultiplyOnLoad )
{
namespace Internal
{
-LoadingTask::LoadingTask(uint32_t id, Dali::AnimatedImageLoading animatedImageLoading, uint32_t frameIndex)
+LoadingTask::LoadingTask(uint32_t id, Dali::AnimatedImageLoading animatedImageLoading, uint32_t frameIndex, DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad)
: pixelBuffer(),
url(),
encodedImageBuffer(),
fittingMode(),
samplingMode(),
orientationCorrection(),
- preMultiplyOnLoad(DevelAsyncImageLoader::PreMultiplyOnLoad::OFF),
+ preMultiplyOnLoad(preMultiplyOnLoad),
isMaskTask(false),
maskPixelBuffer(),
contentScale(1.0f),
* @param [in] id of the task
* @param [in] animatedImageLoading The AnimatedImageLoading to load animated image
* @param [in] frameIndex The frame index of a frame to be loaded frame
+ * @param [in] preMultiplyOnLoad ON if the image's color should be multiplied by it's alpha. Set to OFF if there is no alpha or if the image need to be applied alpha mask.
*/
- LoadingTask(uint32_t id,
- Dali::AnimatedImageLoading animatedImageLoading,
- uint32_t frameIndex);
+ LoadingTask(uint32_t id,
+ Dali::AnimatedImageLoading animatedImageLoading,
+ uint32_t frameIndex,
+ DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad);
/**
* Constructor.
}
}
+ void CreateSelectionPopup()
+ {
+ if(!mCopyPastePopup.actor)
+ {
+ mCopyPastePopup.actor = TextSelectionPopup::New(&mTextSelectionPopupCallbackInterface);
+ #ifdef DECORATOR_DEBUG
+ mCopyPastePopup.actor.SetProperty(Dali::Actor::Property::NAME, "mCopyPastePopup");
+ #endif
+ mCopyPastePopup.actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ mCopyPastePopup.actor.OnRelayoutSignal().Connect(this, &Decorator::Impl::SetPopupPosition); // Position popup after size negotiation
+ }
+ }
+
void CalculateHandleWorldCoordinates(HandleImpl& handle, Vector2& position)
{
// Gets the world position of the active layer. The active layer is where the handles are added.
void Decorator::SetEnabledPopupButtons(TextSelectionPopup::Buttons& enabledButtonsBitMask)
{
mImpl->mEnabledPopupButtons = enabledButtonsBitMask;
-
- if(!mImpl->mCopyPastePopup.actor)
- {
- mImpl->mCopyPastePopup.actor = TextSelectionPopup::New(&mImpl->mTextSelectionPopupCallbackInterface);
-#ifdef DECORATOR_DEBUG
- mImpl->mCopyPastePopup.actor.SetProperty(Dali::Actor::Property::NAME, "mCopyPastePopup");
-#endif
- mImpl->mCopyPastePopup.actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
- mImpl->mCopyPastePopup.actor.OnRelayoutSignal().Connect(mImpl, &Decorator::Impl::SetPopupPosition); // Position popup after size negotiation
- }
-
+ mImpl->CreateSelectionPopup();
mImpl->mCopyPastePopup.actor.EnableButtons(mImpl->mEnabledPopupButtons);
}
return mImpl->mEnabledPopupButtons;
}
+void Decorator::SetSelectionPopupStyle(const Property::Map& options)
+{
+ mImpl->CreateSelectionPopup();
+ mImpl->mCopyPastePopup.actor.SetProperties(options);
+}
+
+void Decorator::GetSelectionPopupStyle(Property::Map& options)
+{
+ if(mImpl->mCopyPastePopup.actor)
+ {
+ mImpl->mCopyPastePopup.actor.GetProperties(options);
+ }
+}
+
/** Scroll **/
void Decorator::SetScrollThreshold(float threshold)
#include <dali/public-api/common/intrusive-ptr.h>
#include <dali/public-api/math/rect.h>
#include <dali/public-api/object/ref-object.h>
+#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup.h>
TextSelectionPopup::Buttons& GetEnabledPopupButtons();
/**
+ * @brief Used to set the selection popup options
+ *
+ * @param[in] options The property map of selection popup options
+ */
+ void SetSelectionPopupStyle(const Property::Map& options);
+
+ /**
+ * @brief Used to get the selection popup options
+ *
+ * @param[out] options The property map of selection popup options
+ */
+ void GetSelectionPopupStyle(Property::Map& options);
+
+ /**
* @brief Sets the scroll threshold.
*
* It defines a square area inside the control, close to the edge.
controller.mImpl->RequestRelayout();
}
}
+ else if((NULL != controller.mImpl->mEventData) && (keyEvent.GetState() == KeyEvent::UP))
+ {
+ // Handles specific keys that require event propagation.
+ if(Dali::DALI_KEY_BACK == keyEvent.GetKeyCode())
+ {
+ // Do nothing
+ return false;
+ }
+ }
if(textChanged &&
(NULL != controller.mImpl->mEditableControlInterface))
{
}
-void TextureAsyncLoadingHelper::LoadAnimatedImage(const TextureManager::TextureId& textureId,
- Dali::AnimatedImageLoading animatedImageLoading,
- const std::uint32_t& frameIndex)
+void TextureAsyncLoadingHelper::LoadAnimatedImage(const TextureManager::TextureId& textureId,
+ Dali::AnimatedImageLoading animatedImageLoading,
+ const std::uint32_t& frameIndex,
+ const DevelAsyncImageLoader::PreMultiplyOnLoad& preMultiplyOnLoad)
{
mLoadingInfoContainer.push_back(AsyncLoadingInfo(textureId));
- auto id = GetImplementation(mLoader).LoadAnimatedImage(animatedImageLoading, frameIndex);
+ auto id = GetImplementation(mLoader).LoadAnimatedImage(animatedImageLoading, frameIndex, preMultiplyOnLoad);
mLoadingInfoContainer.back().loadId = id;
}
* @param[in] textureId TextureId to reference the texture that will be loaded
* @param[in] animatedImageLoading The AnimatedImageLoading to load animated image
* @param[in] frameIndex The frame index of a frame to be loaded frame
+ * @param[in] preMultiplyOnLoad if the image's color should be multiplied by it's alpha. Set to OFF if there is no alpha or if the image need to be applied alpha mask.
*/
- void LoadAnimatedImage(const TextureManager::TextureId& textureId,
- Dali::AnimatedImageLoading animatedImageLoading,
- const std::uint32_t& frameIndex);
+ void LoadAnimatedImage(const TextureManager::TextureId& textureId,
+ Dali::AnimatedImageLoading animatedImageLoading,
+ const std::uint32_t& frameIndex,
+ const DevelAsyncImageLoader::PreMultiplyOnLoad& preMultiplyOnLoad);
/**
* @brief Load a new texture.
const Dali::WrapMode::Type& wrapModeU,
const Dali::WrapMode::Type& wrapModeV,
const bool& synchronousLoading,
- TextureUploadObserver* textureObserver)
+ TextureUploadObserver* textureObserver,
+ TextureManager::MultiplyOnLoad& preMultiplyOnLoad)
{
TextureSet textureSet;
DALI_LOG_ERROR("TextureManager::LoadAnimatedImageTexture: Synchronous mask image loading is failed\n");
}
}
+
+ if(preMultiplyOnLoad == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD)
+ {
+ PreMultiply(pixelBuffer, preMultiplyOnLoad);
+ }
+
PixelData pixelData = Devel::PixelBuffer::Convert(pixelBuffer); // takes ownership of buffer
if(!textureSet)
{
cropToMask = maskInfo->mCropToMask;
}
- auto preMultiply = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
- textureId = RequestLoadInternal(url, alphaMaskId, contentScaleFactor, ImageDimensions(), FittingMode::SCALE_TO_FILL, SamplingMode::BOX_THEN_LINEAR, UseAtlas::NO_ATLAS, cropToMask, StorageType::UPLOAD_TO_TEXTURE, textureObserver, true, TextureManager::ReloadPolicy::CACHED, preMultiply, animatedImageLoading, frameIndex, false);
+ textureId = RequestLoadInternal(url, alphaMaskId, contentScaleFactor, ImageDimensions(), FittingMode::SCALE_TO_FILL, SamplingMode::BOX_THEN_LINEAR, UseAtlas::NO_ATLAS, cropToMask, StorageType::UPLOAD_TO_TEXTURE, textureObserver, true, TextureManager::ReloadPolicy::CACHED, preMultiplyOnLoad, animatedImageLoading, frameIndex, false);
TextureManager::LoadState loadState = mTextureCacheManager.GetTextureStateInternal(textureId);
if(loadState == TextureManager::LoadState::UPLOADED)
{
TextureHash textureHash = INITIAL_HASH_NUMBER;
TextureCacheIndex cacheIndex = INVALID_CACHE_INDEX;
- if(storageType != StorageType::RETURN_PIXEL_BUFFER)
+ if(storageType != StorageType::RETURN_PIXEL_BUFFER && frameIndex == 0)
{
textureHash = mTextureCacheManager.GenerateHash(url, desiredSize, fittingMode, samplingMode, useAtlas, maskTextureId, cropToMask, frameIndex);
DALI_ASSERT_ALWAYS(loadingHelperIt != loadersContainer.End());
if(textureInfo.animatedImageLoading)
{
- loadingHelperIt->LoadAnimatedImage(textureInfo.textureId, textureInfo.animatedImageLoading, textureInfo.frameIndex);
+ loadingHelperIt->LoadAnimatedImage(textureInfo.textureId, textureInfo.animatedImageLoading, textureInfo.frameIndex, premultiplyOnLoad);
}
else
{
* @param[in] synchronousLoading true if the frame should be loaded synchronously
* @param[in] textureObserver The client object should inherit from this and provide the "LoadCompleted" virtual.
* This is called when an image load completes (or fails).
+ * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
+ * image has no alpha channel
*
* @return The texture set containing the frame of animated image, or empty if still loading.
*/
const Dali::WrapMode::Type& wrapModeU,
const Dali::WrapMode::Type& wrapModeV,
const bool& synchronousLoading,
- TextureUploadObserver* textureObserver);
+ TextureUploadObserver* textureObserver,
+ TextureManager::MultiplyOnLoad& preMultiplyOnLoad);
/**
* @brief Requests an image load of the given URL to get PixelBuffer.
if(mAnimatedImageLoading)
{
- mImageCache = new RollingAnimatedImageCache(textureManager, mAnimatedImageLoading, mMaskingData, *this, mCacheSize, mBatchSize, IsSynchronousLoadingRequired());
+ mImageCache = new RollingAnimatedImageCache(textureManager, mAnimatedImageLoading, mMaskingData, *this, mCacheSize, mBatchSize, IsSynchronousLoadingRequired(),mFactoryCache.GetPreMultiplyOnLoad());
}
else if(mImageUrls)
{
mStartFirstFrame(false),
mIsJumpTo(false)
{
+ EnablePreMultipliedAlpha(mFactoryCache.GetPreMultiplyOnLoad());
}
AnimatedImageVisual::~AnimatedImageVisual()
{
mImpl->mRenderer.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, mPixelArea);
}
+
+ // Enable PreMultipliedAlpha if it need premultiplied
+ auto preMultiplyOnLoad = IsPreMultipliedAlphaEnabled() && !mImpl->mCustomShader
+ ? TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD
+ : TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
+ EnablePreMultipliedAlpha(preMultiplyOnLoad == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD);
}
void AnimatedImageVisual::StartFirstFrame(TextureSet& textureSet, uint32_t firstInterval)
ImageCache::FrameReadyObserver& observer,
uint16_t cacheSize,
uint16_t batchSize,
- bool isSynchronousLoading)
+ bool isSynchronousLoading,
+ bool preMultiplyOnLoad)
: ImageCache(textureManager, maskingData, observer, batchSize, 0u),
mImageUrl(animatedImageLoading.GetUrl()),
mAnimatedImageLoading(animatedImageLoading),
mFrameIndex(FIRST_FRAME_INDEX),
mCacheSize(cacheSize),
mQueue(cacheSize),
- mIsSynchronousLoading(isSynchronousLoading)
+ mIsSynchronousLoading(isSynchronousLoading),
+ mPreMultiplyOnLoad(preMultiplyOnLoad)
{
mTextureIds.resize(mFrameCount);
mIntervals.assign(mFrameCount, 0);
mLoadState = TextureManager::LoadState::LOADING;
+ auto preMultiplyOnLoading = mPreMultiplyOnLoad ? TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD
+ : TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
+
TextureManager::TextureId loadTextureId = TextureManager::INVALID_TEXTURE_ID;
TextureSet textureSet = mTextureManager.LoadAnimatedImageTexture(mImageUrl,
mAnimatedImageLoading,
Dali::WrapMode::Type::DEFAULT,
Dali::WrapMode::Type::DEFAULT,
synchronousLoading,
- this);
+ this,
+ preMultiplyOnLoading);
mTextureIds[frameIndex] = loadTextureId;
ImageCache::FrameReadyObserver& observer,
uint16_t cacheSize,
uint16_t batchSize,
- bool isSynchronousLoading);
+ bool isSynchronousLoading,
+ bool preMultiplyOnLoad);
/**
* @brief Destructor
std::vector<uint32_t> mLoadWaitingQueue;
CircularQueue<ImageFrame> mQueue;
bool mIsSynchronousLoading;
+ bool mPreMultiplyOnLoad;
};
} // namespace Internal
{
namespace Internal
{
-RasterizingTask::RasterizingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi, unsigned int width, unsigned int height)
+SvgTask::SvgTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer)
: mSvgVisual(svgVisual),
mVectorRenderer(vectorRenderer),
+ mHasSucceeded(false)
+{
+}
+
+SvgVisual* SvgTask::GetSvgVisual() const
+{
+ return mSvgVisual.Get();
+}
+
+PixelData SvgTask::GetPixelData() const
+{
+ return PixelData();
+}
+
+bool SvgTask::HasSucceeded() const
+{
+ return mHasSucceeded;
+}
+
+SvgLoadingTask::SvgLoadingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi)
+: SvgTask(svgVisual, vectorRenderer),
mUrl(url),
- mDpi(dpi),
- mWidth(width),
- mHeight(height),
- mLoadSuccess(false)
+ mDpi(dpi)
{
}
-RasterizingTask::~RasterizingTask()
+SvgLoadingTask::~SvgLoadingTask()
{
}
-void RasterizingTask::Load()
+void SvgLoadingTask::Process()
{
if(mVectorRenderer.IsLoaded())
{
// Already loaded
- mLoadSuccess = true;
+ mHasSucceeded = true;
return;
}
return;
}
- mLoadSuccess = true;
+ mHasSucceeded = true;
}
-void RasterizingTask::Rasterize()
+SvgRasterizingTask::SvgRasterizingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, unsigned int width, unsigned int height)
+: SvgTask(svgVisual, vectorRenderer),
+ mWidth(width),
+ mHeight(height)
{
- Devel::PixelBuffer pixelBuffer = mVectorRenderer.Rasterize(mWidth, mHeight);
- if(!pixelBuffer)
- {
- DALI_LOG_ERROR("Rasterize is failed! [%s]\n", mUrl.GetUrl().c_str());
- return;
- }
-
- mPixelData = Devel::PixelBuffer::Convert(pixelBuffer);
}
-bool RasterizingTask::IsLoaded() const
+SvgRasterizingTask::~SvgRasterizingTask()
{
- return mLoadSuccess;
}
-SvgVisual* RasterizingTask::GetSvgVisual() const
+void SvgRasterizingTask::Process()
{
- return mSvgVisual.Get();
+ if(!mVectorRenderer.IsLoaded())
+ {
+ DALI_LOG_ERROR("File is not loaded!\n");
+ return;
+ }
+
+ Devel::PixelBuffer pixelBuffer = mVectorRenderer.Rasterize(mWidth, mHeight);
+ if(!pixelBuffer)
+ {
+ DALI_LOG_ERROR("Rasterize is failed!\n");
+ return;
+ }
+
+ mPixelData = Devel::PixelBuffer::Convert(pixelBuffer);
+ mHasSucceeded = true;
}
-PixelData RasterizingTask::GetPixelData() const
+PixelData SvgRasterizingTask::GetPixelData() const
{
return mPixelData;
}
if(thread)
{
// add an empty task would stop the thread from conditional wait.
- thread->AddTask(RasterizingTaskPtr());
+ thread->AddTask(SvgTaskPtr());
// stop the thread
thread->Join();
// delete the thread
}
}
-void SvgRasterizeThread::AddTask(RasterizingTaskPtr task)
+void SvgRasterizeThread::AddTask(SvgTaskPtr task)
{
bool wasEmpty = false;
{
// Remove the tasks with the same renderer.
// Older task which waiting to rasterize and apply the svg to the same renderer is expired.
- for(std::vector<RasterizingTaskPtr>::iterator it = mRasterizeTasks.begin(), endIt = mRasterizeTasks.end(); it != endIt; ++it)
+ // Rasterizing task only, loading task is not duplicated.
+ for(std::vector<SvgTaskPtr>::iterator it = mRasterizeTasks.begin(), endIt = mRasterizeTasks.end(); it != endIt; ++it)
{
if((*it) && (*it)->GetSvgVisual() == task->GetSvgVisual())
{
- mRasterizeTasks.erase(it);
- break;
+ SvgRasterizingTask* oldTask = dynamic_cast<SvgRasterizingTask*>(it->Get());
+ SvgRasterizingTask* newTask = dynamic_cast<SvgRasterizingTask*>(task.Get());
+ if(oldTask && newTask)
+ {
+ mRasterizeTasks.erase(it);
+ break;
+ }
}
}
}
}
}
-RasterizingTaskPtr SvgRasterizeThread::NextCompletedTask()
+SvgTaskPtr SvgRasterizeThread::NextCompletedTask()
{
// Lock while popping task out from the queue
Mutex::ScopedLock lock(mMutex);
if(mCompletedTasks.empty())
{
- return RasterizingTaskPtr();
+ return SvgTaskPtr();
}
- std::vector<RasterizingTaskPtr>::iterator next = mCompletedTasks.begin();
- RasterizingTaskPtr nextTask = *next;
+ std::vector<SvgTaskPtr>::iterator next = mCompletedTasks.begin();
+ SvgTaskPtr nextTask = *next;
mCompletedTasks.erase(next);
return nextTask;
ConditionalWait::ScopedLock lock(mConditionalWait);
if(!mRasterizeTasks.empty())
{
- for(std::vector<RasterizingTaskPtr>::iterator it = mRasterizeTasks.begin(), endIt = mRasterizeTasks.end(); it != endIt; ++it)
+ for(std::vector<SvgTaskPtr>::iterator it = mRasterizeTasks.begin(), endIt = mRasterizeTasks.end(); it != endIt; ++it)
{
if((*it) && (*it)->GetSvgVisual() == visual)
{
mRasterizeTasks.erase(it);
- break;
}
}
}
UnregisterProcessor();
}
-RasterizingTaskPtr SvgRasterizeThread::NextTaskToProcess()
+SvgTaskPtr SvgRasterizeThread::NextTaskToProcess()
{
// Lock while popping task out from the queue
ConditionalWait::ScopedLock lock(mConditionalWait);
mIsThreadWaiting = false;
// pop out the next task from the queue
- std::vector<RasterizingTaskPtr>::iterator next = mRasterizeTasks.begin();
- RasterizingTaskPtr nextTask = *next;
+ std::vector<SvgTaskPtr>::iterator next = mRasterizeTasks.begin();
+ SvgTaskPtr nextTask = *next;
mRasterizeTasks.erase(next);
return nextTask;
}
-void SvgRasterizeThread::AddCompletedTask(RasterizingTaskPtr task)
+void SvgRasterizeThread::AddCompletedTask(SvgTaskPtr task)
{
// Lock while adding task to the queue
Mutex::ScopedLock lock(mMutex);
SetThreadName("SVGThread");
mLogFactory.InstallLogFunction();
- while(RasterizingTaskPtr task = NextTaskToProcess())
+ while(SvgTaskPtr task = NextTaskToProcess())
{
- task->Load();
- task->Rasterize();
+ task->Process();
AddCompletedTask(task);
}
}
void SvgRasterizeThread::ApplyRasterizedSVGToSampler()
{
- while(RasterizingTaskPtr task = NextCompletedTask())
+ while(SvgTaskPtr task = NextCompletedTask())
{
- task->GetSvgVisual()->ApplyRasterizedImage(task->GetPixelData(), task->IsLoaded());
+ task->GetSvgVisual()->ApplyRasterizedImage(task->GetPixelData(), task->HasSucceeded());
}
UnregisterProcessor();
{
class SvgVisual;
typedef IntrusivePtr<SvgVisual> SvgVisualPtr;
-class RasterizingTask;
-typedef IntrusivePtr<RasterizingTask> RasterizingTaskPtr;
+class SvgTask;
+typedef IntrusivePtr<SvgTask> SvgTaskPtr;
/**
* The svg rasterizing tasks to be processed in the worker thread.
* 3. If this task gets its turn to do the rasterization, it triggers main thread to apply the rasterized image to material then been deleted in main thread call back
* Or if this task is been removed ( new image/size set to the visual or actor off stage) before its turn to be processed, it then been deleted in the worker thread.
*/
-class RasterizingTask : public RefObject
+class SvgTask : public RefObject
{
public:
/**
* Constructor
* @param[in] svgVisual The visual which the rasterized image to be applied.
* @param[in] vectorRenderer The vector rasterizer.
- * @param[in] url The URL to svg resource to use.
- * @param[in] dpi The DPI of the screen.
- * @param[in] width The rasterization width.
- * @param[in] height The rasterization height.
*/
- RasterizingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi, unsigned int width, unsigned int height);
+ SvgTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer);
/**
* Destructor.
*/
- ~RasterizingTask() override;
+ virtual ~SvgTask() = default;
/**
- * Load svg file
+ * Process the task
*/
- void Load();
+ virtual void Process() = 0;
/**
- * Do the rasterization with the mRasterizer.
+ * Whether the task has succeeded.
+ * @return True if the task has succeeded.
*/
- void Rasterize();
+ bool HasSucceeded() const;
/**
* Get the svg visual
* Get the rasterization result.
* @return The pixel data with the rasterized pixels.
*/
- PixelData GetPixelData() const;
+ virtual PixelData GetPixelData() const;
+
+private:
+ // Undefined
+ SvgTask(const SvgTask& task) = delete;
+
+ // Undefined
+ SvgTask& operator=(const SvgTask& task) = delete;
+
+protected:
+ SvgVisualPtr mSvgVisual;
+ VectorImageRenderer mVectorRenderer;
+ bool mHasSucceeded;
+};
+
+class SvgLoadingTask : public SvgTask
+{
+public:
+ /**
+ * Constructor
+ * @param[in] svgVisual The visual which the rasterized image to be applied.
+ * @param[in] vectorRenderer The vector rasterizer.
+ * @param[in] url The URL to svg resource to use.
+ * @param[in] dpi The DPI of the screen.
+ */
+ SvgLoadingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi);
/**
- * Whether the resource is loaded.
- * @return True if the resource is loaded.
+ * Destructor.
*/
- bool IsLoaded() const;
+ ~SvgLoadingTask() override;
+
+ /**
+ * Process the task
+ */
+ void Process() override;
private:
// Undefined
- RasterizingTask(const RasterizingTask& task);
+ SvgLoadingTask(const SvgLoadingTask& task) = delete;
// Undefined
- RasterizingTask& operator=(const RasterizingTask& task);
+ SvgLoadingTask& operator=(const SvgLoadingTask& task) = delete;
private:
- SvgVisualPtr mSvgVisual;
- VectorImageRenderer mVectorRenderer;
- VisualUrl mUrl;
- PixelData mPixelData;
- float mDpi;
- uint32_t mWidth;
- uint32_t mHeight;
- bool mLoadSuccess;
+ VisualUrl mUrl;
+ float mDpi;
+};
+
+class SvgRasterizingTask : public SvgTask
+{
+public:
+ /**
+ * Constructor
+ * @param[in] svgVisual The visual which the rasterized image to be applied.
+ * @param[in] vectorRenderer The vector rasterizer.
+ * @param[in] width The rasterization width.
+ * @param[in] height The rasterization height.
+ */
+ SvgRasterizingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, unsigned int width, unsigned int height);
+
+ /**
+ * Destructor.
+ */
+ ~SvgRasterizingTask() override;
+
+ /**
+ * Process the task accodring to the type
+ */
+ void Process() override;
+
+ /**
+ * Get the rasterization result.
+ * @return The pixel data with the rasterized pixels.
+ */
+ PixelData GetPixelData() const override;
+
+private:
+ // Undefined
+ SvgRasterizingTask(const SvgRasterizingTask& task) = delete;
+
+ // Undefined
+ SvgRasterizingTask& operator=(const SvgRasterizingTask& task) = delete;
+
+private:
+ PixelData mPixelData;
+ uint32_t mWidth;
+ uint32_t mHeight;
};
/**
*
* @param[in] task The task added to the queue.
*/
- void AddTask(RasterizingTaskPtr task);
+ void AddTask(SvgTaskPtr task);
/**
* Pop the next task out from the completed queue, called by main thread.
*
* @return The next task in the completed queue.
*/
- RasterizingTaskPtr NextCompletedTask();
+ SvgTaskPtr NextCompletedTask();
/**
* Remove the task with the given visual from the waiting queue, called by main thread.
*
* @return The next task to be processed.
*/
- RasterizingTaskPtr NextTaskToProcess();
+ SvgTaskPtr NextTaskToProcess();
/**
* Add a task in to the queue
*
* @param[in] task The task added to the queue.
*/
- void AddCompletedTask(RasterizingTaskPtr task);
+ void AddCompletedTask(SvgTaskPtr task);
/**
* Applies the rasterized image to material
SvgRasterizeThread& operator=(const SvgRasterizeThread& thread);
private:
- std::vector<RasterizingTaskPtr> mRasterizeTasks; //The queue of the tasks waiting to rasterize the SVG image
- std::vector<RasterizingTaskPtr> mCompletedTasks; //The queue of the tasks with the SVG rasterization completed
+ std::vector<SvgTaskPtr> mRasterizeTasks; //The queue of the tasks waiting to rasterize the SVG image
+ std::vector<SvgTaskPtr> mCompletedTasks; //The queue of the tasks with the SVG rasterization completed
ConditionalWait mConditionalWait;
Dali::Mutex mMutex;
Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
mImpl->mRenderer = VisualRenderer::New(geometry, shader);
mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
+
+ Vector2 dpi = Stage::GetCurrent().GetDpi();
+ float meanDpi = (dpi.height + dpi.width) * 0.5f;
+
+ SvgTaskPtr newTask = new SvgLoadingTask(this, mVectorRenderer, mImageUrl, meanDpi);
+
+ if(IsSynchronousLoadingRequired() && mImageUrl.IsLocalResource())
+ {
+ newTask->Process();
+ }
+ else
+ {
+ mFactoryCache.GetSVGRasterizationThread()->AddTask(newTask);
+ }
}
void SvgVisual::DoSetProperties(const Property::Map& propertyMap)
unsigned int width = static_cast<unsigned int>(size.width);
unsigned int height = static_cast<unsigned int>(size.height);
- Vector2 dpi = Stage::GetCurrent().GetDpi();
- float meanDpi = (dpi.height + dpi.width) * 0.5f;
-
- RasterizingTaskPtr newTask = new RasterizingTask(this, mVectorRenderer, mImageUrl, meanDpi, width, height);
+ SvgTaskPtr newTask = new SvgRasterizingTask(this, mVectorRenderer, width, height);
if(IsSynchronousLoadingRequired() && mImageUrl.IsLocalResource())
{
- newTask->Load();
- newTask->Rasterize();
- ApplyRasterizedImage(newTask->GetPixelData(), newTask->IsLoaded());
+ newTask->Process();
+ ApplyRasterizedImage(newTask->GetPixelData(), newTask->HasSucceeded());
}
else
{
}
}
-void SvgVisual::ApplyRasterizedImage(PixelData rasterizedPixelData, bool isLoaded)
+void SvgVisual::ApplyRasterizedImage(PixelData rasterizedPixelData, bool success)
{
- if(isLoaded && rasterizedPixelData && IsOnScene())
+ if(success)
{
if(mDefaultWidth == 0 || mDefaultHeight == 0)
{
mVectorRenderer.GetDefaultSize(mDefaultWidth, mDefaultHeight);
}
- mRasterizedSize.x = static_cast<float>(rasterizedPixelData.GetWidth());
- mRasterizedSize.y = static_cast<float>(rasterizedPixelData.GetHeight());
-
- TextureSet currentTextureSet = mImpl->mRenderer.GetTextures();
- if(mImpl->mFlags & Impl::IS_ATLASING_APPLIED)
+ // Rasterization success
+ if(rasterizedPixelData && IsOnScene())
{
- mFactoryCache.GetAtlasManager()->Remove(currentTextureSet, mAtlasRect);
- }
-
- TextureSet textureSet;
+ mRasterizedSize.x = static_cast<float>(rasterizedPixelData.GetWidth());
+ mRasterizedSize.y = static_cast<float>(rasterizedPixelData.GetHeight());
- if(mAttemptAtlasing && !mImpl->mCustomShader)
- {
- Vector4 atlasRect;
- textureSet = mFactoryCache.GetAtlasManager()->Add(atlasRect, rasterizedPixelData);
- if(textureSet) // atlasing
+ TextureSet currentTextureSet = mImpl->mRenderer.GetTextures();
+ if(mImpl->mFlags & Impl::IS_ATLASING_APPLIED)
{
- if(textureSet != currentTextureSet)
- {
- mImpl->mRenderer.SetTextures(textureSet);
- }
- mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, atlasRect);
- mAtlasRect = atlasRect;
- mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
+ mFactoryCache.GetAtlasManager()->Remove(currentTextureSet, mAtlasRect);
}
- }
- if(!textureSet) // no atlasing - mAttemptAtlasing is false or adding to atlas is failed
- {
- Texture texture = Texture::New(Dali::TextureType::TEXTURE_2D, Pixel::RGBA8888, rasterizedPixelData.GetWidth(), rasterizedPixelData.GetHeight());
- texture.Upload(rasterizedPixelData);
- mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
+ TextureSet textureSet;
- if(mAtlasRect == FULL_TEXTURE_RECT)
+ if(mAttemptAtlasing && !mImpl->mCustomShader)
{
- textureSet = currentTextureSet;
+ Vector4 atlasRect;
+ textureSet = mFactoryCache.GetAtlasManager()->Add(atlasRect, rasterizedPixelData);
+ if(textureSet) // atlasing
+ {
+ if(textureSet != currentTextureSet)
+ {
+ mImpl->mRenderer.SetTextures(textureSet);
+ }
+ mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, atlasRect);
+ mAtlasRect = atlasRect;
+ mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
+ }
}
- else
+
+ if(!textureSet) // no atlasing - mAttemptAtlasing is false or adding to atlas is failed
{
- textureSet = TextureSet::New();
- mImpl->mRenderer.SetTextures(textureSet);
+ Texture texture = Texture::New(Dali::TextureType::TEXTURE_2D, Pixel::RGBA8888, rasterizedPixelData.GetWidth(), rasterizedPixelData.GetHeight());
+ texture.Upload(rasterizedPixelData);
+ mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
+
+ if(mAtlasRect == FULL_TEXTURE_RECT)
+ {
+ textureSet = currentTextureSet;
+ }
+ else
+ {
+ textureSet = TextureSet::New();
+ mImpl->mRenderer.SetTextures(textureSet);
- mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT);
- mAtlasRect = FULL_TEXTURE_RECT;
+ mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT);
+ mAtlasRect = FULL_TEXTURE_RECT;
+ }
+
+ if(textureSet)
+ {
+ textureSet.SetTexture(0, texture);
+ }
}
- if(textureSet)
+ // Rasterized pixels are uploaded to texture. If weak handle is holding a placement actor, it is the time to add the renderer to actor.
+ Actor actor = mPlacementActor.GetHandle();
+ if(actor)
{
- textureSet.SetTexture(0, texture);
+ actor.AddRenderer(mImpl->mRenderer);
+ // reset the weak handle so that the renderer only get added to actor once
+ mPlacementActor.Reset();
}
- }
- // Rasterized pixels are uploaded to texture. If weak handle is holding a placement actor, it is the time to add the renderer to actor.
- Actor actor = mPlacementActor.GetHandle();
- if(actor)
- {
- actor.AddRenderer(mImpl->mRenderer);
- // reset the weak handle so that the renderer only get added to actor once
- mPlacementActor.Reset();
+ // Svg loaded and ready to display
+ ResourceReady(Toolkit::Visual::ResourceStatus::READY);
}
-
- // Svg loaded and ready to display
- ResourceReady(Toolkit::Visual::ResourceStatus::READY);
}
- else if(!isLoaded || !rasterizedPixelData)
+ else if(!success && !mLoadFailed)
{
mLoadFailed = true;
* @bried Apply the rasterized image to the visual.
*
* @param[in] rasterizedPixelData The pixel buffer with the rasterized pixels
- * @param[in] bool Whether the resource is loaded
+ * @param[in] success Whether the task succeeds.
*/
- void ApplyRasterizedImage(PixelData rasterizedPixelData, bool isLoaded);
+ void ApplyRasterizedImage(PixelData rasterizedPixelData, bool success);
private:
/**
{
const unsigned int TOOLKIT_MAJOR_VERSION = 2;
const unsigned int TOOLKIT_MINOR_VERSION = 1;
-const unsigned int TOOLKIT_MICRO_VERSION = 23;
+const unsigned int TOOLKIT_MICRO_VERSION = 24;
const char* const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali2-toolkit
Summary: Dali 3D engine Toolkit
-Version: 2.1.23
+Version: 2.1.24
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff