X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Fdevel-api%2Fadaptor-framework%2Fwindow-devel.cpp;h=34b609a19f91aebf5f38dc67802d0f614d9fbe20;hb=c14e40e115165083feb961ddc43fc298bfe83859;hp=3cd89e2d02fa318f331f52563b39c871a63dd285;hpb=5a5baed26c6a946192134f68532b1ba6f3581566;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git

diff --git a/dali/devel-api/adaptor-framework/window-devel.cpp b/dali/devel-api/adaptor-framework/window-devel.cpp
index 3cd89e2..34b609a 100644
--- a/dali/devel-api/adaptor-framework/window-devel.cpp
+++ b/dali/devel-api/adaptor-framework/window-devel.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
@@ -16,8 +16,8 @@
  */
 
 // EXTERNAL INCLUDES
+#include <dali/public-api/adaptor-framework/window-enumerations.h>
 #include <dali/public-api/events/key-event.h>
-#include <dali/public-api/events/touch-event.h>
 #include <dali/public-api/events/wheel-event.h>
 
 // INTERNAL INCLUDES
@@ -26,10 +26,8 @@
 
 namespace Dali
 {
-
 namespace DevelWindow
 {
-
 Window New(Any surface, PositionSize windowPosition, const std::string& name, bool isTransparent)
 {
   return DevelWindow::New(surface, windowPosition, name, "", isTransparent);
@@ -40,23 +38,23 @@ Window New(Any surface, PositionSize windowPosition, const std::string& name, co
   Window newWindow;
 
   const bool isAdaptorAvailable = Dali::Adaptor::IsAvailable();
-  bool isNewWindowAllowed = true;
+  bool       isNewWindowAllowed = true;
 
-  if (isAdaptorAvailable)
+  if(isAdaptorAvailable)
   {
     Dali::Adaptor& adaptor = Internal::Adaptor::Adaptor::Get();
-    isNewWindowAllowed = Internal::Adaptor::Adaptor::GetImplementation(adaptor).IsMultipleWindowSupported();
+    isNewWindowAllowed     = Internal::Adaptor::Adaptor::GetImplementation(adaptor).IsMultipleWindowSupported();
   }
 
-  if (isNewWindowAllowed)
+  if(isNewWindowAllowed)
   {
-    Internal::Adaptor::Window* window = Internal::Adaptor::Window::New(surface, windowPosition, name, className, isTransparent);
+    Internal::Adaptor::Window* window = Internal::Adaptor::Window::New(surface, windowPosition, name, className, WindowType::NORMAL, isTransparent);
 
     Integration::SceneHolder sceneHolder = Integration::SceneHolder(window);
-    if (isAdaptorAvailable)
+    if(isAdaptorAvailable)
     {
       Dali::Adaptor& adaptor = Internal::Adaptor::Adaptor::Get();
-      Internal::Adaptor::Adaptor::GetImplementation(adaptor).AddWindow(sceneHolder, name, className, isTransparent);
+      Internal::Adaptor::Adaptor::GetImplementation(adaptor).AddWindow(sceneHolder);
     }
     newWindow = Window(window);
   }
@@ -68,89 +66,182 @@ Window New(Any surface, PositionSize windowPosition, const std::string& name, co
   return newWindow;
 }
 
-void SetPositionSize( Window window, PositionSize positionSize )
+void SetPositionSize(Window window, PositionSize positionSize)
+{
+  GetImplementation(window).SetPositionSize(positionSize);
+}
+
+Window Get(Actor actor)
+{
+  return Internal::Adaptor::Window::Get(actor);
+}
+
+EventProcessingFinishedSignalType& EventProcessingFinishedSignal(Window window)
+{
+  return GetImplementation(window).EventProcessingFinishedSignal();
+}
+
+WheelEventSignalType& WheelEventSignal(Window window)
+{
+  return GetImplementation(window).WheelEventSignal();
+}
+
+VisibilityChangedSignalType& VisibilityChangedSignal(Window window)
+{
+  return GetImplementation(window).VisibilityChangedSignal();
+}
+
+TransitionEffectEventSignalType& TransitionEffectEventSignal(Window window)
+{
+  return GetImplementation(window).TransitionEffectEventSignal();
+}
+
+KeyboardRepeatSettingsChangedSignalType& KeyboardRepeatSettingsChangedSignal(Window window)
+{
+  return GetImplementation(window).KeyboardRepeatSettingsChangedSignal();
+}
+
+AuxiliaryMessageSignalType& AuxiliaryMessageSignal(Window window)
+{
+  return GetImplementation(window).AuxiliaryMessageSignal();
+}
+
+AccessibilityHighlightSignalType& AccessibilityHighlightSignal(Window window)
+{
+  return GetImplementation(window).AccessibilityHighlightSignal();
+}
+
+void SetParent(Window window, Window parent)
+{
+  GetImplementation(window).SetParent(parent);
+}
+
+void SetParent(Window window, Window parent, bool belowParent)
+{
+  GetImplementation(window).SetParent(parent, belowParent);
+}
+
+void Unparent(Window window)
+{
+  GetImplementation(window).Unparent();
+}
+
+Window GetParent(Window window)
+{
+  return GetImplementation(window).GetParent();
+}
+
+Window DownCast(BaseHandle handle)
+{
+  return Window(dynamic_cast<Dali::Internal::Adaptor::Window*>(handle.GetObjectPtr()));
+}
+
+WindowOrientation GetCurrentOrientation(Window window)
+{
+  return GetImplementation(window).GetCurrentOrientation();
+}
+
+int GetPhysicalOrientation(Window window)
+{
+  return GetImplementation(window).GetPhysicalOrientation();
+}
+
+void SetAvailableOrientations(Window window, const Dali::Vector<WindowOrientation>& orientations)
+{
+  GetImplementation(window).SetAvailableOrientations(orientations);
+}
+
+int32_t GetNativeId(Window window)
+{
+  return GetImplementation(window).GetNativeId();
+}
+
+void AddFrameRenderedCallback(Window window, std::unique_ptr<CallbackBase> callback, int32_t frameId)
 {
-  GetImplementation( window ).SetPositionSize( positionSize );
+  GetImplementation(window).AddFrameRenderedCallback(std::move(callback), frameId);
 }
 
-Window Get( Actor actor )
+void AddFramePresentedCallback(Window window, std::unique_ptr<CallbackBase> callback, int32_t frameId)
 {
-  return Internal::Adaptor::Window::Get( actor );
+  GetImplementation(window).AddFramePresentedCallback(std::move(callback), frameId);
 }
 
-EventProcessingFinishedSignalType& EventProcessingFinishedSignal( Window window )
+void SetPositionSizeWithOrientation(Window window, PositionSize positionSize, WindowOrientation orientation)
 {
-  return GetImplementation( window ).EventProcessingFinishedSignal();
+  GetImplementation(window).SetPositionSizeWithOrientation(positionSize, orientation);
 }
 
-WheelEventSignalType& WheelEventSignal( Window window )
+void RequestMoveToServer(Window window)
 {
-  return GetImplementation( window ).WheelEventSignal();
+  GetImplementation(window).RequestMoveToServer();
 }
 
-VisibilityChangedSignalType& VisibilityChangedSignal( Window window )
+void RequestResizeToServer(Window window, WindowResizeDirection direction)
 {
-  return GetImplementation( window ).VisibilityChangedSignal();
+  GetImplementation(window).RequestResizeToServer(direction);
 }
 
-TransitionEffectEventSignalType& TransitionEffectEventSignal( Window window )
+void EnableFloatingMode(Window window, bool enable)
 {
-  return GetImplementation( window ).TransitionEffectEventSignal();
+  GetImplementation(window).EnableFloatingMode(enable);
 }
 
-KeyboardRepeatSettingsChangedSignalType& KeyboardRepeatSettingsChangedSignal( Window window )
+void IncludeInputRegion(Window window, const Rect<int>& inputRegion)
 {
-  return GetImplementation( window ).KeyboardRepeatSettingsChangedSignal();
+  GetImplementation(window).IncludeInputRegion(inputRegion);
 }
 
-void SetParent( Window window, Window parent )
+void ExcludeInputRegion(Window window, const Rect<int>& inputRegion)
 {
-  GetImplementation( window ).SetParent( parent );
+  GetImplementation(window).ExcludeInputRegion(inputRegion);
 }
 
-void Unparent( Window window )
+void SetNeedsRotationCompletedAcknowledgement(Window window, bool needAcknowledgement)
 {
-  GetImplementation( window ).Unparent();
+  GetImplementation(window).SetNeedsRotationCompletedAcknowledgement(needAcknowledgement);
 }
 
-Window GetParent( Window window )
+void SendRotationCompletedAcknowledgement(Window window)
 {
-  return GetImplementation( window ).GetParent();
+  GetImplementation(window).SendRotationCompletedAcknowledgement();
 }
 
-Window DownCast( BaseHandle handle )
+void FeedTouchPoint(Window window, const Dali::TouchPoint& point, int32_t timeStamp)
 {
-  return Window( dynamic_cast<Dali::Internal::Adaptor::Window*>( handle.GetObjectPtr()) );
+  Integration::Point convertedPoint(point);
+  GetImplementation(window).FeedTouchPoint(convertedPoint, timeStamp);
 }
 
-Dali::Window::WindowOrientation GetCurrentOrientation( Window window )
+void FeedWheelEvent(Window window, const Dali::WheelEvent& wheelEvent)
 {
-  return GetImplementation( window ).GetCurrentOrientation();
+  Integration::WheelEvent convertedEvent(static_cast<Integration::WheelEvent::Type>(wheelEvent.GetType()), wheelEvent.GetDirection(), wheelEvent.GetModifiers(), wheelEvent.GetPoint(), wheelEvent.GetDelta(), wheelEvent.GetTime());
+  GetImplementation(window).FeedWheelEvent(convertedEvent);
 }
 
-void SetAvailableOrientations( Window window, const Dali::Vector<Dali::Window::WindowOrientation>& orientations )
+void FeedKeyEvent(Window window, const Dali::KeyEvent& keyEvent)
 {
-  GetImplementation( window ).SetAvailableOrientations( orientations );
+  Integration::KeyEvent convertedEvent(keyEvent.GetKeyName(), keyEvent.GetLogicalKey(), keyEvent.GetKeyString(), keyEvent.GetKeyCode(), keyEvent.GetKeyModifier(), keyEvent.GetTime(), static_cast<Integration::KeyEvent::State>(keyEvent.GetState()), keyEvent.GetCompose(), keyEvent.GetDeviceName(), keyEvent.GetDeviceClass(), keyEvent.GetDeviceSubclass());
+  GetImplementation(window).FeedKeyEvent(convertedEvent);
 }
 
-int32_t GetNativeId( Window window )
+void Maximize(Window window, bool maximize)
 {
-  return GetImplementation( window ).GetNativeId();
+  GetImplementation(window).Maximize(maximize);
 }
 
-void SetDamagedAreas(Window window, std::vector<Dali::Rect<int>>& areas)
+bool IsMaximized(Window window)
 {
-  GetImplementation(window).SetDamagedAreas(areas);
+  return GetImplementation(window).IsMaximized();
 }
 
-void AddFrameRenderedCallback( Window window, std::unique_ptr< CallbackBase > callback, int32_t frameId )
+void Minimize(Window window, bool miniimize)
 {
-  GetImplementation( window ).AddFrameRenderedCallback( std::move( callback ), frameId );
+  GetImplementation(window).Minimize(miniimize);
 }
 
-void AddFramePresentedCallback( Window window, std::unique_ptr< CallbackBase > callback, int32_t frameId )
+bool IsMinimized(Window window)
 {
-  GetImplementation( window ).AddFramePresentedCallback( std::move( callback ), frameId );
+  return GetImplementation(window).IsMinimized();
 }
 
 } // namespace DevelWindow