Move Clipboard to TextClipboard

We plan to create a new Clipboard class and
remove the dependency on Text and the legacy clipboard.

Change-Id: I87eeb622e4ea524d5c2d9b38c5a16e958b89c52c
Signed-off-by: Bowon Ryu <bowon.ryu@samsung.com>

diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Controller.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Controller.cpp
index a1e3c6e..dd5ec2f 100644 (file)
--- a/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Controller.cpp
+++ b/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Controller.cpp
@@ -45,7 +45,7 @@ const char* const OPTION_CLIPBOARD("optionClipboard");    // "Clipboard" popup o
 const Size CONTROL_SIZE(300.f, 60.f);
 
 std::string gClipboardText;
-void        ContentSelectedCallback(ClipboardEventNotifier& notifier)
+void        ContentSelectedCallback(TextClipboardEventNotifier& notifier)
 {
   gClipboardText = notifier.GetContent();
 }
@@ -547,7 +547,7 @@ int UtcDaliTextControllerTextPopupButtonTouched(void)
   controller->GetText(text);
   DALI_TEST_CHECK(text.empty());
 
-  ClipboardEventNotifier clipboardEventNotifier = ClipboardEventNotifier::Get();
+  TextClipboardEventNotifier clipboardEventNotifier = TextClipboardEventNotifier::Get();
   clipboardEventNotifier.ContentSelectedSignal().Connect(&ContentSelectedCallback);
 
   // Paste the text.

diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
index cbfe93e..cfc2a96 100644 (file)
--- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
+++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
@@ -30,15 +30,15 @@ namespace Internal
 namespace Adaptor
 {
 
-class ClipboardEventNotifier : public Dali::BaseObject
+class TextClipboardEventNotifier : public Dali::BaseObject
 {
 public:
 
-  typedef Dali::ClipboardEventNotifier::ClipboardEventSignalType ClipboardEventSignalType;
+  typedef Dali::TextClipboardEventNotifier::TextClipboardEventSignalType TextClipboardEventSignalType;
 
   // Creation
-  static Dali::ClipboardEventNotifier New();
-  static Dali::ClipboardEventNotifier Get();
+  static Dali::TextClipboardEventNotifier New();
+  static Dali::TextClipboardEventNotifier Get();
 
   // Public API
   const std::string& GetContent() const;
@@ -47,97 +47,97 @@ public:
   void EmitContentSelectedSignal();
 
   // Signals
-  ClipboardEventSignalType& ContentSelectedSignal()
+  TextClipboardEventSignalType& ContentSelectedSignal()
   {
     return mContentSelectedSignal;
   }
 
 private:
   // Construction & Destruction
-  ClipboardEventNotifier();
-  virtual ~ClipboardEventNotifier();
+  TextClipboardEventNotifier();
+  virtual ~TextClipboardEventNotifier();
 
   // Undefined
-  ClipboardEventNotifier( const ClipboardEventNotifier& );
-  ClipboardEventNotifier& operator=( ClipboardEventNotifier& );
+  TextClipboardEventNotifier( const TextClipboardEventNotifier& );
+  TextClipboardEventNotifier& operator=( TextClipboardEventNotifier& );
 
 private:
 
   std::string mContent;    ///< The current selected content.
-  ClipboardEventSignalType mContentSelectedSignal;
+  TextClipboardEventSignalType mContentSelectedSignal;
 
-  static Dali::ClipboardEventNotifier mToolkitClipboardEventNotifier;
+  static Dali::TextClipboardEventNotifier mToolkitClipboardEventNotifier;
 
 public:
 
   // Helpers for public-api forwarding methods
 
-  inline static Internal::Adaptor::ClipboardEventNotifier& GetImplementation(Dali::ClipboardEventNotifier& detector)
+  inline static Internal::Adaptor::TextClipboardEventNotifier& GetImplementation(Dali::TextClipboardEventNotifier& detector)
   {
-    DALI_ASSERT_ALWAYS( detector && "ClipboardEventNotifier handle is empty" );
+    DALI_ASSERT_ALWAYS( detector && "TextClipboardEventNotifier handle is empty" );
 
     BaseObject& handle = detector.GetBaseObject();
 
-    return static_cast<Internal::Adaptor::ClipboardEventNotifier&>(handle);
+    return static_cast<Internal::Adaptor::TextClipboardEventNotifier&>(handle);
   }
 
-  inline static const Internal::Adaptor::ClipboardEventNotifier& GetImplementation(const Dali::ClipboardEventNotifier& detector)
+  inline static const Internal::Adaptor::TextClipboardEventNotifier& GetImplementation(const Dali::TextClipboardEventNotifier& detector)
   {
-    DALI_ASSERT_ALWAYS( detector && "ClipboardEventNotifier handle is empty" );
+    DALI_ASSERT_ALWAYS( detector && "TextClipboardEventNotifier handle is empty" );
 
     const BaseObject& handle = detector.GetBaseObject();
 
-    return static_cast<const Internal::Adaptor::ClipboardEventNotifier&>(handle);
+    return static_cast<const Internal::Adaptor::TextClipboardEventNotifier&>(handle);
   }
 
 };
 
-Dali::ClipboardEventNotifier ClipboardEventNotifier::mToolkitClipboardEventNotifier;
+Dali::TextClipboardEventNotifier TextClipboardEventNotifier::mToolkitClipboardEventNotifier;
 
-Dali::ClipboardEventNotifier ClipboardEventNotifier::New()
+Dali::TextClipboardEventNotifier TextClipboardEventNotifier::New()
 {
   return Get();
 }
 
-Dali::ClipboardEventNotifier ClipboardEventNotifier::Get()
+Dali::TextClipboardEventNotifier TextClipboardEventNotifier::Get()
 {
   if ( !mToolkitClipboardEventNotifier )
   {
-    mToolkitClipboardEventNotifier = Dali::ClipboardEventNotifier( new ClipboardEventNotifier );
+    mToolkitClipboardEventNotifier = Dali::TextClipboardEventNotifier( new TextClipboardEventNotifier );
   }
   return mToolkitClipboardEventNotifier;
 }
 
-const std::string& ClipboardEventNotifier::GetContent() const
+const std::string& TextClipboardEventNotifier::GetContent() const
 {
   return mContent;
 }
 
-void ClipboardEventNotifier::SetContent( const std::string& content )
+void TextClipboardEventNotifier::SetContent( const std::string& content )
 {
   mContent = content;
 }
 
-void ClipboardEventNotifier::ClearContent()
+void TextClipboardEventNotifier::ClearContent()
 {
   mContent.clear();
 }
 
-void ClipboardEventNotifier::EmitContentSelectedSignal()
+void TextClipboardEventNotifier::EmitContentSelectedSignal()
 {
   if ( !mContentSelectedSignal.Empty() )
   {
-    Dali::ClipboardEventNotifier handle( this );
+    Dali::TextClipboardEventNotifier handle( this );
     mContentSelectedSignal.Emit( handle );
   }
 }
 
-ClipboardEventNotifier::ClipboardEventNotifier()
+TextClipboardEventNotifier::TextClipboardEventNotifier()
 : mContent()
 {
 }
 
-ClipboardEventNotifier::~ClipboardEventNotifier()
+TextClipboardEventNotifier::~TextClipboardEventNotifier()
 {
 }
 
@@ -146,45 +146,45 @@ ClipboardEventNotifier::~ClipboardEventNotifier()
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ClipboardEventNotifier::ClipboardEventNotifier()
+TextClipboardEventNotifier::TextClipboardEventNotifier()
 {
 }
 
-ClipboardEventNotifier ClipboardEventNotifier::Get()
+TextClipboardEventNotifier TextClipboardEventNotifier::Get()
 {
-  return Internal::Adaptor::ClipboardEventNotifier::Get();
+  return Internal::Adaptor::TextClipboardEventNotifier::Get();
 }
 
-ClipboardEventNotifier::~ClipboardEventNotifier()
+TextClipboardEventNotifier::~TextClipboardEventNotifier()
 {
 }
 
-const std::string& ClipboardEventNotifier::GetContent() const
+const std::string& TextClipboardEventNotifier::GetContent() const
 {
-  return Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).GetContent();
+  return Internal::Adaptor::TextClipboardEventNotifier::GetImplementation(*this).GetContent();
 }
 
-void ClipboardEventNotifier::SetContent( const std::string& content )
+void TextClipboardEventNotifier::SetContent( const std::string& content )
 {
-  Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).SetContent(content);
+  Internal::Adaptor::TextClipboardEventNotifier::GetImplementation(*this).SetContent(content);
 }
 
