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   // Accessibility
 401   self.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
 402   self.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::DIALOG);
 403 }
 404
 405 DevelControl::ControlAccessible* TextSelectionPopup::CreateAccessibleObject()
 406 {
 407   return new TextSelectionPopupAccessible(Self());
 408 }
 409
 410 Dali::Accessibility::States TextSelectionPopup::TextSelectionPopupAccessible::CalculateStates()
 411 {
 412   auto states = ControlAccessible::CalculateStates();
 413
 414   states[Dali::Accessibility::State::MODAL] = true;
 415
 416   return states;
 417 }
 418
 419 void TextSelectionPopup::HideAnimationFinished(Animation& animation)
 420 {
 421   Actor self = Self();
 422   if(!mPopupShowing) // During the Hide/Fade animation there could be a call to Show the Popup again, mPopupShowing will be true in this case.
 423   {
 424     DALI_LOG_INFO(gLogFilter, Debug::General, "TextSelectionPopup::HideAnimationFinished\n");
 425     UnparentAndReset(mToolbar);
 426   }
 427 }
 428
 429 bool TextSelectionPopup::OnCutButtonPressed(Toolkit::Button button)
 430 {
 431   if(mCallbackInterface)
 432   {
 433     mCallbackInterface->TextPopupButtonTouched(Toolkit::TextSelectionPopup::CUT);
 434   }
 435
 436   return true;
 437 }
 438
 439 bool TextSelectionPopup::OnCopyButtonPressed(Toolkit::Button button)
 440 {
 441   if(mCallbackInterface)
 442   {
 443     mCallbackInterface->TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::COPY);
 444   }
 445
 446   return true;
 447 }
 448
 449 bool TextSelectionPopup::OnPasteButtonPressed(Toolkit::Button button)
 450 {
 451   if(mCallbackInterface)
 452   {
 453     mCallbackInterface->TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::PASTE);
 454   }
 455
 456   return true;
 457 }
 458
 459 bool TextSelectionPopup::OnSelectButtonPressed(Toolkit::Button button)
 460 {
 461   if(mCallbackInterface)
 462   {
 463     mCallbackInterface->TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::SELECT);
 464   }
 465
 466   return true;
 467 }
 468
 469 bool TextSelectionPopup::OnSelectAllButtonPressed(Toolkit::Button button)
 470 {
 471   if(mCallbackInterface)
 472   {
 473     mCallbackInterface->TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::SELECT_ALL);
 474   }
 475
 476   return true;
 477 }
 478
 479 bool TextSelectionPopup::OnClipboardButtonPressed(Toolkit::Button button)
 480 {
 481   if(mCallbackInterface)
 482   {
 483     mCallbackInterface->TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::CLIPBOARD);
 484   }
 485
 486   return true;
 487 }
 488
 489 void TextSelectionPopup::SetDimensionToCustomise(const PopupCustomisations& settingToCustomise, const Size& dimension)
 490 {
 491   switch(settingToCustomise)
 492   {
 493     case POPUP_MAXIMUM_SIZE:
 494     {
 495       mPopupMaxSize = dimension;
 496       if(mToolbar)
 497       {
 498         mToolbar.SetProperty(Toolkit::TextSelectionToolbar::Property::MAX_SIZE, dimension);
 499       }
 500       break;
 501     }
 502     case OPTION_MAXIMUM_SIZE:
 503     {
 504       mOptionMaxSize = dimension;
 505       // Option max size not currently currently supported
 506       break;
 507     }
 508     case OPTION_MINIMUM_SIZE:
 509     {
 510       mOptionMinSize = dimension;
 511       // Option min size not currently currently supported
 512       break;
 513     }
 514     case OPTION_DIVIDER_SIZE:
 515     {
 516       mOptionDividerSize = dimension;
 517       if(mToolbar)
 518       {
 519         // Resize Dividers not currently supported
 520       }
 521       break;
 522     }
 523   } // switch
 524 }
 525
 526 Size TextSelectionPopup::GetDimensionToCustomise(const PopupCustomisations& settingToCustomise) const
 527 {
 528   switch(settingToCustomise)
 529   {
 530     case POPUP_MAXIMUM_SIZE:
 531     {
 532       if(mToolbar)
 533       {
 534         return mToolbar.GetProperty(Toolkit::TextSelectionToolbar::Property::MAX_SIZE).Get<Vector2>();
 535       }
 536       else
 537       {
 538         return mPopupMaxSize;
 539       }
 540     }
 541     case OPTION_MAXIMUM_SIZE:
 542     {
 543       return mOptionMaxSize;
 544     }
 545     case OPTION_MINIMUM_SIZE:
 546     {
 547       return mOptionMinSize;
 548     }
 549     case OPTION_DIVIDER_SIZE:
 550     {
 551       return mOptionDividerSize;
 552     }
 553   } // switch
 554
 555   return Size::ZERO;
 556 }
 557
 558 void TextSelectionPopup::SetButtonImage(Toolkit::TextSelectionPopup::Buttons button, const std::string& image)
 559 {
 560   switch(button)
 561   {
 562     case Toolkit::TextSelectionPopup::CLIPBOARD:
 563     {
 564       mClipboardIconImage = image;
 565       break;
 566     }
 567     case Toolkit::TextSelectionPopup::CUT:
 568     {
 569       mCutIconImage = image;
 570       break;
 571     }
 572     case Toolkit::TextSelectionPopup::COPY:
 573     {
 574       mCopyIconImage = image;
 575       break;
 576     }
 577     case Toolkit::TextSelectionPopup::PASTE:
 578     {
 579       mPasteIconImage = image;
 580       break;
 581     }
 582     case Toolkit::TextSelectionPopup::SELECT:
 583     {
 584       mSelectIconImage = image;
 585       break;
 586     }
 587     case Toolkit::TextSelectionPopup::SELECT_ALL:
 588     {
 589       mSelectAllIconImage = image;
 590       break;
 591     }
 592     default:
 593     {
 594       DALI_ASSERT_DEBUG("TextSelectionPopup SetPopupImage Unknown Button");
 595     }
 596   } // switch
 597 }
 598
 599 const std::string& TextSelectionPopup::GetButtonImage(Toolkit::TextSelectionPopup::Buttons button) const
 600 {
 601   switch(button)
 602   {
 603     case Toolkit::TextSelectionPopup::CLIPBOARD:
 604     {
 605       return mClipboardIconImage;
 606       break;
 607     }
 608     case Toolkit::TextSelectionPopup::CUT:
 609     {
 610       return mCutIconImage;
 611       break;
 612     }
 613     case Toolkit::TextSelectionPopup::COPY:
 614     {
 615       return mCopyIconImage;
 616       break;
 617     }
 618     case Toolkit::TextSelectionPopup::PASTE:
 619     {
 620       return mPasteIconImage;
 621       break;
 622     }
 623     case Toolkit::TextSelectionPopup::SELECT:
 624     {
 625       return mSelectIconImage;
 626       break;
 627     }
 628     case Toolkit::TextSelectionPopup::SELECT_ALL:
 629     {
 630       return mSelectAllIconImage;
 631       break;
 632     }
 633     case Toolkit::TextSelectionPopup::NONE:
 634     {
 635       break;
 636     }
 637   } // switch
 638
 639   DALI_ASSERT_DEBUG("TextSelectionPopup GetPopupImage Unknown Button");
 640   static std::string empty;
 641   return empty;
 642 }
 643
 644 void TextSelectionPopup::SetPressedImage(const std::string& filename)
 645 {
 646   mPressedImage = filename;
 647 }
 648
 649 std::string TextSelectionPopup::GetPressedImage() const
 650 {
 651   return mPressedImage;
 652 }
 653
 654 void TextSelectionPopup::SetOptionDividerPadding(const Padding& padding)
 655 {
 656   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextSelectionPopup::SetOptionDividerPadding padding(%f,%f,%f,%f)\n", padding.left, padding.right, padding.top, padding.bottom);
 657   mOptionDividerPadding = Padding(padding.left, padding.right, padding.top, padding.bottom);
 658 }
 659
 660 Padding TextSelectionPopup::GetOptionDividerPadding() const
 661 {
 662   return mOptionDividerPadding;
 663 }
 664
 665 void TextSelectionPopup::CreateOrderedListOfPopupOptions()
 666 {
 667   mOrderListOfButtons.clear();
 668   mOrderListOfButtons.reserve(8u);
 669
 670   // Create button for each possible option using Option priority
 671   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::CUT, mCutOptionPriority, OPTION_CUT, POPUP_CUT_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::CUT)));
 672   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::COPY, mCopyOptionPriority, OPTION_COPY, POPUP_COPY_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::COPY)));
 673   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::PASTE, mPasteOptionPriority, OPTION_PASTE, POPUP_PASTE_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::PASTE)));
 674   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::SELECT, mSelectOptionPriority, OPTION_SELECT_WORD, POPUP_SELECT_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::SELECT)));
 675   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::SELECT_ALL, mSelectAllOptionPriority, OPTION_SELECT_ALL, POPUP_SELECT_ALL_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::SELECT_ALL)));
 676   mOrderListOfButtons.push_back(ButtonRequirement(Toolkit::TextSelectionPopup::CLIPBOARD, mClipboardOptionPriority, OPTION_CLIPBOARD, POPUP_CLIPBOARD_STRING, 0 != (mEnabledButtons & Toolkit::TextSelectionPopup::CLIPBOARD)));
 677
 678   // Sort the buttons according their priorities.
 679   std::sort(mOrderListOfButtons.begin(), mOrderListOfButtons.end(), TextSelectionPopup::ButtonPriorityCompare());
 680 }
 681
 682 void TextSelectionPopup::AddOption(const ButtonRequirement& button, bool showDivider, bool showIcons, bool showCaption)
 683 {
 684   // 1. Create a option.
 685   DALI_LOG_INFO(gLogFilter, Debug::General, "TextSelectionPopup::AddOption\n");
 686
 687   Toolkit::PushButton option = Toolkit::PushButton::New();
 688   option.SetProperty(Dali::Actor::Property::NAME, button.name);
 689   option.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
 690
 691   switch(button.id)
 692   {
 693     case Toolkit::TextSelectionPopup::CUT:
 694     {
 695       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnCutButtonPressed);
 696       break;
 697     }
 698     case Toolkit::TextSelectionPopup::COPY:
 699     {
 700       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnCopyButtonPressed);
 701       break;
 702     }
 703     case Toolkit::TextSelectionPopup::PASTE:
 704     {
 705       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnPasteButtonPressed);
 706       break;
 707     }
 708     case Toolkit::TextSelectionPopup::SELECT:
 709     {
 710       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnSelectButtonPressed);
 711       break;
 712     }
 713     case Toolkit::TextSelectionPopup::SELECT_ALL:
 714     {
 715       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnSelectAllButtonPressed);
 716       break;
 717     }
 718     case Toolkit::TextSelectionPopup::CLIPBOARD:
 719     {
 720       option.ClickedSignal().Connect(this, &TextSelectionPopup::OnClipboardButtonPressed);
 721       break;
 722     }
 723     case Toolkit::TextSelectionPopup::NONE:
 724     {
 725       // Nothing to do:
 726       break;
 727     }
 728   }
 729
 730   // 2. Set the options contents.
 731   if(showCaption)
 732   {
 733     // PushButton layout properties.
 734     option.SetProperty(Toolkit::PushButton::Property::LABEL_PADDING, Vector4(24.0f, 24.0f, 14.0f, 14.0f));
 735
 736     // Label properties.
 737     Property::Map buttonLabelProperties;
 738     buttonLabelProperties.Insert(Toolkit::TextVisual::Property::TEXT, button.caption);
 739     option.SetProperty(Toolkit::Button::Property::LABEL, buttonLabelProperties);
 740   }
 741   if(showIcons)
 742   {
 743     option.SetProperty(Toolkit::PushButton::Property::ICON_PADDING, Vector4(10.0f, 10.0f, 10.0f, 10.0f));
 744     option.SetProperty(Toolkit::DevelButton::Property::LABEL_RELATIVE_ALIGNMENT, "BOTTOM");
 745
 746     // TODO: This is temporarily disabled until the text-selection-popup image API is changed to strings.
 747     //option.SetProperty(  Toolkit::Button::Property::SELECTED_VISUAL, button.icon );
 748     //option.SetProperty(  Toolkit::Button::Property::UNSELECTED_VISUAL, button.icon );
 749   }
 750
 751   // 3. Set the normal option image (blank / Transparent).
 752   option.SetProperty(Toolkit::Button::Property::UNSELECTED_BACKGROUND_VISUAL, "");
 753
 754   // 4. Set the pressed option image.
 755   Property::Value selectedBackgroundValue(mPressedImage);
 756   if(mPressedImage.empty())
 757   {
 758     // The image can be blank, the color can be used in that case.
 759     selectedBackgroundValue = Property::Value{{Toolkit::Visual::Property::TYPE, Toolkit::Visual::COLOR},
 760                                               {Toolkit::ColorVisual::Property::MIX_COLOR, mPressedColor}};
 761   }
 762   option.SetProperty(Toolkit::Button::Property::SELECTED_BACKGROUND_VISUAL, selectedBackgroundValue);
 763   option.SetProperty(Toolkit::Control::Property::STYLE_NAME, TEXT_SELECTION_POPUP_BUTTON_STYLE_NAME);
 764
 765   // 5 Add option to tool bar
 766   mToolbar.AddOption(option);
 767
 768   // 6. Add the divider
 769   if(showDivider)
 770   {
 771     const Size    size(mOptionDividerSize.width, 0.0f); // Height FILL_TO_PARENT
 772     const Padding padding(mOptionDividerPadding);
 773
 774     Toolkit::Control divider = Toolkit::Control::New();
 775 #ifdef DECORATOR_DEBUG
 776     divider.SetProperty(Dali::Actor::Property::NAME, "Text's popup divider");
 777 #endif
 778     divider.SetProperty(Actor::Property::SIZE, size);
 779     divider.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::HEIGHT);
 780     divider.SetProperty(Actor::Property::PADDING, padding);
 781     divider.SetBackgroundColor(mDividerColor);
 782     mToolbar.AddDivider(divider);
 783   }
 784 }
 785
 786 std::size_t TextSelectionPopup::GetNumberOfEnabledOptions() const
 787 {
 788   std::size_t numberOfOptions = 0u;
 789   for(std::vector<ButtonRequirement>::const_iterator it = mOrderListOfButtons.begin(), endIt = mOrderListOfButtons.end(); (it != endIt); ++it)
 790   {
 791     const ButtonRequirement& button(*it);
 792     if(button.enabled)
 793     {
 794       ++numberOfOptions;
 795     }
 796   }
 797
 798   return numberOfOptions;
 799 }
 800
 801 void TextSelectionPopup::AddPopupOptionsToToolbar(bool showIcons, bool showCaptions)
 802 {
 803   DALI_LOG_INFO(gLogFilter, Debug::General, "TextSelectionPopup::AddPopupOptionsToToolbar\n");
 804
 805   CreateOrderedListOfPopupOptions();
 806
 807   mButtonsChanged = false;
 808   UnparentAndReset(mToolbar);
 809
 810   if(!mToolbar)
 811   {
 812     Actor self = Self();
 813     mToolbar   = Toolkit::TextSelectionToolbar::New();
 814     if(mPopupMaxSize != Vector2::ZERO) // If PopupMaxSize property set then apply to Toolbar. Toolbar currently is not retriving this from json
 815     {
 816       mToolbar.SetProperty(Toolkit::TextSelectionToolbar::Property::MAX_SIZE, mPopupMaxSize);
 817     }
 818     mToolbar.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 819 #ifdef DECORATOR_DEBUG
 820     mToolbar.SetProperty(Dali::Actor::Property::NAME, "TextSelectionToolbar");
 821 #endif
 822     self.Add(mToolbar);
 823   }
 824
 825   // Whether to mirror the list of buttons (for right to left languages)
 826   bool mirror = false;
 827 #if defined(__GLIBC__)
 828   char* idsLtr = GET_LOCALE_TEXT(IDS_LTR.c_str());
 829   if(NULL != idsLtr)
 830   {
 831     mirror = (0 == strcmp(idsLtr, RTL_DIRECTION.c_str()));
 832
 833     if(mirror)
 834     {
 835       std::reverse(mOrderListOfButtons.begin(), mOrderListOfButtons.end());
 836     }
 837   }
 838 #endif
 839
 840   // Iterate list of buttons and add active ones to Toolbar
 841   std::size_t numberOfOptionsRequired = GetNumberOfEnabledOptions();
 842   std::size_t numberOfOptionsAdded    = 0u;
 843   for(std::vector<ButtonRequirement>::const_iterator it = mOrderListOfButtons.begin(), endIt = mOrderListOfButtons.end(); (it != endIt); ++it)
 844   {
 845     const ButtonRequirement& button(*it);
 846     if(button.enabled)
 847     {
 848       numberOfOptionsAdded++;
 849       AddOption(button, (numberOfOptionsAdded < numberOfOptionsRequired), showIcons, showCaptions);
 850     }
 851   }
 852
 853   if(mirror)
 854   {
 855     mToolbar.ScrollTo(Vector2(mPopupMaxSize.x, 0.f));
 856   }
 857 }
 858
 859 void TextSelectionPopup::CreateBackgroundBorder(Property::Map& propertyMap)
 860 {
 861   // Removes previous image if necessary
 862   DevelControl::UnregisterVisual(*this, Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER);
 863
 864   if(!propertyMap.Empty())
 865   {
 866     Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual(propertyMap);
 867
 868     if(visual)
 869     {
 870       DevelControl::RegisterVisual(*this, Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER, visual, DepthIndex::CONTENT);
 871     }
 872   }
 873 }
 874
 875 TextSelectionPopup::TextSelectionPopup(TextSelectionPopupCallbackInterface* callbackInterface)
 876 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
 877   mToolbar(),
 878   mPopupMaxSize(),
 879   mOptionMaxSize(),
 880   mOptionMinSize(),
 881   mOptionDividerSize(),
 882   mOptionDividerPadding(),
 883   mEnabledButtons(Toolkit::TextSelectionPopup::NONE),
 884   mCallbackInterface(callbackInterface),
 885   mPressedColor(DEFAULT_OPTION_PRESSED_COLOR),
 886   mDividerColor(Color::WHITE),
 887   mIconColor(Color::WHITE),
 888   mSelectOptionPriority(1),
 889   mSelectAllOptionPriority(2),
 890   mCutOptionPriority(4),
 891   mCopyOptionPriority(3),
 892   mPasteOptionPriority(5),
 893   mClipboardOptionPriority(6),
 894   mFadeInDuration(0.0f),
 895   mFadeOutDuration(0.0f),
 896   mShowIcons(false),
 897   mShowCaptions(true),
 898   mPopupShowing(false),
 899   mButtonsChanged(false)
 900 {
 901 }
 902
 903 TextSelectionPopup::~TextSelectionPopup()
 904 {
 905 }
 906
 907 } // namespace Internal
 908
 909 } // namespace Toolkit
 910
 911 } // namespace Dali