rtsk_ui.ks

////////////////////////////////////////////////////////////////////////////////
// RTSK		USER INTERFACE
////////////////////////////////////////////////////////////////////////////////
// REGISTERED MODE NAMES
GLOBAL MODE_NAMES TO LEXICON().

// REGISTERED VERB NAMES
GLOBAL VERB_NAMES TO LEXICON().
VERB_NAMES:ADD( 0, "TRANSFER MODE").
VERB_NAMES:ADD(10, "TRANSFER MODE").
VERB_NAMES:ADD(20, "TRANSFER MODE").
VERB_NAMES:ADD(30, "TRANSFER MODE").
VERB_NAMES:ADD(40, "TRANSFER MODE").
VERB_NAMES:ADD(50, "TRANSFER MODE").
VERB_NAMES:ADD(60, "TRANSFER MODE").
VERB_NAMES:ADD(70, "TRANSFER MODE").
VERB_NAMES:ADD(80, "TRANSFER MODE").
VERB_NAMES:ADD(90, "TRANSFER MODE").

// LIST OF PREVIOUSLY KNOWN VALUES FOR PREVIOUSLY PRINTED VARIABLES
GLOBAL UI_PREVIOUS_VALUES TO LEXICON().

// SOME CONSTANTS USED FOR DATA OUTPUT
GLOBAL NUMBER TO 0.
GLOBAL SIGNED TO 1.
GLOBAL ONOFF  TO 2.
GLOBAL TEXT   TO 3.




////////////////////////////////////////////////////////////////////////////////
// UI HEADER TASK
////////////////////////////////////////////////////////////////////////////////
GLOBAL UI_HEADER_REFRESH TO FALSE.
ON MAJOR_MODE {
	IF NOT UI_HEADER_REFRESH {
		SET UI_HEADER_REFRESH TO TRUE.
		TASK_SCHEDULE(0, TASK_UI_HEADER@).
	}
	PRESERVE.
}
ON MINOR_MODE {
	IF NOT UI_HEADER_REFRESH {
		SET UI_HEADER_REFRESH TO TRUE.
		TASK_SCHEDULE(0, TASK_UI_HEADER@).
	}
	PRESERVE.
}

FUNCTION TASK_UI_HEADER { PARAMETER DT.
	IF DT = INIT {
		SET UI_HEADER_REFRESH TO TRUE.
	}
	
	// DRAW BASE HEADER
	IF UI_HEADER_REFRESH {
		SET UI_HEADER_REFRESH TO FALSE.
		CLEARLINE(0).
		
		// SOFTWARE MODE
		PRINT "OP" AT (0,0).
		PRINT MAJOR_MODE AT (2,0).
		PRINT MINOR_MODE AT (3,0).
		
		// CURRENT SOFTWARE MODE NAME
		LOCAL MODE_ID IS MAJOR_MODE*10 + MINOR_MODE.
		IF MODE_NAMES:HASKEY(MODE_ID) {
			PRINT MODE_NAMES[MODE_ID] AT (5,0).
		} ELSE {
			PRINT "----- RTSK -----" AT (5,0).
		}
		
		// DRAW RESOURCES INFO
		PRINT "  0.0R" AT (22,0).
		PRINT "    0C" AT (29,0).
		
		// DAYS ON ORBIT
		PRINT "-" AT (39,0).
	}
	
	// PRINT RESOURCES
	PRINT N2S(SHIP:MONOPROPELLANT,1,5) AT (22,0).
	PRINT N2S(SHIP:ELECTRICCHARGE,0,5) AT (29,0).
	
	// PRINT MISSION TIME
	PRINT (FLOOR(MISSIONTIME/21600) + ""):PADLEFT(3):REPLACE(" ", "0") AT (36,0).
	PRINT_TIME(MISSIONTIME,40,0).
	
	// RE-SCHEDULE TASK
	TASK_SCHEDULE(17, TASK_UI_HEADER@).
}




