dali-toolkit/internal/controls/text-controls/text-selection-popup-impl.cpp

   1 /*
   2  * Copyright (c) 2017 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 #include <libintl.h>
  23 #include <string.h>
  24 #include <cfloat>
  25 #include <dali/public-api/animation/animation.h>
  26 #include <dali/devel-api/images/nine-patch-image.h>
  27 #include <dali/public-api/images/resource-image.h>
  28 #include <dali/public-api/math/vector2.h>
  29 #include <dali/public-api/math/vector4.h>
  30 #include <dali/public-api/object/property-map.h>
  31 #include <dali/public-api/object/type-registry-helper.h>
  32 #include <dali/integration-api/debug.h>
  33
  34 // INTERNAL INCLUDES
  35 #include <dali-toolkit/public-api/controls/text-controls/text-label.h>
  36 #include <dali-toolkit/devel-api/controls/buttons/button-devel.h>
  37 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
  38 #include <dali-toolkit/devel-api/controls/control-devel.h>
  39 #include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup-callback-interface.h>
  40 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
  41 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  42 #include <dali-toolkit/internal/helpers/color-conversion.h>
  43 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  44
  45 namespace Dali
  46 {
  47
  48 namespace Toolkit
  49 {
  50
  51 namespace Internal
  52 {
  53
  54 namespace
  55 {
  56
  57 #define GET_LOCALE_TEXT(string) dgettext("dali-toolkit", string)
  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, "popupClipboardButtonImage", STRING, POPUP_CLIPBOARD_BUTTON_ICON_IMAGE )
 111 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupCutButtonImage", STRING, POPUP_CUT_BUTTON_ICON_IMAGE )
 112 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupCopyButtonImage", STRING, POPUP_COPY_BUTTON_ICON_IMAGE )
 113 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupPasteButtonImage", STRING, POPUP_PASTE_BUTTON_ICON_IMAGE )
 114 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupSelectButtonImage", STRING, POPUP_SELECT_BUTTON_ICON_IMAGE )
 115 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupSelectAllButtonImage", STRING, POPUP_SELECT_ALL_BUTTON_ICON_IMAGE )
 116 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupDividerColor", VECTOR4, POPUP_DIVIDER_COLOR )
 117 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupIconColor", VECTOR4, POPUP_ICON_COLOR )
 118 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupPressedColor", VECTOR4, POPUP_PRESSED_COLOR )
 119 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupPressedImage", STRING, POPUP_PRESSED_IMAGE )
 120 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupFadeInDuration", FLOAT, POPUP_FADE_IN_DURATION )
 121 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "popupFadeOutDuration", FLOAT, POPUP_FADE_OUT_DURATION )
 122 DALI_PROPERTY_REGISTRATION( Toolkit, TextSelectionPopup, "backgroundBorder", MAP, BACKGROUND_BORDER )
 123
 124 DALI_TYPE_REGISTRATION_END()
 125
 126 } // namespace
 127
 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::POPUP_CLIPBOARD_BUTTON_ICON_IMAGE:
 177       {
 178         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 179         impl.SetButtonImage( Toolkit::TextSelectionPopup::CLIPBOARD, image );
 180         break;
 181       }
 182       case Toolkit::TextSelectionPopup::Property::POPUP_CUT_BUTTON_ICON_IMAGE:
 183       {
 184         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 185         impl.SetButtonImage( Toolkit::TextSelectionPopup::CUT, image );
 186         break;
 187       }
 188       case Toolkit::TextSelectionPopup::Property::POPUP_COPY_BUTTON_ICON_IMAGE:
 189       {
 190         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 191         impl.SetButtonImage( Toolkit::TextSelectionPopup::COPY, image );
 192         break;
 193       }
 194       case Toolkit::TextSelectionPopup::Property::POPUP_PASTE_BUTTON_ICON_IMAGE:
 195       {
 196         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 197         impl.SetButtonImage( Toolkit::TextSelectionPopup::PASTE, image );
 198         break;
 199       }
 200       case Toolkit::TextSelectionPopup::Property::POPUP_SELECT_BUTTON_ICON_IMAGE:
 201       {
 202         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 203         impl.SetButtonImage( Toolkit::TextSelectionPopup::SELECT, image );
 204         break;
 205       }
 206       case Toolkit::TextSelectionPopup::Property::POPUP_SELECT_ALL_BUTTON_ICON_IMAGE:
 207       {
 208         ResourceImage image = ResourceImage::New( value.Get< std::string >() );
 209         impl.SetButtonImage( Toolkit::TextSelectionPopup::SELECT_ALL, image );
 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::POPUP_CLIPBOARD_BUTTON_ICON_IMAGE:
 285       {
 286         ResourceImage image = ResourceImage::DownCast( impl.GetButtonImage( Toolkit::TextSelectionPopup::CLIPBOARD ) );
 287         if( image )
 288         {
 289           value = image.GetUrl();
 290         }
 291         break;
 292       }
 293       case Toolkit::TextSelectionPopup::Property::POPUP_CUT_BUTTON_ICON_IMAGE:
 294       {
 295         ResourceImage image = ResourceImage::DownCast( impl.GetButtonImage( Toolkit::TextSelectionPopup::CUT ) );
 296         if( image )
 297         {
 298           value = image.GetUrl();
 299         }
 300         break;
 301       }
 302       case Toolkit::TextSelectionPopup::Property::POPUP_COPY_BUTTON_ICON_IMAGE:
 303       {
 304         ResourceImage image = ResourceImage::DownCast( impl.GetButtonImage( Toolkit::TextSelectionPopup::COPY ) );
 305         if( image )
 306         {
 307           value = image.GetUrl();
 308         }
 309         break;
 310       }
 311       case Toolkit::TextSelectionPopup::Property::POPUP_PASTE_BUTTON_ICON_IMAGE:
 312       {
 313         ResourceImage image = ResourceImage::DownCast( impl.GetButtonImage( Toolkit::TextSelectionPopup::PASTE ) );
 314         if( image )
 315         {
 316           value = image.GetUrl();
 317         }
 318         break;
 319       }
 320       case Toolkit::TextSelectionPopup::Property::POPUP_SELECT_BUTTON_ICON_IMAGE:
 321       {
 322         ResourceImage image = ResourceImage::DownCast( impl.GetButtonImage( Toolkit::TextSelectionPopup::SELECT ) );
 323         if( image )
 324         {
 325           value = image.GetUrl();
 326         }
 327         break;
 328       }
 329       case Toolkit::TextSelectionPopup::Property::POPUP_SELECT_ALL_BUTTON_ICON_IMAGE:
 330       {
 331         ResourceImage image = ResourceImage::DownCast( impl.GetButtonImage( Toolkit::TextSelectionPopup::SELECT_ALL ) );
 332         if( image )
 333         {
 334           value = image.GetUrl();
 335         }
 336         break;
 337       }
 338       case Toolkit::TextSelectionPopup::Property::POPUP_PRESSED_IMAGE:
 339       {
 340         value = impl.GetPressedImage();
 341         break;
 342       }
 343       case Toolkit::TextSelectionPopup::Property::POPUP_FADE_IN_DURATION:
 344       {
 345         value = impl.mFadeInDuration;
 346         break;
 347       }
 348       case Toolkit::TextSelectionPopup::Property::POPUP_FADE_OUT_DURATION:
 349       {
 350         value = impl.mFadeOutDuration;
 351         break;
 352       }
 353       case Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER:
 354       {
 355         Property::Map map;
 356         Toolkit::Visual::Base visual = DevelControl::GetVisual( impl, Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER );
 357         if( visual )
 358         {
 359           visual.CreatePropertyMap( map );
 360         }
 361         value = map;
 362         break;
 363       }
 364     } // switch
 365   }
 366   return value;
 367 }
 368
 369 void TextSelectionPopup::EnableButtons( Toolkit::TextSelectionPopup::Buttons buttonsToEnable )
 370 {
 371   mEnabledButtons = buttonsToEnable;
 372   mButtonsChanged = true;
 373 }
 374
 375 void TextSelectionPopup::RaiseAbove( Layer target )
 376 {
 377   if( mToolbar )
 378   {
 379     mToolbar.RaiseAbove( target );
 380   }
 381 }
 382
 383 void TextSelectionPopup::ShowPopup()
 384 {
 385   if( ( !mPopupShowing || mButtonsChanged ) &&
 386       ( Toolkit::TextSelectionPopup::NONE != mEnabledButtons ) )
 387   {
 388     Actor self = Self();
 389     AddPopupOptionsToToolbar( mShowIcons, mShowCaptions );
 390
 391     Animation animation = Animation::New( mFadeInDuration );
 392     animation.AnimateTo( Property(self, Actor::Property::COLOR_ALPHA), 1.0f  );
 393     animation.Play();
 394     mPopupShowing = true;
 395   }
 396 }
 397
 398 void TextSelectionPopup::HidePopup()
 399 {
 400   if ( mPopupShowing )
 401   {
 402     mPopupShowing = false;
 403     Actor self = Self();
 404     Animation animation = Animation::New( mFadeOutDuration );
 405     animation.AnimateTo( Property(self, Actor::Property::COLOR_ALPHA), 0.0f  );
 406     animation.FinishedSignal().Connect( this, &TextSelectionPopup::HideAnimationFinished );
 407     animation.Play();
 408   }
 409 }
 410
 411 void TextSelectionPopup::OnInitialize()
 412 {
 413   DALI_LOG_INFO( gLogFilter, Debug::General, "TextSelectionPopup::OnInitialize\n" );
 414   Actor self = Self();
 415   self.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::ALL_DIMENSIONS );
 416   self.SetProperty( Actor::Property::COLOR_ALPHA, 0.0f );
 417
 418   // The Popup Control background is a nine-patch image. We clip against this so the
 419   // contents are correctly clipped against the edges of the nine-patch.
 420   self.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
 421 }
 422
 423 void TextSelectionPopup::HideAnimationFinished( Animation& animation )
 424 {
 425   Actor self = Self();
 426   if ( !mPopupShowing ) // During the Hide/Fade animation there could be a call to Show the Popup again, mPopupShowing will be true in this case.
 427   {
 428     DALI_LOG_INFO( gLogFilter, Debug::General, "TextSelectionPopup::HideAnimationFinished\n" );
 429     UnparentAndReset( mToolbar );
 430   }
 431 }
 432
 433 bool TextSelectionPopup::OnCutButtonPressed( Toolkit::Button button )
 434 {
 435   if( mCallbackInterface )
 436   {
 437     mCallbackInterface->TextPopupButtonTouched( Toolkit::TextSelectionPopup::CUT );
 438   }
 439
 440   return true;
 441 }
 442
 443 bool TextSelectionPopup::OnCopyButtonPressed( Toolkit::Button button )
 444 {
 445   if( mCallbackInterface )
 446   {
 447     mCallbackInterface->TextPopupButtonTouched( Dali::Toolkit::TextSelectionPopup::COPY );
 448   }
 449
 450   return true;
 451 }
 452
 453 bool TextSelectionPopup::OnPasteButtonPressed( Toolkit::Button button )
 454 {
 455   if( mCallbackInterface )
 456   {
 457     mCallbackInterface->TextPopupButtonTouched( Dali::Toolkit::TextSelectionPopup::PASTE );
 458   }
 459
 460   return true;
 461 }
 462
 463 bool TextSelectionPopup::OnSelectButtonPressed( Toolkit::Button button )
 464 {
 465   if( mCallbackInterface )
 466   {
 467     mCallbackInterface->TextPopupButtonTouched( Dali::Toolkit::TextSelectionPopup::SELECT );
 468   }
 469
 470   return true;
 471 }
 472
 473 bool TextSelectionPopup::OnSelectAllButtonPressed( Toolkit::Button button )
 474 {
 475   if( mCallbackInterface )
 476   {
 477     mCallbackInterface->TextPopupButtonTouched( Dali::Toolkit::TextSelectionPopup::SELECT_ALL );
 478   }
 479
 480   return true;
 481 }
 482
 483 bool TextSelectionPopup::OnClipboardButtonPressed( Toolkit::Button button )
 484 {
 485   if( mCallbackInterface )
 486   {
 487     mCallbackInterface->TextPopupButtonTouched( Dali::Toolkit::TextSelectionPopup::CLIPBOARD );
 488   }
 489
 490   return true;
 491 }
 492
 493 void TextSelectionPopup::SetDimensionToCustomise( const PopupCustomisations& settingToCustomise, const Size& dimension )
 494 {
 495   switch( settingToCustomise )
 496   {
 497     case POPUP_MAXIMUM_SIZE :
 498     {
 499       mPopupMaxSize = dimension;
 500       if ( mToolbar )
 501       {
 502         mToolbar.SetProperty( Toolkit::TextSelectionToolbar::Property::MAX_SIZE, dimension );
 503       }
 504       break;
 505     }
 506     case OPTION_MAXIMUM_SIZE :
 507     {
 508       mOptionMaxSize = dimension;
 509       // Option max size not currently currently supported
 510       break;
 511     }
 512     case OPTION_MINIMUM_SIZE :
 513     {
 514       mOptionMinSize = dimension;
 515       // Option min size not currently currently supported
 516       break;
 517     }
 518     case OPTION_DIVIDER_SIZE :
 519     {
 520       mOptionDividerSize = dimension;
 521       if ( mToolbar )
 522       {
 523         // Resize Dividers not currently supported
 524       }
 525       break;
 526     }
 527   } // switch
 528 }
 529
 530 Size TextSelectionPopup::GetDimensionToCustomise( const PopupCustomisations& settingToCustomise )
 531 {
 532   switch( settingToCustomise )
 533   {
 534     case POPUP_MAXIMUM_SIZE :
 535     {
 536       if ( mToolbar )
 537       {
 538         return mToolbar.GetProperty( Toolkit::TextSelectionToolbar::Property::MAX_SIZE ).Get< Vector2 >();
 539       }
 540       else
 541       {
 542         return mPopupMaxSize;
 543       }
 544     }
 545     case OPTION_MAXIMUM_SIZE :
 546     {
 547       return mOptionMaxSize;
 548     }
 549     case OPTION_MINIMUM_SIZE :
 550     {
 551       return mOptionMinSize;
 552     }
 553     case OPTION_DIVIDER_SIZE :
 554     {
 555       return mOptionDividerSize;
 556     }
 557   } // switch
 558
 559   return Size::ZERO;
 560 }
 561
 562 void TextSelectionPopup::SetButtonImage( Toolkit::TextSelectionPopup::Buttons button, Dali::Image image )
 563 {
 564    switch ( button )
 565    {
 566    break;
 567    case Toolkit::TextSelectionPopup::CLIPBOARD:
 568    {
 569      mClipboardIconImage  = image;
 570    }
 571    break;
 572    case Toolkit::TextSelectionPopup::CUT :
 573    {
 574      mCutIconImage = image;
 575    }
 576    break;
 577    case Toolkit::TextSelectionPopup::COPY :
 578    {
 579      mCopyIconImage = image;
 580    }
 581    break;
 582    case Toolkit::TextSelectionPopup::PASTE :
 583    {
 584      mPasteIconImage = image;
 585    }
 586    break;
 587    case Toolkit::TextSelectionPopup::SELECT :
 588    {
 589      mSelectIconImage = image;
 590    }
 591    break;
 592    case Toolkit::TextSelectionPopup::SELECT_ALL :
 593    {
 594      mSelectAllIconImage = image;
 595    }
 596    break;
 597    default :
 598    {
 599      DALI_ASSERT_DEBUG( "TextSelectionPopup SetPopupImage Unknown Button" );
 600    }
 601    } // switch
 602 }
 603
 604 Dali::Image TextSelectionPopup::GetButtonImage( Toolkit::TextSelectionPopup::Buttons button )
 605 {
 606   switch ( button )
 607   {
 608   case Toolkit::TextSelectionPopup::CLIPBOARD :
 609   {
 610     return mClipboardIconImage;
 611   }
 612   break;
 613   case Toolkit::TextSelectionPopup::CUT :
 614   {
 615     return mCutIconImage;
 616   }
 617   break;
 618   case Toolkit::TextSelectionPopup::COPY :
 619   {
 620     return mCopyIconImage;
 621   }
 622   break;
 623   case Toolkit::TextSelectionPopup::PASTE :
 624   {
 625     return mPasteIconImage;
 626   }
 627   break;
 628   case Toolkit::TextSelectionPopup::SELECT :
 629   {
 630     return mSelectIconImage;
 631   }
 632   break;
 633   case Toolkit::TextSelectionPopup::SELECT_ALL :
 634   {
 635     return mSelectAllIconImage;
 636   }
 637   break;
 638   default :
 639   {
 640     DALI_ASSERT_DEBUG( "TextSelectionPopup GetPopupImage Unknown Button" );
 641   }
 642   } // switch
 643
 644   return Dali::Image();
 645 }
 646
 647 void TextSelectionPopup::SetPressedImage( const std::string& filename )
 648 {
 649   mPressedImage = filename;
 650 }
 651
 652 std::string TextSelectionPopup::GetPressedImage() const
 653 {
 654   return mPressedImage;
 655 }
 656
 657  void TextSelectionPopup::CreateOrderedListOfPopupOptions()
 658  {
 659    mOrderListOfButtons.clear();
 660    mOrderListOfButtons.reserve( 8u );
 661
 662    // Create button for each possible option using Option priority
 663    mOrderListOfButtons.push_back( ButtonRequirement( Toolkit::TextSelectionPopup::CUT, mCutOptionPriority, OPTION_CUT, POPUP_CUT_STRING , mCutIconImage, 0 != ( mEnabledButtons & Toolkit::TextSelectionPopup::CUT)  ) );
 664    mOrderListOfButtons.push_back( ButtonRequirement( Toolkit::TextSelectionPopup::COPY, mCopyOptionPriority, OPTION_COPY, POPUP_COPY_STRING, mCopyIconImage, 0 != ( mEnabledButtons & Toolkit::TextSelectionPopup::COPY)  ) );
 665    mOrderListOfButtons.push_back( ButtonRequirement( Toolkit::TextSelectionPopup::PASTE, mPasteOptionPriority, OPTION_PASTE, POPUP_PASTE_STRING, mPasteIconImage, 0 != ( mEnabledButtons & Toolkit::TextSelectionPopup::PASTE)  ) );
 666    mOrderListOfButtons.push_back( ButtonRequirement( Toolkit::TextSelectionPopup::SELECT, mSelectOptionPriority, OPTION_SELECT_WORD, POPUP_SELECT_STRING, mSelectIconImage, 0 != ( mEnabledButtons & Toolkit::TextSelectionPopup::SELECT)  ) );
 667    mOrderListOfButtons.push_back( ButtonRequirement( Toolkit::TextSelectionPopup::SELECT_ALL, mSelectAllOptionPriority, OPTION_SELECT_ALL, POPUP_SELECT_ALL_STRING, mSelectAllIconImage, 0 != ( mEnabledButtons & Toolkit::TextSelectionPopup::SELECT_ALL)  ) );
 668    mOrderListOfButtons.push_back( ButtonRequirement( Toolkit::TextSelectionPopup::CLIPBOARD, mClipboardOptionPriority, OPTION_CLIPBOARD, POPUP_CLIPBOARD_STRING, mClipboardIconImage, 0 != ( mEnabledButtons & Toolkit::TextSelectionPopup::CLIPBOARD)  ) );
 669
 670    // Sort the buttons according their priorities.
 671    std::sort( mOrderListOfButtons.begin(), mOrderListOfButtons.end(), TextSelectionPopup::ButtonPriorityCompare() );
 672  }
 673
 674  void TextSelectionPopup::AddOption( const ButtonRequirement& button, bool showDivider, bool showIcons, bool showCaption  )
 675  {
 676    // 1. Create a option.
 677    DALI_LOG_INFO( gLogFilter, Debug::General, "TextSelectionPopup::AddOption\n" );
 678
 679    Toolkit::PushButton option = Toolkit::PushButton::New();
 680    option.SetName( button.name );
 681    option.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
 682
 683    switch( button.id )
 684    {
 685      case Toolkit::TextSelectionPopup::CUT:
 686      {
 687        option.ClickedSignal().Connect( this, &TextSelectionPopup::OnCutButtonPressed );
 688        break;
 689      }
 690      case Toolkit::TextSelectionPopup::COPY:
 691      {
 692        option.ClickedSignal().Connect( this, &TextSelectionPopup::OnCopyButtonPressed );
 693        break;
 694      }
 695      case Toolkit::TextSelectionPopup::PASTE:
 696      {
 697        option.ClickedSignal().Connect( this, &TextSelectionPopup::OnPasteButtonPressed );
 698        break;
 699      }
 700      case Toolkit::TextSelectionPopup::SELECT:
 701      {
 702        option.ClickedSignal().Connect( this, &TextSelectionPopup::OnSelectButtonPressed );
 703        break;
 704      }
 705      case Toolkit::TextSelectionPopup::SELECT_ALL:
 706      {
 707        option.ClickedSignal().Connect( this, &TextSelectionPopup::OnSelectAllButtonPressed );
 708        break;
 709      }
 710      case Toolkit::TextSelectionPopup::CLIPBOARD:
 711      {
 712        option.ClickedSignal().Connect( this, &TextSelectionPopup::OnClipboardButtonPressed );
 713        break;
 714      }
 715      case Toolkit::TextSelectionPopup::NONE:
 716      {
 717        // Nothing to do:
 718        break;
 719      }
 720    }
 721
 722    // 2. Set the options contents.
 723    if( showCaption )
 724    {
 725      // PushButton layout properties.
 726      option.SetProperty( Toolkit::PushButton::Property::LABEL_PADDING, Vector4( 24.0f, 24.0f, 14.0f, 14.0f ) );
 727
 728      // Label properties.
 729      Property::Map buttonLabelProperties;
 730      buttonLabelProperties.Insert( Toolkit::TextVisual::Property::TEXT, button.caption );
 731      option.SetProperty( Toolkit::Button::Property::LABEL, buttonLabelProperties );
 732    }
 733    if( showIcons )
 734    {
 735      option.SetProperty( Toolkit::PushButton::Property::ICON_PADDING, Vector4( 10.0f, 10.0f, 10.0f, 10.0f ) );
 736      option.SetProperty( Toolkit::PushButton::Property::ICON_ALIGNMENT, "TOP" );
 737
 738      // TODO: This is temporarily disabled until the text-selection-popup image API is changed to strings.
 739      //option.SetProperty( Toolkit::PushButton::Property::SELECTED_ICON, button.icon );
 740      //option.SetProperty( Toolkit::PushButton::Property::UNSELECTED_ICON, button.icon );
 741    }
 742
 743    // 3. Set the normal option image (blank / Transparent).
 744    option.SetProperty( Toolkit::DevelButton::Property::UNSELECTED_BACKGROUND_VISUAL, "" );
 745
 746    // 4. Set the pressed option image.
 747    // The image can be blank, the color can be used regardless.
 748    option.SetProperty( Toolkit::DevelButton::Property::SELECTED_BACKGROUND_VISUAL, mPressedImage );
 749    option.SetProperty( Toolkit::Button::Property::SELECTED_COLOR, mPressedColor );
 750    option.SetProperty( Toolkit::Control::Property::STYLE_NAME, TEXT_SELECTION_POPUP_BUTTON_STYLE_NAME );
 751
 752    // 5 Add option to tool bar
 753    mToolbar.AddOption( option );
 754
 755    // 6. Add the divider
 756    if( showDivider )
 757    {
 758      const Size size( mOptionDividerSize.width, 0.0f ); // Height FILL_TO_PARENT
 759
 760      Toolkit::Control divider = Toolkit::Control::New();
 761 #ifdef DECORATOR_DEBUG
 762      divider.SetName("Text's popup divider");
 763 #endif
 764      divider.SetSize( size );
 765      divider.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::HEIGHT );
 766      divider.SetBackgroundColor( mDividerColor  );
 767      mToolbar.AddDivider( divider );
 768    }
 769  }
 770
 771  std::size_t TextSelectionPopup::GetNumberOfEnabledOptions()
 772  {
 773    std::size_t numberOfOptions = 0u;
 774    for( std::vector<ButtonRequirement>::const_iterator it = mOrderListOfButtons.begin(), endIt = mOrderListOfButtons.end(); ( it != endIt ); ++it )
 775    {
 776      const ButtonRequirement& button( *it );
 777      if( button.enabled )
 778      {
 779        ++numberOfOptions;
 780      }
 781    }
 782
 783    return numberOfOptions;
 784  }
 785
 786  void TextSelectionPopup::AddPopupOptionsToToolbar( bool showIcons, bool showCaptions )
 787  {
 788    DALI_LOG_INFO( gLogFilter, Debug::General, "TextSelectionPopup::AddPopupOptionsToToolbar\n" );
 789
 790    CreateOrderedListOfPopupOptions();
 791
 792    mButtonsChanged = false;
 793    UnparentAndReset( mToolbar);
 794
 795    if( !mToolbar )
 796    {
 797      Actor self = Self();
 798      mToolbar = Toolkit::TextSelectionToolbar::New();
 799      if ( mPopupMaxSize != Vector2::ZERO ) // If PopupMaxSize property set then apply to Toolbar. Toolbar currently is not retriving this from json
 800      {
 801        mToolbar.SetProperty( Toolkit::TextSelectionToolbar::Property::MAX_SIZE, mPopupMaxSize );
 802      }
 803      mToolbar.SetParentOrigin( ParentOrigin::CENTER );
 804 #ifdef DECORATOR_DEBUG
 805      mToolbar.SetName("TextSelectionToolbar");
 806 #endif
 807      self.Add( mToolbar );
 808    }
 809
 810    // Whether to mirror the list of buttons (for right to left languages)
 811    bool mirror = false;
 812    char* idsLtr = GET_LOCALE_TEXT( IDS_LTR.c_str() );
 813    if( NULL != idsLtr )
 814    {
 815      mirror = ( 0 == strcmp( idsLtr, RTL_DIRECTION.c_str() ) );
 816
 817      if( mirror )
 818      {
 819        std::reverse( mOrderListOfButtons.begin(), mOrderListOfButtons.end() );
 820      }
 821    }
 822
 823    // Iterate list of buttons and add active ones to Toolbar
 824    std::size_t numberOfOptionsRequired =  GetNumberOfEnabledOptions();
 825    std::size_t numberOfOptionsAdded = 0u;
 826    for( std::vector<ButtonRequirement>::const_iterator it = mOrderListOfButtons.begin(), endIt = mOrderListOfButtons.end(); ( it != endIt ); ++it )
 827    {
 828      const ButtonRequirement& button( *it );
 829      if ( button.enabled )
 830      {
 831        numberOfOptionsAdded++;
 832        AddOption(  button, ( numberOfOptionsAdded < numberOfOptionsRequired ) , showIcons, showCaptions );
 833      }
 834    }
 835
 836    if( mirror )
 837    {
 838      mToolbar.ScrollTo( Vector2( mPopupMaxSize.x, 0.f ) );
 839    }
 840  }
 841
 842 void TextSelectionPopup::CreateBackgroundBorder( Property::Map& propertyMap )
 843 {
 844   // Removes previous image if necessary
 845   DevelControl::UnregisterVisual( *this, Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER );
 846
 847   if( ! propertyMap.Empty() )
 848   {
 849     Toolkit::Visual::Base visual = Toolkit::VisualFactory::Get().CreateVisual( propertyMap );
 850
 851     if( visual )
 852     {
 853       DevelControl::RegisterVisual( *this, Toolkit::TextSelectionPopup::Property::BACKGROUND_BORDER, visual );
 854       visual.SetDepthIndex( DepthIndex::CONTENT );
 855     }
 856   }
 857 }
 858
 859 TextSelectionPopup::TextSelectionPopup( TextSelectionPopupCallbackInterface* callbackInterface )
 860 : Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
 861   mToolbar(),
 862   mPopupMaxSize(),
 863   mOptionMaxSize(),
 864   mOptionMinSize(),
 865   mOptionDividerSize(),
 866   mEnabledButtons( Toolkit::TextSelectionPopup::NONE ),
 867   mCallbackInterface( callbackInterface ),
 868   mPressedColor( DEFAULT_OPTION_PRESSED_COLOR ),
 869   mDividerColor( Color::WHITE ),
 870   mIconColor( Color::WHITE ),
 871   mSelectOptionPriority( 1 ),
 872   mSelectAllOptionPriority ( 2 ),
 873   mCutOptionPriority ( 4 ),
 874   mCopyOptionPriority ( 3 ),
 875   mPasteOptionPriority ( 5 ),
 876   mClipboardOptionPriority( 6 ),
 877   mFadeInDuration(0.0f),
 878   mFadeOutDuration(0.0f),
 879   mShowIcons( false ),
 880   mShowCaptions( true ),
 881   mPopupShowing( false ),
 882   mButtonsChanged( false )
 883 {
 884 }
 885
 886 TextSelectionPopup::~TextSelectionPopup()
 887 {
 888 }
 889
 890
 891 } // namespace Internal
 892
 893 } // namespace Toolkit
 894
 895 } // namespace Dali