calendarui/controller/src/calenidlestate.cpp
changeset 18 c198609911f9
parent 0 f979ecb2b13e
child 45 b6db4fd4947b
equal deleted inserted replaced
0:f979ecb2b13e 18:c198609911f9
    22 #include "calencontroller.h"
    22 #include "calencontroller.h"
    23 #include "calenstatemachine.h"
    23 #include "calenstatemachine.h"
    24 #include "calennotifier.h"
    24 #include "calennotifier.h"
    25 
    25 
    26 // ----------------------------------------------------------------------------
    26 // ----------------------------------------------------------------------------
    27 // CCalenIdleState::NewLC
    27 // CalenIdleState::NewLC
    28 // First stage construction
    28 // First stage construction
    29 // ----------------------------------------------------------------------------
    29 // ----------------------------------------------------------------------------
    30 CCalenIdleState* CCalenIdleState::NewLC( CCalenController& aController, 
    30 CCalenIdleState* CCalenIdleState::NewLC( CCalenController& aController, 
    31                     RHashSet<TCalenNotification>&  aOutstandingNotifications  )
    31                     RHashSet<TCalenNotification>&  aOutstandingNotifications  )
    32     {
    32     {
    96     switch( cmd )
    96     switch( cmd )
    97         {
    97         {
    98         case ECalenMonthView:
    98         case ECalenMonthView:
    99         case ECalenWeekView:
    99         case ECalenWeekView:
   100         case ECalenDayView:
   100         case ECalenDayView:
   101         case ECalenTodoView:
   101         case ECalenStartActiveStep:
       
   102             {
       
   103             // set previous state to idle
       
   104             CCalenStateMachine::TCalenStateIndex cachedState = GetCurrentState(aStateMachine);
       
   105             SetCurrentState( aStateMachine, CCalenStateMachine::ECalenPopulationState );
       
   106             SetCurrentPreviousState( aStateMachine, cachedState );
       
   107             ActivateCurrentStateL(aStateMachine);               
       
   108             cmdUsed = ETrue;
       
   109             }
       
   110             break;
       
   111         case ECalenTodoEditor:
       
   112         case ECalenTodoEditorDone:
   102         case ECalenForwardsToDayView:
   113         case ECalenForwardsToDayView:
   103         case ECalenNextView:
   114         case ECalenNextView:
   104         case ECalenPrevView:
   115         case ECalenPrevView:
   105         case ECalenSwitchView:
   116         case ECalenSwitchView:
   106         case ECalenHidePreview:
   117         case ECalenHidePreview:
   117         case ECalenMissedEventViewFromIdle:
   128         case ECalenMissedEventViewFromIdle:
   118         case ECalenMissedAlarmsViewFromIdle:    
   129         case ECalenMissedAlarmsViewFromIdle:    
   119         	 cmdUsed = ETrue;
   130         	 cmdUsed = ETrue;
   120              break;
   131              break;
   121         
   132         
   122         case ECalenStartActiveStep:
   133         
   123         	{
       
   124         	// set previous state to idle
       
   125             CCalenStateMachine::TCalenStateIndex cachedState = GetCurrentState(aStateMachine);
       
   126             SetCurrentState( aStateMachine, CCalenStateMachine::ECalenPopulationState );
       
   127            	SetCurrentPreviousState( aStateMachine, cachedState );
       
   128             ActivateCurrentStateL(aStateMachine);           	
       
   129            	cmdUsed = ETrue;
       
   130            	}
       
   131            	break;
       
   132         case ECalenEventView: 
   134         case ECalenEventView: 
   133         case ECalenMissedEventView: 
   135         case ECalenMissedEventView: 
   134             {
   136             {
   135         	// set previous state to idle
   137         	// set previous state to idle
   136             CCalenStateMachine::TCalenStateIndex cachedState = GetCurrentState(aStateMachine);
   138             CCalenStateMachine::TCalenStateIndex cachedState = GetCurrentState(aStateMachine);
   139             ActivateCurrentStateL(aStateMachine);            
   141             ActivateCurrentStateL(aStateMachine);            
   140             cmdUsed = ETrue;
   142             cmdUsed = ETrue;
   141         	}
   143         	}
   142         	break;
   144         	break;
   143         case ECalenNewMeeting:
   145         case ECalenNewMeeting:
   144         case ECalenNewTodo:
       
   145         case ECalenNewAnniv:
   146         case ECalenNewAnniv:
   146         case ECalenNewDayNote:
   147         case ECalenNewDayNote:
   147         case ECalenNewReminder:
   148         case ECalenNewReminder:
   148         case ECalenNewMeetingRequest:
   149         case ECalenNewMeetingRequest:
       
   150         case ECalenNewEntry:
   149         case ECalenEditCurrentEntry:
   151         case ECalenEditCurrentEntry:
   150         case ECalenEditSeries:
   152         case ECalenEditSeries:
   151         case ECalenEditOccurrence:
   153         case ECalenEditOccurrence:
   152         case ECalenViewCurrentEntry:
   154         case ECalenViewCurrentEntry:
   153             {
   155             {
   204         	} 
   206         	} 
   205         	break;       
   207         	break;       
   206         case ECalenGetLocation:
   208         case ECalenGetLocation:
   207     	case ECalenShowLocation:
   209     	case ECalenShowLocation:
   208     	case ECalenGetLocationAndSave:
   210     	case ECalenGetLocationAndSave:
   209     		{
   211     		{    		
   210     		CCalenStateMachine::TCalenStateIndex cachedState = GetCurrentState(aStateMachine);
   212     		}       
   211 	        SetCurrentState( aStateMachine, CCalenStateMachine::ECalenMapState );
       
   212 	        SetCurrentPreviousState( aStateMachine, cachedState );
       
   213 	        ActivateCurrentStateL(aStateMachine);        
       
   214 	        cmdUsed = ETrue;
       
   215     		}
       
   216 			break;
       
   217 		case ECalenEventViewFromAlarm:
       
   218         case ECalenEventViewFromAlarmStopOnly:	
       
   219 			{
       
   220 			CCalenStateMachine::TCalenStateIndex cachedState = GetCurrentState(aStateMachine);
       
   221             SetCurrentState( aStateMachine, CCalenStateMachine::ECalenAlarmState);
       
   222             SetCurrentPreviousState( aStateMachine, cachedState );
       
   223             ActivateCurrentStateL(aStateMachine);            
       
   224             cmdUsed = ETrue;
       
   225 			}
       
   226 			break;
       
   227     	case ECalenAddAttachment:
       
   228     	case ECalenRemoveAttachment:
       
   229     	case ECalenViewAttachmentList:    
       
   230     	    {
       
   231     	    CCalenStateMachine::TCalenStateIndex cachedState = GetCurrentState(aStateMachine);
       
   232     	    SetCurrentState( aStateMachine, CCalenStateMachine::ECalenAttachmentState );
       
   233             SetCurrentPreviousState( aStateMachine, cachedState );
       
   234             ActivateCurrentStateL(aStateMachine);        
       
   235             cmdUsed = ETrue;
       
   236     	    }
       
   237     	    break;
       
   238         default:
   213         default:
   239             // This a valid custom command as there is a command handler
   214             // This a valid custom command as there is a command handler
   240             // do not modify the new start and remain in idle.
   215             // do not modify the new start and remain in idle.
   241             // remain in idle
   216             // remain in idle
   242             // don't modify aNewState.
   217             // don't modify aNewState.