////////////////////////////////////////////////////////////////////////////////
// SYSTEMS SCREENS DRAWING TASK
////////////////////////////////////////////////////////////////////////////////
GLOBAL UI_SYSTEMS_SCREENS_REFRESH TO FALSE.
ON RCS {
	IF NOT UI_SYSTEMS_SCREENS_REFRESH {
		SET UI_SYSTEMS_SCREENS_REFRESH TO TRUE.
		TASK_SCHEDULE(0, TASK_UI_SYSTEMS_SCREENS@).
	}
	PRESERVE.
}
ON SAS {
	IF NOT UI_SYSTEMS_SCREENS_REFRESH {
		SET UI_SYSTEMS_SCREENS_REFRESH TO TRUE.
		TASK_SCHEDULE(0, TASK_UI_SYSTEMS_SCREENS@).
	}
	PRESERVE.
}	

GLOBAL UI_SYSTEMS_SCREEN_PRIORITY TO 0.
FUNCTION TASK_UI_SYSTEMS_SCREENS { PARAMETER DT.
	IF DT = INIT {
		SET UI_SYSTEMS_SCREENS_REFRESH TO TRUE.
		VERT_LINE(30, 3, 19).
	}
	IF UI_SYSTEMS_SCREENS_REFRESH {
		SET UI_SYSTEMS_SCREENS_REFRESH TO FALSE.
	}

	UI_VARIABLE("CPU",	"%",	CPU_LOAD*100, 			0,3, NUMBER,	32,0).
	UI_VARIABLE("TSK",	"",		TASK_LIST:LENGTH+1, 	0,2, NUMBER,	42,0). // +1 SO IT COUNTS CURRENT TASK TOO
	UI_VARIABLE("  LF",	"U",	SHIP:LIQUIDFUEL,		1,7, NUMBER,	32,2).
	UI_VARIABLE("  OX",	"U",	SHIP:OXIDIZER, 			1,7, NUMBER,	32,3).

	UI_VARIABLE("   R",	"KM",	SHIP:ALTITUDE/1000,		3,8, SIGNED,	32,5).
	UI_VARIABLE("  AP",	"KM",	SHIP:APOAPSIS/1000,		3,8, SIGNED,	32,6).
	UI_VARIABLE("  PE",	"KM",	SHIP:PERIAPSIS/1000,	3,8, SIGNED,	32,7).
		
	UI_VARIABLE("T AP",	"SEC",	ETA:APOAPSIS,			0,7, SIGNED,	32,9).
	UI_VARIABLE("T PE",	"SEC",	ETA:PERIAPSIS,			0,7, SIGNED,	32,10).

	UI_VARIABLE("RCS",	"",		RCS,					0,3, ONOFF,		32,12).
	UI_VARIABLE("SAS",	"",		SAS,					0,3, ONOFF,		41,12).
	UI_VARIABLE("FCL",	"",		FUELCELLS,				0,3, ONOFF,		32,13).

	// RE-SCHEDULE TASK
	IF MODES_TASKLIST:HASKEY(MAJOR_MODE) {
		IF UI_SYSTEMS_SCREEN_PRIORITY > 0 {
			TASK_SCHEDULE(UI_SYSTEMS_SCREEN_PRIORITY, TASK_UI_SYSTEMS_SCREENS@).
		} ELSE {
			TASK_SCHEDULE(6, TASK_UI_SYSTEMS_SCREENS@).
		}
	} ELSE {
		TASK_SCHEDULE(3, TASK_UI_SYSTEMS_SCREENS@).
	}
}




////////////////////////////////////////////////////////////////////////////////
// UI INPUT QUASI-TASK
////////////////////////////////////////////////////////////////////////////////
GLOBAL UI_ENTERING TO FALSE.
GLOBAL UI_COMMAND TO -1.
GLOBAL UI_PARAMETER TO 0.

