dali-toolkit/internal/controls/text-controls/text-editor-property-handler.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <dali-toolkit/internal/controls/text-controls/text-editor-property-handler.h>
  18
  19 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
  20
  21 #include <dali-toolkit/internal/text/decorator/text-decorator.h>
  22 #include <dali-toolkit/internal/text/text-controller.h>
  23 #include <dali-toolkit/internal/text/text-effects-style.h>
  24 #include <dali-toolkit/internal/text/text-enumerations-impl.h>
  25 #include <dali-toolkit/internal/text/text-font-style.h>
  26 #include <dali-toolkit/public-api/text/text-enumerations.h>
  27 #include <dali/integration-api/debug.h>
  28
  29 #if defined(DEBUG_ENABLED)
  30 extern Debug::Filter* gTextEditorLogFilter;
  31 #endif
  32
  33 namespace Dali::Toolkit::Internal
  34 {
  35 const char* const TextEditor::PropertyHandler::IMAGE_MAP_FILENAME_STRING{"filename"};
  36
  37 /// Retrieves a filename from a value that is a Property::Map
  38 std::string TextEditor::PropertyHandler::GetImageFileNameFromPropertyValue(const Property::Value& value)
  39 {
  40   std::string          filename;
  41   const Property::Map* map = value.GetMap();
  42   if(map)
  43   {
  44     const Property::Value* filenameValue = map->Find(TextEditor::PropertyHandler::IMAGE_MAP_FILENAME_STRING);
  45     if(filenameValue)
  46     {
  47       filenameValue->Get(filename);
  48     }
  49   }
  50   return filename;
  51 }
  52
  53 void TextEditor::PropertyHandler::SetProperty(Toolkit::TextEditor textEditor, Property::Index index, const Property::Value& value)
  54 {
  55   TextEditor& impl(GetImpl(textEditor));
  56   DALI_ASSERT_DEBUG(impl.mController && "No text controller");
  57   DALI_ASSERT_DEBUG(impl.mDecorator && "No text decorator");
  58
  59   switch(index)
  60   {
  61     case Toolkit::DevelTextEditor::Property::RENDERING_BACKEND:
  62     {
  63       int backend = value.Get<int>();
  64       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor %p RENDERING_BACKEND %d\n", impl.mController.Get(), backend);
  65
  66       if(impl.mRenderingBackend != backend)
  67       {
  68         impl.mRenderingBackend = backend;
  69         impl.mRenderer.Reset();
  70         impl.RequestTextRelayout();
  71       }
  72       break;
  73     }
  74     case Toolkit::TextEditor::Property::TEXT:
  75     {
  76       const std::string& text = value.Get<std::string>();
  77       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p TEXT %s\n", impl.mController.Get(), text.c_str());
  78
  79       impl.mController->SetText(text);
  80       break;
  81     }
  82     case Toolkit::TextEditor::Property::TEXT_COLOR:
  83     {
  84       const Vector4& textColor = value.Get<Vector4>();
  85       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p TEXT_COLOR %f,%f,%f,%f\n", impl.mController.Get(), textColor.r, textColor.g, textColor.b, textColor.a);
  86
  87       if(impl.mController->GetDefaultColor() != textColor)
  88       {
  89         impl.mController->SetDefaultColor(textColor);
  90         impl.mController->SetInputColor(textColor);
  91         impl.mRenderer.Reset();
  92       }
  93       break;
  94     }
  95     case Toolkit::TextEditor::Property::FONT_FAMILY:
  96     {
  97       const std::string& fontFamily = value.Get<std::string>();
  98       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p FONT_FAMILY %s\n", impl.mController.Get(), fontFamily.c_str());
  99       impl.mController->SetDefaultFontFamily(fontFamily);
 100       break;
 101     }
 102     case Toolkit::TextEditor::Property::FONT_STYLE:
 103     {
 104       SetFontStyleProperty(impl.mController, value, Text::FontStyle::DEFAULT);
 105       break;
 106     }
 107     case Toolkit::TextEditor::Property::POINT_SIZE:
 108     {
 109       const float pointSize = value.Get<float>();
 110       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p POINT_SIZE %f\n", impl.mController.Get(), pointSize);
 111
 112       if(!Equals(impl.mController->GetDefaultFontSize(Text::Controller::POINT_SIZE), pointSize))
 113       {
 114         impl.mController->SetDefaultFontSize(pointSize, Text::Controller::POINT_SIZE);
 115       }
 116       break;
 117     }
 118     case Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT:
 119     {
 120       Text::HorizontalAlignment::Type alignment(static_cast<Text::HorizontalAlignment::Type>(-1)); // Set to invalid value to ensure a valid mode does get set
 121       if(Text::GetHorizontalAlignmentEnumeration(value, alignment))
 122       {
 123         DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p HORIZONTAL_ALIGNMENT %d\n", impl.mController.Get(), alignment);
 124         impl.mController->SetHorizontalAlignment(alignment);
 125       }
 126       break;
 127     }
 128     case Toolkit::TextEditor::Property::SCROLL_THRESHOLD:
 129     {
 130       const float threshold = value.Get<float>();
 131       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor %p SCROLL_THRESHOLD %f\n", impl.mController.Get(), threshold);
 132
 133       impl.mDecorator->SetScrollThreshold(threshold);
 134       break;
 135     }
 136     case Toolkit::TextEditor::Property::SCROLL_SPEED:
 137     {
 138       const float speed = value.Get<float>();
 139       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor %p SCROLL_SPEED %f\n", impl.mController.Get(), speed);
 140
 141       impl.mDecorator->SetScrollSpeed(speed);
 142       break;
 143     }
 144     case Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR:
 145     {
 146       const Vector4& color = value.Get<Vector4>();
 147       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p PRIMARY_CURSOR_COLOR %f,%f,%f,%f\n", impl.mController.Get(), color.r, color.g, color.b, color.a);
 148
 149       impl.mDecorator->SetCursorColor(Toolkit::Text::PRIMARY_CURSOR, color);
 150       impl.RequestTextRelayout();
 151       break;
 152     }
 153     case Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR:
 154     {
 155       const Vector4& color = value.Get<Vector4>();
 156       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p SECONDARY_CURSOR_COLOR %f,%f,%f,%f\n", impl.mController.Get(), color.r, color.g, color.b, color.a);
 157
 158       impl.mDecorator->SetCursorColor(Toolkit::Text::SECONDARY_CURSOR, color);
 159       impl.RequestTextRelayout();
 160       break;
 161     }
 162     case Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK:
 163     {
 164       const bool enable = value.Get<bool>();
 165       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor %p ENABLE_CURSOR_BLINK %d\n", impl.mController.Get(), enable);
 166
 167       impl.mController->SetEnableCursorBlink(enable);
 168       impl.RequestTextRelayout();
 169       break;
 170     }
 171     case Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL:
 172     {
 173       const float interval = value.Get<float>();
 174       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor %p CURSOR_BLINK_INTERVAL %f\n", impl.mController.Get(), interval);
 175
 176       impl.mDecorator->SetCursorBlinkInterval(interval);
 177       break;
 178     }
 179     case Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION:
 180     {
 181       const float duration = value.Get<float>();
 182       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor %p CURSOR_BLINK_DURATION %f\n", impl.mController.Get(), duration);
 183
 184       impl.mDecorator->SetCursorBlinkDuration(duration);
 185       break;
 186     }
 187     case Toolkit::TextEditor::Property::CURSOR_WIDTH:
 188     {
 189       const int width = value.Get<int>();
 190       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor %p CURSOR_WIDTH %d\n", impl.mController.Get(), width);
 191
 192       impl.mDecorator->SetCursorWidth(width);
 193       impl.mController->GetLayoutEngine().SetCursorWidth(width);
 194       break;
 195     }
 196     case Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE:
 197     {
 198       const std::string imageFileName = value.Get<std::string>();
 199       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor %p GRAB_HANDLE_IMAGE %s\n", impl.mController.Get(), imageFileName.c_str());
 200
 201       if(imageFileName.size())
 202       {
 203         impl.mDecorator->SetHandleImage(Toolkit::Text::GRAB_HANDLE, Toolkit::Text::HANDLE_IMAGE_RELEASED, imageFileName);
 204         impl.RequestTextRelayout();
 205       }
 206       break;
 207     }
 208     case Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE:
 209     {
 210       const std::string imageFileName = value.Get<std::string>();
 211       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor %p GRAB_HANDLE_PRESSED_IMAGE %s\n", impl.mController.Get(), imageFileName.c_str());
 212
 213       if(imageFileName.size())
 214       {
 215         impl.mDecorator->SetHandleImage(Toolkit::Text::GRAB_HANDLE, Toolkit::Text::HANDLE_IMAGE_PRESSED, imageFileName);
 216         impl.RequestTextRelayout();
 217       }
 218       break;
 219     }
 220     case Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT:
 221     {
 222       const std::string filename = GetImageFileNameFromPropertyValue(value);
 223
 224       if(filename.size())
 225       {
 226         impl.mDecorator->SetHandleImage(Toolkit::Text::LEFT_SELECTION_HANDLE, Toolkit::Text::HANDLE_IMAGE_RELEASED, filename);
 227         impl.RequestTextRelayout();
 228       }
 229       break;
 230     }
 231     case Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT:
 232     {
 233       const std::string filename = GetImageFileNameFromPropertyValue(value);
 234
 235       if(filename.size())
 236       {
 237         impl.mDecorator->SetHandleImage(Toolkit::Text::RIGHT_SELECTION_HANDLE, Toolkit::Text::HANDLE_IMAGE_RELEASED, filename);
 238         impl.RequestTextRelayout();
 239       }
 240       break;
 241     }
 242     case Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT:
 243     {
 244       const std::string filename = GetImageFileNameFromPropertyValue(value);
 245
 246       if(filename.size())
 247       {
 248         impl.mDecorator->SetHandleImage(Toolkit::Text::LEFT_SELECTION_HANDLE, Toolkit::Text::HANDLE_IMAGE_PRESSED, filename);
 249         impl.RequestTextRelayout();
 250       }
 251       break;
 252     }
 253     case Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT:
 254     {
 255       const std::string filename = GetImageFileNameFromPropertyValue(value);
 256
 257       if(filename.size())
 258       {
 259         impl.mDecorator->SetHandleImage(Toolkit::Text::RIGHT_SELECTION_HANDLE, Toolkit::Text::HANDLE_IMAGE_PRESSED, filename);
 260         impl.RequestTextRelayout();
 261       }
 262       break;
 263     }
 264     case Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT:
 265     {
 266       const std::string filename = GetImageFileNameFromPropertyValue(value);
 267
 268       if(filename.size())
 269       {
 270         impl.mDecorator->SetHandleImage(Toolkit::Text::LEFT_SELECTION_HANDLE_MARKER,
 271                                         Toolkit::Text::HANDLE_IMAGE_RELEASED,
 272                                         filename);
 273         impl.RequestTextRelayout();
 274       }
 275       break;
 276     }
 277     case Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT:
 278     {
 279       const std::string filename = GetImageFileNameFromPropertyValue(value);
 280
 281       if(filename.size())
 282       {
 283         impl.mDecorator->SetHandleImage(Toolkit::Text::RIGHT_SELECTION_HANDLE_MARKER,
 284                                         Toolkit::Text::HANDLE_IMAGE_RELEASED,
 285                                         filename);
 286         impl.RequestTextRelayout();
 287       }
 288       break;
 289     }
 290     case Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR:
 291     {
 292       const Vector4 color = value.Get<Vector4>();
 293       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p SELECTION_HIGHLIGHT_COLOR %f,%f,%f,%f\n", impl.mController.Get(), color.r, color.g, color.b, color.a);
 294
 295       impl.mDecorator->SetHighlightColor(color);
 296       impl.RequestTextRelayout();
 297       break;
 298     }
 299     case Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX:
 300     {
 301       const Rect<int>& box = value.Get<Rect<int> >();
 302       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p DECORATION_BOUNDING_BOX %d,%d %dx%d\n", impl.mController.Get(), box.x, box.y, box.width, box.height);
 303
 304       impl.mDecorator->SetBoundingBox(box);
 305       impl.RequestTextRelayout();
 306       break;
 307     }
 308     case Toolkit::TextEditor::Property::ENABLE_MARKUP:
 309     {
 310       const bool enableMarkup = value.Get<bool>();
 311       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p ENABLE_MARKUP %d\n", impl.mController.Get(), enableMarkup);
 312
 313       impl.mController->SetMarkupProcessorEnabled(enableMarkup);
 314       break;
 315     }
 316     case Toolkit::TextEditor::Property::INPUT_COLOR:
 317     {
 318       const Vector4& inputColor = value.Get<Vector4>();
 319       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p INPUT_COLOR %f,%f,%f,%f\n", impl.mController.Get(), inputColor.r, inputColor.g, inputColor.b, inputColor.a);
 320
 321       impl.mController->SetInputColor(inputColor);
 322       break;
 323     }
 324     case Toolkit::TextEditor::Property::INPUT_FONT_FAMILY:
 325     {
 326       const std::string& fontFamily = value.Get<std::string>();
 327       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p INPUT_FONT_FAMILY %s\n", impl.mController.Get(), fontFamily.c_str());
 328       impl.mController->SetInputFontFamily(fontFamily);
 329       break;
 330     }
 331     case Toolkit::TextEditor::Property::INPUT_FONT_STYLE:
 332     {
 333       SetFontStyleProperty(impl.mController, value, Text::FontStyle::INPUT);
 334       break;
 335     }
 336     case Toolkit::TextEditor::Property::INPUT_POINT_SIZE:
 337     {
 338       const float pointSize = value.Get<float>();
 339       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p INPUT_POINT_SIZE %f\n", impl.mController.Get(), pointSize);
 340       impl.mController->SetInputFontPointSize(pointSize);
 341       break;
 342     }
 343     case Toolkit::TextEditor::Property::LINE_SPACING:
 344     {
 345       const float lineSpacing = value.Get<float>();
 346       impl.mController->SetDefaultLineSpacing(lineSpacing);
 347       impl.mRenderer.Reset();
 348       break;
 349     }
 350     case Toolkit::TextEditor::Property::INPUT_LINE_SPACING:
 351     {
 352       const float lineSpacing = value.Get<float>();
 353       impl.mController->SetInputLineSpacing(lineSpacing);
 354       impl.mRenderer.Reset();
 355       break;
 356     }
 357     case Toolkit::TextEditor::Property::UNDERLINE:
 358     {
 359       const bool update = SetUnderlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 360       if(update)
 361       {
 362         impl.mRenderer.Reset();
 363       }
 364       break;
 365     }
 366     case Toolkit::TextEditor::Property::INPUT_UNDERLINE:
 367     {
 368       const bool update = SetUnderlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
 369       if(update)
 370       {
 371         impl.mRenderer.Reset();
 372       }
 373       break;
 374     }
 375     case Toolkit::TextEditor::Property::SHADOW:
 376     {
 377       const bool update = SetShadowProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 378       if(update)
 379       {
 380         impl.mRenderer.Reset();
 381       }
 382       break;
 383     }
 384     case Toolkit::TextEditor::Property::INPUT_SHADOW:
 385     {
 386       const bool update = SetShadowProperties(impl.mController, value, Text::EffectStyle::INPUT);
 387       if(update)
 388       {
 389         impl.mRenderer.Reset();
 390       }
 391       break;
 392     }
 393     case Toolkit::TextEditor::Property::EMBOSS:
 394     {
 395       const bool update = SetEmbossProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 396       if(update)
 397       {
 398         impl.mRenderer.Reset();
 399       }
 400       break;
 401     }
 402     case Toolkit::TextEditor::Property::INPUT_EMBOSS:
 403     {
 404       const bool update = SetEmbossProperties(impl.mController, value, Text::EffectStyle::INPUT);
 405       if(update)
 406       {
 407         impl.mRenderer.Reset();
 408       }
 409       break;
 410     }
 411     case Toolkit::TextEditor::Property::OUTLINE:
 412     {
 413       const bool update = SetOutlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 414       if(update)
 415       {
 416         impl.mRenderer.Reset();
 417       }
 418       break;
 419     }
 420     case Toolkit::TextEditor::Property::INPUT_OUTLINE:
 421     {
 422       const bool update = SetOutlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
 423       if(update)
 424       {
 425         impl.mRenderer.Reset();
 426       }
 427       break;
 428     }
 429     case Toolkit::TextEditor::Property::SMOOTH_SCROLL:
 430     {
 431       const bool enable = value.Get<bool>();
 432       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor SMOOTH_SCROLL %d\n", enable);
 433
 434       impl.mScrollAnimationEnabled = enable;
 435       break;
 436     }
 437     case Toolkit::TextEditor::Property::SMOOTH_SCROLL_DURATION:
 438     {
 439       const float duration = value.Get<float>();
 440       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor SMOOTH_SCROLL_DURATION %f\n", duration);
 441
 442       impl.mScrollAnimationDuration = duration;
 443       if(impl.mTextVerticalScroller)
 444       {
 445         impl.mTextVerticalScroller->SetDuration(duration);
 446       }
 447       break;
 448     }
 449     case Toolkit::TextEditor::Property::ENABLE_SCROLL_BAR:
 450     {
 451       const bool enable = value.Get<bool>();
 452       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor SHOW_SCROLL_BAR %d\n", enable);
 453
 454       impl.mScrollBarEnabled = enable;
 455       break;
 456     }
 457     case Toolkit::TextEditor::Property::SCROLL_BAR_SHOW_DURATION:
 458     {
 459       const float duration = value.Get<float>();
 460       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor SCROLL_BAR_SHOW_DURATION %f\n", duration);
 461
 462       impl.mAnimationPeriod.delaySeconds = duration;
 463       break;
 464     }
 465     case Toolkit::TextEditor::Property::SCROLL_BAR_FADE_DURATION:
 466     {
 467       const float duration = value.Get<float>();
 468       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor SCROLL_BAR_FADE_DURATION %f\n", duration);
 469
 470       impl.mAnimationPeriod.durationSeconds = duration;
 471       break;
 472     }
 473     case Toolkit::TextEditor::Property::PIXEL_SIZE:
 474     {
 475       const float pixelSize = value.Get<float>();
 476       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p PIXEL_SIZE %f\n", impl.mController.Get(), pixelSize);
 477
 478       if(!Equals(impl.mController->GetDefaultFontSize(Text::Controller::PIXEL_SIZE), pixelSize))
 479       {
 480         impl.mController->SetDefaultFontSize(pixelSize, Text::Controller::PIXEL_SIZE);
 481       }
 482       break;
 483     }
 484     case Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT:
 485     {
 486       const std::string& text = value.Get<std::string>();
 487       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor::OnPropertySet %p PLACEHOLDER_TEXT %s\n", impl.mController.Get(), text.c_str());
 488
 489       impl.mController->SetPlaceholderText(Text::Controller::PLACEHOLDER_TYPE_INACTIVE, text);
 490       break;
 491     }
 492     case Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT_COLOR:
 493     {
 494       const Vector4& textColor = value.Get<Vector4>();
 495       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p PLACEHOLDER_TEXT_COLOR %f,%f,%f,%f\n", impl.mController.Get(), textColor.r, textColor.g, textColor.b, textColor.a);
 496
 497       if(impl.mController->GetPlaceholderTextColor() != textColor)
 498       {
 499         impl.mController->SetPlaceholderTextColor(textColor);
 500         impl.mRenderer.Reset();
 501       }
 502       break;
 503     }
 504     case Toolkit::TextEditor::Property::ENABLE_SELECTION:
 505     {
 506       const bool enableSelection = value.Get<bool>();
 507       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p ENABLE_SELECTION %d\n", impl.mController.Get(), enableSelection);
 508       impl.mController->SetSelectionEnabled(enableSelection);
 509       break;
 510     }
 511     case Toolkit::TextEditor::Property::PLACEHOLDER:
 512     {
 513       const Property::Map* map = value.GetMap();
 514       if(map)
 515       {
 516         impl.mController->SetPlaceholderProperty(*map);
 517       }
 518       break;
 519     }
 520     case Toolkit::TextEditor::Property::LINE_WRAP_MODE:
 521     {
 522       Text::LineWrap::Mode lineWrapMode(static_cast<Text::LineWrap::Mode>(-1)); // Set to invalid value to ensure a valid mode does get set
 523       if(Toolkit::Text::GetLineWrapModeEnumeration(value, lineWrapMode))
 524       {
 525         DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p LineWrap::MODE %d\n", impl.mController.Get(), lineWrapMode);
 526         impl.mController->SetLineWrapMode(lineWrapMode);
 527       }
 528       break;
 529     }
 530     case Toolkit::DevelTextEditor::Property::ENABLE_SHIFT_SELECTION:
 531     {
 532       const bool shiftSelection = value.Get<bool>();
 533       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p ENABLE_SHIFT_SELECTION %d\n", impl.mController.Get(), shiftSelection);
 534
 535       impl.mController->SetShiftSelectionEnabled(shiftSelection);
 536       break;
 537     }
 538     case Toolkit::DevelTextEditor::Property::ENABLE_GRAB_HANDLE:
 539     {
 540       const bool grabHandleEnabled = value.Get<bool>();
 541       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p ENABLE_GRAB_HANDLE %d\n", impl.mController.Get(), grabHandleEnabled);
 542
 543       impl.mController->SetGrabHandleEnabled(grabHandleEnabled);
 544       break;
 545     }
 546     case Toolkit::DevelTextEditor::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION:
 547     {
 548       impl.mController->SetMatchLayoutDirection(value.Get<bool>() ? DevelText::MatchLayoutDirection::LOCALE : DevelText::MatchLayoutDirection::CONTENTS);
 549       break;
 550     }
 551     case Toolkit::DevelTextEditor::Property::MAX_LENGTH:
 552     {
 553       const int max = value.Get<int>();
 554       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p MAX_LENGTH %d\n", impl.mController.Get(), max);
 555
 556       impl.mController->SetMaximumNumberOfCharacters(max);
 557       break;
 558     }
 559     case Toolkit::DevelTextEditor::Property::SELECTED_TEXT_START:
 560     {
 561       uint32_t start = static_cast<uint32_t>(value.Get<int>());
 562       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p SELECTED_TEXT_START %d\n", impl.mController.Get(), start);
 563       impl.SetTextSelectionRange(&start, nullptr);
 564       break;
 565     }
 566     case Toolkit::DevelTextEditor::Property::SELECTED_TEXT_END:
 567     {
 568       uint32_t end = static_cast<uint32_t>(value.Get<int>());
 569       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p SELECTED_TEXT_END %d\n", impl.mController.Get(), end);
 570       impl.SetTextSelectionRange(nullptr, &end);
 571       break;
 572     }
 573     case Toolkit::DevelTextEditor::Property::ENABLE_EDITING:
 574     {
 575       const bool editable = value.Get<bool>();
 576       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p ENABLE_EDITING %d\n", impl.mController.Get(), editable);
 577       impl.SetEditable(editable);
 578       break;
 579     }
 580     case Toolkit::DevelTextEditor::Property::HORIZONTAL_SCROLL_POSITION:
 581     {
 582       float horizontalScroll = value.Get<float>();
 583       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p HORIZONTAL_SCROLL_POSITION %d\n", impl.mController.Get(), horizontalScroll);
 584       if(horizontalScroll >= 0.0f)
 585       {
 586         impl.ScrollBy(Vector2(horizontalScroll - impl.GetHorizontalScrollPosition(), 0));
 587       }
 588       break;
 589     }
 590     case Toolkit::DevelTextEditor::Property::VERTICAL_SCROLL_POSITION:
 591     {
 592       float verticalScroll = value.Get<float>();
 593       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p VERTICAL_SCROLL_POSITION %d\n", impl.mController.Get(), verticalScroll);
 594       if(verticalScroll >= 0.0f)
 595       {
 596         impl.ScrollBy(Vector2(0, verticalScroll - impl.GetVerticalScrollPosition()));
 597       }
 598       break;
 599     }
 600     case Toolkit::DevelTextEditor::Property::FONT_SIZE_SCALE:
 601     {
 602       const float scale = value.Get<float>();
 603       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p FONT_SIZE_SCALE %f\n", impl.mController.Get(), scale);
 604
 605       if(!Equals(impl.mController->GetFontSizeScale(), scale))
 606       {
 607         impl.mController->SetFontSizeScale(scale);
 608       }
 609       break;
 610     }
 611     case Toolkit::DevelTextEditor::Property::PRIMARY_CURSOR_POSITION:
 612     {
 613       uint32_t position = static_cast<uint32_t>(value.Get<int>());
 614       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p PRIMARY_CURSOR_POSITION %d\n", impl.mController.Get(), position);
 615       if(impl.mController->SetPrimaryCursorPosition(position, impl.HasKeyInputFocus()))
 616       {
 617         impl.SetKeyInputFocus();
 618       }
 619       break;
 620     }
 621     case Toolkit::DevelTextEditor::Property::GRAB_HANDLE_COLOR:
 622     {
 623       const Vector4 color = value.Get<Vector4>();
 624       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p GRAB_HANDLE_COLOR %f,%f,%f,%f\n", impl.mController.Get(), color.r, color.g, color.b, color.a);
 625
 626       impl.mDecorator->SetHandleColor(color);
 627       impl.RequestTextRelayout();
 628       break;
 629     }
 630     case Toolkit::DevelTextEditor::Property::ENABLE_GRAB_HANDLE_POPUP:
 631     {
 632       const bool grabHandlePopupEnabled = value.Get<bool>();
 633       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p ENABLE_GRAB_HANDLE_POPUP %d\n", impl.mController.Get(), grabHandlePopupEnabled);
 634
 635       impl.mController->SetGrabHandlePopupEnabled(grabHandlePopupEnabled);
 636       break;
 637     }
 638     case Toolkit::DevelTextEditor::Property::INPUT_METHOD_SETTINGS:
 639     {
 640       const Property::Map* map = value.GetMap();
 641       if(map)
 642       {
 643         impl.mInputMethodOptions.ApplyProperty(*map);
 644       }
 645       impl.mController->SetInputModePassword(impl.mInputMethodOptions.IsPassword());
 646
 647       Toolkit::Control control = Toolkit::KeyInputFocusManager::Get().GetCurrentFocusControl();
 648       if(control == textEditor)
 649       {
 650         impl.mInputMethodContext.ApplyOptions(impl.mInputMethodOptions);
 651       }
 652       break;
 653     }
 654     case Toolkit::DevelTextEditor::Property::INPUT_FILTER:
 655     {
 656       const Property::Map* map = value.GetMap();
 657       if(map)
 658       {
 659         impl.mController->SetInputFilterOption(*map);
 660       }
 661       break;
 662     }
 663     case Toolkit::DevelTextEditor::Property::ELLIPSIS:
 664     {
 665       const bool ellipsis = value.Get<bool>();
 666       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p ELLIPSIS %d\n", impl.mController.Get(), ellipsis);
 667
 668       impl.mController->SetTextElideEnabled(ellipsis);
 669       break;
 670     }
 671     case Toolkit::DevelTextEditor::Property::ELLIPSIS_POSITION:
 672     {
 673       DevelText::EllipsisPosition::Type ellipsisPositionType(static_cast<DevelText::EllipsisPosition::Type>(-1)); // Set to invalid value to ensure a valid mode does get set
 674       if(Text::GetEllipsisPositionTypeEnumeration(value, ellipsisPositionType))
 675       {
 676         DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p EllipsisPosition::Type %d\n", impl.mController.Get(), ellipsisPositionType);
 677         impl.mController->SetEllipsisPosition(ellipsisPositionType);
 678       }
 679       break;
 680     }
 681     case Toolkit::DevelTextEditor::Property::MIN_LINE_SIZE:
 682     {
 683       const float minLineSize = value.Get<float>();
 684       DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor %p MIN_LINE_SIZE %f\n", impl.mController.Get(), minLineSize);
 685
 686       impl.mController->SetDefaultLineSize(minLineSize);
 687       impl.mRenderer.Reset();
 688       break;
 689     }
 690   }
 691 }
 692
 693 Property::Value TextEditor::PropertyHandler::GetProperty(Toolkit::TextEditor textEditor, Property::Index index)
 694 {
 695   Property::Value value;
 696   TextEditor&     impl(GetImpl(textEditor));
 697   DALI_ASSERT_DEBUG(impl.mController && "No text controller");
 698   DALI_ASSERT_DEBUG(impl.mDecorator && "No text decorator");
 699
 700   switch(index)
 701   {
 702     case Toolkit::DevelTextEditor::Property::RENDERING_BACKEND:
 703     {
 704       value = impl.mRenderingBackend;
 705       break;
 706     }
 707     case Toolkit::TextEditor::Property::TEXT:
 708     {
 709       std::string text;
 710       impl.mController->GetText(text);
 711       DALI_LOG_INFO(gTextEditorLogFilter, Debug::General, "TextEditor %p returning text: %s\n", impl.mController.Get(), text.c_str());
 712       value = text;
 713       break;
 714     }
 715     case Toolkit::TextEditor::Property::TEXT_COLOR:
 716     {
 717       value = impl.mController->GetDefaultColor();
 718       break;
 719     }
 720     case Toolkit::TextEditor::Property::FONT_FAMILY:
 721     {
 722       value = impl.mController->GetDefaultFontFamily();
 723       break;
 724     }
 725     case Toolkit::TextEditor::Property::FONT_STYLE:
 726     {
 727       GetFontStyleProperty(impl.mController, value, Text::FontStyle::DEFAULT);
 728       break;
 729     }
 730     case Toolkit::TextEditor::Property::POINT_SIZE:
 731     {
 732       value = impl.mController->GetDefaultFontSize(Text::Controller::POINT_SIZE);
 733       break;
 734     }
 735     case Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT:
 736     {
 737       const char* name = Text::GetHorizontalAlignmentString(impl.mController->GetHorizontalAlignment());
 738       if(name)
 739       {
 740         value = std::string(name);
 741       }
 742       break;
 743     }
 744     case Toolkit::TextEditor::Property::SCROLL_THRESHOLD:
 745     {
 746       value = impl.mDecorator->GetScrollThreshold();
 747       break;
 748     }
 749     case Toolkit::TextEditor::Property::SCROLL_SPEED:
 750     {
 751       value = impl.mDecorator->GetScrollSpeed();
 752       break;
 753     }
 754     case Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR:
 755     {
 756       value = impl.mDecorator->GetColor(Text::PRIMARY_CURSOR);
 757       break;
 758     }
 759     case Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR:
 760     {
 761       value = impl.mDecorator->GetColor(Text::SECONDARY_CURSOR);
 762       break;
 763     }
 764     case Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK:
 765     {
 766       value = impl.mController->GetEnableCursorBlink();
 767       break;
 768     }
 769     case Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL:
 770     {
 771       value = impl.mDecorator->GetCursorBlinkInterval();
 772       break;
 773     }
 774     case Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION:
 775     {
 776       value = impl.mDecorator->GetCursorBlinkDuration();
 777       break;
 778     }
 779     case Toolkit::TextEditor::Property::CURSOR_WIDTH:
 780     {
 781       value = impl.mDecorator->GetCursorWidth();
 782       break;
 783     }
 784     case Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE:
 785     {
 786       value = impl.mDecorator->GetHandleImage(Text::GRAB_HANDLE, Text::HANDLE_IMAGE_RELEASED);
 787       break;
 788     }
 789     case Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE:
 790     {
 791       value = impl.mDecorator->GetHandleImage(Text::GRAB_HANDLE, Text::HANDLE_IMAGE_PRESSED);
 792       break;
 793     }
 794     case Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT:
 795     {
 796       impl.GetHandleImagePropertyValue(value, Text::LEFT_SELECTION_HANDLE, Text::HANDLE_IMAGE_RELEASED);
 797       break;
 798     }
 799     case Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT:
 800     {
 801       impl.GetHandleImagePropertyValue(value, Text::RIGHT_SELECTION_HANDLE, Text::HANDLE_IMAGE_RELEASED);
 802       break;
 803     }
 804     case Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT:
 805     {
 806       impl.GetHandleImagePropertyValue(value, Text::LEFT_SELECTION_HANDLE, Text::HANDLE_IMAGE_PRESSED);
 807       break;
 808     }
 809     case Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT:
 810     {
 811       impl.GetHandleImagePropertyValue(value, Text::RIGHT_SELECTION_HANDLE, Text::HANDLE_IMAGE_PRESSED);
 812       break;
 813     }
 814     case Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT:
 815     {
 816       impl.GetHandleImagePropertyValue(value, Text::LEFT_SELECTION_HANDLE_MARKER, Text::HANDLE_IMAGE_RELEASED);
 817       break;
 818     }
 819     case Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT:
 820     {
 821       impl.GetHandleImagePropertyValue(value, Text::RIGHT_SELECTION_HANDLE_MARKER, Text::HANDLE_IMAGE_RELEASED);
 822       break;
 823     }
 824     case Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR:
 825     {
 826       value = impl.mDecorator->GetHighlightColor();
 827       break;
 828     }
 829     case Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX:
 830     {
 831       Rect<int> boundingBox;
 832       impl.mDecorator->GetBoundingBox(boundingBox);
 833       value = boundingBox;
 834       break;
 835     }
 836     case Toolkit::TextEditor::Property::ENABLE_MARKUP:
 837     {
 838       value = impl.mController->IsMarkupProcessorEnabled();
 839       break;
 840     }
 841     case Toolkit::TextEditor::Property::INPUT_COLOR:
 842     {
 843       value = impl.mController->GetInputColor();
 844       break;
 845     }
 846     case Toolkit::TextEditor::Property::INPUT_FONT_FAMILY:
 847     {
 848       value = impl.mController->GetInputFontFamily();
 849       break;
 850     }
 851     case Toolkit::TextEditor::Property::INPUT_FONT_STYLE:
 852     {
 853       GetFontStyleProperty(impl.mController, value, Text::FontStyle::INPUT);
 854       break;
 855     }
 856     case Toolkit::TextEditor::Property::INPUT_POINT_SIZE:
 857     {
 858       value = impl.mController->GetInputFontPointSize();
 859       break;
 860     }
 861     case Toolkit::TextEditor::Property::LINE_SPACING:
 862     {
 863       value = impl.mController->GetDefaultLineSpacing();
 864       break;
 865     }
 866     case Toolkit::TextEditor::Property::INPUT_LINE_SPACING:
 867     {
 868       value = impl.mController->GetInputLineSpacing();
 869       break;
 870     }
 871     case Toolkit::TextEditor::Property::UNDERLINE:
 872     {
 873       GetUnderlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 874       break;
 875     }
 876     case Toolkit::TextEditor::Property::INPUT_UNDERLINE:
 877     {
 878       GetUnderlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
 879       break;
 880     }
 881     case Toolkit::TextEditor::Property::SHADOW:
 882     {
 883       GetShadowProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 884       break;
 885     }
 886     case Toolkit::TextEditor::Property::INPUT_SHADOW:
 887     {
 888       GetShadowProperties(impl.mController, value, Text::EffectStyle::INPUT);
 889       break;
 890     }
 891     case Toolkit::TextEditor::Property::EMBOSS:
 892     {
 893       GetEmbossProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 894       break;
 895     }
 896     case Toolkit::TextEditor::Property::INPUT_EMBOSS:
 897     {
 898       GetEmbossProperties(impl.mController, value, Text::EffectStyle::INPUT);
 899       break;
 900     }
 901     case Toolkit::TextEditor::Property::OUTLINE:
 902     {
 903       GetOutlineProperties(impl.mController, value, Text::EffectStyle::DEFAULT);
 904       break;
 905     }
 906     case Toolkit::TextEditor::Property::INPUT_OUTLINE:
 907     {
 908       GetOutlineProperties(impl.mController, value, Text::EffectStyle::INPUT);
 909       break;
 910     }
 911     case Toolkit::TextEditor::Property::SMOOTH_SCROLL:
 912     {
 913       value = impl.mScrollAnimationEnabled;
 914       break;
 915     }
 916     case Toolkit::TextEditor::Property::SMOOTH_SCROLL_DURATION:
 917     {
 918       value = impl.mScrollAnimationDuration;
 919       break;
 920     }
 921     case Toolkit::TextEditor::Property::ENABLE_SCROLL_BAR:
 922     {
 923       value = impl.mScrollBarEnabled;
 924       break;
 925     }
 926     case Toolkit::TextEditor::Property::SCROLL_BAR_SHOW_DURATION:
 927     {
 928       value = impl.mAnimationPeriod.delaySeconds;
 929       break;
 930     }
 931     case Toolkit::TextEditor::Property::SCROLL_BAR_FADE_DURATION:
 932     {
 933       value = impl.mAnimationPeriod.durationSeconds;
 934       break;
 935     }
 936     case Toolkit::TextEditor::Property::PIXEL_SIZE:
 937     {
 938       value = impl.mController->GetDefaultFontSize(Text::Controller::PIXEL_SIZE);
 939       break;
 940     }
 941     case Toolkit::TextEditor::Property::LINE_COUNT:
 942     {
 943       float width = textEditor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>();
 944       value       = impl.mController->GetLineCount(width);
 945       break;
 946     }
 947     case Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT:
 948     {
 949       std::string text;
 950       impl.mController->GetPlaceholderText(Text::Controller::PLACEHOLDER_TYPE_INACTIVE, text);
 951       value = text;
 952       break;
 953     }
 954     case Toolkit::DevelTextEditor::Property::PLACEHOLDER_TEXT_COLOR:
 955     {
 956       value = impl.mController->GetPlaceholderTextColor();
 957       break;
 958     }
 959     case Toolkit::TextEditor::Property::ENABLE_SELECTION:
 960     {
 961       value = impl.mController->IsSelectionEnabled();
 962       break;
 963     }
 964     case Toolkit::TextEditor::Property::PLACEHOLDER:
 965     {
 966       Property::Map map;
 967       impl.mController->GetPlaceholderProperty(map);
 968       value = map;
 969       break;
 970     }
 971     case Toolkit::TextEditor::Property::LINE_WRAP_MODE:
 972     {
 973       value = impl.mController->GetLineWrapMode();
 974       break;
 975     }
 976     case Toolkit::DevelTextEditor::Property::ENABLE_SHIFT_SELECTION:
 977     {
 978       value = impl.mController->IsShiftSelectionEnabled();
 979       break;
 980     }
 981     case Toolkit::DevelTextEditor::Property::ENABLE_GRAB_HANDLE:
 982     {
 983       value = impl.mController->IsGrabHandleEnabled();
 984       break;
 985     }
 986     case Toolkit::DevelTextEditor::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION:
 987     {
 988       value = impl.mController->GetMatchLayoutDirection() != DevelText::MatchLayoutDirection::CONTENTS;
 989       break;
 990     }
 991     case Toolkit::DevelTextEditor::Property::MAX_LENGTH:
 992     {
 993       value = impl.mController->GetMaximumNumberOfCharacters();
 994       break;
 995     }
 996     case Toolkit::DevelTextEditor::Property::SELECTED_TEXT:
 997     {
 998       value = impl.mController->GetSelectedText();
 999       break;
1000     }
1001     case Toolkit::DevelTextEditor::Property::SELECTED_TEXT_START:
1002     {
1003       Uint32Pair range = impl.GetTextSelectionRange();
1004       value            = static_cast<int>(range.first);
1005       break;
1006     }
1007     case Toolkit::DevelTextEditor::Property::SELECTED_TEXT_END:
1008     {
1009       Uint32Pair range = impl.GetTextSelectionRange();
1010       value            = static_cast<int>(range.second);
1011       break;
1012     }
1013     case Toolkit::DevelTextEditor::Property::ENABLE_EDITING:
1014     {
1015       value = impl.IsEditable();
1016       break;
1017     }
1018     case Toolkit::DevelTextEditor::Property::HORIZONTAL_SCROLL_POSITION:
1019     {
1020       value = impl.GetHorizontalScrollPosition();
1021       break;
1022     }
1023     case Toolkit::DevelTextEditor::Property::VERTICAL_SCROLL_POSITION:
1024     {
1025       value = impl.GetVerticalScrollPosition();
1026       break;
1027     }
1028     case Toolkit::DevelTextEditor::Property::FONT_SIZE_SCALE:
1029     {
1030       value = impl.mController->GetFontSizeScale();
1031       break;
1032     }
1033     case Toolkit::DevelTextEditor::Property::PRIMARY_CURSOR_POSITION:
1034     {
1035       value = static_cast<int>(impl.mController->GetPrimaryCursorPosition());
1036       break;
1037     }
1038     case Toolkit::DevelTextEditor::Property::GRAB_HANDLE_COLOR:
1039     {
1040       value = impl.mDecorator->GetHandleColor();
1041       break;
1042     }
1043     case Toolkit::DevelTextEditor::Property::ENABLE_GRAB_HANDLE_POPUP:
1044     {
1045       value = impl.mController->IsGrabHandlePopupEnabled();
1046       break;
1047     }
1048     case Toolkit::DevelTextEditor::Property::INPUT_METHOD_SETTINGS:
1049     {
1050       Property::Map map;
1051       impl.mInputMethodOptions.RetrieveProperty(map);
1052       value = map;
1053       break;
1054     }
1055     case Toolkit::DevelTextEditor::Property::INPUT_FILTER:
1056     {
1057       Property::Map map;
1058       impl.mController->GetInputFilterOption(map);
1059       value = map;
1060       break;
1061     }
1062     case Toolkit::DevelTextEditor::Property::ELLIPSIS:
1063     {
1064       value = impl.mController->IsTextElideEnabled();
1065       break;
1066     }
1067     case Toolkit::DevelTextEditor::Property::ELLIPSIS_POSITION:
1068     {
1069       value = impl.mController->GetEllipsisPosition();
1070       break;
1071     }
1072     case Toolkit::DevelTextEditor::Property::MIN_LINE_SIZE:
1073     {
1074       value = impl.mController->GetDefaultLineSize();
1075       break;
1076     }
1077   } //switch
1078   return value;
1079 }
1080
1081 } // namespace Dali::Toolkit::Internal