-void ClipboardEventNotifier::ClearContent()
+void TextClipboardEventNotifier::ClearContent()
 {
-  Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).ClearContent();
+  Internal::Adaptor::TextClipboardEventNotifier::GetImplementation(*this).ClearContent();
 }
 
-void ClipboardEventNotifier::EmitContentSelectedSignal()
+void TextClipboardEventNotifier::EmitContentSelectedSignal()
 {
-  Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).EmitContentSelectedSignal();
+  Internal::Adaptor::TextClipboardEventNotifier::GetImplementation(*this).EmitContentSelectedSignal();
 }
 
-ClipboardEventNotifier::ClipboardEventSignalType& ClipboardEventNotifier::ContentSelectedSignal()
+TextClipboardEventNotifier::TextClipboardEventSignalType& TextClipboardEventNotifier::ContentSelectedSignal()
 {
-  return Internal::Adaptor::ClipboardEventNotifier::GetImplementation(*this).ContentSelectedSignal();
+  return Internal::Adaptor::TextClipboardEventNotifier::GetImplementation(*this).ContentSelectedSignal();
 }
 
-ClipboardEventNotifier::ClipboardEventNotifier( Internal::Adaptor::ClipboardEventNotifier* notifier )
+TextClipboardEventNotifier::TextClipboardEventNotifier( Internal::Adaptor::TextClipboardEventNotifier* notifier )
 : BaseHandle( notifier )
 {
 }

diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.h
index 282a0c0..b2aabe4 100644 (file)
--- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.h
+++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.h
@@ -22,7 +22,7 @@
 #include <string>
 
 // PUBLIC INCLUDES
-#define DALI_CLIPBOARD_EVENT_NOTIFIER_H
+#define DALI_TEXT_CLIPBOARD_EVENT_NOTIFIER_H
 #include <dali/public-api/object/base-handle.h>
 #include <dali/public-api/signals/dali-signal.h>
 
@@ -34,27 +34,27 @@ namespace Internal
 {
 namespace Adaptor
 {
-class ClipboardEventNotifier;
+class TextClipboardEventNotifier;
 }
 }
 
-class ClipboardEventNotifier : public BaseHandle
+class TextClipboardEventNotifier : public BaseHandle
 {
 public:
-  typedef Signal< void ( ClipboardEventNotifier& ) > ClipboardEventSignalType;
+  typedef Signal< void ( TextClipboardEventNotifier& ) > TextClipboardEventSignalType;
 
-  ClipboardEventNotifier();
-  static ClipboardEventNotifier Get();
-  ~ClipboardEventNotifier();
+  TextClipboardEventNotifier();
+  static TextClipboardEventNotifier Get();
+  ~TextClipboardEventNotifier();
 
   const std::string& GetContent() const;
   void SetContent( const std::string& content );
   void ClearContent();
 
   void EmitContentSelectedSignal();
-  ClipboardEventSignalType& ContentSelectedSignal();
+  TextClipboardEventSignalType& ContentSelectedSignal();
 
-  ClipboardEventNotifier( Internal::Adaptor::ClipboardEventNotifier* notifier );
+  TextClipboardEventNotifier( Internal::Adaptor::TextClipboardEventNotifier* notifier );
 };
 
 } // namespace Dali

diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp
index 15c74ae..177dc95 100644 (file)
--- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp
+++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp
@@ -19,7 +19,7 @@
 
 // EXTERNAL INCLUDES
 #include <dali/public-api/object/base-object.h>