FUNCTION TASK_HANDLE_COMMAND { PARAMETER DT.
	IF UI_COMMAND = 0 {
		IF UI_PARAMETER = 99 { // SERVICE COMMAND: REFRESH SCREEN
			// CLEAR SCREEN AND ALL KNOWN VALUES
			CLEARSCREEN.
			SET UI_PREVIOUS_VALUES TO LEXICON().
			
			// REFRESH HEADER AND SCREENS
			TASK_UI_HEADER(INIT).
			TASK_UI_SYSTEMS_SCREENS(INIT).
		} ELSE IF UI_PARAMETER = 98 { // SERVICE COMMAND: EVENT TEST
			PUSH_EVENT("999 EVT TEST", HIGH).
		} ELSE IF UI_PARAMETER = 97 { // TOGGLE OUTPUT
			SET OUTPUT_PERMITTED TO NOT OUTPUT_PERMITTED.
		} ELSE {
			LOCAL MINOR IS MOD(FLOOR(UI_PARAMETER),10).
			LOCAL MAJOR IS MOD(FLOOR(UI_PARAMETER/10),10).
			TRANSFER_MODE(MAJOR, MINOR).
		}
	} ELSE {
		IF MODES_COMMAND:HASKEY(MAJOR_MODE) {
			MODES_COMMAND[MAJOR_MODE]:CALL(UI_COMMAND, UI_PARAMETER).
		} ELSE {
			IF MODES_COMMAND:HASKEY(0) {
				MODES_COMMAND[0]:CALL(UI_COMMAND, UI_PARAMETER).
			}
		}
	}
}

FUNCTION UI_INPUT_REDRAW {
	IF UI_ENTERING {
		PRINT "VERB" AT (2,2).
		IF UI_COMMAND = -1 {
			PRINT "?" AT (6,2).
		} ELSE {
			IF VERB_NAMES:HASKEY(MAJOR_MODE*10 + UI_COMMAND) {
				LOCAL VERB_NAME IS " [" + VERB_NAMES[MAJOR_MODE*10 + UI_COMMAND] + "]".
				PRINT VERB_NAME AT (6,2).
				PRINT UI_PARAMETER AT (7+VERB_NAME:LENGTH,2).
			} ELSE {
				PRINT UI_COMMAND AT (6,2).
				PRINT UI_PARAMETER AT (8,2).
			}
		}
	} ELSE {
		CLEARLINE(2).
	}
}

FUNCTION UI_ENTER_DIGIT {
	PARAMETER DIGIT.
	IF UI_ENTERING {
		IF UI_COMMAND = -1 {
			SET UI_COMMAND TO DIGIT.
		} ELSE {
			IF UI_PARAMETER < 0 {
				SET UI_PARAMETER TO UI_PARAMETER*10 - DIGIT.
			} ELSE {
				SET UI_PARAMETER TO UI_PARAMETER*10 + DIGIT.
			}
		}
		UI_INPUT_REDRAW().
	}
}




////////////////////////////////////////////////////////////////////////////////
// HANDLERS FOR THE KEYS
////////////////////////////////////////////////////////////////////////////////
ON AG20 { UI_ENTER_DIGIT(0). PRESERVE. }
ON AG21 { UI_ENTER_DIGIT(1). PRESERVE. }
ON AG22 { UI_ENTER_DIGIT(2). PRESERVE. }
ON AG23 { UI_ENTER_DIGIT(3). PRESERVE. }
ON AG24 { UI_ENTER_DIGIT(4). PRESERVE. }
ON AG25 { UI_ENTER_DIGIT(5). PRESERVE. }
ON AG26 { UI_ENTER_DIGIT(6). PRESERVE. }
ON AG27 { UI_ENTER_DIGIT(7). PRESERVE. }
ON AG28 { UI_ENTER_DIGIT(8). PRESERVE. }
ON AG29 { UI_ENTER_DIGIT(9). PRESERVE. }
ON AG30 { // PRO
	IF UI_ENTERING {
		SET UI_ENTERING TO FALSE.
		UI_INPUT_REDRAW().
		
		// HANDLE COMMAND IN MAIN LOOP
		TASK_SCHEDULE(0, TASK_HANDLE_COMMAND@).
	}
	PRESERVE.
}
ON AG31 { // ACK
	IF UI_ENTERING {
		SET UI_PARAMETER TO -UI_PARAMETER.
		UI_INPUT_REDRAW().
	} ELSE {
		SET EVENT_PENDING TO NOT EVENT_PENDING.
		EVENT_REDRAW().
	}
	PRESERVE.
}
ON AG32 { // REFRESH
	// CLEAR SCREEN AND ALL KNOWN VALUES
	CLEARSCREEN.
	SET UI_PREVIOUS_VALUES TO LEXICON().
	
	// REFRESH HEADER AND SCREENS
	TASK_UI_HEADER(INIT).
	PRESERVE.
}
ON AG33 { // VERB
	IF UI_ENTERING {
		SET UI_ENTERING TO FALSE.
	} ELSE {
		SET UI_ENTERING TO TRUE.
		SET UI_COMMAND TO -1.
		SET UI_PARAMETER TO 0.
	}
	UI_INPUT_REDRAW().
	PRESERVE.
}




