dali-toolkit/internal/controls/text-controls/text-selection-popup-impl.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
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/controls/text-controls/text-selection-popup-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #if defined(__GLIBC__)
  23 #include <libintl.h>
  24 #endif
  25 #include <dali/integration-api/debug.h>
  26 #include <dali/public-api/animation/animation.h>
  27 #include <dali/public-api/math/vector2.h>
  28 #include <dali/public-api/math/vector4.h>
  29 #include <dali/public-api/object/property-map.h>
  30 #include <dali/public-api/object/type-registry-helper.h>
  31 #include <string.h>
  32 #include <cfloat>
  33
  34 // INTERNAL INCLUDES
  35 #include <dali-toolkit/devel-api/controls/buttons/button-devel.h>
  36 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
  37 #include <dali-toolkit/devel-api/controls/control-devel.h>
  38 #include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup-callback-interface.h>
  39 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  40 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  41 #include <dali-toolkit/internal/helpers/color-conversion.h>
  42 #include <dali-toolkit/public-api/controls/text-controls/text-label.h>
  43 #include <dali-toolkit/public-api/visuals/color-visual-properties.h>
  44 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
  45 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  46
  47 namespace Dali
  48 {
  49 namespace Toolkit
  50 {
  51 namespace Internal
  52 {
  53 namespace
  54 {
  55 #if defined(__GLIBC__)
  56 #define GET_LOCALE_TEXT(string) dgettext("dali-toolkit", string)
  57 #endif
  58
  59 const std::string   TEXT_SELECTION_POPUP_BUTTON_STYLE_NAME("TextSelectionPopupButton");
  60 const Dali::Vector4 DEFAULT_OPTION_PRESSED_COLOR(Dali::Vector4(0.24f, 0.72f, 0.8f, 1.0f));
  61
  62 #if defined(DEBUG_ENABLED)
  63 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
  64 #endif
  65
  66 #ifdef DGETTEXT_ENABLED
  67
  68 #define POPUP_CUT_STRING GET_LOCALE_TEXT("IDS_COM_BODY_CUT")
  69 #define POPUP_COPY_STRING GET_LOCALE_TEXT("IDS_COM_BODY_COPY")
  70 #define POPUP_PASTE_STRING GET_LOCALE_TEXT("IDS_COM_BODY_PASTE")
  71 #define POPUP_SELECT_STRING GET_LOCALE_TEXT("IDS_COM_SK_SELECT")
  72 #define POPUP_SELECT_ALL_STRING GET_LOCALE_TEXT("IDS_COM_BODY_SELECT_ALL")
  73 #define POPUP_CLIPBOARD_STRING GET_LOCALE_TEXT("IDS_COM_BODY_CLIPBOARD")
  74
  75 #else
  76
  77 #define POPUP_CUT_STRING "Cut"
  78 #define POPUP_COPY_STRING "Copy"
  79 #define POPUP_PASTE_STRING "Paste"
  80 #define POPUP_SELECT_STRING "Select"
  81 #define POPUP_SELECT_ALL_STRING "Select All"
  82 #define POPUP_CLIPBOARD_STRING "Clipboard"
  83
  84 #endif
  85
  86 const char* const OPTION_SELECT_WORD = "option-select_word"; // "Select Word" popup option.
  87 const char* const OPTION_SELECT_ALL("option-select_all");    // "Select All" popup option.
  88 const char* const OPTION_CUT("optionCut");                   // "Cut" popup option.
  89 const char* const OPTION_COPY("optionCopy");                 // "Copy" popup option.
  90 const char* const OPTION_PASTE("optionPaste");               // "Paste" popup option.
  91 const char* const OPTION_CLIPBOARD("optionClipboard");       // "Clipboard" popup option.
  92
  93 const std::string IDS_LTR("IDS_LTR");
  94 const std::string RTL_DIRECTION("RTL");
  95
  96 BaseHandle Create()
  97 {
  98   return Toolkit::TextSelectionPopup::New(NULL);
  99 }
 100
 101 // Setup properties, signals and actions using the type-registry.
 102
 103 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::TextSelectionPopup, Toolkit::Control, Create);
 104
 105 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupMaxSize", VECTOR2, POPUP_MAX_SIZE)
 106 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupMinSize", VECTOR2, POPUP_MIN_SIZE)
 107 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionMaxSize", VECTOR2, OPTION_MAX_SIZE)
 108 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionMinSize", VECTOR2, OPTION_MIN_SIZE)
 109 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionDividerSize", VECTOR2, OPTION_DIVIDER_SIZE)
 110 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "optionDividerPadding", VECTOR4, OPTION_DIVIDER_PADDING)
 111 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupClipboardButtonImage", STRING, POPUP_CLIPBOARD_BUTTON_ICON_IMAGE)
 112 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupCutButtonImage", STRING, POPUP_CUT_BUTTON_ICON_IMAGE)
 113 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupCopyButtonImage", STRING, POPUP_COPY_BUTTON_ICON_IMAGE)
 114 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupPasteButtonImage", STRING, POPUP_PASTE_BUTTON_ICON_IMAGE)
 115 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupSelectButtonImage", STRING, POPUP_SELECT_BUTTON_ICON_IMAGE)
 116 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupSelectAllButtonImage", STRING, POPUP_SELECT_ALL_BUTTON_ICON_IMAGE)
 117 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupDividerColor", VECTOR4, POPUP_DIVIDER_COLOR)
 118 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupIconColor", VECTOR4, POPUP_ICON_COLOR)
 119 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupPressedColor", VECTOR4, POPUP_PRESSED_COLOR)
 120 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupPressedImage", STRING, POPUP_PRESSED_IMAGE)
 121 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupFadeInDuration", FLOAT, POPUP_FADE_IN_DURATION)
 122 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "popupFadeOutDuration", FLOAT, POPUP_FADE_OUT_DURATION)
 123 DALI_PROPERTY_REGISTRATION(Toolkit, TextSelectionPopup, "backgroundBorder", MAP, BACKGROUND_BORDER)
 124
 125 DALI_TYPE_REGISTRATION_END()
 126
 127 } // namespace
 128
 129 Dali::Toolkit::TextSelectionPopup TextSelectionPopup::New(TextSelectionPopupCallbackInterface* callbackInterface)
 130 {
 131   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextSelectionPopup::New\n");
 132
 133   // Create the implementation, temporarily owned by this handle on stack
 134   IntrusivePtr<TextSelectionPopup> impl = new TextSelectionPopup(callbackInterface);
 135
 136   // Pass ownership to CustomActor handle
 137   Dali::Toolkit::TextSelectionPopup handle(*impl);
 138
 139   // Second-phase init of the implementation
 140   // This can only be done after the CustomActor connection has been made...
 141   impl->Initialize();
 142
 143   return handle;
 144 }
 145
 146 void TextSelectionPopup::SetProperty(BaseObject* object, Property::Index index, const Property::Value& value)
 147 {
 148   Toolkit::TextSelectionPopup selectionPopup = Toolkit::TextSelectionPopup::DownCast(Dali::BaseHandle(object));
 149
 150   if(selectionPopup)
 151   {
 152     TextSelectionPopup& impl(GetImpl(selectionPopup));
 153
 154     switch(index)
 155     {
 156       case Toolkit::TextSelectionPopup::Property::POPUP_MAX_SIZE:
 157       {
 158         impl.SetDimensionToCustomise(POPUP_MAXIMUM_SIZE, value.Get<Vector2>());
 159         break;
 160       }
 161       case Toolkit::TextSelectionPopup::Property::OPTION_MAX_SIZE:
 162       {
 163         impl.SetDimensionToCustomise(OPTION_MAXIMUM_SIZE, value.Get<Vector2>());
 164         break;
 165       }
 166       case Toolkit::TextSelectionPopup::Property::OPTION_MIN_SIZE:
 167       {
 168         impl.SetDimensionToCustomise(OPTION_MINIMUM_SIZE, value.Get<Vector2>());
 169         break;
 170       }
 171       case Toolkit::TextSelectionPopup::Property::OPTION_DIVIDER_SIZE:
 172       {
 173         impl.SetDimensionToCustomise(OPTION_DIVIDER_SIZE, value.Get<Vector2>());
 174         break;
 175       }
 176       case Toolkit::TextSelectionPopup::Property::OPTION_DIVIDER_PADDING:
 177       {
 178         Vector4 padding(value.Get<Vector4>());
 179         impl.SetOptionDividerPadding(Padding(padding.x, padding.y, padding.z, padding.w));
 180         break;
 181       }
 182       case Toolkit::TextSelectionPopup::Property::POPUP_CLIPBOARD_BUTTON_ICON_IMAGE:
 183       {
 184         impl.SetButtonImage(Toolkit::TextSelectionPopup::CLIPBOARD, value.Get<std::string>());
 185         break;
 186       }
 187       case Toolkit::TextSelectionPopup::Property::POPUP_CUT_BUTTON_ICON_IMAGE:
 188       {
 189         impl.SetButtonImage(Toolkit::TextSelectionPopup::CUT, value.Get<std::string>());
 190         break;
 191       }
 192       case Toolkit::TextSelectionPopup::Property::POPUP_COPY_BUTTON_ICON_IMAGE:
 193       {
 194         impl.SetButtonImage(Toolkit::TextSelectionPopup::COPY, value.Get<std::string>());
 195         break;
 196       }
 197       case Toolkit::TextSelectionPopup::Property::POPUP_PASTE_BUTTON_ICON_IMAGE:
 198       {
 199         impl.SetButtonImage(Toolkit::TextSelectionPopup::PASTE, value.Get<std::string>());
 200         break;
 201       }
 202       case Toolkit::TextSelectionPopup::Property::POPUP_SELECT_BUTTON_ICON_IMAGE:
 203       {
 204         impl.SetButtonImage(Toolkit::TextSelectionPopup::SELECT, value.Get<std::string>());
 205         break;
 206       }
 207       case Toolkit::TextSelectionPopup::Property::POPUP_SELECT_ALL_BUTTON_ICON_IMAGE:
 208       {
 209         impl.SetButtonImage(Toolkit::TextSelectionPopup::SELECT_ALL, value.Get<std::string>());
 210         break;
 211       }
 212       case Toolkit::TextSelectionPopup::Property::POPUP_DIVIDER_COLOR:
 213       {
 214         impl.mDividerColor = value.Get<Vector4>();
 215         break;
 216       }
 217       case Toolkit::TextSelectionPopup::Property::POPUP_ICON_COLOR:
 218       {
 219         impl.mIconColor = value.Get<Vector4>();
 220         break;
 221       }
 222       case Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_COLOR:
 223       {
 224         impl.mPressedColor = value.Get<Vector4>();
 225         break;
 226       }
 227       case Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_IMAGE:
 228       {
 229         impl.SetPressedImage(value.Get<std::string>());
 230         break;
 231       }
 232       case Toolkit::TextSelectionPopup::Property::POPUP_FADE_IN_DURATION:
 233       {
 234         impl.mFadeInDuration = value.Get<float>();
 235         break;
 236       }
 237       case Toolkit::TextSelectionPopup::Property::POPUP_FADE_OUT_DURATION:
 238       {
 239         impl.mFadeOutDuration = value.Get<float>();
 240         break;
 241       }
 242       case Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER:
 243       {
 244         Property::Map map = value.Get<Property::Map>();
 245         impl.CreateBackgroundBorder(map);
 246         break;
 247       }
 248     } // switch
 249   }   // TextSelectionPopup
 250 }
 251
 252 Property::Value TextSelectionPopup::GetProperty(BaseObject* object, Property::Index index)
 253 {
 254   Property::Value value;
 255
 256   Toolkit::TextSelectionPopup selectionPopup = Toolkit::TextSelectionPopup::DownCast(Dali::BaseHandle(object));
 257
 258   if(selectionPopup)
 259   {
 260     TextSelectionPopup& impl(GetImpl(selectionPopup));
 261
 262     switch(index)
 263     {
 264       case Toolkit::TextSelectionPopup::Property::POPUP_MAX_SIZE:
 265       {
 266         value = impl.GetDimensionToCustomise(POPUP_MAXIMUM_SIZE);
 267         break;
 268       }
 269       case Toolkit::TextSelectionPopup::Property::OPTION_MAX_SIZE:
 270       {
 271         value = impl.GetDimensionToCustomise(OPTION_MAXIMUM_SIZE);
 272         break;
 273       }
 274       case Toolkit::TextSelectionPopup::Property::OPTION_MIN_SIZE:
 275       {
 276         value = impl.GetDimensionToCustomise(OPTION_MINIMUM_SIZE);
 277         break;
 278       }
 279       case Toolkit::TextSelectionPopup::Property::OPTION_DIVIDER_SIZE:
 280       {
 281         value = impl.GetDimensionToCustomise(OPTION_DIVIDER_SIZE);
 282         break;
 283       }
 284       case Toolkit::TextSelectionPopup::Property::OPTION_DIVIDER_PADDING:
 285       {
 286         Padding padding = impl.GetOptionDividerPadding();
 287         value           = Vector4(padding.left, padding.right, padding.top, padding.bottom);
 288         break;
 289       }
 290       case Toolkit::TextSelectionPopup::Property::POPUP_CLIPBOARD_BUTTON_ICON_IMAGE:
 291       {
 292         value = impl.GetButtonImage(Toolkit::TextSelectionPopup::CLIPBOARD);
 293         break;
 294       }
 295       case Toolkit::TextSelectionPopup::Property::POPUP_CUT_BUTTON_ICON_IMAGE:
 296       {
 297         value = impl.GetButtonImage(Toolkit::TextSelectionPopup::CUT);
 298         break;
 299       }
 300       case Toolkit::TextSelectionPopup::Property::POPUP_COPY_BUTTON_ICON_IMAGE:
 301       {
 302         value = impl.GetButtonImage(Toolkit::TextSelectionPopup::COPY);
 303         break;
 304       }
 305       case Toolkit::TextSelectionPopup::Property::POPUP_PASTE_BUTTON_ICON_IMAGE:
 306       {
 307         value = impl.GetButtonImage(Toolkit::TextSelectionPopup::PASTE);
 308         break;
 309       }
 310       case Toolkit::TextSelectionPopup::Property::POPUP_SELECT_BUTTON_ICON_IMAGE:
 311       {
 312         value = impl.GetButtonImage(Toolkit::TextSelectionPopup::SELECT);
 313         break;
 314       }
 315       case Toolkit::TextSelectionPopup::Property::POPUP_SELECT_ALL_BUTTON_ICON_IMAGE:
 316       {
 317         value = impl.GetButtonImage(Toolkit::TextSelectionPopup::SELECT_ALL);
 318         break;
 319       }
 320       case Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_IMAGE:
 321       {
 322         value = impl.GetPressedImage();
 323         break;
 324       }
 325       case Toolkit::TextSelectionPopup::Property::POPUP_FADE_IN_DURATION:
 326       {
 327         value = impl.mFadeInDuration;
 328         break;
 329       }
 330       case Toolkit::TextSelectionPopup::Property::POPUP_FADE_OUT_DURATION:
 331       {
 332         value = impl.mFadeOutDuration;
 333         break;
 334       }
 335       case Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER:
 336       {
 337         Property::Map         map;
 338         Toolkit::Visual::Base visual = DevelControl::GetVisual(impl, Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER);
 339         if(visual)
 340         {
 341           visual.CreatePropertyMap(map);
 342         }
 343         value = map;
 344         break;
 345       }
 346     } // switch
 347   }
 348   return value;
 349 }
 350
 351 void TextSelectionPopup::EnableButtons(Toolkit::TextSelectionPopup::Buttons buttonsToEnable)
 352 {
 353   mEnabledButtons = buttonsToEnable;
 354   mButtonsChanged = true;
 355 }
 356
 357 void TextSelectionPopup::RaiseAbove(Actor target)
 358 {
 359   if(mToolbar)
 360   {
 361     mToolbar.RaiseAbove(target);
 362   }
 363 }
 364
 365 void TextSelectionPopup::ShowPopup()
 366 {
 367   if((!mPopupShowing || mButtonsChanged) &&
 368      (Toolkit::TextSelectionPopup::NONE != mEnabledButtons))
 369   {
 370     Actor self = Self();
 371     AddPopupOptionsToToolbar(mShowIcons, mShowCaptions);
 372
 373     Animation animation = Animation::New(mFadeInDuration);
 374     animation.AnimateTo(Property(self, Actor::Property::COLOR_ALPHA), 1.0f);
 375     animation.Play();
 376     mPopupShowing = true;
 377   }
 378 }
 379
 380 void TextSelectionPopup::HidePopup()
 381 {
 382   if(mPopupShowing)
 383   {
 384     mPopupShowing       = false;
 385     Actor     self      = Self();
 386     Animation animation = Animation::New(mFadeOutDuration);
 387     animation.AnimateTo(Property(self, Actor::Property::COLOR_ALPHA), 0.0f);
 388     animation.FinishedSignal().Connect(this, &TextSelectionPopup::HideAnimationFinished);
 389     animation.Play();
 390   }
 391 }
 392
 393 void TextSelectionPopup::OnInitialize()
 394 {
 395   DALI_LOG_INFO(gLogFilter, Debug::General, "TextSelectionPopup::OnInitialize\n");
 396   Actor self = Self();
 397   self.SetResizePolicy(ResizePolicy::FIT_TO_CHILDREN, Dimension::ALL_DIMENSIONS);
 398   self.SetProperty(Actor::Property::COLOR_ALPHA, 0.0f);
 399
 400   DevelControl::SetAccessibilityConstructor(Self(), [](Dali::Actor actor) {
 401     return std::make_unique<DevelControl::ControlAccessible>(actor, Dali::Accessibility::Role::DIALOG, true);
 402   });
 403
 404   //Enable highightability
 405   self.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
 406 }
 407
 408 void TextSelectionPopup::HideAnimationFinished(Animation& animation)
 409 {
 410   Actor self = Self();
 411   if(!mPopupShowing) // During the Hide/Fade animation there could be a call to Show the Popup again, mPopupShowing will be true in this case.
 412   {
 413     DALI_LOG_INFO(gLogFilter, Debug::General, "TextSelectionPopup::HideAnimationFinished\n");
 414     UnparentAndReset(mToolbar);
 415   }
 416 }
 417
 418 bool TextSelectionPopup::OnCutButtonPressed(Toolkit::Button button)
 419 {
 420   if(mCallbackInterface)
 421   {
 422     mCallbackInterface->TextPopupButtonTouched(Toolkit::TextSelectionPopup::CUT);
 423   }
 424
 425   return true;
 426 }
 427
 428 bool TextSelectionPopup::OnCopyButtonPressed(Toolkit::Button button)
 429 {
 430   if(mCallbackInterface)
 431   {
 432     mCallbackInterface->TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::COPY);
 433   }
 434
 435   return true;
 436 }
 437
 438 bool TextSelectionPopup::OnPasteButtonPressed(Toolkit::Button button)
 439 {
 440   if(mCallbackInterface)
 441   {
 442     mCallbackInterface->TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::PASTE);
 443   }
 444
 445   return true;
 446 }
 447
 448 bool TextSelectionPopup::OnSelectButtonPressed(Toolkit::Button button)
 449 {
 450   if(mCallbackInterface)
 451   {
 452     mCallbackInterface->TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::SELECT);
 453   }
 454
 455   return true;
 456 }
 457
 458 bool TextSelectionPopup::OnSelectAllButtonPressed(Toolkit::Button button)
 459 {
 460   if(mCallbackInterface)
 461   {
 462     mCallbackInterface->TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::SELECT_ALL);
 463   }
 464
 465   return true;
 466 }
 467
 468 bool TextSelectionPopup::OnClipboardButtonPressed(Toolkit::Button button)
 469 {
 470   if(mCallbackInterface)
 471   {
 472     mCallbackInterface->TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::CLIPBOARD);
 473   }
 474
 475   return true;
 476 }
 477
 478 void TextSelectionPopup::SetDimensionToCustomise(const PopupCustomisations& settingToCustomise, const Size& dimension)
 479 {
 480   switch(settingToCustomise)
 481   {
 482     case POPUP_MAXIMUM_SIZE:
 483     {
 484       mPopupMaxSize = dimension;
 485       if(mToolbar)
 486       {
 487         mToolbar.SetProperty(Toolkit::TextSelectionToolbar::Property::MAX_SIZE, dimension);
 488       }
 489       break;
 490     }
 491     case OPTION_MAXIMUM_SIZE:
 492     {
 493       mOptionMaxSize = dimension;
 494       // Option max size not currently currently supported
 495       break;
 496     }
 497     case OPTION_MINIMUM_SIZE:
 498     {
 499       mOptionMinSize = dimension;
 500       // Option min size not currently currently supported
 501       break;
 502     }
 503     case OPTION_DIVIDER_SIZE:
 504     {
 505       mOptionDividerSize = dimension;
 506       if(mToolbar)
 507       {
 508         // Resize Dividers not currently supported
 509       }
 510       break;
 511     }
 512   } // switch
 513 }
 514
 515 Size TextSelectionPopup::GetDimensionToCustomise(const PopupCustomisations& settingToCustomise) const
 516 {
 517   switch(settingToCustomise)
 518   {
 519     case POPUP_MAXIMUM_SIZE:
 520     {
 521       if(mToolbar)
 522       {
 523         return mToolbar.GetProperty(Toolkit::TextSelectionToolbar::Property::MAX_SIZE).Get<Vector2>();
 524       }
 525       else
 526       {
 527         return mPopupMaxSize;
 528       }
 529     }
 530     case OPTION_MAXIMUM_SIZE:
 531     {
 532       return mOptionMaxSize;
 533     }
 534     case OPTION_MINIMUM_SIZE:
 535     {
 536       return mOptionMinSize;
 537     }
 538     case OPTION_DIVIDER_SIZE:
 539     {
 540       return mOptionDividerSize;
 541     }
 542   } // switch
 543
 544   return Size::ZERO;
 545 }
 546
 547 void TextSelectionPopup::SetButtonImage(Toolkit::TextSelectionPopup::Buttons button, const std::string& image)
 548 {
 549   switch(button)
 550   {
 551     case Toolkit::TextSelectionPopup::CLIPBOARD:
 552     {
 553       mClipboardIconImage = image;
 554       break;
 555     }
 556     case Toolkit::TextSelectionPopup::CUT:
 557     {
 558       mCutIconImage = image;
 559       break;
 560     }
 561     case Toolkit::TextSelectionPopup::COPY:
 562     {
 563       mCopyIconImage = image;
 564       break;
 565     }
 566     case Toolkit::TextSelectionPopup::PASTE:
 567     {
 568       mPasteIconImage = image;
 569       break;
 570     }
 571     case Toolkit::TextSelectionPopup::SELECT:
 572     {
 573       mSelectIconImage = image;
 574       break;
 575     }
 576     case Toolkit::TextSelectionPopup::SELECT_ALL:
 577     {
 578       mSelectAllIconImage = image;
 579       break;
 580     }
 581     default:
 582     {
 583       DALI_ASSERT_DEBUG("TextSelectionPopup SetPopupImage Unknown Button");
 584     }
 585   } // switch
 586 }
 587
 588 const std::string& TextSelectionPopup::GetButtonImage(Toolkit::TextSelectionPopup::Buttons button) const
 589 {
 590   switch(button)
 591   {
 592     case Toolkit::TextSelectionPopup::CLIPBOARD:
 593     {
 594       return mClipboardIconImage;
 595       break;
 596     }
 597     case Toolkit::TextSelectionPopup::CUT:
 598     {
 599       return mCutIconImage;
 600       break;
 601     }
 602     case Toolkit::TextSelectionPopup::COPY:
 603     {
 604       return mCopyIconImage;
 605       break;
 606     }
 607     case Toolkit::TextSelectionPopup::PASTE:
 608     {
 609       return mPasteIconImage;
 610       break;
 611     }
 612     case Toolkit::TextSelectionPopup::SELECT:
 613     {
 614       return mSelectIconImage;
 615       break;
 616     }
 617     case Toolkit::TextSelectionPopup::SELECT_ALL:
 618     {
 619       return mSelectAllIconImage;
 620       break;
 621     }
 622     case Toolkit::TextSelectionPopup::NONE:
 623     {
 624       break;
 625     }
 626   } // switch
 627
 628   DALI_ASSERT_DEBUG("TextSelectionPopup GetPopupImage Unknown Button");
 629   static std::string empty;
 630   return empty;
 631 }
 632
 633 void TextSelectionPopup::SetPressedImage(const std::string& filename)
 634 {
 635   mPressedImage = filename;
 636 }
 637
 638 std::string TextSelectionPopup::GetPressedImage() const
 639 {
 640   return mPressedImage;
 641 }
 642
 643 void TextSelectionPopup::SetOptionDividerPadding(const Padding& padding)
 644 {
 645   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextSelectionPopup::SetOptionDividerPadding padding(%f,%f,%f,%f)\n", padding.left, padding.right, padding.top, padding.bottom);
 646   mOptionDividerPadding = Padding(padding.left, padding.right, padding.top, padding.bottom);
 647 }
 648
 649 Padding TextSelectionPopup::GetOptionDividerPadding() const
 650 {
 651   return mOptionDividerPadding;
 652 }
 653
 654 void TextSelectionPopup::CreateOrderedListOfPopupOptions()
 655 {
 656   mOrderListOfButtons.clear();
 657   mOrderListOfButtons.reserve(8u);
 658
 659   // Create button for each possible option using Option priority
 660   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::CUT, mCutOptionPriority, OPTION_CUT, POPUP_CUT_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::CUT)));
 661   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::COPY, mCopyOptionPriority, OPTION_COPY, POPUP_COPY_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::COPY)));
 662   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::PASTE, mPasteOptionPriority, OPTION_PASTE, POPUP_PASTE_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::PASTE)));
 663   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::SELECT, mSelectOptionPriority, OPTION_SELECT_WORD, POPUP_SELECT_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::SELECT)));
 664   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::SELECT_ALL, mSelectAllOptionPriority, OPTION_SELECT_ALL, POPUP_SELECT_ALL_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::SELECT_ALL)));
 665   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::CLIPBOARD, mClipboardOptionPriority, OPTION_CLIPBOARD, POPUP_CLIPBOARD_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::CLIPBOARD)));
 666
 667   // Sort the buttons according their priorities.
 668   std::sort(mOrderListOfButtons.begin(), mOrderListOfButtons.end(), TextSelectionPopup::ButtonPriorityCompare());
 669 }
 670
 671 void TextSelectionPopup::AddOption(const ButtonRequirement& button, bool showDivider, bool showIcons, bool showCaption)
 672 {
 673   // 1. Create a option.
 674   DALI_LOG_INFO(gLogFilter, Debug::General, "TextSelectionPopup::AddOption\n");
 675
 676   Toolkit::PushButton option = Toolkit::PushButton::New();
 677   option.SetProperty(Dali::Actor::Property::NAME, button.name);
 678   option.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
 679
 680   switch(button.id)
 681   {
 682     case Toolkit::TextSelectionPopup::CUT:
 683     {
 684       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnCutButtonPressed);
 685       break;
 686     }
 687     case Toolkit::TextSelectionPopup::COPY:
 688     {
 689       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnCopyButtonPressed);
 690       break;
 691     }
 692     case Toolkit::TextSelectionPopup::PASTE:
 693     {
 694       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnPasteButtonPressed);
 695       break;
 696     }
 697     case Toolkit::TextSelectionPopup::SELECT:
 698     {
 699       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnSelectButtonPressed);
 700       break;
 701     }
 702     case Toolkit::TextSelectionPopup::SELECT_ALL:
 703     {
 704       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnSelectAllButtonPressed);
 705       break;
 706     }
 707     case Toolkit::TextSelectionPopup::CLIPBOARD:
 708     {
 709       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnClipboardButtonPressed);
 710       break;
 711     }
 712     case Toolkit::TextSelectionPopup::NONE:
 713     {
 714       // Nothing to do:
 715       break;
 716     }
 717   }
 718
 719   // 2. Set the options contents.
 720   if(showCaption)
 721   {
 722     // PushButton layout properties.
 723     option.SetProperty(Toolkit::PushButton::Property::LABEL_PADDING, Vector4(24.0f, 24.0f, 14.0f, 14.0f));
 724
 725     // Label properties.
 726     Property::Map buttonLabelProperties;
 727     buttonLabelProperties.Insert(Toolkit::TextVisual::Property::TEXT, button.caption);
 728     option.SetProperty(Toolkit::Button::Property::LABEL, buttonLabelProperties);
 729   }
 730   if(showIcons)
 731   {
 732     option.SetProperty(Toolkit::PushButton::Property::ICON_PADDING, Vector4(10.0f, 10.0f, 10.0f, 10.0f));
 733     option.SetProperty(Toolkit::DevelButton::Property::LABEL_RELATIVE_ALIGNMENT, "BOTTOM");
 734
 735     // TODO: This is temporarily disabled until the text-selection-popup image API is changed to strings.
 736     //option.SetProperty(  Toolkit::Button::Property::SELECTED_VISUAL, button.icon );
 737     //option.SetProperty(  Toolkit::Button::Property::UNSELECTED_VISUAL, button.icon );
 738   }
 739
 740   // 3. Set the normal option image (blank / Transparent).
 741   option.SetProperty(Toolkit::Button::Property::UNSELECTED_BACKGROUND_VISUAL, "");
 742
 743   // 4. Set the pressed option image.
 744   Property::Value selectedBackgroundValue(mPressedImage);
 745   if(mPressedImage.empty())
 746   {
 747     // The image can be blank, the color can be used in that case.
 748     selectedBackgroundValue = Property::Value{{Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR},
 749                                               {Toolkit::ColorVisual::Property::MIX_COLOR, mPressedColor}};
 750   }
 751   option.SetProperty(Toolkit::Button::Property::SELECTED_BACKGROUND_VISUAL, selectedBackgroundValue);
 752   option.SetProperty(Toolkit::Control::Property::STYLE_NAME, TEXT_SELECTION_POPUP_BUTTON_STYLE_NAME);
 753
 754   // 5 Add option to tool bar
 755   mToolbar.AddOption(option);
 756
 757   // 6. Add the divider
 758   if(showDivider)
 759   {
 760     const Size    size(mOptionDividerSize.width, 0.0f); // Height FILL_TO_PARENT
 761     const Padding padding(mOptionDividerPadding);
 762
 763     Toolkit::Control divider = Toolkit::Control::New();
 764 #ifdef DECORATOR_DEBUG
 765     divider.SetProperty(Dali::Actor::Property::NAME, "Text's popup divider");
 766 #endif
 767     divider.SetProperty(Actor::Property::SIZE, size);
 768     divider.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::HEIGHT);
 769     divider.SetProperty(Actor::Property::PADDING, padding);
 770     divider.SetBackgroundColor(mDividerColor);
 771     mToolbar.AddDivider(divider);
 772   }
 773 }
 774
 775 std::size_t TextSelectionPopup::GetNumberOfEnabledOptions() const
 776 {
 777   std::size_t numberOfOptions = 0u;
 778   for(std::vector<ButtonRequirement>::const_iterator it = mOrderListOfButtons.begin(), endIt = mOrderListOfButtons.end(); (it != endIt); ++it)
 779   {
 780     const ButtonRequirement& button(*it);
 781     if(button.enabled)
 782     {
 783       ++numberOfOptions;
 784     }
 785   }
 786
 787   return numberOfOptions;
 788 }
 789
 790 void TextSelectionPopup::AddPopupOptionsToToolbar(bool showIcons, bool showCaptions)
 791 {
 792   DALI_LOG_INFO(gLogFilter, Debug::General, "TextSelectionPopup::AddPopupOptionsToToolbar\n");
 793
 794   CreateOrderedListOfPopupOptions();
 795
 796   mButtonsChanged = false;
 797   UnparentAndReset(mToolbar);
 798
 799   if(!mToolbar)
 800   {
 801     Actor self = Self();
 802     mToolbar   = Toolkit::TextSelectionToolbar::New();
 803     if(mPopupMaxSize != Vector2::ZERO) // If PopupMaxSize property set then apply to Toolbar. Toolbar currently is not retriving this from json
 804     {
 805       mToolbar.SetProperty(Toolkit::TextSelectionToolbar::Property::MAX_SIZE, mPopupMaxSize);
 806     }
 807     mToolbar.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 808 #ifdef DECORATOR_DEBUG
 809     mToolbar.SetProperty(Dali::Actor::Property::NAME, "TextSelectionToolbar");
 810 #endif
 811     self.Add(mToolbar);
 812   }
 813
 814   // Whether to mirror the list of buttons (for right to left languages)
 815   bool mirror = false;
 816 #if defined(__GLIBC__)
 817   char* idsLtr = GET_LOCALE_TEXT(IDS_LTR.c_str());
 818   if(NULL != idsLtr)
 819   {
 820     mirror = (0 == strcmp(idsLtr, RTL_DIRECTION.c_str()));
 821
 822     if(mirror)
 823     {
 824       std::reverse(mOrderListOfButtons.begin(), mOrderListOfButtons.end());
 825     }
 826   }
 827 #endif
 828
 829   // Iterate list of buttons and add active ones to Toolbar
 830   std::size_t numberOfOptionsRequired = GetNumberOfEnabledOptions();
 831   std::size_t numberOfOptionsAdded    = 0u;
 832   for(std::vector<ButtonRequirement>::const_iterator it = mOrderListOfButtons.begin(), endIt = mOrderListOfButtons.end(); (it != endIt); ++it)
 833   {
 834     const ButtonRequirement& button(*it);
 835     if(button.enabled)
 836     {
 837       numberOfOptionsAdded++;
 838       AddOption(button, (numberOfOptionsAdded < numberOfOptionsRequired), showIcons, showCaptions);
 839     }
 840   }
 841
 842   if(mirror)
 843   {
 844     mToolbar.ScrollTo(Vector2(mPopupMaxSize.x, 0.f));
 845   }
 846 }
 847
 848 void TextSelectionPopup::CreateBackgroundBorder(Property::Map& propertyMap)
 849 {
 850   // Removes previous image if necessary
 851   DevelControl::UnregisterVisual(*this, Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER);
 852
 853   if(!propertyMap.Empty())
 854   {
 855     Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual(propertyMap);
 856
 857     if(visual)
 858     {
 859       DevelControl::RegisterVisual(*this, Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER, visual, DepthIndex::CONTENT);
 860     }
 861   }
 862 }
 863
 864 TextSelectionPopup::TextSelectionPopup(TextSelectionPopupCallbackInterface* callbackInterface)
 865 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
 866   mToolbar(),
 867   mPopupMaxSize(),
 868   mOptionMaxSize(),
 869   mOptionMinSize(),
 870   mOptionDividerSize(),
 871   mOptionDividerPadding(),
 872   mEnabledButtons(Toolkit::TextSelectionPopup::NONE),
 873   mCallbackInterface(callbackInterface),
 874   mPressedColor(DEFAULT_OPTION_PRESSED_COLOR),
 875   mDividerColor(Color::WHITE),
 876   mIconColor(Color::WHITE),
 877   mSelectOptionPriority(1),
 878   mSelectAllOptionPriority(2),
 879   mCutOptionPriority(4),
 880   mCopyOptionPriority(3),
 881   mPasteOptionPriority(5),
 882   mClipboardOptionPriority(6),
 883   mFadeInDuration(0.0f),
 884   mFadeOutDuration(0.0f),
 885   mShowIcons(false),
 886   mShowCaptions(true),
 887   mPopupShowing(false),
 888   mButtonsChanged(false)
 889 {
 890 }
 891
 892 TextSelectionPopup::~TextSelectionPopup()
 893 {
 894 }
 895
 896 } // namespace Internal
 897
 898 } // namespace Toolkit
 899
 900 } // namespace Dali