9 * Initial Contributors: |
9 * Initial Contributors: |
10 * Nokia Corporation - initial contribution. |
10 * Nokia Corporation - initial contribution. |
11 * |
11 * |
12 * Contributors: |
12 * Contributors: |
13 * |
13 * |
14 * Description: Calendar state machine |
14 * Description: Calendar state machine |
15 * |
15 * |
16 */ |
16 */ |
|
17 |
17 |
18 |
18 |
19 |
19 // includes |
20 // includes |
20 #include "calendarui_debug.h" // Debug macros |
21 #include "calendarui_debug.h" // Debug macros |
21 #include "calenstate.h" // Calendar States |
22 #include "calenstate.h" // Calendar States |
22 #include "calencontroller.h" |
23 #include "calencontroller.h" |
23 #include "calenstatemachine.h" |
24 #include "calenstatemachine.h" |
24 #include "calennotifier.h" |
25 #include "calennotifier.h" |
25 #include "calenasynccallback.h" |
26 #include "calenasynccallback.h" |
26 #include "OstTraceDefinitions.h" |
27 |
27 #ifdef OST_TRACE_COMPILER_IN_USE |
28 #include <featmgr.h> |
28 #include "calenstateTraces.h" |
|
29 #endif |
|
30 |
29 |
31 // ---------------------------------------------------------------------------- |
30 // ---------------------------------------------------------------------------- |
32 // CCalenState::CCalenState |
31 // CCalenState::CCalenState |
33 // C++ constructor |
32 // C++ constructor |
34 // ---------------------------------------------------------------------------- |
33 // ---------------------------------------------------------------------------- |
35 CCalenState::CCalenState( CCalenController& aController,RHashSet<TCalenNotification>& aOutstandingNotifications ) |
34 CCalenState::CCalenState( CCalenController& aController,RHashSet<TCalenNotification>& aOutstandingNotifications ) |
36 : iController( aController ), |
35 : iController( aController ), |
37 iOutstandingNotifications( aOutstandingNotifications ), |
36 iOutstandingNotifications( aOutstandingNotifications ), |
38 iPreviousState( CCalenStateMachine::ECalenIdleState ) |
37 iPreviousState( CCalenStateMachine::ECalenIdleState ) |
39 { |
38 { |
40 OstTraceFunctionEntry0( CCALENSTATE_CCALENSTATE_ENTRY ); |
39 TRACE_ENTRY_POINT; |
41 |
40 |
42 OstTraceFunctionExit0( CCALENSTATE_CCALENSTATE_EXIT ); |
41 TRACE_EXIT_POINT; |
43 } |
42 } |
44 |
43 |
45 // ---------------------------------------------------------------------------- |
44 // ---------------------------------------------------------------------------- |
46 // CCalenState::ConstructL |
45 // CCalenState::ConstructL |
47 // second phase construction |
46 // second phase construction |
48 // ---------------------------------------------------------------------------- |
47 // ---------------------------------------------------------------------------- |
49 void CCalenState::BaseConstructL() |
48 void CCalenState::BaseConstructL() |
50 { |
49 { |
51 OstTraceFunctionEntry0( CCALENSTATE_BASECONSTRUCTL_ENTRY ); |
50 TRACE_ENTRY_POINT; |
52 |
51 |
53 TCalenCommand command; |
52 TCalenCommand command; |
54 MCalenCommandHandler* handler( NULL ); |
53 MCalenCommandHandler* handler( NULL ); |
55 iCallBackPackage = new( ELeave ) CalenCallbackPackage( this, command, handler ); |
54 iCallBackPackage = new( ELeave ) CCalenCallbackPackage( this, command, handler ); |
56 |
55 |
57 OstTraceFunctionExit0( CCALENSTATE_BASECONSTRUCTL_EXIT ); |
56 TRACE_EXIT_POINT; |
58 } |
57 } |
59 |
58 |
60 // ---------------------------------------------------------------------------- |
59 // ---------------------------------------------------------------------------- |
61 // CCalenState::~CCalenState |
60 // CCalenState::~CCalenState |
62 // Destructor |
61 // Destructor |
63 // ---------------------------------------------------------------------------- |
62 // ---------------------------------------------------------------------------- |
64 CCalenState::~CCalenState() |
63 CCalenState::~CCalenState() |
65 { |
64 { |
66 OstTraceFunctionEntry0( DUP1_CCALENSTATE_CCALENSTATE_ENTRY ); |
65 TRACE_ENTRY_POINT; |
67 |
66 |
68 delete iCallBackPackage; |
67 delete iCallBackPackage; |
69 iCallBackPackage = NULL; |
68 iCallBackPackage = NULL; |
70 delete iCmdCallback; |
69 delete iCmdCallback; |
71 |
70 |
72 OstTraceFunctionExit0( DUP1_CCALENSTATE_CCALENSTATE_EXIT ); |
71 TRACE_EXIT_POINT; |
73 } |
72 } |
74 |
73 |
75 // ---------------------------------------------------------------------------- |
74 // ---------------------------------------------------------------------------- |
76 // CCalenState::RequestCallback |
75 // CCalenState::RequestCallback |
77 // Request a callback |
76 // Request a callback |
78 // ---------------------------------------------------------------------------- |
77 // ---------------------------------------------------------------------------- |
79 void CCalenState::RequestCallbackL( MCalenCommandHandler* aCommandHandler, const TCalenCommand& aCommand ) |
78 void CCalenState::RequestCallbackL( MCalenCommandHandler* aCommandHandler, const TCalenCommand& aCommand ) |
80 { |
79 { |
81 OstTraceFunctionEntry0( CCALENSTATE_REQUESTCALLBACKL_ENTRY ); |
80 TRACE_ENTRY_POINT; |
82 |
81 |
83 iCallBackPackage->SetCommandHandler(this, aCommand, aCommandHandler); |
82 iCallBackPackage->SetCommandHandler(this, aCommand, aCommandHandler); |
84 |
83 |
85 if( !iCmdCallback ) |
84 if( !iCmdCallback ) |
86 { |
85 { |
87 TCallBack callback( CommandCallback, iCallBackPackage ); |
86 TCallBack callback( CommandCallback, iCallBackPackage ); |
88 iCmdCallback = CalenAsyncCallBack::NewL( callback, CActive::EPriorityHigh , iController ); |
87 iCmdCallback = CCalenAsyncCallBack::NewL( callback, CActive::EPriorityHigh , iController ); |
89 } |
88 } |
90 |
89 |
91 TCallBack callback( CommandCallback, iCallBackPackage ); |
90 TCallBack callback( CommandCallback, iCallBackPackage ); |
92 |
91 |
93 iCmdCallback->Cancel(); |
92 iCmdCallback->Cancel(); |
94 iCmdCallback->Set( callback ); |
93 iCmdCallback->Set( callback ); |
95 iCmdCallback->CallBack(); |
94 iCmdCallback->CallBack(); |
96 |
95 |
97 OstTraceFunctionExit0( CCALENSTATE_REQUESTCALLBACKL_EXIT ); |
96 TRACE_EXIT_POINT; |
98 } |
97 } |
99 |
98 |
100 |
99 |
101 |
100 |
102 // ---------------------------------------------------------------------------- |
101 // ---------------------------------------------------------------------------- |
103 // CCalenState::CommandCallback |
102 // CCalenState::CommandCallback |
104 // Static callback function |
103 // Static callback function |
105 // ---------------------------------------------------------------------------- |
104 // ---------------------------------------------------------------------------- |
106 TInt CCalenState::CommandCallback( TAny* aCommandStruct ) |
105 TInt CCalenState::CommandCallback( TAny* aCommandStruct ) |
107 { |
106 { |
108 OstTraceFunctionEntry0( CCALENSTATE_COMMANDCALLBACK_ENTRY ); |
107 TRACE_ENTRY_POINT; |
109 |
|
110 TBool continueCommand(EFalse); |
108 TBool continueCommand(EFalse); |
111 |
109 |
112 CalenCallbackPackage* package = static_cast<CalenCallbackPackage*>( aCommandStruct ); |
110 CCalenCallbackPackage* package = static_cast<CCalenCallbackPackage*>( aCommandStruct ); |
113 continueCommand = package->HandleCallBack(); |
111 continueCommand = package->HandleCallBack(); |
114 |
112 |
115 OstTraceFunctionExit0( CCALENSTATE_COMMANDCALLBACK_EXIT ); |
113 TRACE_EXIT_POINT; |
116 return continueCommand; |
114 return continueCommand; |
117 } |
115 } |
118 |
116 |
119 // ---------------------------------------------------------------------------- |
117 // ---------------------------------------------------------------------------- |
120 // CCalenState::HandleNotificationL |
118 // CCalenState::HandleNotificationL |
123 // to the command issued. |
121 // to the command issued. |
124 // ---------------------------------------------------------------------------- |
122 // ---------------------------------------------------------------------------- |
125 void CCalenState::HandleNotificationL(const TCalenNotification& aNotification, |
123 void CCalenState::HandleNotificationL(const TCalenNotification& aNotification, |
126 CCalenStateMachine& aStateMachine ) |
124 CCalenStateMachine& aStateMachine ) |
127 { |
125 { |
128 OstTraceFunctionEntry0( CCALENSTATE_HANDLENOTIFICATIONL_ENTRY ); |
126 TRACE_ENTRY_POINT; |
129 |
127 |
130 switch( aNotification ) |
128 switch( aNotification ) |
131 { |
129 { |
132 case ECalenNotifyAppBackgrounded: |
130 case ECalenNotifyAppBackgrounded: |
133 { |
131 { |
134 CCalenStateMachine::TCalenStateIndex cachedState = aStateMachine.GetCurrentState(); |
132 CCalenStateMachine::TCalenStateIndex cachedState = aStateMachine.GetCurrentState(); |
135 aStateMachine.SetCurrentState(CCalenStateMachine::ECalenBackgroundState); |
133 // Never send calendar to background state in MapState as maps will |
136 aStateMachine.SetCurrentPreviousState(cachedState); |
134 // launched in cahin mode not in stand alone mode |
137 iOutstandingNotifications.InsertL(aNotification); |
135 if((cachedState != CCalenStateMachine::ECalenMapState) && |
138 aStateMachine.ActivateCurrentStateL(); |
136 (cachedState != CCalenStateMachine::ECalenPopulationState)) |
139 |
137 { |
|
138 aStateMachine.SetCurrentState(CCalenStateMachine::ECalenBackgroundState); |
|
139 aStateMachine.SetCurrentPreviousState(cachedState); |
|
140 iOutstandingNotifications.InsertL(aNotification); |
|
141 aStateMachine.ActivateCurrentStateL(); |
|
142 } |
140 } |
143 } |
141 break; |
144 break; |
142 default: |
145 default: |
143 iController.Notifier().BroadcastApprovedNotification( aNotification ); |
146 iController.Notifier().BroadcastApprovedNotification( aNotification ); |
144 break; |
147 break; |
145 } |
148 } |
146 |
149 |
147 OstTraceFunctionExit0( CCALENSTATE_HANDLENOTIFICATIONL_EXIT ); |
150 |
|
151 TRACE_EXIT_POINT; |
|
152 |
148 } |
153 } |
149 |
154 |
150 |
155 |
151 // ---------------------------------------------------------------------------- |
156 // ---------------------------------------------------------------------------- |
152 // CCalenState::PreviousState |
157 // CCalenState::PreviousState |
153 // C++ constructor |
158 // C++ constructor |
154 // ---------------------------------------------------------------------------- |
159 // ---------------------------------------------------------------------------- |
155 CCalenStateMachine::TCalenStateIndex CCalenState::PreviousState() |
160 CCalenStateMachine::TCalenStateIndex CCalenState::PreviousState() |
156 { |
161 { |
157 OstTraceFunctionEntry0( CCALENSTATE_PREVIOUSSTATE_ENTRY ); |
162 TRACE_ENTRY_POINT; |
158 |
163 |
159 OstTraceFunctionExit0( CCALENSTATE_PREVIOUSSTATE_EXIT ); |
164 TRACE_EXIT_POINT; |
160 return iPreviousState; |
165 return iPreviousState; |
161 } |
166 } |
162 |
167 |
163 // ---------------------------------------------------------------------------- |
168 // ---------------------------------------------------------------------------- |
164 // CCalenState::SetPreviousState |
169 // CCalenState::SetPreviousState |
165 // Sets previous state. |
170 // Sets previous state. |
166 // ---------------------------------------------------------------------------- |
171 // ---------------------------------------------------------------------------- |
167 void CCalenState::SetPreviousState(const CCalenStateMachine::TCalenStateIndex& aPreviousState ) |
172 void CCalenState::SetPreviousState(const CCalenStateMachine::TCalenStateIndex& aPreviousState ) |
168 { |
173 { |
169 OstTraceFunctionEntry0( CCALENSTATE_SETPREVIOUSSTATE_ENTRY ); |
174 TRACE_ENTRY_POINT; |
170 |
175 |
171 iPreviousState = aPreviousState; |
176 iPreviousState = aPreviousState; |
172 |
177 |
173 OstTraceFunctionExit0( CCALENSTATE_SETPREVIOUSSTATE_EXIT ); |
178 TRACE_EXIT_POINT; |
174 } |
179 } |
175 |
180 |
176 // ---------------------------------------------------------------------------- |
181 // ---------------------------------------------------------------------------- |
177 // CCalenState::CommandExecuting |
182 // CCalenState::CommandExecuting |
178 // From CCalenState |
183 // From CCalenState |
179 // ---------------------------------------------------------------------------- |
184 // ---------------------------------------------------------------------------- |
180 void CCalenState::CommandExecuting() |
185 void CCalenState::CommandExecuting() |
181 { |
186 { |
182 OstTraceFunctionEntry0( CCALENSTATE_COMMANDEXECUTING_ENTRY ); |
187 TRACE_ENTRY_POINT; |
183 |
188 TRACE_EXIT_POINT; |
184 OstTraceFunctionExit0( CCALENSTATE_COMMANDEXECUTING_EXIT ); |
|
185 } |
189 } |
186 |
190 |
187 // ---------------------------------------------------------------------------- |
191 // ---------------------------------------------------------------------------- |
188 // CCalenState::CalenCallbackPackage::CalenCallbackPackage |
192 // CCalenState::CCalenCallbackPackage::CCalenCallbackPackage |
189 // C++ constructor |
193 // C++ constructor |
190 // ---------------------------------------------------------------------------- |
194 // ---------------------------------------------------------------------------- |
191 CCalenState::CalenCallbackPackage::CalenCallbackPackage( CCalenState* aSelf, |
195 CCalenState::CCalenCallbackPackage::CCalenCallbackPackage( CCalenState* aSelf, |
192 TCalenCommand aCommand, MCalenCommandHandler* aCommandHandler) |
196 TCalenCommand aCommand, MCalenCommandHandler* aCommandHandler) |
193 : iSelf( aSelf ), iCommand( aCommand ), iCommandHandler( aCommandHandler ) |
197 : iSelf( aSelf ), iCommand( aCommand ), iCommandHandler( aCommandHandler ) |
194 { |
198 { |
195 OstTraceFunctionEntry0( CALENCALLBACKPACKAGE_CALENCALLBACKPACKAGE_ENTRY ); |
199 TRACE_ENTRY_POINT; |
196 |
200 TRACE_EXIT_POINT; |
197 OstTraceFunctionExit0( CALENCALLBACKPACKAGE_CALENCALLBACKPACKAGE_EXIT ); |
201 } |
198 } |
202 |
199 |
203 // ---------------------------------------------------------------------------- |
200 // ---------------------------------------------------------------------------- |
204 // CCalenState::CCalenCallbackPackage::HandleCallBack |
201 // CCalenState::CalenCallbackPackage::HandleCallBack |
|
202 // Handles a callback |
205 // Handles a callback |
203 // ---------------------------------------------------------------------------- |
206 // ---------------------------------------------------------------------------- |
204 TBool CCalenState::CalenCallbackPackage::HandleCallBack() |
207 TBool CCalenState::CCalenCallbackPackage::HandleCallBack() |
205 { |
208 { |
206 OstTraceFunctionEntry0( CALENCALLBACKPACKAGE_HANDLECALLBACK_ENTRY ); |
209 TRACE_ENTRY_POINT; |
207 |
|
208 TBool continueCommand(EFalse); |
210 TBool continueCommand(EFalse); |
209 |
211 |
210 iSelf->CommandExecuting(); |
212 iSelf->CommandExecuting(); |
211 PIM_TRAPD_HANDLE ( continueCommand = iCommandHandler->HandleCommandL( iCommand ) ); |
213 PIM_TRAPD_HANDLE ( continueCommand = iCommandHandler->HandleCommandL( iCommand ) ); |
212 |
214 |
213 OstTraceFunctionExit0( CALENCALLBACKPACKAGE_HANDLECALLBACK_EXIT ); |
215 TRACE_EXIT_POINT; |
214 return continueCommand; |
216 return continueCommand; |
215 } |
217 } |
216 |
218 |
217 // ---------------------------------------------------------------------------- |
219 // ---------------------------------------------------------------------------- |
218 // CCalenState::CalenCallbackPackage::SetCommandHandler |
220 // CCalenState::CCalenCallbackPackage::SetCommandHandler |
219 // Sets the command handler and command |
221 // Sets the command handler and command |
220 // ---------------------------------------------------------------------------- |
222 // ---------------------------------------------------------------------------- |
221 void CCalenState::CalenCallbackPackage::SetCommandHandler(CCalenState* aSelf, |
223 void CCalenState::CCalenCallbackPackage::SetCommandHandler(CCalenState* aSelf, |
222 TCalenCommand aCommand, MCalenCommandHandler* aCommandHandler) |
224 TCalenCommand aCommand, MCalenCommandHandler* aCommandHandler) |
223 { |
225 { |
224 OstTraceFunctionEntry0( CALENCALLBACKPACKAGE_SETCOMMANDHANDLER_ENTRY ); |
226 TRACE_ENTRY_POINT; |
225 |
227 |
226 iSelf = aSelf; |
228 iSelf = aSelf; |
227 iCommand = aCommand; |
229 iCommand = aCommand; |
228 iCommandHandler = aCommandHandler; |
230 iCommandHandler = aCommandHandler; |
229 |
231 |
230 OstTraceFunctionExit0( CALENCALLBACKPACKAGE_SETCOMMANDHANDLER_EXIT ); |
232 TRACE_EXIT_POINT; |
231 } |
233 } |
232 |
234 |
233 // ---------------------------------------------------------------------------- |
235 // ---------------------------------------------------------------------------- |
234 // CCalenState::HandleStateActivationL |
236 // CCalenState::HandleStateActivationL |
235 // Default behavior when state is activated. Check and issue any outstanding |
237 // Default behavior when state is activated. Check and issue any outstanding |
236 // notifications |
238 // notifications |
237 // ---------------------------------------------------------------------------- |
239 // ---------------------------------------------------------------------------- |
238 void CCalenState::HandleStateActivationL(CCalenStateMachine& /*aStateMachine*/) |
240 void CCalenState::HandleStateActivationL(CCalenStateMachine& /*aStateMachine*/) |
239 { |
241 { |
240 OstTraceFunctionEntry0( CCALENSTATE_HANDLESTATEACTIVATIONL_ENTRY ); |
242 TRACE_ENTRY_POINT; |
241 |
243 |
242 // Can only issue one of the following Notifications |
244 // Can only issue one of the following Notifications |
243 // ECalenNotifySettingsChanged or |
245 // ECalenNotifySettingsChanged or |
244 // ECalenNotifySystemLocaleChanged or |
246 // ECalenNotifySystemLocaleChanged or |
245 // ECalenNotifySettingsClosed |
247 // ECalenNotifySettingsClosed |
246 |
248 |
247 if(iOutstandingNotifications.Find(ECalenNotifySettingsChanged)) |
249 if(iOutstandingNotifications.Find(ECalenNotifySettingsChanged)) |
248 { |
250 { |
249 iOutstandingNotifications.Remove(ECalenNotifySystemLocaleChanged); |
251 iOutstandingNotifications.Remove(ECalenNotifySystemLocaleChanged); |
250 iOutstandingNotifications.Remove(ECalenNotifySettingsClosed); |
252 if(!FeatureManager::FeatureSupported(KFeatureIdFfCalScrollablePreview )) |
|
253 { |
|
254 iOutstandingNotifications.Remove(ECalenNotifySettingsClosed); |
|
255 } |
251 } |
256 } |
252 else if(iOutstandingNotifications.Find(ECalenNotifySystemLocaleChanged)) |
257 else if(iOutstandingNotifications.Find(ECalenNotifySystemLocaleChanged)) |
253 { |
258 { |
254 iOutstandingNotifications.Remove(ECalenNotifySettingsClosed); |
259 if(!FeatureManager::FeatureSupported(KFeatureIdFfCalScrollablePreview )) |
|
260 { |
|
261 iOutstandingNotifications.Remove(ECalenNotifySettingsClosed); |
|
262 } |
255 } |
263 } |
256 |
264 |
257 THashSetIter<TCalenNotification> iterator(iOutstandingNotifications); |
265 THashSetIter<TCalenNotification> iterator(iOutstandingNotifications); |
258 const TCalenNotification* notification = iterator.Next(); |
266 const TCalenNotification* notification = iterator.Next(); |
259 while(notification) |
267 while(notification) |
262 notification = iterator.Next(); |
270 notification = iterator.Next(); |
263 } |
271 } |
264 |
272 |
265 iOutstandingNotifications.Close(); |
273 iOutstandingNotifications.Close(); |
266 |
274 |
267 OstTraceFunctionExit0( CCALENSTATE_HANDLESTATEACTIVATIONL_EXIT ); |
275 TRACE_EXIT_POINT; |
268 } |
276 } |
269 |
277 |
270 // ---------------------------------------------------------------------------- |
278 // ---------------------------------------------------------------------------- |
271 // CCalenState::SetCurrentState |
279 // CCalenState::SetCurrentState |
272 // Sets the current state |
280 // Sets the current state |
273 // ---------------------------------------------------------------------------- |
281 // ---------------------------------------------------------------------------- |
274 void CCalenState::SetCurrentState(CCalenStateMachine& aStateMachine, |
282 void CCalenState::SetCurrentState(CCalenStateMachine& aStateMachine, |
275 const CCalenStateMachine::TCalenStateIndex& aState ) |
283 const CCalenStateMachine::TCalenStateIndex& aState ) |
276 { |
284 { |
277 OstTraceFunctionEntry0( CCALENSTATE_SETCURRENTSTATE_ENTRY ); |
285 TRACE_ENTRY_POINT; |
278 |
286 |
279 aStateMachine.SetCurrentState(aState); |
287 aStateMachine.SetCurrentState(aState); |
280 |
288 |
281 OstTraceFunctionExit0( CCALENSTATE_SETCURRENTSTATE_EXIT ); |
289 TRACE_EXIT_POINT; |
282 } |
290 } |
283 |
291 |
284 // ---------------------------------------------------------------------------- |
292 // ---------------------------------------------------------------------------- |
285 // CCalenState::GetCurrentState |
293 // CCalenState::GetCurrentState |
286 // Gets the current state |
294 // Gets the current state |
287 // ---------------------------------------------------------------------------- |
295 // ---------------------------------------------------------------------------- |
288 CCalenStateMachine::TCalenStateIndex CCalenState::GetCurrentState( |
296 CCalenStateMachine::TCalenStateIndex CCalenState::GetCurrentState( |
289 CCalenStateMachine& aStateMachine) |
297 CCalenStateMachine& aStateMachine) |
290 { |
298 { |
291 OstTraceFunctionEntry0( CCALENSTATE_GETCURRENTSTATE_ENTRY ); |
299 TRACE_ENTRY_POINT; |
292 |
300 TRACE_EXIT_POINT; |
293 OstTraceFunctionExit0( CCALENSTATE_GETCURRENTSTATE_EXIT ); |
301 |
294 return aStateMachine.GetCurrentState(); |
302 return aStateMachine.GetCurrentState(); |
295 } |
303 } |
296 |
304 |
297 // ---------------------------------------------------------------------------- |
305 // ---------------------------------------------------------------------------- |
298 // CCalenState::SetPreviousState |
306 // CCalenState::SetPreviousState |
299 // Sets the previous state through state machine |
307 // Sets the previous state through state machine |
300 // ---------------------------------------------------------------------------- |
308 // ---------------------------------------------------------------------------- |
301 void CCalenState::SetCurrentPreviousState(CCalenStateMachine& aStateMachine, |
309 void CCalenState::SetCurrentPreviousState(CCalenStateMachine& aStateMachine, |
302 const CCalenStateMachine::TCalenStateIndex& aState) |
310 const CCalenStateMachine::TCalenStateIndex& aState) |
303 { |
311 { |
304 OstTraceFunctionEntry0( CCALENSTATE_SETCURRENTPREVIOUSSTATE_ENTRY ); |
312 TRACE_ENTRY_POINT; |
305 |
313 |
306 aStateMachine.SetCurrentPreviousState(aState); |
314 aStateMachine.SetCurrentPreviousState(aState); |
307 |
315 |
308 OstTraceFunctionExit0( CCALENSTATE_SETCURRENTPREVIOUSSTATE_EXIT ); |
316 TRACE_EXIT_POINT; |
309 } |
317 } |
310 |
318 |
311 // ---------------------------------------------------------------------------- |
319 // ---------------------------------------------------------------------------- |
312 // CCalenState::ActivateCurrentStateL |
320 // CCalenState::ActivateCurrentStateL |
313 // Activate current state |
321 // Activate current state |
314 // ---------------------------------------------------------------------------- |
322 // ---------------------------------------------------------------------------- |
315 void CCalenState::ActivateCurrentStateL(CCalenStateMachine& aStateMachine) |
323 void CCalenState::ActivateCurrentStateL(CCalenStateMachine& aStateMachine) |
316 { |
324 { |
317 OstTraceFunctionEntry0( CCALENSTATE_ACTIVATECURRENTSTATEL_ENTRY ); |
325 TRACE_ENTRY_POINT; |
318 |
326 |
319 aStateMachine.ActivateCurrentStateL(); |
327 aStateMachine.ActivateCurrentStateL(); |
320 |
328 |
321 OstTraceFunctionExit0( CCALENSTATE_ACTIVATECURRENTSTATEL_EXIT ); |
329 TRACE_EXIT_POINT; |
322 } |
330 } |
323 // ---------------------------------------------------------------------------- |
331 // ---------------------------------------------------------------------------- |
324 // CCalenState::CancelPreviousCmd |
332 // CCalenState::CancelPreviousCmd |
325 // Cancel the previous command |
333 // Cancel the previous command |
326 // ---------------------------------------------------------------------------- |
334 // ---------------------------------------------------------------------------- |
327 void CCalenState::CancelPreviousCmd(CCalenStateMachine& aStateMachine) |
335 void CCalenState::CancelPreviousCmd(CCalenStateMachine& aStateMachine) |
328 { |
336 { |
329 OstTraceFunctionEntry0( CCALENSTATE_CANCELPREVIOUSCMD_ENTRY ); |
337 TRACE_ENTRY_POINT; |
330 |
338 |
331 aStateMachine.CancelPreviousCmd(); |
339 aStateMachine.CancelPreviousCmd(); |
332 |
340 |
333 OstTraceFunctionExit0( CCALENSTATE_CANCELPREVIOUSCMD_EXIT ); |
341 TRACE_EXIT_POINT; |
334 } |
342 } |
335 |
343 |
336 // ---------------------------------------------------------------------------- |
344 // ---------------------------------------------------------------------------- |
337 // CCalenState::CancelExecutingCmd |
345 // CCalenState::CancelExecutingCmd |
338 // Cancels executing command |
346 // Cancels executing command |
339 // ---------------------------------------------------------------------------- |
347 // ---------------------------------------------------------------------------- |
340 void CCalenState::CancelExecutingCmd() |
348 void CCalenState::CancelExecutingCmd() |
341 { |
349 { |
342 OstTraceFunctionEntry0( CCALENSTATE_CANCELEXECUTINGCMD_ENTRY ); |
350 TRACE_ENTRY_POINT; |
343 |
351 |
344 if(iCmdCallback) |
352 if(iCmdCallback) |
345 { |
353 { |
346 iCmdCallback->Cancel(); |
354 iCmdCallback->Cancel(); |
347 } |
355 } |
348 |
356 |
349 OstTraceFunctionExit0( CCALENSTATE_CANCELEXECUTINGCMD_EXIT ); |
357 TRACE_EXIT_POINT; |
350 } |
358 } |
351 // End of file |
359 // End of file |