////////////////////////////////////////////////////////////////////////////////
//
// PRINT A VARIABLE ON SCREEN
//
FUNCTION UI_VARIABLE {
	PARAMETER NAME, UNITS, VALUE, N, NMAX, TYPE, X, Y.

	LOCAL VALUE_NUM IS 0.
	LOCAL VALUE_STR IS "".
	IF TYPE = SIGNED {
		SET VALUE_NUM TO ROUND(VALUE, N).
	} ELSE IF TYPE = NUMBER {
		SET VALUE_NUM TO ROUND(VALUE, N).
	} ELSE IF TYPE = ONOFF {
		IF VALUE {
			SET VALUE_NUM TO 1.
		} ELSE {
			SET VALUE_NUM TO 0.
		}
	} ELSE {
		SET VALUE_NUM TO VALUE.
	}

	// NEW VALUE
	IF NOT UI_PREVIOUS_VALUES:HASKEY(NAME) {
		// >> START
		IF TYPE = SIGNED {
			SET VALUE_STR TO N2S_SIGN(VALUE, N, NMAX).
		} ELSE IF TYPE = NUMBER {
			SET VALUE_STR TO N2S(VALUE, N, NMAX).
		} ELSE IF TYPE = ONOFF {
			IF VALUE {
				SET VALUE_STR TO " ON".
			} ELSE {
				SET VALUE_STR TO "OFF".
			}
		} ELSE {
			SET VALUE_STR TO VALUE:PADLEFT(NMAX):SUBSTRING(0, NMAX).
		}
		// << END
	
		PRINT NAME AT (X, Y+3).
		PRINT UNITS AT (X+NAME:LENGTH+1+VALUE_STR:LENGTH+1, Y+3).
		IF TYPE = TEXT {
			UI_PREVIOUS_VALUES:ADD(NAME, "").
		} ELSE {
			UI_PREVIOUS_VALUES:ADD(NAME, VALUE_NUM - 1).
		}
	}
	
	// PRINT ONLY IF UPDATED
	IF UI_PREVIOUS_VALUES[NAME] <> VALUE_NUM {
		// >> START
		IF TYPE = SIGNED {
			SET VALUE_STR TO N2S_SIGN(VALUE, N, NMAX).
		} ELSE IF TYPE = NUMBER {
			SET VALUE_STR TO N2S(VALUE, N, NMAX).
		} ELSE IF TYPE = ONOFF {
			IF VALUE {
				SET VALUE_STR TO " ON".
			} ELSE {
				SET VALUE_STR TO "OFF".
			}
		} ELSE {
			SET VALUE_STR TO VALUE:PADLEFT(NMAX):SUBSTRING(0, NMAX).
		}
		// << END
		
		PRINT VALUE_STR AT (X+NAME:LENGTH+1, Y+3).
		SET UI_PREVIOUS_VALUES[NAME] TO VALUE_NUM.
	}
}


//
// CONVERT NUMBER TO PADDED STRING WITH FIXED NUMBER OF FRACTIONAL DIGITS
//
FUNCTION N2S {
	PARAMETER X,N,NMAX.
	
	IF N = 0 {
		IF X >= 0 {
			LOCAL XI IS ROUND(X).
			RETURN ("" + XI):PADLEFT(NMAX):SUBSTRING(0, NMAX).
		} ELSE {
			LOCAL XI IS -ROUND(X).
			RETURN ("-" + XI):PADLEFT(NMAX):SUBSTRING(0, NMAX).
		}
	} ELSE {
		IF X >= 0 {
			LOCAL XI IS FLOOR(X).
			LOCAL XF IS FLOOR((10^N)*(X - XI)).
			RETURN (XI + "." + (XF + ""):PADLEFT(N):REPLACE(" ", "0")):PADLEFT(NMAX):SUBSTRING(0, NMAX).
		} ELSE {
			LOCAL XI IS FLOOR(-X).
			LOCAL XF IS FLOOR((10^N)*(-X - XI)).
			RETURN ("-" + XI + "." + (XF + ""):PADLEFT(N):REPLACE(" ", "0")):PADLEFT(NMAX):SUBSTRING(0, NMAX).
		}
	}
}

