Dali-toolkit: Replace constraints with SizeMode
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / focus-manager / keyinput-focus-manager-impl.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 // CLASS HEADER
19 #include "keyinput-focus-manager-impl.h"
20
21 // EXTERNAL INCLUDES
22 #include <dali/public-api/actors/layer.h>
23 #include <dali/public-api/common/stage.h>
24
25 // INTERNAL INCLUDES
26 #include <dali-toolkit/public-api/controls/control-impl.h>
27 #include <dali/integration-api/debug.h>
28
29 namespace Dali
30 {
31
32 namespace Toolkit
33 {
34
35 namespace Internal
36 {
37
38 KeyInputFocusManager::KeyInputFocusManager()
39 : mSlotDelegate( this )
40 {
41   Stage::GetCurrent().KeyEventSignal().Connect(mSlotDelegate, &KeyInputFocusManager::OnKeyEvent);
42   mObjectRegistry = Dali::Stage::GetCurrent().GetObjectRegistry();
43   mObjectRegistry.ObjectDestroyedSignal().Connect( this, &KeyInputFocusManager::OnObjectDestroyed );
44 }
45
46 KeyInputFocusManager::~KeyInputFocusManager()
47 {
48 }
49
50 void KeyInputFocusManager::SetFocus( Toolkit::Control control )
51 {
52   if( !control )
53   {
54     // No-op
55     return;
56   }
57
58   FocusStackIterator pos = FindFocusControlInStack( control );
59
60   if( ( mFocusStack.Count() != 0 ) && ( pos == mFocusStack.End()-1 ) )
61   {
62     // Control already in front, so No-op
63     return;
64   }
65
66   if( pos != mFocusStack.End() )
67   {
68     // A previously focused control wants to regain focus
69     mFocusStack.Erase( pos );
70   }
71   else
72   {
73     control.OffStageSignal().Connect( mSlotDelegate, &KeyInputFocusManager::OnFocusControlStageDisconnection );
74   }
75
76   Dali::Toolkit::Control previousFocusControl = GetCurrentFocusControl();
77   if( previousFocusControl )
78   {
79     // Notify the control that it has lost key input focus
80     previousFocusControl.GetImplementation().OnKeyInputFocusLost();
81   }
82
83   mFocusStack.PushBack( &control.GetBaseObject() );
84
85   // Tell the new actor that it has gained focus.
86   control.GetImplementation().OnKeyInputFocusGained();
87
88   // Emit the signal to inform focus change to the application.
89   if ( !mKeyInputFocusChangedSignal.Empty() )
90   {
91     mKeyInputFocusChangedSignal.Emit( control, previousFocusControl );
92   }
93 }
94
95 void KeyInputFocusManager::RemoveFocus( Toolkit::Control control )
96 {
97   if( control )
98   {
99     FocusStackIterator pos = FindFocusControlInStack( control );
100     if( pos != mFocusStack.End() )
101     {
102       control.OffStageSignal().Disconnect( mSlotDelegate, &KeyInputFocusManager::OnFocusControlStageDisconnection );
103
104       // Notify the control that it has lost key input focus
105       control.GetImplementation().OnKeyInputFocusLost();
106
107       // If this is the top-most actor, pop it and change focus to the previous control
108       if( pos == mFocusStack.End() - 1 )
109       {
110         mFocusStack.Erase( pos );
111
112         Toolkit::Control previouslyFocusedControl = GetCurrentFocusControl();
113         if( previouslyFocusedControl )
114         {
115           // Tell the control that it has gained focus.
116           previouslyFocusedControl.GetImplementation().OnKeyInputFocusGained();
117         }
118       }
119       else
120       {
121         // If the removed control is not currently focused, then no need to emit signal.
122         mFocusStack.Erase( pos );
123       }
124     }
125   }
126 }
127
128 Toolkit::Control KeyInputFocusManager::GetCurrentFocusControl() const
129 {
130   Toolkit::Control currentControl;
131
132   FocusStack::SizeType count = mFocusStack.Count();
133   if( count != 0 )
134   {
135     BaseObject* object = mFocusStack[ count - 1 ];
136     BaseHandle handle( object );
137     currentControl = Dali::Toolkit::Control::DownCast( handle );
138   }
139   return currentControl;
140 }
141
142 bool KeyInputFocusManager::IsKeyboardListener( Toolkit::Control control ) const
143 {
144   bool result = false;
145
146   if( FindFocusControlInStack( control ) != mFocusStack.End() )
147   {
148     result = true;
149   }
150
151   return result;
152 }
153
154 Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType& KeyInputFocusManager::KeyInputFocusChangedSignal()
155 {
156   return mKeyInputFocusChangedSignal;
157 }
158
159 Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType& KeyInputFocusManager::UnhandledKeyEventSignal()
160 {
161   return mUnhandledKeyEventSignal;
162 }
163
164 KeyInputFocusManager::FocusStackIterator KeyInputFocusManager::FindFocusControlInStack( Toolkit::Control control ) const
165 {
166   BaseObject* controlObject = &control.GetBaseObject();
167   return std::find( mFocusStack.Begin(), mFocusStack.End(), controlObject );
168 }
169
170 void KeyInputFocusManager::OnKeyEvent( const KeyEvent& event )
171 {
172   bool consumed = false;
173
174   if( mFocusStack.Count() > 0 )
175   {
176     FocusStack::SizeType index = mFocusStack.Count();
177     while( mFocusStack.Count() != 0 && !consumed && index > 0 )
178     {
179       --index;
180       BaseObject* object = mFocusStack[ index ];
181       BaseHandle handle( object );
182       Toolkit::Control control = Toolkit::Control::DownCast( object );
183       if( control )
184       {
185         // Notify the control about the key event
186         consumed = control.GetImplementation().EmitKeyEventSignal( event );
187       }
188     }
189   }
190
191   if( !consumed )
192   {
193     // Emit signal to inform that a key event is not consumed.
194     if( !mUnhandledKeyEventSignal.Empty() )
195     {
196       mUnhandledKeyEventSignal.Emit(event);
197     }
198   }
199 }
200
201 void KeyInputFocusManager::OnFocusControlStageDisconnection( Dali::Actor actor )
202 {
203   RemoveFocus( Dali::Toolkit::Control::DownCast( actor ) );
204 }
205
206 void KeyInputFocusManager::OnObjectDestroyed( const Dali::RefObject* object )
207 {
208   // The object is already destroyed. Don't create handles to it, or try sending
209   // signals to it. Remove it's pointer from the stack.
210   const BaseObject* baseObject = static_cast<const BaseObject*>( object );
211   FocusStackIterator pos = std::find( mFocusStack.Begin(), mFocusStack.End(), baseObject );
212   if( pos != mFocusStack.End() )
213   {
214     mFocusStack.Erase( pos );
215   }
216 }
217
218 bool KeyInputFocusManager::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
219 {
220   Dali::BaseHandle handle( object );
221
222   bool connected( true );
223   KeyInputFocusManager* manager = dynamic_cast<KeyInputFocusManager*>(object);
224
225   if( Dali::Toolkit::KeyInputFocusManager::SIGNAL_KEY_INPUT_FOCUS_CHANGED == signalName )
226   {
227     manager->KeyInputFocusChangedSignal().Connect( tracker, functor );
228   }
229   else
230   {
231     // signalName does not match any signal
232     connected = false;
233   }
234
235   return connected;
236 }
237
238 } // namespace Internal
239
240 } // namespace Toolkit
241
242 } // namespace Dali