-#include <dali/devel-api/adaptor-framework/clipboard-event-notifier.h>
+#include <dali/devel-api/adaptor-framework/text-clipboard-event-notifier.h>
 
 namespace Dali
 {
@@ -34,91 +34,91 @@ namespace Adaptor
  * Implementation of the Clip Board
  */
 
-class Clipboard :  public Dali::BaseObject
+class TextClipboard :  public Dali::BaseObject
 {
 public:
 
   /**
-   * @copydoc Dali::ClipboardEventNotifier::Get()
+   * @copydoc Dali::TextClipboardEventNotifier::Get()
    */
-  static Dali::Clipboard Get();
+  static Dali::TextClipboard Get();
 
   /**
    * Constructor
    * @param[in] ecoreXwin, The window is created by application.
    */
-  Clipboard(/*Ecore_X_Window ecoreXwin*/);
-  virtual ~Clipboard();
+  TextClipboard(/*Ecore_X_Window ecoreXwin*/);
+  virtual ~TextClipboard();
 
   /**
-   * @copydoc Dali::Clipboard::IsAvailable()
+   * @copydoc Dali::TextClipboard::IsAvailable()
    */
   static bool IsAvailable();
 
   /**
-   * @copydoc Dali::Clipboard::SetItem()
+   * @copydoc Dali::TextClipboard::SetItem()
    */
   bool SetItem(const std::string &itemData);
 
   /**
-   * @copydoc Dali::Clipboard::RequestItem()
+   * @copydoc Dali::TextClipboard::RequestItem()
    */
   void RequestItem();
 
   /**
-   * @copydoc Dali::Clipboard::NumberOfClipboardItems()
+   * @copydoc Dali::TextClipboard::NumberOfClipboardItems()
    */
   unsigned int NumberOfItems();
 
   /**
-   * @copydoc Dali::Clipboard::ShowClipboard()
+   * @copydoc Dali::TextClipboard::ShowClipboard()
    */
   void ShowClipboard();
 
   /**
-   * @copydoc Dali::Clipboard::HideClipboard()
+   * @copydoc Dali::TextClipboard::HideClipboard()
    */
   void HideClipboard();
 
   /**
-  * @copydoc Dali::Clipboard::IsVisible()
+  * @copydoc Dali::TextClipboard::IsVisible()
   */
   bool IsVisible() const;
 
 private:
-  Clipboard( const Clipboard& );
-  Clipboard& operator=( Clipboard& );
+  TextClipboard( const TextClipboard& );
+  TextClipboard& operator=( TextClipboard& );
 
-  static Dali::Clipboard mToolkitClipboard;
+  static Dali::TextClipboard mToolkitClipboard;
   bool mVisible;
   std::string mItem;
   int mCount;
-}; // class clipboard
+}; // class TextClipboard
 
 
-Dali::Clipboard Dali::Internal::Adaptor::Clipboard::mToolkitClipboard;
+Dali::TextClipboard Dali::Internal::Adaptor::TextClipboard::mToolkitClipboard;
 
 
-Clipboard::Clipboard()
+TextClipboard::TextClipboard()
 {
   mVisible = false;
   mCount = 0;
 }
 
-Clipboard::~Clipboard()
+TextClipboard::~TextClipboard()
 {
 }
 
-Dali::Clipboard Clipboard::Get()
+Dali::TextClipboard TextClipboard::Get()
 {
   if( ! mToolkitClipboard )
   {
-    mToolkitClipboard = Dali::Clipboard( new Dali::Internal::Adaptor::Clipboard() );
+    mToolkitClipboard = Dali::TextClipboard( new Dali::Internal::Adaptor::TextClipboard() );
   }
   return mToolkitClipboard;
 }
 
-bool Clipboard::IsAvailable()
+bool TextClipboard::IsAvailable()
 {
   if(mToolkitClipboard)
   {
@@ -127,16 +127,16 @@ bool Clipboard::IsAvailable()
   return false;
 }
 
-bool Clipboard::SetItem(const std::string &itemData )
+bool TextClipboard::SetItem(const std::string &itemData )
 {
   mItem = itemData;
   mCount = 1;
   return true;
 }
 
-void Clipboard::RequestItem()
+void TextClipboard::RequestItem()
 {
-  Dali::ClipboardEventNotifier clipboardEventNotifier(Dali::ClipboardEventNotifier::Get());
+  Dali::TextClipboardEventNotifier clipboardEventNotifier(Dali::TextClipboardEventNotifier::Get());
   if ( clipboardEventNotifier )
   {
     clipboardEventNotifier.SetContent( mItem );
@@ -144,22 +144,22 @@ void Clipboard::RequestItem()
   }
 }
 
-unsigned int Clipboard::NumberOfItems()
+unsigned int TextClipboard::NumberOfItems()
 {
   return mCount;
 }
 
-void Clipboard::ShowClipboard()
+void TextClipboard::ShowClipboard()
 {
   mVisible = true;
 }
 
-void Clipboard::HideClipboard()
+void TextClipboard::HideClipboard()
 {
   mVisible = false;
 }
 
-bool Clipboard::IsVisible() const
+bool TextClipboard::IsVisible() const
 {
   return mVisible;
 }
@@ -169,64 +169,64 @@ bool Clipboard::IsVisible() const
 } // namespace Internal
 
 
