../dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-application.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp
- ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-event-thread-callback.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-environment-variable.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-feedback-player.cpp
const Size CONTROL_SIZE(300.f, 60.f);
-std::string gClipboardText;
-void ContentSelectedCallback(TextClipboardEventNotifier& notifier)
-{
- gClipboardText = notifier.GetContent();
-}
-
// Generate a KeyEvent to send to Core.
Dali::KeyEvent GenerateKey(const std::string& keyName,
const std::string& keyString,
controller->GetText(text);
DALI_TEST_CHECK(text.empty());
- TextClipboardEventNotifier clipboardEventNotifier = TextClipboardEventNotifier::Get();
- clipboardEventNotifier.ContentSelectedSignal().Connect(&ContentSelectedCallback);
-
// Paste the text.
button = PushButton::DownCast(textPopup.FindChildByName(OPTION_PASTE));
DALI_TEST_CHECK(button);
// Call relayout to process the input events.
controller->Relayout(CONTROL_SIZE);
+ controller->GetText(text);
- DALI_TEST_EQUALS("Hello world", gClipboardText, TEST_LOCATION);
+ DALI_TEST_EQUALS("Hello world", text.c_str(), TEST_LOCATION);
// Show the clipboard.
button = PushButton::DownCast(textPopup.FindChildByName(OPTION_CLIPBOARD));
../dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-text-abstraction.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-timer.cpp
- ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-tts-player.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-video-player.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-virtual-keyboard.cpp
SET(TEST_HARNESS_SOURCES
../dali-toolkit/dali-toolkit-test-utils/toolkit-application.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp
- ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-event-thread-callback.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-environment-variable.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-input-method-context.cpp
dali-toolkit-test-utils/toolkit-application.cpp
dali-toolkit-test-utils/toolkit-canvas-renderer.cpp
dali-toolkit-test-utils/toolkit-clipboard.cpp
- dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
dali-toolkit-test-utils/toolkit-event-thread-callback.cpp
dali-toolkit-test-utils/toolkit-environment-variable.cpp
dali-toolkit-test-utils/toolkit-input-method-context.cpp
#include "toolkit-test-application.h"
#include "toolkit-application.h"
#include "toolkit-input-method-context.h"
-#include "toolkit-clipboard-event-notifier.h"
#endif // DALI_TOOLKIT_TEST_SUITE_UTILS_H
+++ /dev/null
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "toolkit-clipboard-event-notifier.h"
-
-#include <dali-toolkit/public-api/dali-toolkit-common.h>
-#include <dali/public-api/object/base-object.h>
-#include <dali/public-api/signals/dali-signal.h>
-
-namespace Dali
-{
-
-namespace Internal
-{
-
-namespace Adaptor
-{
-
-class TextClipboardEventNotifier : public Dali::BaseObject
-{
-public:
-
- typedef Dali::TextClipboardEventNotifier::TextClipboardEventSignalType TextClipboardEventSignalType;
-
- // Creation
- static Dali::TextClipboardEventNotifier New();
- static Dali::TextClipboardEventNotifier Get();
-
- // Public API
- const std::string& GetContent() const;
- void SetContent( const std::string& content );
- void ClearContent();
- void EmitContentSelectedSignal();
-
- // Signals
- TextClipboardEventSignalType& ContentSelectedSignal()
- {
- return mContentSelectedSignal;
- }
-
-private:
- // Construction & Destruction
- TextClipboardEventNotifier();
- virtual ~TextClipboardEventNotifier();
-
- // Undefined
- TextClipboardEventNotifier( const TextClipboardEventNotifier& );
- TextClipboardEventNotifier& operator=( TextClipboardEventNotifier& );
-
-private:
-
- std::string mContent; ///< The current selected content.
- TextClipboardEventSignalType mContentSelectedSignal;
-
- static Dali::TextClipboardEventNotifier mToolkitClipboardEventNotifier;
-
-public:
-
- // Helpers for public-api forwarding methods
-
- inline static Internal::Adaptor::TextClipboardEventNotifier& GetImplementation(Dali::TextClipboardEventNotifier& detector)
- {
- DALI_ASSERT_ALWAYS( detector && "TextClipboardEventNotifier handle is empty" );
-
- BaseObject& handle = detector.GetBaseObject();
-
- return static_cast<Internal::Adaptor::TextClipboardEventNotifier&>(handle);
- }
-
- inline static const Internal::Adaptor::TextClipboardEventNotifier& GetImplementation(const Dali::TextClipboardEventNotifier& detector)
- {
- DALI_ASSERT_ALWAYS( detector && "TextClipboardEventNotifier handle is empty" );
-
- const BaseObject& handle = detector.GetBaseObject();
-
- return static_cast<const Internal::Adaptor::TextClipboardEventNotifier&>(handle);
- }
-
-};
-
-Dali::TextClipboardEventNotifier TextClipboardEventNotifier::mToolkitClipboardEventNotifier;
-
-Dali::TextClipboardEventNotifier TextClipboardEventNotifier::New()
-{
- return Get();
-}
-
-Dali::TextClipboardEventNotifier TextClipboardEventNotifier::Get()
-{
- if ( !mToolkitClipboardEventNotifier )
- {
- mToolkitClipboardEventNotifier = Dali::TextClipboardEventNotifier( new TextClipboardEventNotifier );
- }
- return mToolkitClipboardEventNotifier;
-}
-
-const std::string& TextClipboardEventNotifier::GetContent() const
-{
- return mContent;
-}
-
-void TextClipboardEventNotifier::SetContent( const std::string& content )
-{
- mContent = content;
-}
-
-void TextClipboardEventNotifier::ClearContent()
-{
- mContent.clear();
-}
-
-void TextClipboardEventNotifier::EmitContentSelectedSignal()
-{
- if ( !mContentSelectedSignal.Empty() )
- {
- Dali::TextClipboardEventNotifier handle( this );
- mContentSelectedSignal.Emit( handle );
- }
-}
-
-TextClipboardEventNotifier::TextClipboardEventNotifier()
-: mContent()
-{
-}
-
-TextClipboardEventNotifier::~TextClipboardEventNotifier()
-{
-}
-
-} // namespace Adaptor
-} // namespace Internal
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-TextClipboardEventNotifier::TextClipboardEventNotifier()
-{
-}
-
-TextClipboardEventNotifier TextClipboardEventNotifier::Get()
-{
- return Internal::Adaptor::TextClipboardEventNotifier::Get();
-}
-
-TextClipboardEventNotifier::~TextClipboardEventNotifier()
-{
-}
-
-const std::string& TextClipboardEventNotifier::GetContent() const
-{
- return Internal::Adaptor::TextClipboardEventNotifier::GetImplementation(*this).GetContent();
-}
-
-void TextClipboardEventNotifier::SetContent( const std::string& content )
-{
- Internal::Adaptor::TextClipboardEventNotifier::GetImplementation(*this).SetContent(content);
-}
-
-void TextClipboardEventNotifier::ClearContent()
-{
- Internal::Adaptor::TextClipboardEventNotifier::GetImplementation(*this).ClearContent();
-}
-
-void TextClipboardEventNotifier::EmitContentSelectedSignal()
-{
- Internal::Adaptor::TextClipboardEventNotifier::GetImplementation(*this).EmitContentSelectedSignal();
-}
-
-TextClipboardEventNotifier::TextClipboardEventSignalType& TextClipboardEventNotifier::ContentSelectedSignal()
-{
- return Internal::Adaptor::TextClipboardEventNotifier::GetImplementation(*this).ContentSelectedSignal();
-}
-
-TextClipboardEventNotifier::TextClipboardEventNotifier( Internal::Adaptor::TextClipboardEventNotifier* notifier )
-: BaseHandle( notifier )
-{
-}
-
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_TOOLKIT_CLIPBOARD_EVENT_NOTIFIER_H
-#define DALI_TOOLKIT_CLIPBOARD_EVENT_NOTIFIER_H
-
-/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// EXTERNAL INCLUDES
-#include <string>
-
-// PUBLIC INCLUDES
-#define DALI_TEXT_CLIPBOARD_EVENT_NOTIFIER_H
-#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/signals/dali-signal.h>
-
-
-namespace Dali
-{
-
-namespace Internal
-{
-namespace Adaptor
-{
-class TextClipboardEventNotifier;
-}
-}
-
-class TextClipboardEventNotifier : public BaseHandle
-{
-public:
- typedef Signal< void ( TextClipboardEventNotifier& ) > TextClipboardEventSignalType;
-
- TextClipboardEventNotifier();
- static TextClipboardEventNotifier Get();
- ~TextClipboardEventNotifier();
-
- const std::string& GetContent() const;
- void SetContent( const std::string& content );
- void ClearContent();
-
- void EmitContentSelectedSignal();
- TextClipboardEventSignalType& ContentSelectedSignal();
-
- TextClipboardEventNotifier( Internal::Adaptor::TextClipboardEventNotifier* notifier );
-};
-
-} // namespace Dali
-
-#endif // DALI_TOOLKIT_TOOLKIT_CLIPBOARD_EVENT_NOTIFIER_H
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-object.h>
-#include <dali/devel-api/adaptor-framework/text-clipboard-event-notifier.h>
namespace Dali
{
{
/**
- * Implementation of the Clip Board
+ * Implementation of the Clipboard
*/
-class TextClipboard : public Dali::BaseObject
+class Clipboard : public Dali::BaseObject
{
public:
/**
- * @copydoc Dali::TextClipboardEventNotifier::Get()
+ * @copydoc Dali::ClipboardEventNotifier::Get()
*/
- static Dali::TextClipboard Get();
+ static Dali::Clipboard Get();
/**
* Constructor
* @param[in] ecoreXwin, The window is created by application.
*/
- TextClipboard(/*Ecore_X_Window ecoreXwin*/);
- virtual ~TextClipboard();
+ Clipboard(/*Ecore_X_Window ecoreXwin*/);
+ virtual ~Clipboard();
/**
- * @copydoc Dali::TextClipboard::IsAvailable()
+ * @copydoc Dali::Clipboard::IsAvailable()
*/
static bool IsAvailable();
/**
- * @copydoc Dali::TextClipboard::SetItem()
+ * @copydoc Dali::Clipboard::DataSentSignal()
*/
- bool SetItem(const std::string &itemData);
+ Dali::Clipboard::DataSentSignalType& DataSentSignal();
/**
- * @copydoc Dali::TextClipboard::RequestItem()
+ * @copydoc Dali::Clipboard::DataReceivedSignal()
*/
- void RequestItem();
+ Dali::Clipboard::DataReceivedSignalType& DataReceivedSignal();
/**
- * @copydoc Dali::TextClipboard::NumberOfClipboardItems()
+ * @copydoc Dali::Clipboard::SetData()
*/
- unsigned int NumberOfItems();
+ bool SetData(const Dali::Clipboard::ClipData& clipData);
/**
- * @copydoc Dali::TextClipboard::ShowClipboard()
+ * @copydoc Dali::Clipboard::GetData()
+ */
+ uint32_t GetData(const std::string &mimeType);
+
+ /**
+ * @copydoc Dali::Clipboard::NumberOfClipboardItems()
+ */
+ size_t NumberOfItems();
+
+ /**
+ * @copydoc Dali::Clipboard::ShowClipboard()
*/
void ShowClipboard();
/**
- * @copydoc Dali::TextClipboard::HideClipboard()
+ * @copydoc Dali::Clipboard::HideClipboard()
*/
void HideClipboard();
/**
- * @copydoc Dali::TextClipboard::IsVisible()
+ * @copydoc Dali::Clipboard::IsVisible()
*/
bool IsVisible() const;
private:
- TextClipboard( const TextClipboard& );
- TextClipboard& operator=( TextClipboard& );
+ Clipboard( const Clipboard& );
+ Clipboard& operator=( Clipboard& );
- static Dali::TextClipboard mToolkitClipboard;
- bool mVisible;
- std::string mItem;
- int mCount;
-}; // class TextClipboard
+ static Dali::Clipboard mToolkitClipboard;
+ bool mVisible;
+ std::string mMimeType;
+ std::string mData;
+ uint32_t mDataId{0};
+ size_t mCount;
-Dali::TextClipboard Dali::Internal::Adaptor::TextClipboard::mToolkitClipboard;
+ Dali::Clipboard::DataSentSignalType mDataSentSignal;
+ Dali::Clipboard::DataReceivedSignalType mDataReceivedSignal;
+}; // class clipboard
-TextClipboard::TextClipboard()
+Dali::Clipboard Dali::Internal::Adaptor::Clipboard::mToolkitClipboard;
+
+
+Clipboard::Clipboard()
{
mVisible = false;
- mCount = 0;
+ mCount = 0u;
}
-TextClipboard::~TextClipboard()
+Clipboard::~Clipboard()
{
}
-Dali::TextClipboard TextClipboard::Get()
+Dali::Clipboard Clipboard::Get()
{
- if( ! mToolkitClipboard )
+ if(!mToolkitClipboard)
{
- mToolkitClipboard = Dali::TextClipboard( new Dali::Internal::Adaptor::TextClipboard() );
+ mToolkitClipboard = Dali::Clipboard(new Dali::Internal::Adaptor::Clipboard());
}
return mToolkitClipboard;
}
-bool TextClipboard::IsAvailable()
+bool Clipboard::IsAvailable()
{
if(mToolkitClipboard)
{
return false;
}
-bool TextClipboard::SetItem(const std::string &itemData )
+Dali::Clipboard::DataSentSignalType& Clipboard::DataSentSignal()
+{
+ return mDataSentSignal;
+}
+
+Dali::Clipboard::DataReceivedSignalType& Clipboard::DataReceivedSignal()
+{
+ return mDataReceivedSignal;
+}
+
+bool Clipboard::SetData(const Dali::Clipboard::ClipData& clipData)
{
- mItem = itemData;
- mCount = 1;
+ mMimeType = clipData.GetMimeType();
+ mData = clipData.GetData();
+ mCount = 1u;
+
+ if(mData.empty())
+ {
+ return false;
+ }
+
+ mDataSentSignal.Emit(mMimeType.c_str(), mData.c_str());
+
return true;
}
-void TextClipboard::RequestItem()
+uint32_t Clipboard::GetData(const std::string &mimeType)
{
- Dali::TextClipboardEventNotifier clipboardEventNotifier(Dali::TextClipboardEventNotifier::Get());
- if ( clipboardEventNotifier )
+ if(!mMimeType.compare(mimeType.c_str()))
{
- clipboardEventNotifier.SetContent( mItem );
- clipboardEventNotifier.EmitContentSelectedSignal();
+ mDataId++;
+ mDataReceivedSignal.Emit(mDataId, mMimeType.c_str(), mData.c_str());
+ return mDataId;
}
+ return 0u;
}
-unsigned int TextClipboard::NumberOfItems()
+size_t Clipboard::NumberOfItems()
{
return mCount;
}
-void TextClipboard::ShowClipboard()
+void Clipboard::ShowClipboard()
{
mVisible = true;
}
-void TextClipboard::HideClipboard()
+void Clipboard::HideClipboard()
{
mVisible = false;
}
-bool TextClipboard::IsVisible() const
+bool Clipboard::IsVisible() const
{
return mVisible;
}
} // namespace Internal
-inline static Internal::Adaptor::TextClipboard& GetImplementation(Dali::TextClipboard& clipboard)
+inline static Internal::Adaptor::Clipboard& GetImplementation(Dali::Clipboard& clipboard)
{
// Bypass any passed in clipboard handle - it probably won't be initialized
- Dali::TextClipboard theClipboard = Dali::TextClipboard::Get();
+ Dali::Clipboard theClipboard = Dali::Clipboard::Get();
BaseObject& object = theClipboard.GetBaseObject();
- return static_cast<Internal::Adaptor::TextClipboard&>(object);
+ return static_cast<Internal::Adaptor::Clipboard&>(object);
}
-inline static const Internal::Adaptor::TextClipboard& GetImplementation(const Dali::TextClipboard& clipboard)
+inline static const Internal::Adaptor::Clipboard& GetImplementation(const Dali::Clipboard& clipboard)
{
// Bypass any passed in clipboard handle - it probably won't be initialized
- Dali::TextClipboard theClipboard = Dali::TextClipboard::Get();
+ Dali::Clipboard theClipboard = Dali::Clipboard::Get();
const BaseObject& object = theClipboard.GetBaseObject();
- return static_cast<const Internal::Adaptor::TextClipboard&>(object);
+ return static_cast<const Internal::Adaptor::Clipboard&>(object);
}
-TextClipboard::TextClipboard()
+Clipboard::Clipboard()
{
}
-TextClipboard::~TextClipboard()
+Clipboard::~Clipboard()
{
}
-TextClipboard::TextClipboard(Internal::Adaptor::TextClipboard *impl)
+Clipboard::Clipboard(Internal::Adaptor::Clipboard *impl)
: BaseHandle(impl)
{
}
-TextClipboard TextClipboard::Get()
-{
- return Internal::Adaptor::TextClipboard::Get();
-}
-bool TextClipboard::SetItem( const std::string &itemData)
-{
- return GetImplementation(*this).SetItem( itemData );
-}
-
-void TextClipboard::RequestItem()
+Clipboard Clipboard::Get()
{
- GetImplementation(*this).RequestItem();
+ return Internal::Adaptor::Clipboard::Get();
}
-unsigned int TextClipboard::NumberOfItems()
+size_t Clipboard::NumberOfItems()
{
return GetImplementation(*this).NumberOfItems();
}
-void TextClipboard::ShowClipboard()
+void Clipboard::ShowClipboard()
{
GetImplementation(*this).ShowClipboard();
}
-void TextClipboard::HideClipboard()
+void Clipboard::HideClipboard()
{
GetImplementation(*this).HideClipboard();
}
-bool TextClipboard::IsVisible() const
+bool Clipboard::IsVisible() const
{
return GetImplementation(*this).IsVisible();
}
-#ifndef TOOLKIT_TEXT_CLIPBOARD_H
-#define TOOLKIT_TEXT_CLIPBOARD_H
+#ifndef TOOLKIT_CLIPBOARD_H
+#define TOOLKIT_CLIPBOARD_H
/*
* Copyright (c) 2019 Samsung Electronics Co., Ltd.
*
*/
-#define DALI_TEXT_CLIPBOARD_H
+#define DALI_CLIPBOARD_H
// EXTERNAL INCLUDES
#include <dali/public-api/math/rect.h>
#include <dali/public-api/object/base-handle.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali DALI_IMPORT_API
{
namespace Adaptor
{
-class TextClipboard;
+class Clipboard;
}
}
* The Clipboard can operate using various funtion.
* Clipboard can manage it's item and set show / hide status.
*/
-class TextClipboard : public BaseHandle
+class Clipboard : public BaseHandle
{
public:
/**
+ * @brief Structure that contains information about the clipboard data information.
+ */
+ struct ClipData
+ {
+ ClipData(const char* mimeType = nullptr, const char* data = nullptr)
+ {
+ this->mimeType = mimeType;
+ this->data = data;
+ }
+ void SetMimeType(const char* mimeType)
+ {
+ this->mimeType = mimeType;
+ }
+ const char* GetMimeType() const
+ {
+ return mimeType;
+ }
+ void SetData(const char* data)
+ {
+ this->data = data;
+ }
+ const char* GetData() const
+ {
+ return data;
+ }
+
+ private:
+ const char* mimeType {nullptr}; ///< The mime type of clip data.
+ const char* data {nullptr}; ///< The clip data.
+ };
+
+ /// @brief Data send completed signal.
+ typedef Signal<void(const char*, const char*)> DataSentSignalType;
+
+ /// @brief Data receive completed signal.
+ typedef Signal<void(uint32_t, const char*, const char*)> DataReceivedSignalType;
+
+
+ /**
* Create an uninitialized Clipboard;
* this can be initialized with one of the derived Clipboard' New() methods
*/
- TextClipboard();
+ Clipboard();
/**
* Non virtual destructor.
*/
- ~TextClipboard();
+ ~Clipboard();
/**
* This constructor is used by Adaptor::GetClipboard().
* @param[in] clipboard A pointer to the clipboard.
*/
- TextClipboard( Internal::Adaptor::TextClipboard* clipboard );
+ Clipboard(Internal::Adaptor::Clipboard* clipboard);
/**
- * Retrieve a handle to the TextClipboardEventNotifier instance
- * @return A handle to the TextClipboard
+ * Retrieve a handle to the ClipboardEventNotifier instance
+ * @return A handle to the Clipboard
*/
- static TextClipboard Get();
+ static Clipboard Get();
/**
* @brief Checks whether the clipboard is available.
- *
* @return true, if it is available, false otherwise.
*/
static bool IsAvailable();
/**
- * Send the given string to the clipboard
- * @param[in] itemData string to send to clip board
- * @return bool true if the internal clip board sending was successful.
+ * @brief This signal is emitted when the data send complete.
+ * @note
+ * SetData() opertion does not follow a synchronous call.
+ * It follows the sequence below.
+ * SetData() -> EcoreEventDataSend() -> SendData() -> DataSentSignal() Emit
+ */
+ DataSentSignalType& DataSentSignal();
+
+ /**
+ * @brief This signal is emitted when the data receive complete.
+ * @note
+ * GetData() opertion does not follow a synchronous call.
+ * It follows the sequence below.
+ * GetData() -> EcoreEventOfferDataReady() -> ReceiveData() -> DataReceivedSignal() Emit
+ */
+ DataReceivedSignalType& DataReceivedSignal();
+
+ /**
+ * @brief Send the given data to the clipboard.
+ * @param[in] clipData data to send to the clipboard
+ * @return bool true if the internal clipboard sending was successful.
*/
- bool SetItem( const std::string& itemData );
+ bool SetData(const ClipData& clipData);
/**
- * Request clipboard service to retrieve an item
+ * @brief Request data from the clipboard.
+ * @param[in] mimeType mime type of data to request.
+ * @return uint32_t Returns the data request id.
*/
- void RequestItem();
+ uint32_t GetData(const std::string& mimeType);
/**
- * Returns the number of item currently in the clipboard
- * @return unsigned int number of clipboard items
+ * @brief Returns the number of item currently in the clipboard.
+ * @return size_t number of clipboard items.
*/
- unsigned int NumberOfItems();
+ size_t NumberOfItems();
/**
* Show the clipboard window
};
} // namespace Dali
-#endif // TOOLKIT_TextCLIPBOARD_H
+#endif // TOOLKIT_CLIPBOARD_H
#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/text-clipboard.h>
+#include <dali/devel-api/adaptor-framework/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>
application.Render();
// Send some taps and check text controller with clipboard window
- Dali::TextClipboard clipboard = TextClipboard::Get();
+ Dali::Clipboard clipboard = Clipboard::Get();
clipboard.ShowClipboard();
TestGenerateTap(application, 3.0f, 25.0f, 100);
clipboard.HideClipboard();
ToolkitTestApplication application;
tet_infoline(" utcDaliTextFieldEvent08");
- Dali::TextClipboard clipboard = TextClipboard::Get();
- clipboard.SetItem("testTextFieldEvent");
+ Dali::Clipboard clipboard = Clipboard::Get();
+ Dali::Clipboard::ClipData data("text/plain;charset=utf-8", "testTextFieldEvent");
+ clipboard.SetData(data);
// Checks Longpress when only place holder text
// When window gain lost focus, the InputMethodContext is deactivated. Thus when window gain focus again, the InputMethodContext must be activated.
mInputMethodContext.SetRestoreAfterFocusLost(true);
}
- TextClipboardEventNotifier notifier(TextClipboardEventNotifier::Get());
-
- if(notifier)
- {
- notifier.ContentSelectedSignal().Connect(this, &TextEditor::OnClipboardTextSelected);
- }
if(IsEditable() && mController->IsUserInteractionEnabled())
{
mInputMethodContext.EventReceivedSignal().Disconnect(this, &TextEditor::OnInputMethodContextEvent);
}
- TextClipboardEventNotifier notifier(TextClipboardEventNotifier::Get());
-
- if(notifier)
- {
- notifier.ContentSelectedSignal().Disconnect(this, &TextEditor::OnClipboardTextSelected);
- }
mController->KeyboardFocusLostEvent();
}
}
-void TextEditor::OnClipboardTextSelected(TextClipboardEventNotifier& clipboard)
-{
- mController->PasteClipboardItemEvent();
-}
-
void TextEditor::KeyboardStatusChanged(bool keyboardShown)
{
DALI_LOG_INFO(gTextEditorLogFilter, Debug::Verbose, "TextEditor::KeyboardStatusChanged %p keyboardShown %d\n", mController.Get(), keyboardShown);
// EXTERNAL INCLUDES
#include <dali/devel-api/adaptor-framework/accessibility.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>
InputMethodContext::CallbackData OnInputMethodContextEvent(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent);
/**
- * @brief Callback when Clipboard signals an item should be pasted
- * @param[in] clipboard handle to TextClipboard Event Notifier
- */
- void OnClipboardTextSelected(TextClipboardEventNotifier& clipboard);
-
- /**
* @brief Get a Property Map for the image used for the required Handle Image
* @param[out] value the returned image property
* @param[in] handleType the type of handle
// When window gain lost focus, the inputMethodContext is deactivated. Thus when window gain focus again, the inputMethodContext must be activated.
mInputMethodContext.SetRestoreAfterFocusLost(true);
}
- TextClipboardEventNotifier notifier(TextClipboardEventNotifier::Get());
-
- if(notifier)
- {
- notifier.ContentSelectedSignal().Connect(this, &TextField::OnClipboardTextSelected);
- }
if(IsEditable() && mController->IsUserInteractionEnabled())
{
mInputMethodContext.EventReceivedSignal().Disconnect(this, &TextField::OnInputMethodContextEvent);
}
- TextClipboardEventNotifier notifier(TextClipboardEventNotifier::Get());
-
- if(notifier)
- {
- notifier.ContentSelectedSignal().Disconnect(this, &TextField::OnClipboardTextSelected);
- }
mController->KeyboardFocusLostEvent();
}
}
-void TextField::OnClipboardTextSelected(TextClipboardEventNotifier& clipboard)
-{
- mController->PasteClipboardItemEvent();
-}
-
void TextField::KeyboardStatusChanged(bool keyboardShown)
{
DALI_LOG_INFO(gTextFieldLogFilter, Debug::Verbose, "TextField::KeyboardStatusChanged %p keyboardShown %d\n", mController.Get(), keyboardShown);
*/
// EXTERNAL INCLUDES
-#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>
InputMethodContext::CallbackData OnInputMethodContextEvent(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent);
/**
- * @brief Callback when Clipboard signals an item should be pasted
- * @param[in] clipboard handle to TextClipboard Event Notifier
- */
- void OnClipboardTextSelected(TextClipboardEventNotifier& clipboard);
-
- /**
* @brief Get a Property Map for the image used for the required Handle Image
* @param[out] value the returned image property
* @param[in] handleType the type of handle
#include <dali-toolkit/internal/text/controller/text-controller-event-handler.h>
// EXTERNAL INCLUDES
-#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>
return callbackData;
}
-void Controller::EventHandler::PasteClipboardItemEvent(Controller& controller)
+void Controller::EventHandler::PasteClipboardItemEvent(Controller& controller, const std::string& text)
{
- // Retrieve the clipboard contents first
- TextClipboardEventNotifier notifier(TextClipboardEventNotifier::Get());
- std::string stringToPaste(notifier.GetContent());
-
// Commit the current pre-edit text; the contents of the clipboard should be appended
controller.mImpl->ResetInputMethodContext();
controller.mImpl->SetClipboardHideEnable(false);
// Paste
- TextUpdater::PasteText(controller, stringToPaste);
+ TextUpdater::PasteText(controller, text);
controller.mImpl->SetClipboardHideEnable(true);
}
*/
static bool DeleteEvent(Controller& controller, int keyCode);
+ /// @copydoc Text::Controller::OnInputMethodContextEvent
+ /// @param[in] controller A reference to the controller class
static InputMethodContext::CallbackData OnInputMethodContextEvent(Controller& controller,
InputMethodContext& inputMethodContext,
const InputMethodContext::EventData& inputMethodContextEvent);
- static void PasteClipboardItemEvent(Controller& controller);
+ /**
+ * @brief This function executes the actual text update when a clipboard paste event occurs.
+ *
+ * @param[in] controller A reference to the controller class.
+ * @param[in] text The text data to be pasted into the text controller.
+ */
+ static void PasteClipboardItemEvent(Controller& controller, const std::string& text);
+
+ /// @copydoc Text::Controller::DecorationEvent
+ /// @param[in] controller A reference to the controller class
static void DecorationEvent(Controller& controller, HandleType handleType, HandleState state, float x, float y);
+
+ /// @copydoc Text::Controller::TextPopupButtonTouched
+ /// @param[in] controller A reference to the controller class
static void TextPopupButtonTouched(Controller& controller, Dali::Toolkit::TextSelectionPopup::Buttons button);
};
constexpr float MAX_FLOAT = std::numeric_limits<float>::max();
const char* EMPTY_STRING = "";
+const char* MIME_TYPE_TEXT_PLAIN = "text/plain;charset=utf-8";
} // namespace
bool Controller::Impl::CopyStringToClipboard(const std::string& source)
{
- //Send string to clipboard
- return (EnsureClipboardCreated() && mClipboard.SetItem(source));
+ if(EnsureClipboardCreated())
+ {
+ Dali::Clipboard::ClipData data(MIME_TYPE_TEXT_PLAIN, source.c_str());
+ return mClipboard.SetData(data); // Send clipboard data to clipboard.
+ }
+
+ return false;
}
void Controller::Impl::SendSelectionToClipboard(bool deleteAfterSending)
ChangeState(EventData::EDITING);
}
-void Controller::Impl::RequestGetTextFromClipboard()
-{
- if(EnsureClipboardCreated())
- {
- mClipboard.RequestItem();
- }
-}
-
void Controller::Impl::RepositionSelectionHandles()
{
SelectionHandleController::Reposition(*this);
*/
// EXTERNAL INCLUDES
-#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>
mModel = Model::New();
mFontClient = TextAbstraction::FontClient::Get();
- if(mEditableControlInterface != nullptr && TextClipboard::IsAvailable())
+ if(mEditableControlInterface != nullptr && Clipboard::IsAvailable())
{
- mClipboard = TextClipboard::Get();
+ mClipboard = Clipboard::Get();
}
mView.SetVisualModel(mModel->mVisualModel);
{
if(!mClipboard)
{
- mClipboard = TextClipboard::Get();
+ mClipboard = Clipboard::Get();
}
return mClipboard != nullptr ? true : false;
bool IsClipboardEmpty()
{
- bool result(TextClipboard::IsAvailable() && EnsureClipboardCreated() && mClipboard.NumberOfItems());
+ bool result(Clipboard::IsAvailable() && EnsureClipboardCreated() && mClipboard.NumberOfItems());
return !result; // If NumberOfItems greater than 0, return false
}
bool IsClipboardVisible()
{
- bool result(TextClipboard::IsAvailable() && EnsureClipboardCreated() && mClipboard.IsVisible());
+ bool result(Clipboard::IsAvailable() && EnsureClipboardCreated() && mClipboard.IsVisible());
return result;
}
void SendSelectionToClipboard(bool deleteAfterSending);
- void RequestGetTextFromClipboard();
-
void RepositionSelectionHandles();
void RepositionSelectionHandles(float visualX, float visualY, Controller::NoTextTap::Action action);
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.
- TextClipboard mClipboard; ///< Handle to the system clipboard
+ Clipboard 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.
#endif
const char* EMPTY_STRING = "";
+const char* MIME_TYPE_TEXT_PLAIN = "text/plain;charset=utf-8";
template<typename Type>
void EnsureCreated(Type*& object)
return mImpl->CutText();
}
-void Controller::PasteText()
+void Controller::PasteClipboardItemEvent(uint32_t id, const char* mimeType, const char* data)
{
- mImpl->RequestGetTextFromClipboard(); // Request clipboard service to retrieve an item
+ // Upon receiving the data, it is important to disconnect the signal
+ // to avoid potential unintended pasting caused by subsequent requests.
+ mImpl->mClipboard.DataReceivedSignal().Disconnect(this, &Controller::PasteClipboardItemEvent);
+
+ // If the id is 0u, it is an invalid response.
+ // text-controller allows only plain text type.
+ if(id != 0u && !strncmp(mimeType, MIME_TYPE_TEXT_PLAIN, strlen(MIME_TYPE_TEXT_PLAIN)))
+ {
+ EventHandler::PasteClipboardItemEvent(*this, data);
+ }
}
-InputMethodContext::CallbackData Controller::OnInputMethodContextEvent(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
+void Controller::PasteText()
{
- return EventHandler::OnInputMethodContextEvent(*this, inputMethodContext, inputMethodContextEvent);
+ if(mImpl->EnsureClipboardCreated())
+ {
+ // Connect the signal before calling GetData() of the clipboard.
+ mImpl->mClipboard.DataReceivedSignal().Connect(this, &Controller::PasteClipboardItemEvent);
+
+ // Request clipboard service to retrieve an item.
+ uint id = mImpl->mClipboard.GetData(MIME_TYPE_TEXT_PLAIN);
+ if(id == 0u)
+ {
+ // If the return id is 0u, the signal is not emitted, we must disconnect signal here.
+ mImpl->mClipboard.DataReceivedSignal().Disconnect(this, &Controller::PasteClipboardItemEvent);
+ }
+ }
}
-void Controller::PasteClipboardItemEvent()
+InputMethodContext::CallbackData Controller::OnInputMethodContextEvent(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
{
- EventHandler::PasteClipboardItemEvent(*this);
+ return EventHandler::OnInputMethodContextEvent(*this, inputMethodContext, inputMethodContextEvent);
}
void Controller::GetTargetSize(Vector2& targetSize)
// EXTERNAL INCLUDES
#include <dali-toolkit/devel-api/text/spanned.h>
+#include <dali/devel-api/adaptor-framework/clipboard.h>
#include <dali/devel-api/adaptor-framework/input-method-context.h>
#include <dali/public-api/events/gesture.h>
*
* The text selection popup button callbacks are as well handled via the TextSelectionPopupCallbackInterface interface.
*/
-class Controller : public RefObject, public Decorator::ControllerInterface, public TextSelectionPopupCallbackInterface, public HiddenText::Observer
+class Controller : public RefObject, public Decorator::ControllerInterface, public TextSelectionPopupCallbackInterface, public HiddenText::Observer, public ConnectionTracker
{
public: // Enumerated types.
/**
/**
* @brief Event from Clipboard notifying an Item has been selected for pasting
+ *
+ * @param[in] id The id of the data request.
+ * @param[in] mimeType The mime type of data received.
+ * @param[in] data The data received.
+ * @note
+ * This event is executed by receiving the Clipboard's DataReceivedSignal.
*/
- void PasteClipboardItemEvent();
+ void PasteClipboardItemEvent(uint32_t id, const char* mimeType, const char* data);
/**
* @brief Return true when text control should clear key input focus when escape key is pressed.
projects / platform / core / uifw / dali-toolkit.git / commitdiff