5851ab24021ef397094073e571152009fe2b7b1f
[platform/core/uifw/dali-adaptor.git] / dali / internal / window-system / common / window-impl.cpp
1 /*
2  * Copyright (c) 2019 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 // CLASS HEADER
19 #include <dali/internal/window-system/common/window-impl.h>
20
21 // EXTERNAL HEADERS
22 #include <thread>
23 #include <dali/integration-api/core.h>
24 #include <dali/public-api/actors/actor.h>
25 #include <dali/public-api/actors/layer.h>
26 #include <dali/public-api/actors/camera-actor.h>
27 #include <dali/public-api/render-tasks/render-task.h>
28 #include <dali/public-api/render-tasks/render-task-list.h>
29 #include <dali/public-api/rendering/frame-buffer.h>
30 #include <dali/devel-api/adaptor-framework/orientation.h>
31 #include <dali/integration-api/events/touch-event-integ.h>
32
33 // INTERNAL HEADERS
34 #include <dali/integration-api/adaptor-framework/render-surface-interface.h>
35 #include <dali/internal/window-system/common/event-handler.h>
36 #include <dali/internal/window-system/common/orientation-impl.h>
37 #include <dali/internal/window-system/common/render-surface-factory.h>
38 #include <dali/internal/window-system/common/window-factory.h>
39 #include <dali/internal/window-system/common/window-base.h>
40 #include <dali/internal/window-system/common/window-system.h>
41 #include <dali/internal/window-system/common/window-render-surface.h>
42 #include <dali/internal/window-system/common/window-visibility-observer.h>
43
44 namespace Dali
45 {
46 namespace Internal
47 {
48 namespace Adaptor
49 {
50
51 namespace
52 {
53
54 #if defined(DEBUG_ENABLED)
55 Debug::Filter* gWindowLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_WINDOW" );
56 #endif
57
58 } // unnamed namespace
59
60 Window* Window::New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
61 {
62   Any surface;
63   return Window::New(surface, positionSize, name, className, isTransparent);
64 }
65
66 Window* Window::New(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
67 {
68   Window* window = new Window();
69   window->mIsTransparent = isTransparent;
70   window->Initialize(surface, positionSize, name, className);
71   return window;
72 }
73
74 Window::Window()
75 : mWindowSurface( nullptr ),
76   mWindowBase(),
77   mIsTransparent( false ),
78   mIsFocusAcceptable( true ),
79   mIconified( false ),
80   mOpaqueState( false ),
81   mResizeEnabled( false ),
82   mType( Dali::Window::NORMAL ),
83   mParentWindow( NULL ),
84   mPreferredAngle( Dali::Window::NO_ORIENTATION_PREFERENCE ),
85   mRotationAngle( -1 ),
86   mWindowWidth( 0 ),
87   mWindowHeight( 0 ),
88   mOrientationMode( Internal::Adaptor::Window::OrientationMode::PORTRAIT ),
89   mNativeWindowId( -1 ),
90   mFocusChangedSignal(),
91   mResizedSignal(),
92   mDeleteRequestSignal(),
93   mFocusChangeSignal(),
94   mResizeSignal(),
95   mVisibilityChangedSignal(),
96   mTransitionEffectEventSignal()
97 {
98 }
99
100 Window::~Window()
101 {
102   if ( mEventHandler )
103   {
104     mEventHandler->RemoveObserver( *this );
105   }
106 }
107
108 void Window::Initialize(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className)
109 {
110   // Create a window render surface
111   auto renderSurfaceFactory = Dali::Internal::Adaptor::GetRenderSurfaceFactory();
112   mSurface = renderSurfaceFactory->CreateWindowRenderSurface( positionSize, surface, mIsTransparent );
113   mWindowSurface = static_cast<WindowRenderSurface*>( mSurface.get() );
114
115   // Get a window base
116   mWindowBase = mWindowSurface->GetWindowBase();
117
118   // Connect signals
119   mWindowBase->IconifyChangedSignal().Connect( this, &Window::OnIconifyChanged );
120   mWindowBase->FocusChangedSignal().Connect( this, &Window::OnFocusChanged );
121   mWindowBase->DeleteRequestSignal().Connect( this, &Window::OnDeleteRequest );
122   mWindowBase->TransitionEffectEventSignal().Connect( this, &Window::OnTransitionEffectEvent );
123
124   mWindowSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed );
125
126   if( !positionSize.IsEmpty() )
127   {
128     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
129     mResizeEnabled = true;
130   }
131
132   SetClass( name, className );
133
134   mWindowSurface->Map();
135
136   mOrientation = Orientation::New( this );
137
138   // Get OrientationMode
139   int screenWidth, screenHeight;
140   WindowSystem::GetScreenSize( screenWidth, screenHeight );
141   if( screenWidth > screenHeight )
142   {
143     mOrientationMode = Internal::Adaptor::Window::OrientationMode::LANDSCAPE;
144   }
145   else
146   {
147     mOrientationMode = Internal::Adaptor::Window::OrientationMode::PORTRAIT;
148   }
149   // For Debugging
150   mNativeWindowId = mWindowBase->GetNativeWindowId();
151 }
152
153 void Window::OnAdaptorSet(Dali::Adaptor& adaptor)
154 {
155   mEventHandler = EventHandlerPtr(new EventHandler( mWindowSurface, *mAdaptor ) );
156   mEventHandler->AddObserver( *this );
157 }
158
159 void Window::OnSurfaceSet( Dali::RenderSurfaceInterface* surface )
160 {
161   mWindowSurface = static_cast<WindowRenderSurface*>( surface );
162 }
163
164 void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode )
165 {
166 }
167
168 void Window::SetIndicatorBgOpacity( Dali::Window::IndicatorBgOpacity opacityMode )
169 {
170 }
171
172 void Window::RotateIndicator( Dali::Window::WindowOrientation orientation )
173 {
174 }
175
176 void Window::SetClass( std::string name, std::string className )
177 {
178   mName = name;
179   mClassName = className;
180   mWindowBase->SetClass( name, className );
181 }
182
183 std::string Window::GetClassName() const
184 {
185   return mClassName;
186 }
187
188 void Window::Raise()
189 {
190   mWindowBase->Raise();
191   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Raise() \n", this, mNativeWindowId );
192 }
193
194 void Window::Lower()
195 {
196   mWindowBase->Lower();
197   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Lower() \n", this, mNativeWindowId );
198 }
199
200 void Window::Activate()
201 {
202   mWindowBase->Activate();
203   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Activate() \n", this, mNativeWindowId );
204 }
205
206 uint32_t Window::GetLayerCount() const
207 {
208   return mScene.GetLayerCount();
209 }
210
211 Dali::Layer Window::GetLayer( uint32_t depth ) const
212 {
213   return mScene.GetLayer( depth );
214 }
215
216 Dali::RenderTaskList Window::GetRenderTaskList() const
217 {
218   return mScene.GetRenderTaskList();
219 }
220
221 void Window::AddAvailableOrientation( Dali::Window::WindowOrientation orientation )
222 {
223   if( IsOrientationAvailable( orientation ) == false )
224   {
225     return;
226   }
227
228   bool found = false;
229   int convertedAngle = ConvertToAngle( orientation );
230   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), AddAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle );
231   for( std::size_t i = 0; i < mAvailableAngles.size(); i++ )
232   {
233     if( mAvailableAngles[i] == convertedAngle )
234     {
235       found = true;
236       break;
237     }
238   }
239
240   if( !found )
241   {
242     mAvailableAngles.push_back( convertedAngle );
243     SetAvailableAnlges( mAvailableAngles );
244   }
245 }
246
247 void Window::RemoveAvailableOrientation( Dali::Window::WindowOrientation orientation )
248 {
249   if( IsOrientationAvailable( orientation ) == false )
250   {
251     return;
252   }
253
254   int convertedAngle = ConvertToAngle( orientation );
255   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), RemoveAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle );
256   for( std::vector< int >::iterator iter = mAvailableAngles.begin();
257        iter != mAvailableAngles.end(); ++iter )
258   {
259     if( *iter == convertedAngle )
260     {
261       mAvailableAngles.erase( iter );
262       break;
263     }
264   }
265
266   SetAvailableAnlges( mAvailableAngles );
267 }
268
269 void Window::SetPreferredOrientation( Dali::Window::WindowOrientation orientation )
270 {
271   if( orientation < Dali::Window::NO_ORIENTATION_PREFERENCE || orientation > Dali::Window::LANDSCAPE_INVERSE )
272   {
273     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::CheckOrientation: Invalid input orientation [%d]\n", orientation );
274     return;
275   }
276   mPreferredAngle = ConvertToAngle( orientation );
277   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle );
278   mWindowBase->SetPreferredAngle( mPreferredAngle );
279 }
280
281 Dali::Window::WindowOrientation Window::GetPreferredOrientation()
282 {
283   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), GetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle );
284   Dali::Window::WindowOrientation preferredOrientation = ConvertToOrientation( mPreferredAngle );
285   return preferredOrientation;
286 }
287
288 void Window::SetAvailableAnlges( const std::vector< int >& angles )
289 {
290   if( angles.size() > 4 )
291   {
292     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetAvailableAnlges: Invalid vector size! [%d]\n", angles.size() );
293     return;
294   }
295
296   mWindowBase->SetAvailableAnlges( angles );
297 }
298
299 int Window::ConvertToAngle( Dali::Window::WindowOrientation orientation )
300 {
301   int convertAngle = static_cast< int >( orientation );
302   if( mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE )
303   {
304     switch( orientation )
305     {
306       case Dali::Window::LANDSCAPE:
307       {
308         convertAngle = 0;
309         break;
310       }
311       case Dali::Window::PORTRAIT:
312       {
313         convertAngle = 90;
314         break;
315       }
316       case Dali::Window::LANDSCAPE_INVERSE:
317       {
318         convertAngle = 180;
319         break;
320       }
321       case Dali::Window::PORTRAIT_INVERSE:
322       {
323         convertAngle = 270;
324         break;
325       }
326       case Dali::Window::NO_ORIENTATION_PREFERENCE:
327       {
328         convertAngle = -1;
329         break;
330       }
331     }
332   }
333   return convertAngle;
334 }
335
336 Dali::Window::WindowOrientation Window::ConvertToOrientation( int angle ) const
337 {
338   Dali::Window::WindowOrientation orientation = static_cast< Dali::Window::WindowOrientation >( angle );
339   if( mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE )
340   {
341     switch( angle )
342     {
343       case 0:
344       {
345         orientation = Dali::Window::LANDSCAPE;
346         break;
347       }
348       case 90:
349       {
350         orientation = Dali::Window::PORTRAIT;
351         break;
352       }
353       case 180:
354       {
355         orientation = Dali::Window::LANDSCAPE_INVERSE;
356         break;
357       }
358       case 270:
359       {
360         orientation = Dali::Window::PORTRAIT_INVERSE;
361         break;
362       }
363       case -1:
364       {
365         orientation = Dali::Window::NO_ORIENTATION_PREFERENCE;
366         break;
367       }
368     }
369   }
370   return orientation;
371 }
372
373 bool Window::IsOrientationAvailable( Dali::Window::WindowOrientation orientation ) const
374 {
375   if( orientation <= Dali::Window::NO_ORIENTATION_PREFERENCE || orientation > Dali::Window::LANDSCAPE_INVERSE )
376   {
377     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::IsOrientationAvailable: Invalid input orientation [%d]\n", orientation );
378     return false;
379   }
380   return true;
381 }
382
383 Dali::Any Window::GetNativeHandle() const
384 {
385   return mWindowSurface->GetNativeWindow();
386 }
387
388 void Window::SetAcceptFocus( bool accept )
389 {
390   mIsFocusAcceptable = accept;
391
392   mWindowBase->SetAcceptFocus( accept );
393 }
394
395 bool Window::IsFocusAcceptable() const
396 {
397   return mIsFocusAcceptable;
398 }
399
400 void Window::Show()
401 {
402   mVisible = true;
403
404   mWindowBase->Show();
405
406   if( !mIconified )
407   {
408     WindowVisibilityObserver* observer( mAdaptor );
409     observer->OnWindowShown();
410
411     Dali::Window handle( this );
412     mVisibilityChangedSignal.Emit( handle, true );
413   }
414
415   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Show(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
416 }
417
418 void Window::Hide()
419 {
420   mVisible = false;
421
422   mWindowBase->Hide();
423
424   if( !mIconified )
425   {
426     WindowVisibilityObserver* observer( mAdaptor );
427     observer->OnWindowHidden();
428
429     Dali::Window handle( this );
430     mVisibilityChangedSignal.Emit( handle, false );
431   }
432
433   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Hide(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
434 }
435
436 bool Window::IsVisible() const
437 {
438   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), IsVisible(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
439   return mVisible && !mIconified;
440 }
441
442 unsigned int Window::GetSupportedAuxiliaryHintCount() const
443 {
444   return mWindowBase->GetSupportedAuxiliaryHintCount();
445 }
446
447 std::string Window::GetSupportedAuxiliaryHint( unsigned int index ) const
448 {
449   return mWindowBase->GetSupportedAuxiliaryHint( index );
450 }
451
452 unsigned int Window::AddAuxiliaryHint( const std::string& hint, const std::string& value )
453 {
454   return mWindowBase->AddAuxiliaryHint( hint, value );
455 }
456
457 bool Window::RemoveAuxiliaryHint( unsigned int id )
458 {
459   return mWindowBase->RemoveAuxiliaryHint( id );
460 }
461
462 bool Window::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
463 {
464   return mWindowBase->SetAuxiliaryHintValue( id, value );
465 }
466
467 std::string Window::GetAuxiliaryHintValue( unsigned int id ) const
468 {
469   return mWindowBase->GetAuxiliaryHintValue( id );
470 }
471
472 unsigned int Window::GetAuxiliaryHintId( const std::string& hint ) const
473 {
474   return mWindowBase->GetAuxiliaryHintId( hint );
475 }
476
477 void Window::SetInputRegion( const Rect< int >& inputRegion )
478 {
479   mWindowBase->SetInputRegion( inputRegion );
480
481   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetInputRegion: x = %d, y = %d, w = %d, h = %d\n", inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
482 }
483
484 void Window::SetType( Dali::Window::Type type )
485 {
486   if( type != mType )
487   {
488     mWindowBase->SetType( type );
489
490     mType = type;
491   }
492 }
493
494 Dali::Window::Type Window::GetType() const
495 {
496   return mType;
497 }
498
499 bool Window::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
500 {
501   if( mType != Dali::Window::NOTIFICATION )
502   {
503     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", mType );
504     return false;
505   }
506
507   return mWindowBase->SetNotificationLevel( level );
508 }
509
510 Dali::Window::NotificationLevel::Type Window::GetNotificationLevel() const
511 {
512   if( mType != Dali::Window::NOTIFICATION )
513   {
514     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", mType );
515     return Dali::Window::NotificationLevel::NONE;
516   }
517
518   return mWindowBase->GetNotificationLevel();
519 }
520
521 void Window::SetOpaqueState( bool opaque )
522 {
523   mOpaqueState = opaque;
524
525   mWindowBase->SetOpaqueState( opaque );
526
527   DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque );
528 }
529
530 bool Window::IsOpaqueState() const
531 {
532   return mOpaqueState;
533 }
534
535 bool Window::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
536 {
537   return mWindowBase->SetScreenOffMode( screenOffMode );
538 }
539
540 Dali::Window::ScreenOffMode::Type Window::GetScreenOffMode() const
541 {
542   return mWindowBase->GetScreenOffMode();
543 }
544
545 bool Window::SetBrightness( int brightness )
546 {
547   if( brightness < 0 || brightness > 100 )
548   {
549     DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Invalid brightness value [%d]\n", brightness );
550     return false;
551   }
552
553   return mWindowBase->SetBrightness( brightness );
554 }
555
556 int Window::GetBrightness() const
557 {
558   return mWindowBase->GetBrightness();
559 }
560
561 void Window::SetSize( Dali::Window::WindowSize size )
562 {
563   if( !mResizeEnabled )
564   {
565     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
566     mResizeEnabled = true;
567   }
568
569   PositionSize oldRect = mSurface->GetPositionSize();
570
571   mWindowSurface->MoveResize( PositionSize( oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight() ) );
572
573   PositionSize newRect = mSurface->GetPositionSize();
574
575   // When surface size is updated, inform adaptor of resizing and emit ResizeSignal
576   if( ( oldRect.width != newRect.width ) || ( oldRect.height != newRect.height ) )
577   {
578     Uint16Pair newSize( newRect.width, newRect.height );
579
580     bool forceUpdate = false;
581     if( mWindowBase->IsEglWindowRotationSupported() )
582     {
583       forceUpdate = true;
584     }
585
586     SurfaceResized( forceUpdate );
587
588     mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
589
590     DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetSize(): resize signal [%d x %d]\n", this, mNativeWindowId, newRect.width, newRect.height );
591
592     Dali::Window handle( this );
593     mResizedSignal.Emit( newSize );
594     mResizeSignal.Emit( handle, newSize );
595
596     mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
597   }
598 }
599
600 Dali::Window::WindowSize Window::GetSize() const
601 {
602   PositionSize positionSize = mSurface->GetPositionSize();
603
604   return Dali::Window::WindowSize( positionSize.width, positionSize.height );
605 }
606
607 void Window::SetPosition( Dali::Window::WindowPosition position )
608 {
609   if( !mResizeEnabled )
610   {
611     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
612     mResizeEnabled = true;
613   }
614
615   PositionSize oldRect = mSurface->GetPositionSize();
616
617   mWindowSurface->MoveResize( PositionSize( position.GetX(), position.GetY(), oldRect.width, oldRect.height ) );
618 }
619
620 Dali::Window::WindowPosition Window::GetPosition() const
621 {
622   PositionSize positionSize = mSurface->GetPositionSize();
623
624   return Dali::Window::WindowPosition( positionSize.x, positionSize.y );
625 }
626
627 void Window::SetPositionSize( PositionSize positionSize )
628 {
629   if( !mResizeEnabled )
630   {
631     AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
632     mResizeEnabled = true;
633   }
634
635   PositionSize oldRect = mSurface->GetPositionSize();
636
637   mWindowSurface->MoveResize( positionSize );
638
639   PositionSize newRect = mSurface->GetPositionSize();
640
641   // When surface size is updated, inform adaptor of resizing and emit ResizeSignal
642   if( ( oldRect.width != newRect.width ) || ( oldRect.height != newRect.height ) )
643   {
644     Uint16Pair newSize( newRect.width, newRect.height );
645
646     bool forceUpdate = false;
647     if( mWindowBase->IsEglWindowRotationSupported() )
648     {
649       forceUpdate = true;
650     }
651
652     SurfaceResized( forceUpdate );
653
654     mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
655
656     DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetPositionSize():resize signal [%d x %d]\n", this, mNativeWindowId, newRect.width, newRect.height );
657     Dali::Window handle( this );
658     mResizedSignal.Emit( newSize );
659     mResizeSignal.Emit( handle, newSize );
660     mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
661   }
662 }
663
664 Dali::Layer Window::GetRootLayer() const
665 {
666   return mScene.GetRootLayer();
667 }
668
669 void Window::SetTransparency( bool transparent )
670 {
671   mWindowSurface->SetTransparency( transparent );
672 }
673
674 bool Window::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
675 {
676   return mWindowBase->GrabKey( key, grabMode );
677 }
678
679 bool Window::UngrabKey( Dali::KEY key )
680 {
681   return mWindowBase->UngrabKey( key );
682 }
683
684 bool Window::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result )
685 {
686   return mWindowBase->GrabKeyList( key, grabMode, result );
687 }
688
689 bool Window::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result )
690 {
691   return mWindowBase->UngrabKeyList( key, result );
692 }
693
694 void Window::OnIconifyChanged( bool iconified )
695 {
696   if( iconified )
697   {
698     mIconified = true;
699
700     if( mVisible )
701     {
702       WindowVisibilityObserver* observer( mAdaptor );
703       observer->OnWindowHidden();
704
705       Dali::Window handle( this );
706       mVisibilityChangedSignal.Emit( handle, false );
707     }
708
709     DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Iconified: visible = %d\n", this, mNativeWindowId, mVisible );
710   }
711   else
712   {
713     mIconified = false;
714
715     if( mVisible )
716     {
717       WindowVisibilityObserver* observer( mAdaptor );
718       observer->OnWindowShown();
719
720       Dali::Window handle( this );
721       mVisibilityChangedSignal.Emit( handle, true );
722     }
723
724     DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Deiconified: visible = %d\n", this, mNativeWindowId, mVisible );
725   }
726 }
727
728 void Window::OnFocusChanged( bool focusIn )
729 {
730   Dali::Window handle( this );
731   mFocusChangedSignal.Emit( focusIn );
732   mFocusChangeSignal.Emit( handle, focusIn );
733 }
734
735 void Window::OnOutputTransformed()
736 {
737   bool forceUpdate = false;
738   if( mWindowBase->IsEglWindowRotationSupported() )
739   {
740     forceUpdate = true;
741   }
742   SurfaceResized( forceUpdate );
743
744   PositionSize positionSize = mSurface->GetPositionSize();
745   mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
746   mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
747 }
748
749 void Window::OnDeleteRequest()
750 {
751   mDeleteRequestSignal.Emit();
752 }
753
754 void Window::OnTransitionEffectEvent( DevelWindow::EffectState state, DevelWindow::EffectType type )
755 {
756   Dali::Window handle( this );
757   mTransitionEffectEventSignal.Emit( handle, state, type );
758 }
759
760 void Window::OnTouchPoint( Dali::Integration::Point& point, int timeStamp )
761 {
762   FeedTouchPoint( point, timeStamp );
763 }
764
765 void Window::OnWheelEvent( Dali::Integration::WheelEvent& wheelEvent )
766 {
767   FeedWheelEvent( wheelEvent );
768 }
769
770 void Window::OnKeyEvent( Dali::Integration::KeyEvent& keyEvent )
771 {
772   FeedKeyEvent( keyEvent );
773 }
774
775 void Window::OnRotation( const RotationEvent& rotation )
776 {
777   mRotationAngle = rotation.angle;
778   mWindowWidth = rotation.width;
779   mWindowHeight = rotation.height;
780
781   // Notify that the orientation is changed
782   mOrientation->OnOrientationChange( rotation );
783
784   mWindowSurface->RequestRotation( mRotationAngle, mWindowWidth, mWindowHeight );
785
786   bool forceUpdate = false;
787   if( mWindowBase->IsEglWindowRotationSupported() )
788   {
789     forceUpdate = true;
790   }
791
792   SurfaceResized( forceUpdate );
793
794   mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) );
795
796   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), OnRotation(): resize signal emit [%d x %d]\n", this, mNativeWindowId, mWindowWidth, mWindowHeight );
797   // Emit signal
798   Dali::Window handle( this );
799   mResizedSignal.Emit( Dali::Window::WindowSize( mWindowWidth, mWindowHeight ) );
800   mResizeSignal.Emit( handle, Dali::Window::WindowSize( mWindowWidth, mWindowHeight ) );
801
802   mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) );
803 }
804
805 void Window::OnPause()
806 {
807   if( mEventHandler )
808   {
809     mEventHandler->Pause();
810   }
811 }
812
813 void Window::OnResume()
814 {
815   if( mEventHandler )
816   {
817     mEventHandler->Resume();
818   }
819 }
820
821 void Window::RecalculateTouchPosition( Integration::Point& point )
822 {
823   Vector2 position = point.GetScreenPosition();
824   Vector2 convertedPosition;
825
826   switch( mRotationAngle )
827   {
828     case 90:
829     {
830       convertedPosition.x = static_cast<float>( mWindowWidth ) - position.y;
831       convertedPosition.y = position.x;
832       break;
833     }
834     case 180:
835     {
836       convertedPosition.x = static_cast<float>( mWindowWidth ) - position.x;
837       convertedPosition.y = static_cast<float>( mWindowHeight ) - position.y;
838       break;
839     }
840     case 270:
841     {
842       convertedPosition.x = position.y;
843       convertedPosition.y = static_cast<float>( mWindowHeight ) - position.x;
844       break;
845     }
846     default:
847     {
848       convertedPosition = position;
849       break;
850     }
851   }
852
853   point.SetScreenPosition( convertedPosition );
854 }
855
856 Dali::Window Window::Get( Dali::Actor actor )
857 {
858   Internal::Adaptor::Window* windowImpl = nullptr;
859
860   if ( Internal::Adaptor::Adaptor::IsAvailable() )
861   {
862     Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation( Internal::Adaptor::Adaptor::Get() );
863     windowImpl = dynamic_cast<Internal::Adaptor::Window*>( adaptor.GetWindow( actor ) );
864     if( windowImpl )
865     {
866       return Dali::Window( windowImpl );
867     }
868   }
869
870   return Dali::Window();
871 }
872
873 void Window::SetParent( Dali::Window& parent )
874 {
875   if ( DALI_UNLIKELY( parent ) )
876   {
877     mParentWindow = parent;
878     Dali::Window self = Dali::Window( this );
879     // check circular parent window setting
880     if ( Dali::DevelWindow::GetParent( parent ) == self )
881     {
882       Dali::DevelWindow::Unparent( parent );
883     }
884     mWindowBase->SetParent( GetImplementation( mParentWindow ).mWindowBase );
885   }
886 }
887
888 void Window::Unparent()
889 {
890   mWindowBase->SetParent( nullptr );
891   mParentWindow.Reset();
892 }
893
894 Dali::Window Window::GetParent()
895 {
896   return mParentWindow;
897 }
898
899 Dali::Window::WindowOrientation Window::GetCurrentOrientation() const
900 {
901   DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), GetCurrentOrientation(): %d\n", this, mNativeWindowId, mRotationAngle );
902   return ConvertToOrientation( mRotationAngle );
903 }
904
905 void Window::SetAvailableOrientations( const Dali::Vector<Dali::Window::WindowOrientation>& orientations )
906 {
907   Dali::Vector<float>::SizeType count = orientations.Count();
908   for( Dali::Vector<float>::SizeType index = 0; index < count; ++index )
909   {
910     if( IsOrientationAvailable( orientations[index] ) == false )
911     {
912       DALI_LOG_ERROR("Window::SetAvailableOrientations, invalid orientation: %d\n", orientations[index]);
913       continue;
914     }
915
916     bool found = false;
917     int convertedAngle = ConvertToAngle( orientations[index] );
918
919     for( std::size_t i = 0; i < mAvailableAngles.size(); i++ )
920     {
921       if( mAvailableAngles[i] == convertedAngle )
922       {
923         found = true;
924         break;
925       }
926     }
927
928     if( !found )
929     {
930       DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetAvailableOrientations: %d\n", this, mNativeWindowId, convertedAngle );
931       mAvailableAngles.push_back( convertedAngle );
932     }
933   }
934   SetAvailableAnlges( mAvailableAngles );
935 }
936
937 int32_t Window::GetNativeId() const
938 {
939   return mWindowBase->GetNativeWindowId();
940 }
941
942 } // Adaptor
943
944 } // Internal
945
946 } // Dali