rtsk_mm.ks

////////////////////////////////////////////////////////////////////////////////
// RTSK		SOFTWARE MODE MANAGEMENT
////////////////////////////////////////////////////////////////////////////////
// CURRENT SOFTWARE MODE
GLOBAL MAJOR_MODE TO 0.
GLOBAL MINOR_MODE TO 0.

// PREVIOUS SOFTWARE MODE
GLOBAL PREVIOUS_MAJOR_MODE TO 0.
GLOBAL PREVIOUS_MINOR_MODE TO 0.

// LIST OF MAJOR MODES
GLOBAL MODES_TASKLIST TO LEXICON().
// LIST OF MAJOR MODE TRANSFER FUNCTIONS
GLOBAL MODES_ENTER TO LEXICON().
GLOBAL MODES_LEAVE TO LEXICON().
GLOBAL MODES_TRANSFER TO LEXICON().
GLOBAL MODES_COMMAND TO LEXICON().

// TIME SINCE MODE WAS INITIALIZED
GLOBAL MODE_TIMER_START TO TIME:SECONDS.
FUNCTION MODE_TIMER {
	RETURN TIME:SECONDS - MODE_TIMER_START.
}


//
// REGISTER AN EXTRA TASK TO BE LOADED WHEN SWITCHING MAJOR MODE
//
FUNCTION MODE_TASK {
	PARAMETER MAJOR, TASK.
	
	// ADD NEW MAJOR MODE
	IF NOT MODES_TASKLIST:HASKEY(MAJOR) {
		MODES_TASKLIST:ADD(MAJOR, LIST()).
	}
	
	// ADD TASK TO THE TASKLIST
	MODES_TASKLIST[MAJOR]:ADD(TASK).
}

//
// CALLED WHEN MAJOR MODE IS ENTERED
//
FUNCTION MODE_ENTER {
	PARAMETER MAJOR, FUNC.
	MODES_ENTER:ADD(MAJOR, FUNC).
}

//
// CALLED WHEN MAJOR MODE IS LEFT
//
FUNCTION MODE_LEAVE {
	PARAMETER MAJOR, FUNC.
	MODES_LEAVE:ADD(MAJOR, FUNC).
}

//
// CALLED WHEN MINOR MODE IS SWITCHED
//
FUNCTION MODE_TRANSFER {
	PARAMETER MAJOR, FUNC.
	MODES_TRANSFER:ADD(MAJOR, FUNC).
}
//

// CALLED WHEN MINOR MODE IS SWITCHED
//
FUNCTION MODE_COMMAND {
	PARAMETER MAJOR, FUNC.
	MODES_COMMAND:ADD(MAJOR, FUNC).
}

//
// CLEAR MODE SCREEN
//
FUNCTION RESET_DISPLAY {
	CLEAR_MM().
	SET UI_PREVIOUS_VALUES TO LEXICON().
}

//
// TRANSFER BETWEEN MODES
//
FUNCTION TRANSFER_MODE {
	PARAMETER MAJOR, MINOR.
	
	// REMEMBER PREVIOUS MODE
	SET PREVIOUS_MAJOR_MODE TO MAJOR_MODE.
	SET PREVIOUS_MINOR_MODE TO MINOR_MODE.
	
	// CHECK IF MAJOR MODE CHANGED
	IF MAJOR_MODE <> MAJOR {
		// STOP ALL TASKS FROM THE OLD MODE
		IF MODES_TASKLIST:HASKEY(MAJOR_MODE) {
			FOR OLD_TASK IN MODES_TASKLIST[MAJOR_MODE] {
				LOCAL INDEX IS 0.
				UNTIL INDEX >= TASK_LIST:LENGTH {
					LOCAL TASK IS TASK_LIST[INDEX].
					IF TASK[3] = OLD_TASK {
						TASK_LIST:REMOVE(INDEX).
						TASK_LIST_LOOKUP:REMOVE(TASK[3]).
					} ELSE {
						SET INDEX TO INDEX + 1.
					}
				}
			}
		}
	
		// LEAVE OLD MODE
		IF MODES_LEAVE:HASKEY(MAJOR_MODE) {
			MODES_LEAVE[MAJOR_MODE]:CALL().
		}
		
		// CHANGE MODE
		SET MAJOR_MODE TO MAJOR.
		SET MINOR_MODE TO MINOR.
		
		// ENTER NEW MODE
		IF MODES_ENTER:HASKEY(MAJOR_MODE) {
			MODES_ENTER[MAJOR_MODE]:CALL().
		}
		
		// IF MINOR MODE DID NOT CHANGE AFTER "ENTER" CALL, TRANSFER NOW (OTHERWISE
		// ENTER FUNCTION HAS ALREADY TRANSFERRED ITSELF)
		IF MINOR_MODE = MINOR {
			IF MODES_TRANSFER:HASKEY(MAJOR_MODE) {
				MODES_TRANSFER[MAJOR_MODE]:CALL().
			}
		}
		
		// MAJOR MODE CHANGED, REFRESH UI
		RESET_DISPLAY().
		
		// START ALL TASKS FROM THE NEW MODE
		IF MODES_TASKLIST:HASKEY(MAJOR_MODE) {
			FOR NEW_TASK IN MODES_TASKLIST[MAJOR_MODE] {
				NEW_TASK:CALL(INIT).
			}
		}
	} ELSE {
		// TRANSFER MINOR MODE ONLY
		SET MINOR_MODE TO MINOR.
		IF MODES_TRANSFER:HASKEY(MAJOR_MODE) {
			MODES_TRANSFER[MAJOR_MODE]:CALL().
		}
	}
	
	// RESET MODE TIMER
	SET MODE_TIMER_START TO TIME:SECONDS.
	
	// SAVE MODE VALUES
	SET_PVAR("MAJOR_MODE", MAJOR_MODE).
	SET_PVAR("MINOR_MODE", MINOR_MODE).
	DOWNLINK("OP", MAJOR_MODE*10 + MINOR_MODE).
}