//
// CONVERT NUMBER TO PADDED STRING WITH FIXED NUMBER OF FRACTIONAL DIGITS AND EXPLICIT SIGN
//
FUNCTION N2S_SIGN {
	PARAMETER X,N,NMAX.
	
	IF N = 0 {
		IF X >= 0 {
			LOCAL XI IS ROUND(X).
			RETURN "+" + ("" + XI):PADLEFT(NMAX-1):SUBSTRING(0, NMAX-1).
		} ELSE {
			LOCAL XI IS -ROUND(X).
			RETURN "-" + ("" + XI):PADLEFT(NMAX-1):SUBSTRING(0, NMAX-1).
		}
	} ELSE {
		IF X >= 0 {
			LOCAL XI IS FLOOR(X).
			LOCAL XF IS FLOOR((10^N)*(X - XI)).
			RETURN "+" + (XI + "." + (XF + ""):PADLEFT(N):REPLACE(" ", "0")):PADLEFT(NMAX-1):SUBSTRING(0, NMAX-1).
		} ELSE {
			LOCAL XI IS FLOOR(-X).
			LOCAL XF IS FLOOR((10^N)*(-X - XI)).
			RETURN "-" + (XI + "." + (XF + ""):PADLEFT(N):REPLACE(" ", "0")):PADLEFT(NMAX-1):SUBSTRING(0, NMAX-1).
		}
	}
}

//
// PRINT TIME IN EXTENDED FORMAT
//
FUNCTION PRINT_TIME {
	PARAMETER T, X, Y.
	PRINT FORMAT_TIME(T) AT (X,Y).
}

//
// FORMAT A TIME STRING
//
FUNCTION FORMAT_TIME {
	PARAMETER T.

	// SPLIT INTO TIME FORMAT
	LOCAL SECOND IS MOD(FLOOR(T),60).
	LOCAL MINUTE IS MOD(FLOOR(T / 60),60).
	LOCAL HOUR   IS MOD(FLOOR(T / 3600),6).
	LOCAL RESULT IS "".
	
	// PRINT ALL DIGITS
	IF HOUR < 10 {
		SET RESULT TO RESULT + "0" + HOUR + ":".
	} ELSE {
		SET RESULT TO RESULT + HOUR + ":".
	}
	IF MINUTE < 10 {
		SET RESULT TO RESULT + "0" + MINUTE + ":".
	} ELSE {
		SET RESULT TO RESULT + MINUTE + ":".
	}
	IF SECOND < 10 {
		SET RESULT TO RESULT + "0" + SECOND.
	} ELSE {
		SET RESULT TO RESULT + SECOND.
	}
	RETURN RESULT.
}


//
// CLEARS A LINE
//
FUNCTION CLEARLINE {
	PARAMETER Y.
	PRINT "                                                " AT (0,Y).
}

//
// CLEARS ONLY THE MM-RELATED AREA
//
FUNCTION CLEAR_MM {
	LOCAL Y IS 3.
	UNTIL Y > 20 {
		PRINT "                              " AT (0,Y).
		SET Y TO Y + 1.
	}
}

// DRAWS A VERTICAL LINE
FUNCTION VERT_LINE {
	PARAMETER X,Y1,Y2.
	LOCAL I IS Y1.
	UNTIL I = Y2+1 {
		PRINT "|" AT (X,I).
		SET I TO I + 1.
	}
}

// DRAWS A HORIZONTAL LINE
FUNCTION HORIZ_LINE {
	PARAMETER X1,X2,Y.
	LOCAL I IS X1.
	UNTIL I = X2+1 {
		PRINT "-" AT (I,Y).
		SET I TO I + 1.
	}
}