automated-tests/src/dali-toolkit/dali-toolkit-test-utils/dummy-control.cpp

   1 /*
   2  * Copyright (c) 2024 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 "dummy-control.h"
  19
  20 #include <dali-toolkit/dali-toolkit.h>
  21 #include <dali-toolkit/devel-api/controls/control-devel.h>
  22 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  23
  24 namespace Dali
  25 {
  26 namespace Toolkit
  27 {
  28 DummyControl::DummyControl()
  29 {
  30 }
  31
  32 DummyControl::DummyControl(const DummyControl& control)
  33 : Control(control)
  34 {
  35 }
  36
  37 DummyControl::~DummyControl()
  38 {
  39 }
  40
  41 DummyControl DummyControl::DownCast(BaseHandle handle)
  42 {
  43   return Control::DownCast<DummyControl, DummyControlImpl>(handle);
  44 }
  45
  46 DummyControl& DummyControl::operator=(const DummyControl& control)
  47 {
  48   Control::operator=(control);
  49   return *this;
  50 }
  51
  52 // Used to test signal connections
  53 void DummyControlImpl::CustomSlot1(Actor actor)
  54 {
  55   mCustomSlot1Called = true;
  56 }
  57
  58 namespace
  59 {
  60 BaseHandle Create()
  61 {
  62   return DummyControlImpl::New();
  63 }
  64
  65 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::DummyControl, Toolkit::Control, Create);
  66 DALI_TYPE_REGISTRATION_END()
  67
  68 Dali::PropertyRegistration dummyControlVisualProperty01(
  69   typeRegistration, "testVisual", Dali::Toolkit::DummyControl::Property::TEST_VISUAL, Dali::Property::MAP, &Dali::Toolkit::DummyControlImpl::SetProperty, &Dali::Toolkit::DummyControlImpl::GetProperty);
  70
  71 Dali::PropertyRegistration dummyControlVisualProperty02(
  72   typeRegistration, "testVisual2", Dali::Toolkit::DummyControl::Property::TEST_VISUAL2, Dali::Property::MAP, &Dali::Toolkit::DummyControlImpl::SetProperty, &Dali::Toolkit::DummyControlImpl::GetProperty);
  73
  74 Dali::PropertyRegistration dummyControlVisualProperty03(
  75   typeRegistration, "foregroundVisual", Dali::Toolkit::DummyControl::Property::FOREGROUND_VISUAL, Dali::Property::MAP, &Dali::Toolkit::DummyControlImpl::SetProperty, &Dali::Toolkit::DummyControlImpl::GetProperty);
  76
  77 Dali::PropertyRegistration dummyControlVisualProperty04(
  78   typeRegistration, "focusVisual", Dali::Toolkit::DummyControl::Property::FOCUS_VISUAL, Dali::Property::MAP, &Dali::Toolkit::DummyControlImpl::SetProperty, &Dali::Toolkit::DummyControlImpl::GetProperty);
  79
  80 Dali::PropertyRegistration dummyControlVisualProperty05(
  81   typeRegistration, "labelVisual", Dali::Toolkit::DummyControl::Property::LABEL_VISUAL, Dali::Property::MAP, &Dali::Toolkit::DummyControlImpl::SetProperty, &Dali::Toolkit::DummyControlImpl::GetProperty);
  82
  83 } // namespace
  84
  85 DummyControl DummyControlImpl::New()
  86 {
  87   IntrusivePtr<DummyControlImpl> impl = new DummyControlImpl;
  88   DummyControl                   control(*impl);
  89   impl->Initialize();
  90   return control;
  91 }
  92
  93 DummyControlImpl::DummyControlImpl()
  94 : Control(ControlBehaviour()),
  95   mCustomSlot1Called(false)
  96 {
  97 }
  98
  99 DummyControlImpl::~DummyControlImpl()
 100 {
 101 }
 102
 103 void DummyControlImpl::RegisterVisual(Property::Index index, Toolkit::Visual::Base visual)
 104 {
 105   DevelControl::RegisterVisual(*this, index, visual);
 106
 107   VisualIndices::iterator iter = std::find(mRegisteredVisualIndices.begin(), mRegisteredVisualIndices.end(), index);
 108   if(iter == mRegisteredVisualIndices.end())
 109   {
 110     mRegisteredVisualIndices.push_back(index);
 111   }
 112 }
 113
 114 void DummyControlImpl::RegisterVisual(Property::Index index, Toolkit::Visual::Base visual, bool enabled)
 115 {
 116   DevelControl::RegisterVisual(*this, index, visual, enabled);
 117
 118   VisualIndices::iterator iter = std::find(mRegisteredVisualIndices.begin(), mRegisteredVisualIndices.end(), index);
 119   if(iter == mRegisteredVisualIndices.end())
 120   {
 121     mRegisteredVisualIndices.push_back(index);
 122   }
 123 }
 124
 125 void DummyControlImpl::RegisterVisual(Property::Index index, Toolkit::Visual::Base visual, int depthIndex)
 126 {
 127   DevelControl::RegisterVisual(*this, index, visual, depthIndex);
 128
 129   VisualIndices::iterator iter = std::find(mRegisteredVisualIndices.begin(), mRegisteredVisualIndices.end(), index);
 130   if(iter == mRegisteredVisualIndices.end())
 131   {
 132     mRegisteredVisualIndices.push_back(index);
 133   }
 134 }
 135
 136 void DummyControlImpl::UnregisterVisual(Property::Index index)
 137 {
 138   DevelControl::UnregisterVisual(*this, index);
 139
 140   VisualIndices::iterator iter = std::find(mRegisteredVisualIndices.begin(), mRegisteredVisualIndices.end(), index);
 141   if(iter != mRegisteredVisualIndices.end())
 142   {
 143     mRegisteredVisualIndices.erase(iter);
 144   }
 145 }
 146
 147 Toolkit::Visual::Base DummyControlImpl::GetVisual(Property::Index index)
 148 {
 149   return DevelControl::GetVisual(*this, index);
 150 }
 151
 152 void DummyControlImpl::EnableVisual(Property::Index index, bool enabled)
 153 {
 154   DevelControl::EnableVisual(*this, index, enabled);
 155 }
 156
 157 bool DummyControlImpl::IsVisualEnabled(Property::Index index)
 158 {
 159   return DevelControl::IsVisualEnabled(*this, index);
 160 }
 161
 162 Animation DummyControlImpl::CreateTransition(const Toolkit::TransitionData& transition)
 163 {
 164   return DevelControl::CreateTransition(*this, transition);
 165 }
 166
 167 void DummyControlImpl::DoAction(Dali::Property::Index index, Dali::Property::Index action, const Dali::Property::Value attributes)
 168 {
 169   DummyControl control(*this);
 170   DevelControl::DoAction(control, index, action, attributes);
 171 }
 172
 173 void DummyControlImpl::SetProperty(BaseObject* object, Dali::Property::Index index, const Dali::Property::Value& value)
 174 {
 175   Toolkit::DummyControl control   = Toolkit::DummyControl::DownCast(Dali::BaseHandle(object));
 176   DummyControlImpl&     dummyImpl = static_cast<DummyControlImpl&>(control.GetImplementation());
 177
 178   switch(index)
 179   {
 180     case Toolkit::DummyControl::Property::TEST_VISUAL:
 181     case Toolkit::DummyControl::Property::TEST_VISUAL2:
 182     case Toolkit::DummyControl::Property::FOREGROUND_VISUAL:
 183     case Toolkit::DummyControl::Property::FOCUS_VISUAL:
 184     case Toolkit::DummyControl::Property::LABEL_VISUAL:
 185     {
 186       const Property::Map* map = value.GetMap();
 187       if(map != NULL)
 188       {
 189         VisualFactory visualFactory = VisualFactory::Get();
 190         Visual::Base  visual        = visualFactory.CreateVisual(*map);
 191         dummyImpl.RegisterVisual(index, visual);
 192       }
 193       break;
 194     }
 195   }
 196 }
 197
 198 Property::Value DummyControlImpl::GetProperty(BaseObject* object, Dali::Property::Index propertyIndex)
 199 {
 200   Toolkit::DummyControl control   = Toolkit::DummyControl::DownCast(Dali::BaseHandle(object));
 201   DummyControlImpl&     dummyImpl = static_cast<DummyControlImpl&>(control.GetImplementation());
 202
 203   Visual::Base  visual = dummyImpl.GetVisual(propertyIndex);
 204   Property::Map map;
 205   if(visual)
 206   {
 207     visual.CreatePropertyMap(map);
 208   }
 209   Dali::Property::Value value = map;
 210
 211   return value;
 212 }
 213
 214 Toolkit::DummyControl Impl::DummyControl::New()
 215 {
 216   IntrusivePtr<Toolkit::Impl::DummyControl> impl = new Toolkit::Impl::DummyControl;
 217   Toolkit::DummyControl                     control(*impl);
 218   impl->Initialize();
 219   return control;
 220 }
 221
 222 int Impl::DummyControl::constructorCount;
 223 int Impl::DummyControl::destructorCount;
 224
 225 Impl::DummyControl::DummyControl()
 226 : DummyControlImpl(),
 227   initializeCalled(false),
 228   activatedCalled(false),
 229   onAccValueChangeCalled(false),
 230   themeChangeCalled(false),
 231   fontChangeCalled(false),
 232   pinchCalled(false),
 233   panCalled(false),
 234   tapCalled(false),
 235   longPressCalled(false),
 236   stageConnectionCalled(false),
 237   stageDisconnectionCalled(false),
 238   childAddCalled(false),
 239   childRemoveCalled(false),
 240   sizeSetCalled(false),
 241   sizeAnimationCalled(false),
 242   hoverEventCalled(false),
 243   wheelEventCalled(false),
 244   keyEventCalled(false),
 245   keyInputFocusGained(false),
 246   keyInputFocusLost(false)
 247 {
 248   ++constructorCount;
 249 }
 250
 251 Impl::DummyControl::~DummyControl()
 252 {
 253   ++destructorCount;
 254 }
 255
 256 void Impl::DummyControl::OnInitialize()
 257 {
 258   initializeCalled = true;
 259 }
 260 bool Impl::DummyControl::OnAccessibilityActivated()
 261 {
 262   activatedCalled = true;
 263   return true;
 264 }
 265 bool Impl::DummyControl::OnAccessibilityValueChange(bool isIncrease)
 266 {
 267   onAccValueChangeCalled = true;
 268   return true;
 269 }
 270
 271 void Impl::DummyControl::OnStyleChange(Toolkit::StyleManager styleManager, StyleChange::Type change)
 272 {
 273   themeChangeCalled = change == StyleChange::THEME_CHANGE;
 274   fontChangeCalled  = change == StyleChange::DEFAULT_FONT_SIZE_CHANGE;
 275 }
 276 void Impl::DummyControl::OnPinch(const PinchGesture& pinch)
 277 {
 278   pinchCalled = true;
 279 }
 280 void Impl::DummyControl::OnPan(const PanGesture& pan)
 281 {
 282   panCalled = true;
 283 }
 284 void Impl::DummyControl::OnTap(const TapGesture& tap)
 285 {
 286   tapCalled = true;
 287 }
 288 void Impl::DummyControl::OnLongPress(const LongPressGesture& longPress)
 289 {
 290   longPressCalled = true;
 291 }
 292 void Impl::DummyControl::OnSceneConnection(int depth)
 293 {
 294   Control::OnSceneConnection(depth);
 295   stageConnectionCalled = true;
 296 }
 297 void Impl::DummyControl::OnSceneDisconnection()
 298 {
 299   stageDisconnectionCalled = true;
 300   Control::OnSceneDisconnection();
 301 }
 302 void Impl::DummyControl::OnChildAdd(Actor& child)
 303 {
 304   childAddCalled = true;
 305 }
 306 void Impl::DummyControl::OnChildRemove(Actor& child)
 307 {
 308   childRemoveCalled = true;
 309 }
 310 void Impl::DummyControl::OnSizeSet(const Vector3& targetSize)
 311 {
 312   Control::OnSizeSet(targetSize);
 313   sizeSetCalled = true;
 314 }
 315 void Impl::DummyControl::OnSizeAnimation(Animation& animation, const Vector3& targetSize)
 316 {
 317   Control::OnSizeAnimation(animation, targetSize);
 318   sizeAnimationCalled = true;
 319 }
 320 bool Impl::DummyControl::OnKeyEvent(const KeyEvent& event)
 321 {
 322   keyEventCalled = true;
 323   return false;
 324 }
 325 void Impl::DummyControl::OnKeyInputFocusGained()
 326 {
 327   if(this->HasKeyInputFocus())
 328   {
 329     keyInputFocusGained = true;
 330   }
 331 }
 332 void Impl::DummyControl::OnKeyInputFocusLost()
 333 {
 334   if(!this->HasKeyInputFocus())
 335   {
 336     keyInputFocusLost = true;
 337   }
 338 }
 339
 340 void Impl::DummyControl::SetLayout(Property::Index visualIndex, Property::Map& map)
 341 {
 342   Property::Value value(map);
 343   mLayouts[visualIndex] = value;
 344 }
 345
 346 void Impl::DummyControl::OnRelayout(const Vector2& size, RelayoutContainer& container)
 347 {
 348   if(mRelayoutCallback)
 349   {
 350     mRelayoutCallback(size); // Execute callback if set
 351   }
 352
 353   Property::Map emptyMap;
 354
 355   for(VisualIndices::iterator iter = mRegisteredVisualIndices.begin(); iter != mRegisteredVisualIndices.end(); ++iter)
 356   {
 357     Visual::Base    visual = GetVisual(*iter);
 358     Property::Value value  = mLayouts[*iter];
 359     Property::Map*  map    = NULL;
 360
 361     if(value.GetType() != Property::NONE)
 362     {
 363       map = value.GetMap();
 364     }
 365     if(map == NULL)
 366     {
 367       map = &emptyMap;
 368     }
 369
 370     visual.SetTransformAndSize(*map, size);
 371   }
 372 }
 373
 374 void Impl::DummyControl::SetRelayoutCallback(RelayoutCallbackFunc callback)
 375 {
 376   mRelayoutCallback = callback;
 377 }
 378
 379 Vector3 Impl::DummyControl::GetNaturalSize()
 380 {
 381   Vector2 currentSize;
 382
 383   for(auto elem : mRegisteredVisualIndices)
 384   {
 385     Vector2      naturalSize;
 386     Visual::Base visual = GetVisual(elem);
 387     visual.GetNaturalSize(naturalSize);
 388     currentSize.width  = std::max(naturalSize.width, currentSize.width);
 389     currentSize.height = std::max(naturalSize.height, currentSize.height);
 390   }
 391
 392   return Vector3(currentSize);
 393 }
 394
 395 DummyControl DummyControl::New(bool override)
 396 {
 397   DummyControl control;
 398
 399   if(override)
 400   {
 401     control = Impl::DummyControl::New();
 402   }
 403   else
 404   {
 405     control = DummyControlImpl::New();
 406   }
 407
 408   return control;
 409 }
 410
 411 DummyControl::DummyControl(DummyControlImpl& implementation)
 412 : Control(implementation)
 413 {
 414 }
 415
 416 DummyControl::DummyControl(Dali::Internal::CustomActor* internal)
 417 : Control(internal)
 418 {
 419   VerifyCustomActorPointer<DummyControlImpl>(internal);
 420 }
 421
 422 } // namespace Toolkit
 423
 424 } // namespace Dali