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