automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp

   1 /*
   2  * Copyright (c) 2014 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 #include "toolkit-clipboard.h"
  19
  20 // EXTERNAL INCLUDES
  21 #include <dali/public-api/object/base-object.h>
  22
  23 namespace Dali
  24 {
  25
  26 namespace Internal
  27 {
  28
  29 namespace Adaptor
  30 {
  31
  32 /**
  33  * Implementation of the Clipboard
  34  */
  35
  36 class Clipboard :  public Dali::BaseObject
  37 {
  38 public:
  39
  40   /**
  41    * @copydoc Dali::ClipboardEventNotifier::Get()
  42    */
  43   static Dali::Clipboard Get();
  44
  45   /**
  46    * Constructor
  47    * @param[in] ecoreXwin, The window is created by application.
  48    */
  49   Clipboard(/*Ecore_X_Window ecoreXwin*/);
  50   virtual ~Clipboard();
  51
  52   /**
  53    * @copydoc Dali::Clipboard::IsAvailable()
  54    */
  55   static bool IsAvailable();
  56
  57   /**
  58    * @copydoc Dali::Clipboard::DataSentSignal()
  59    */
  60   Dali::Clipboard::DataSentSignalType& DataSentSignal();
  61
  62   /**
  63    * @copydoc Dali::Clipboard::DataReceivedSignal()
  64    */
  65   Dali::Clipboard::DataReceivedSignalType& DataReceivedSignal();
  66
  67   /**
  68    * @copydoc Dali::Clipboard::HasType()
  69    */
  70   bool HasType(const std::string& mimeType);
  71
  72   /**
  73    * @copydoc Dali::Clipboard::SetData()
  74    */
  75   bool SetData(const Dali::Clipboard::ClipData& clipData);
  76
  77   /**
  78    * @copydoc Dali::Clipboard::GetData()
  79    */
  80   uint32_t GetData(const std::string &mimeType);
  81
  82   /**
  83    * @copydoc Dali::Clipboard::NumberOfClipboardItems()
  84    */
  85   size_t NumberOfItems();
  86
  87   /**
  88    * @copydoc Dali::Clipboard::ShowClipboard()
  89    */
  90   void ShowClipboard();
  91
  92   /**
  93    * @copydoc Dali::Clipboard::HideClipboard()
  94    */
  95   void HideClipboard();
  96
  97   /**
  98   * @copydoc Dali::Clipboard::IsVisible()
  99   */
 100   bool IsVisible() const;
 101
 102 private:
 103   Clipboard( const Clipboard& );
 104   Clipboard& operator=( Clipboard& );
 105
 106   static Dali::Clipboard mToolkitClipboard;
 107
 108   bool        mVisible;
 109   std::string mMimeType;
 110   std::string mData;
 111   uint32_t    mDataId{0};
 112   size_t      mCount;
 113
 114   Dali::Clipboard::DataSentSignalType     mDataSentSignal;
 115   Dali::Clipboard::DataReceivedSignalType mDataReceivedSignal;
 116 }; // class clipboard
 117
 118
 119 Dali::Clipboard Dali::Internal::Adaptor::Clipboard::mToolkitClipboard;
 120
 121
 122 Clipboard::Clipboard()
 123 {
 124   mVisible = false;
 125   mCount = 0u;
 126 }
 127
 128 Clipboard::~Clipboard()
 129 {
 130 }
 131
 132 Dali::Clipboard Clipboard::Get()
 133 {
 134   if(!mToolkitClipboard)
 135   {
 136     mToolkitClipboard = Dali::Clipboard(new Dali::Internal::Adaptor::Clipboard());
 137   }
 138   return mToolkitClipboard;
 139 }
 140
 141 bool Clipboard::IsAvailable()
 142 {
 143   if(mToolkitClipboard)
 144   {
 145     return true;
 146   }
 147   return false;
 148 }
 149
 150 Dali::Clipboard::DataSentSignalType& Clipboard::DataSentSignal()
 151 {
 152   return mDataSentSignal;
 153 }
 154
 155 Dali::Clipboard::DataReceivedSignalType& Clipboard::DataReceivedSignal()
 156 {
 157   return mDataReceivedSignal;
 158 }
 159
 160 bool Clipboard::HasType(const std::string& mimeType)
 161 {
 162   return mMimeType == mimeType ? true : false;
 163 }
 164
 165 bool Clipboard::SetData(const Dali::Clipboard::ClipData& clipData)
 166 {
 167   mMimeType = clipData.GetMimeType();
 168   mData     = clipData.GetData();
 169   mCount    = 1u;
 170
 171   if(mData.empty())
 172   {
 173     return false;
 174   }
 175
 176   mDataSentSignal.Emit(mMimeType.c_str(), mData.c_str());
 177
 178   return true;
 179 }
 180
 181 uint32_t Clipboard::GetData(const std::string &mimeType)
 182 {
 183   if(!mMimeType.compare(mimeType.c_str()))
 184   {
 185     mDataId++;
 186     mDataReceivedSignal.Emit(mDataId, mMimeType.c_str(), mData.c_str());
 187     return mDataId;
 188   }
 189   return 0u;
 190 }
 191
 192 size_t Clipboard::NumberOfItems()
 193 {
 194   return mCount;
 195 }
 196
 197 void Clipboard::ShowClipboard()
 198 {
 199   mVisible = true;
 200 }
 201
 202 void Clipboard::HideClipboard()
 203 {
 204   mVisible = false;
 205 }
 206
 207 bool Clipboard::IsVisible() const
 208 {
 209   return mVisible;
 210 }
 211
 212 } // namespace Adaptor
 213
 214 } // namespace Internal
 215
 216
 217 inline static Internal::Adaptor::Clipboard& GetImplementation(Dali::Clipboard& clipboard)
 218 {
 219   // Bypass any passed in clipboard handle - it probably won't be initialized
 220   Dali::Clipboard theClipboard = Dali::Clipboard::Get();
 221   BaseObject& object = theClipboard.GetBaseObject();
 222   return static_cast<Internal::Adaptor::Clipboard&>(object);
 223 }
 224
 225 inline static const  Internal::Adaptor::Clipboard& GetImplementation(const Dali::Clipboard& clipboard)
 226 {
 227   // Bypass any passed in clipboard handle - it probably won't be initialized
 228   Dali::Clipboard theClipboard = Dali::Clipboard::Get();
 229   const BaseObject& object = theClipboard.GetBaseObject();
 230   return static_cast<const Internal::Adaptor::Clipboard&>(object);
 231 }
 232
 233
 234 Clipboard::Clipboard()
 235 {
 236 }
 237 Clipboard::~Clipboard()
 238 {
 239 }
 240 Clipboard::Clipboard(Internal::Adaptor::Clipboard *impl)
 241   : BaseHandle(impl)
 242 {
 243 }
 244
 245 Clipboard Clipboard::Get()
 246 {
 247   return Internal::Adaptor::Clipboard::Get();
 248 }
 249
 250 size_t Clipboard::NumberOfItems()
 251 {
 252   return GetImplementation(*this).NumberOfItems();
 253 }
 254
 255 void Clipboard::ShowClipboard()
 256 {
 257   GetImplementation(*this).ShowClipboard();
 258 }
 259
 260 void Clipboard::HideClipboard()
 261 {
 262   GetImplementation(*this).HideClipboard();
 263 }
 264
 265 bool Clipboard::IsVisible() const
 266 {
 267   return GetImplementation(*this).IsVisible();
 268 }
 269
 270 } // namespace Dali