-inline static Internal::Adaptor::Clipboard& GetImplementation(Dali::Clipboard& clipboard)
+inline static Internal::Adaptor::TextClipboard& GetImplementation(Dali::TextClipboard& clipboard)
 {
   // Bypass any passed in clipboard handle - it probably won't be initialized
-  Dali::Clipboard theClipboard = Dali::Clipboard::Get();
+  Dali::TextClipboard theClipboard = Dali::TextClipboard::Get();
   BaseObject& object = theClipboard.GetBaseObject();
-  return static_cast<Internal::Adaptor::Clipboard&>(object);
+  return static_cast<Internal::Adaptor::TextClipboard&>(object);
 }
 
-inline static const  Internal::Adaptor::Clipboard& GetImplementation(const Dali::Clipboard& clipboard)
+inline static const  Internal::Adaptor::TextClipboard& GetImplementation(const Dali::TextClipboard& clipboard)
 {
   // Bypass any passed in clipboard handle - it probably won't be initialized
-  Dali::Clipboard theClipboard = Dali::Clipboard::Get();
+  Dali::TextClipboard theClipboard = Dali::TextClipboard::Get();
   const BaseObject& object = theClipboard.GetBaseObject();
-  return static_cast<const Internal::Adaptor::Clipboard&>(object);
+  return static_cast<const Internal::Adaptor::TextClipboard&>(object);
 }
 
 
-Clipboard::Clipboard()
+TextClipboard::TextClipboard()
 {
 }
-Clipboard::~Clipboard()
+TextClipboard::~TextClipboard()
 {
 }
-Clipboard::Clipboard(Internal::Adaptor::Clipboard *impl)
+TextClipboard::TextClipboard(Internal::Adaptor::TextClipboard *impl)
   : BaseHandle(impl)
 {
 }
 
-Clipboard Clipboard::Get()
+TextClipboard TextClipboard::Get()
 {
-  return Internal::Adaptor::Clipboard::Get();
+  return Internal::Adaptor::TextClipboard::Get();
 }
-bool Clipboard::SetItem( const std::string &itemData)
+bool TextClipboard::SetItem( const std::string &itemData)
 {
   return GetImplementation(*this).SetItem( itemData );
 }
 
-void Clipboard::RequestItem()
+void TextClipboard::RequestItem()
 {
   GetImplementation(*this).RequestItem();
 }
 
-unsigned int Clipboard::NumberOfItems()
+unsigned int TextClipboard::NumberOfItems()
 {
   return GetImplementation(*this).NumberOfItems();
 }
 
-void Clipboard::ShowClipboard()
+void TextClipboard::ShowClipboard()
 {
   GetImplementation(*this).ShowClipboard();
 }
 
-void Clipboard::HideClipboard()
+void TextClipboard::HideClipboard()
 {
   GetImplementation(*this).HideClipboard();
 }
 
-bool Clipboard::IsVisible() const
+bool TextClipboard::IsVisible() const
 {
   return GetImplementation(*this).IsVisible();
 }

diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.h
index d3d684d..5757cff 100644 (file)
--- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.h
+++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.h
@@ -1,5 +1,5 @@
-#ifndef  TOOLKIT_CLIPBOARD_H
-#define  TOOLKIT_CLIPBOARD_H
+#ifndef  TOOLKIT_TEXT_CLIPBOARD_H
+#define  TOOLKIT_TEXT_CLIPBOARD_H
 
 /*
  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
@@ -18,7 +18,7 @@
  *
  */
 
-#define DALI_CLIPBOARD_H
+#define DALI_TEXT_CLIPBOARD_H
 
 // EXTERNAL INCLUDES
 #include <dali/public-api/math/rect.h>
@@ -32,7 +32,7 @@ namespace Internal DALI_INTERNAL
 
 namespace Adaptor
 {
-class Clipboard;
+class TextClipboard;
 }
 }
 
@@ -40,31 +40,31 @@ class Clipboard;
  * The Clipboard can operate using various funtion.
  * Clipboard can manage it's item and set show / hide status.
  */
