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