-class Clipboard : public BaseHandle
+class TextClipboard : public BaseHandle
 {
 public:
   /**
    * Create an uninitialized Clipboard;
    *  this can be initialized with one of the derived Clipboard' New() methods
    */
-  Clipboard();
+  TextClipboard();
 
   /**
    * Non virtual destructor.
    */
-  ~Clipboard();
+  ~TextClipboard();
 
   /**
    * This constructor is used by Adaptor::GetClipboard().
    * @param[in] clipboard A pointer to the clipboard.
    */
-  Clipboard( Internal::Adaptor::Clipboard* clipboard );
+  TextClipboard( Internal::Adaptor::TextClipboard* clipboard );
 
   /**
-   * Retrieve a handle to the ClipboardEventNotifier instance
-   * @return A handle to the Clipboard
+   * Retrieve a handle to the TextClipboardEventNotifier instance
+   * @return A handle to the TextClipboard
    */
-  static Clipboard Get();
+  static TextClipboard Get();
 
   /**
    * @brief Checks whether the clipboard is available.
@@ -110,4 +110,4 @@ public:
 };
 } // namespace Dali
 
-#endif // TOOLKIT_CLIPBOARD_H
+#endif // TOOLKIT_TextCLIPBOARD_H

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-TextEditor.cpp b/automated-tests/src/dali-toolkit/utc-Dali-TextEditor.cpp
index 17d7d30..389143b 100644 (file)
--- a/automated-tests/src/dali-toolkit/utc-Dali-TextEditor.cpp
+++ b/automated-tests/src/dali-toolkit/utc-Dali-TextEditor.cpp
@@ -23,7 +23,7 @@
 #include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup.h>
 
 #include <dali/devel-api/actors/actor-devel.h>
-#include <dali/devel-api/adaptor-framework/clipboard.h>
+#include <dali/devel-api/adaptor-framework/text-clipboard.h>
 #include <dali/devel-api/adaptor-framework/key-devel.h>
 #include <dali/devel-api/text-abstraction/font-client.h>
 #include <dali/devel-api/events/pan-gesture-devel.h>
@@ -2166,7 +2166,7 @@ int utcDaliTextEditorEvent03(void)
   application.Render();
 
   // Send some taps and check text controller with clipboard window
-  Dali::Clipboard clipboard = Clipboard::Get();
+  Dali::TextClipboard clipboard = TextClipboard::Get();
   clipboard.ShowClipboard();
   TestGenerateTap(application, 3.0f, 25.0f, 100);
   clipboard.HideClipboard();

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-TextField.cpp b/automated-tests/src/dali-toolkit/utc-Dali-TextField.cpp
index d6ac646..357e456 100644 (file)
--- a/automated-tests/src/dali-toolkit/utc-Dali-TextField.cpp
+++ b/automated-tests/src/dali-toolkit/utc-Dali-TextField.cpp
@@ -2981,7 +2981,7 @@ int utcDaliTextFieldEvent08(void)
   ToolkitTestApplication application;
   tet_infoline(" utcDaliTextFieldEvent08");
 
-  Dali::Clipboard clipboard = Clipboard::Get();
+  Dali::TextClipboard clipboard = TextClipboard::Get();
   clipboard.SetItem("testTextFieldEvent");
 
   // Checks Longpress when only place holder text

diff --git a/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp b/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp
index 765d304..6ae5aa0 100644 (file)
--- a/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp
+++ b/dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp
@@ -858,7 +858,7 @@ void TextEditor::OnKeyInputFocusGained()
     // When window gain lost focus, the InputMethodContext is deactivated. Thus when window gain focus again, the InputMethodContext must be activated.
     mInputMethodContext.SetRestoreAfterFocusLost(true);
   }
-  ClipboardEventNotifier notifier(ClipboardEventNotifier::Get());
+  TextClipboardEventNotifier notifier(TextClipboardEventNotifier::Get());
 
   if(notifier)
   {
@@ -888,7 +888,7 @@ void TextEditor::OnKeyInputFocusLost()
 
     mInputMethodContext.EventReceivedSignal().Disconnect(this, &TextEditor::OnInputMethodContextEvent);
   }
-  ClipboardEventNotifier notifier(ClipboardEventNotifier::Get());
+  TextClipboardEventNotifier notifier(TextClipboardEventNotifier::Get());
 
   if(notifier)
   {
@@ -1286,7 +1286,7 @@ void TextEditor::GetHandleImagePropertyValue(Property::Value& value, Text::Handl
   }
 }
 
-void TextEditor::OnClipboardTextSelected(ClipboardEventNotifier& clipboard)
+void TextEditor::OnClipboardTextSelected(TextClipboardEventNotifier& clipboard)
 {
   mController->PasteClipboardItemEvent();
 }

diff --git a/dali-toolkit/internal/controls/text-controls/text-editor-impl.h b/dali-toolkit/internal/controls/text-controls/text-editor-impl.h
index 117a09b..a4491e1 100644 (file)
--- a/dali-toolkit/internal/controls/text-controls/text-editor-impl.h
+++ b/dali-toolkit/internal/controls/text-controls/text-editor-impl.h
@@ -20,7 +20,7 @@
 
 // EXTERNAL INCLUDES
 #include <dali/devel-api/adaptor-framework/accessibility.h>
-#include <dali/devel-api/adaptor-framework/clipboard-event-notifier.h>
+#include <dali/devel-api/adaptor-framework/text-clipboard-event-notifier.h>
 #include <dali/devel-api/adaptor-framework/input-method-context.h>
 #include <dali/devel-api/atspi-interfaces/editable-text.h>
 #include <dali/devel-api/atspi-interfaces/hypertext.h>
@@ -449,9 +449,9 @@ private: // Implementation
 
   /**
    * @brief Callback when Clipboard signals an item should be pasted
-   * @param[in] clipboard handle to Clipboard Event Notifier
+   * @param[in] clipboard handle to TextClipboard Event Notifier
    */
-  void OnClipboardTextSelected(ClipboardEventNotifier& clipboard);
+  void OnClipboardTextSelected(TextClipboardEventNotifier& clipboard);
 
   /**
    * @brief Get a Property Map for the image used for the required Handle Image

diff --git a/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp b/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp
index 499121a..658bb9a 100644 (file)
--- a/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp
+++ b/dali-toolkit/internal/controls/text-controls/text-field-impl.cpp
@@ -765,7 +765,7 @@ void TextField::OnKeyInputFocusGained()
     // When window gain lost focus, the inputMethodContext is deactivated. Thus when window gain focus again, the inputMethodContext must be activated.
     mInputMethodContext.SetRestoreAfterFocusLost(true);
   }
-  ClipboardEventNotifier notifier(ClipboardEventNotifier::Get());
+  TextClipboardEventNotifier notifier(TextClipboardEventNotifier::Get());
 
   if(notifier)
   {
@@ -794,7 +794,7 @@ void TextField::OnKeyInputFocusLost()
 
     mInputMethodContext.EventReceivedSignal().Disconnect(this, &TextField::OnInputMethodContextEvent);
   }
-  ClipboardEventNotifier notifier(ClipboardEventNotifier::Get());
+  TextClipboardEventNotifier notifier(TextClipboardEventNotifier::Get());
 
   if(notifier)
   {
@@ -1118,7 +1118,7 @@ void TextField::EnableClipping()
   }
 }
 
-void TextField::OnClipboardTextSelected(ClipboardEventNotifier& clipboard)
+void TextField::OnClipboardTextSelected(TextClipboardEventNotifier& clipboard)
 {
   mController->PasteClipboardItemEvent();
 }

diff --git a/dali-toolkit/internal/controls/text-controls/text-field-impl.h b/dali-toolkit/internal/controls/text-controls/text-field-impl.h
index fe5056e..36fe57f 100644 (file)
--- a/dali-toolkit/internal/controls/text-controls/text-field-impl.h
+++ b/dali-toolkit/internal/controls/text-controls/text-field-impl.h
@@ -19,7 +19,7 @@
  */
 
 // EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/clipboard-event-notifier.h>
+#include <dali/devel-api/adaptor-framework/text-clipboard-event-notifier.h>
 #include <dali/devel-api/adaptor-framework/input-method-context.h>
 #include <dali/devel-api/atspi-interfaces/editable-text.h>
 #include <dali/devel-api/atspi-interfaces/hypertext.h>
@@ -421,9 +421,9 @@ private: // Implementation
 
   /**
    * @brief Callback when Clipboard signals an item should be pasted
-   * @param[in] clipboard handle to Clipboard Event Notifier
+   * @param[in] clipboard handle to TextClipboard Event Notifier
    */
-  void OnClipboardTextSelected(ClipboardEventNotifier& clipboard);
+  void OnClipboardTextSelected(TextClipboardEventNotifier& clipboard);
 
   /**
    * @brief Get a Property Map for the image used for the required Handle Image

diff --git a/dali-toolkit/internal/text/controller/text-controller-event-handler.cpp b/dali-toolkit/internal/text/controller/text-controller-event-handler.cpp
index e280739..4cff878 100644 (file)
--- a/dali-toolkit/internal/text/controller/text-controller-event-handler.cpp
+++ b/dali-toolkit/internal/text/controller/text-controller-event-handler.cpp
@@ -19,7 +19,7 @@
 #include <dali-toolkit/internal/text/controller/text-controller-event-handler.h>
 
 // EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/clipboard-event-notifier.h>
+#include <dali/devel-api/adaptor-framework/text-clipboard-event-notifier.h>
 #include <dali/devel-api/adaptor-framework/key-devel.h>
 #include <dali/integration-api/debug.h>
 #include <dali/integration-api/trace.h>
@@ -895,7 +895,7 @@ InputMethodContext::CallbackData Controller::EventHandler::OnInputMethodContextE
 void Controller::EventHandler::PasteClipboardItemEvent(Controller& controller)
 {
   // Retrieve the clipboard contents first
-  ClipboardEventNotifier notifier(ClipboardEventNotifier::Get());
+  TextClipboardEventNotifier notifier(TextClipboardEventNotifier::Get());
   std::string            stringToPaste(notifier.GetContent());
 
   // Commit the current pre-edit text; the contents of the clipboard should be appended

diff --git a/dali-toolkit/internal/text/controller/text-controller-impl.h b/dali-toolkit/internal/text/controller/text-controller-impl.h
index 656b9bf..1844cb0 100644 (file)
--- a/dali-toolkit/internal/text/controller/text-controller-impl.h
+++ b/dali-toolkit/internal/text/controller/text-controller-impl.h
@@ -19,7 +19,7 @@
  */
 
 // EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/clipboard.h>
+#include <dali/devel-api/adaptor-framework/text-clipboard.h>
 #include <dali/devel-api/text-abstraction/font-client.h>
 #include <dali/public-api/rendering/shader.h>
 
@@ -371,9 +371,9 @@ struct Controller::Impl
     mModel = Model::New();
 
     mFontClient = TextAbstraction::FontClient::Get();
-    if(mEditableControlInterface != nullptr && Clipboard::IsAvailable())
+    if(mEditableControlInterface != nullptr && TextClipboard::IsAvailable())
     {
-      mClipboard = Clipboard::Get();
+      mClipboard = TextClipboard::Get();
     }
 
     mView.SetVisualModel(mModel->mVisualModel);
@@ -568,7 +568,7 @@ struct Controller::Impl
   {
     if(!mClipboard)
     {
-      mClipboard = Clipboard::Get();
+      mClipboard = TextClipboard::Get();
     }
 
     return mClipboard != nullptr ? true : false;
@@ -576,13 +576,13 @@ struct Controller::Impl
 
   bool IsClipboardEmpty()
   {
-    bool result(Clipboard::IsAvailable() && EnsureClipboardCreated() && mClipboard.NumberOfItems());
+    bool result(TextClipboard::IsAvailable() && EnsureClipboardCreated() && mClipboard.NumberOfItems());
     return !result; // If NumberOfItems greater than 0, return false
   }
 
   bool IsClipboardVisible()
   {
-    bool result(Clipboard::IsAvailable() && EnsureClipboardCreated() && mClipboard.IsVisible());
+    bool result(TextClipboard::IsAvailable() && EnsureClipboardCreated() && mClipboard.IsVisible());
     return result;
   }
 
@@ -1016,7 +1016,7 @@ public:
   OutlineDefaults*             mOutlineDefaults;            ///< Avoid allocating this when the user does not specify outline parameters.
   EventData*                   mEventData;                  ///< Avoid allocating everything for text input until EnableTextInput().
   TextAbstraction::FontClient  mFontClient;                 ///< Handle to the font client.
-  Clipboard                    mClipboard;                  ///< Handle to the system clipboard
+  TextClipboard                mClipboard;                  ///< Handle to the system clipboard
   View                         mView;                       ///< The view interface to the rendering back-end.
   MetricsPtr                   mMetrics;                    ///< A wrapper around FontClient used to get metrics & potentially down-scaled Emoji metrics.
   Layout::Engine               mLayoutEngine;               ///< The layout engine.