mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
tenuous addition of a menu object
things don't crash, but...haven't really validated if they work, either!
This commit is contained in:
parent
3664ff6718
commit
62c9737bbc
10 changed files with 509 additions and 56 deletions
|
|
@ -112,6 +112,12 @@ pub(crate) enum Opcode {
|
|||
/// used to turn keyboard vibrate on and off
|
||||
Vibe,
|
||||
|
||||
/// called by a context when it's done with taking the screen; requests the GAM to revert focus to the last-focused app
|
||||
RevertFocus,
|
||||
|
||||
/// request an app to take the focus
|
||||
RequestFocus,
|
||||
|
||||
/////// planned
|
||||
|
||||
// hides a canvas with a given GID
|
||||
|
|
|
|||
|
|
@ -178,7 +178,7 @@ pub fn deface(gfx: &graphics_server::Gfx, canvases: &mut FnvIndexMap<Gid, Canvas
|
|||
}
|
||||
|
||||
// we use the "screen" parameter to determine when we can turn off drawing to canvases that are off-screen
|
||||
pub fn recompute_canvases(canvases: FnvIndexMap<Gid, Canvas, 32>, screen: Rectangle) -> FnvIndexMap<Gid, Canvas, 32> {
|
||||
pub fn recompute_canvases(canvases: &FnvIndexMap<Gid, Canvas, 32>, screen: Rectangle) -> FnvIndexMap<Gid, Canvas, 32> {
|
||||
let debug = false;
|
||||
// first, sort canvases by trust_level. Canvas implements ord/eq based on the trust_level attribute
|
||||
// so jush pushing it into a max binary heap does the trick.
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ use blitstr_ref as blitstr;
|
|||
use blitstr::GlyphStyle;
|
||||
use graphics_server::*;
|
||||
|
||||
use crate::LayoutApi;
|
||||
use crate::{LayoutApi, LayoutBehavior};
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
// GIDs of canvases that are used the "Chat" layout.
|
||||
|
|
@ -21,6 +21,7 @@ pub(crate) struct ChatLayout {
|
|||
screensize: Point,
|
||||
small_height: i16,
|
||||
regular_height: i16,
|
||||
visible: bool,
|
||||
}
|
||||
impl ChatLayout {
|
||||
// pass in the status canvas so we can size around it, but we can't draw on it
|
||||
|
|
@ -32,10 +33,17 @@ impl ChatLayout {
|
|||
let regular_height: i16 = gfx.glyph_height_hint(GlyphStyle::Regular).expect("couldn't get glyph height") as i16;
|
||||
let margin = 4;
|
||||
|
||||
let checked_base_trust = if base_trust < 4 {
|
||||
4
|
||||
} else {
|
||||
base_trust
|
||||
};
|
||||
|
||||
// allocate canvases in structures, and record their GID for future reference
|
||||
// base trust - 2 so that main menu + status bar always ride on top
|
||||
let predictive_canvas = Canvas::new(
|
||||
Rectangle::new_coords(0, screensize.y - regular_height - margin*2, screensize.x, screensize.y),
|
||||
base_trust,
|
||||
checked_base_trust - 2,
|
||||
&trng, None
|
||||
).expect("couldn't create predictive text canvas");
|
||||
canvases.insert(predictive_canvas.gid(), predictive_canvas).expect("couldn't store predictive canvas");
|
||||
|
|
@ -43,13 +51,13 @@ impl ChatLayout {
|
|||
let min_input_height = regular_height + margin*2;
|
||||
let input_canvas = Canvas::new(
|
||||
Rectangle::new_v_stack(predictive_canvas.clip_rect(), -min_input_height),
|
||||
base_trust, &trng, None
|
||||
checked_base_trust - 2, &trng, None
|
||||
).expect("couldn't create input text canvas");
|
||||
canvases.insert(input_canvas.gid(), input_canvas).expect("couldn't store input canvas");
|
||||
|
||||
let content_canvas = Canvas::new(
|
||||
Rectangle::new_v_span(status_canvas.clip_rect(), input_canvas.clip_rect()),
|
||||
base_trust / 2, &trng, None
|
||||
checked_base_trust / 2, &trng, None
|
||||
).expect("couldn't create content canvas");
|
||||
canvases.insert(content_canvas.gid(), content_canvas).expect("can't store content canvas");
|
||||
|
||||
|
|
@ -62,10 +70,14 @@ impl ChatLayout {
|
|||
screensize,
|
||||
small_height,
|
||||
regular_height,
|
||||
visible: true,
|
||||
})
|
||||
}
|
||||
}
|
||||
impl LayoutApi for ChatLayout {
|
||||
fn behavior(&self) -> LayoutBehavior {
|
||||
LayoutBehavior::App
|
||||
}
|
||||
fn clear(&self, gfx: &graphics_server::Gfx, canvases: &mut FnvIndexMap<Gid, Canvas, {crate::MAX_CANVASES}>) -> Result<(), xous::Error> {
|
||||
let input_canvas = canvases.get(&self.input).expect("couldn't find input canvas");
|
||||
let content_canvas = canvases.get(&self.content).expect("couldn't find content canvas");
|
||||
|
|
@ -124,6 +136,35 @@ impl LayoutApi for ChatLayout {
|
|||
fn get_content_canvas(&self) -> Gid {
|
||||
self.content
|
||||
}
|
||||
fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut FnvIndexMap<Gid, Canvas, {crate::MAX_CANVASES}>) {
|
||||
log::debug!("chatlayout: set_visibility_state onscreen {}, self.visible {}", onscreen, self.visible);
|
||||
if onscreen == self.visible {
|
||||
log::trace!("chatlayout: no change to visibility, moving on");
|
||||
// nothing to do
|
||||
return
|
||||
}
|
||||
let offscreen = if !onscreen && self.visible {
|
||||
// move canvases off-screen
|
||||
Point::new(self.screensize.x*2, 0)
|
||||
} else if onscreen && !self.visible {
|
||||
// undo the off-screen move
|
||||
Point::new(-self.screensize.x*2, 0)
|
||||
} else {
|
||||
// should actually never reach this because of the identity check at the very top
|
||||
Point::new(0, 0)
|
||||
};
|
||||
log::debug!("chatlayout: shifting canvas for input by {:?}", offscreen);
|
||||
let input_canvas = canvases.get_mut(&self.input).expect("couldn't find input canvas");
|
||||
input_canvas.set_clip(input_canvas.clip_rect().translate_chain(offscreen));
|
||||
|
||||
let content_canvas = canvases.get_mut(&self.content).expect("couldn't find content canvas");
|
||||
content_canvas.set_clip(content_canvas.clip_rect().translate_chain(offscreen));
|
||||
|
||||
let predictive_canvas = canvases.get_mut(&self.predictive).expect("couldn't find predictive canvas");
|
||||
predictive_canvas.set_clip(predictive_canvas.clip_rect().translate_chain(offscreen));
|
||||
|
||||
self.visible = onscreen;
|
||||
}
|
||||
}
|
||||
|
||||
// remember GIDs of the canvases for menus
|
||||
|
|
@ -135,19 +176,27 @@ pub(crate) struct MenuLayout {
|
|||
menu_min_height: i16,
|
||||
screensize: Point,
|
||||
small_height: i16,
|
||||
visible: bool,
|
||||
}
|
||||
impl MenuLayout {
|
||||
pub fn init(gfx: &graphics_server::Gfx, trng: &trng::Trng, base_trust: u8, _status_canvas: &Canvas, canvases: &mut FnvIndexMap<Gid, Canvas, {crate::MAX_CANVASES}>) -> Result<MenuLayout, xous::Error> {
|
||||
pub fn init(gfx: &graphics_server::Gfx, trng: &trng::Trng, base_trust: u8, canvases: &mut FnvIndexMap<Gid, Canvas, {crate::MAX_CANVASES}>) -> Result<MenuLayout, xous::Error> {
|
||||
let screensize = gfx.screen_size().expect("Couldn't get screen size");
|
||||
// get the height of various text regions to compute the layout
|
||||
let small_height: i16 = gfx.glyph_height_hint(GlyphStyle::Small).expect("couldn't get glyph height") as i16;
|
||||
|
||||
let checked_base_trust = if base_trust < 4 {
|
||||
4
|
||||
} else {
|
||||
base_trust
|
||||
};
|
||||
|
||||
const MENU_Y_PAD: i16 = 100;
|
||||
const MENU_X_PAD: i16 = 35;
|
||||
// build for an initial size of 1 entry
|
||||
// base trust - 1 so that status bar can always ride on top
|
||||
let menu_canvas = Canvas::new(
|
||||
Rectangle::new_coords(MENU_X_PAD, MENU_Y_PAD, screensize.x - MENU_X_PAD, MENU_Y_PAD + small_height),
|
||||
base_trust, &trng, None
|
||||
checked_base_trust - 1, &trng, None
|
||||
).expect("couldn't create menu canvas");
|
||||
canvases.insert(menu_canvas.gid(), menu_canvas).expect("can't store menu canvas");
|
||||
|
||||
|
|
@ -158,10 +207,14 @@ impl MenuLayout {
|
|||
menu_min_height: small_height,
|
||||
screensize,
|
||||
small_height,
|
||||
visible: true,
|
||||
})
|
||||
}
|
||||
}
|
||||
impl LayoutApi for MenuLayout {
|
||||
fn behavior(&self) -> LayoutBehavior {
|
||||
LayoutBehavior::Alert
|
||||
}
|
||||
fn clear(&self, gfx: &graphics_server::Gfx, canvases: &mut FnvIndexMap<Gid, Canvas, {crate::MAX_CANVASES}>) -> Result<(), xous::Error> {
|
||||
let menu_canvas = canvases.get(&self.menu).expect("couldn't find menu canvas");
|
||||
|
||||
|
|
@ -189,4 +242,26 @@ impl LayoutApi for MenuLayout {
|
|||
fn get_content_canvas(&self) -> Gid {
|
||||
self.menu
|
||||
}
|
||||
fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut FnvIndexMap<Gid, Canvas, {crate::MAX_CANVASES}>) {
|
||||
log::debug!("menu entering set_visibilty_state, self.visible {}, onscreen {}", self.visible, onscreen);
|
||||
if onscreen == self.visible {
|
||||
// nothing to do
|
||||
return
|
||||
}
|
||||
let menu_canvas = canvases.get_mut(&self.menu).expect("couldn't find menu canvas");
|
||||
|
||||
let offscreen = if !onscreen && self.visible {
|
||||
// move canvases off-screen
|
||||
Point::new(self.screensize.x*2, 0)
|
||||
} else if onscreen && !self.visible {
|
||||
// undo the off-screen move
|
||||
Point::new(-self.screensize.x*2, 0)
|
||||
} else {
|
||||
// should actually never reach this because of the identity check at the very top
|
||||
Point::new(0, 0)
|
||||
};
|
||||
log::debug!("moving menu by {:?}", offscreen);
|
||||
menu_canvas.set_clip(menu_canvas.clip_rect().translate_chain(offscreen));
|
||||
self.visible = onscreen;
|
||||
}
|
||||
}
|
||||
|
|
@ -220,6 +220,20 @@ impl Gam {
|
|||
ena, 0, 0, 0,)
|
||||
).map(|_| ())
|
||||
}
|
||||
/// this indicates to the GAM that the currently running app no longer wants to be the focus of attention
|
||||
/// we might respect that. or maybe not. depends on the GAM's policies.
|
||||
pub fn relinquish_focus(&self) -> Result<(), xous::Error> {
|
||||
send_message(self.conn,
|
||||
Message::new_scalar(Opcode::RevertFocus.to_usize().unwrap(),
|
||||
0, 0, 0, 0,)
|
||||
).map(|_| ())
|
||||
}
|
||||
pub fn request_focus(&self, token: [u32; 4]) -> Result<(), xous::Error> {
|
||||
send_message(self.conn,
|
||||
Message::new_blocking_scalar(Opcode::RequestFocus.to_usize().unwrap(),
|
||||
token[0] as usize, token[1] as usize, token[2] as usize, token[3] as usize,)
|
||||
).map(|_| ())
|
||||
}
|
||||
}
|
||||
|
||||
use core::sync::atomic::{AtomicU32, Ordering};
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@ mod status;
|
|||
use status::*;
|
||||
mod canvas;
|
||||
use canvas::*;
|
||||
mod menu;
|
||||
use menu::*;
|
||||
|
||||
mod tokens;
|
||||
use tokens::*;
|
||||
|
|
@ -33,6 +35,14 @@ use enum_dispatch::enum_dispatch;
|
|||
// - create menu server
|
||||
// - add auth tokens to audio streams, so less trusted processes can make direct connections to the codec and reduce latency
|
||||
|
||||
#[derive(PartialEq, Eq)]
|
||||
pub(crate) enum LayoutBehavior {
|
||||
/// a layout that can render over others, takes focus, and only dismissed if explicitly dismissed
|
||||
Alert,
|
||||
/// a layout that assumes it has the full screen and is the primary content when visible
|
||||
App,
|
||||
}
|
||||
|
||||
#[enum_dispatch]
|
||||
pub(crate) trait LayoutApi {
|
||||
fn clear(&self, gfx: &graphics_server::Gfx, canvases: &mut FnvIndexMap<Gid, Canvas, {crate::MAX_CANVASES}>) -> Result<(), xous::Error>;
|
||||
|
|
@ -41,6 +51,11 @@ pub(crate) trait LayoutApi {
|
|||
fn get_input_canvas(&self) -> Option<Gid> { None }
|
||||
fn get_prediction_canvas(&self) -> Option<Gid> { None }
|
||||
fn get_content_canvas(&self) -> Gid; // layouts always have a content canvas
|
||||
// when the argument is true, the context is moved "onscreen" by moving the canvases into the screen clipping rectangle
|
||||
// when false, the context is moved "offscreen" by moving the canvases outside the screen clipping rectangle
|
||||
// note that this visibility state is an independent variable from the trust level draw-ability
|
||||
fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut FnvIndexMap<Gid, Canvas, {crate::MAX_CANVASES}>);
|
||||
fn behavior(&self) -> LayoutBehavior;
|
||||
}
|
||||
|
||||
#[enum_dispatch(LayoutApi)]
|
||||
|
|
@ -80,13 +95,23 @@ pub(crate) struct UxContext {
|
|||
const MAX_UX_CONTEXTS: usize = 4;
|
||||
pub(crate) const MAX_CANVASES: usize = 32;
|
||||
const BOOT_APP_NAME: &'static str = "shellchat"; // this is the app to display on boot
|
||||
pub const MAIN_MENU_NAME: &'static str = "main menu";
|
||||
const BOOT_CONTEXT_TRUSTLEVEL: u8 = 254;
|
||||
|
||||
/*
|
||||
For now, app focus from menus is cooperative (menu items must relinquish focus).
|
||||
However, later on, I think it would be good to implement a press-hold to feature to
|
||||
swap focus in case of an app hang failure. This feature would probably be best done
|
||||
by adding a hook to the keyboard manager to look for a press-hold on the "select" key
|
||||
and then sending a message to the registered listener about the issue.
|
||||
*/
|
||||
struct ContextManager {
|
||||
tm: TokenManager,
|
||||
contexts: [Option<UxContext>; MAX_UX_CONTEXTS],
|
||||
focused_context: Option<[u32; 4]>, // app_token of the app that has I/O focus, if any
|
||||
last_context: Option<[u32; 4]>, // previously focused context, if any
|
||||
imef: ime_plugin_api::ImeFrontEnd,
|
||||
imef_active: bool,
|
||||
kbd: keyboard::Keyboard,
|
||||
}
|
||||
impl ContextManager {
|
||||
|
|
@ -102,7 +127,9 @@ impl ContextManager {
|
|||
tm: TokenManager::new(&xns),
|
||||
contexts: [None; MAX_UX_CONTEXTS],
|
||||
focused_context: None,
|
||||
last_context: None,
|
||||
imef,
|
||||
imef_active: false,
|
||||
kbd,
|
||||
}
|
||||
}
|
||||
|
|
@ -120,6 +147,7 @@ impl ContextManager {
|
|||
trng: &trng::Trng,
|
||||
status_canvas: &Canvas,
|
||||
canvases: &mut FnvIndexMap<Gid, Canvas, MAX_CANVASES>,
|
||||
trust_level: u8,
|
||||
registration: UxRegistration)
|
||||
-> Option<[u32; 4]> {
|
||||
let maybe_token = self.tm.claim_token(registration.app_name.as_str().unwrap());
|
||||
|
|
@ -127,14 +155,16 @@ impl ContextManager {
|
|||
if let Some(token) = maybe_token {
|
||||
match registration.ux_type {
|
||||
UxType::Chat => {
|
||||
let chatlayout = ChatLayout::init(&gfx, &trng,
|
||||
BOOT_CONTEXT_TRUSTLEVEL, &status_canvas, canvases).expect("couldn't create chat layout");
|
||||
let ux_context = UxContext {
|
||||
let mut chatlayout = ChatLayout::init(&gfx, &trng,
|
||||
trust_level, &status_canvas, canvases).expect("couldn't create chat layout");
|
||||
// default to off-screen for all layouts
|
||||
chatlayout.set_visibility_state(false, canvases);
|
||||
let ux_context = UxContext {
|
||||
layout: UxLayout::ChatLayout(chatlayout),
|
||||
predictor: registration.predictor,
|
||||
app_token: token,
|
||||
gam_token: [trng.get_u32().unwrap(), trng.get_u32().unwrap(), trng.get_u32().unwrap(), trng.get_u32().unwrap(), ],
|
||||
trust_level: BOOT_CONTEXT_TRUSTLEVEL,
|
||||
trust_level,
|
||||
listener: xous::connect(xous::SID::from_array(registration.listener)).unwrap(),
|
||||
redraw_id: registration.redraw_id,
|
||||
gotinput_id: registration.gotinput_id,
|
||||
|
|
@ -151,14 +181,17 @@ impl ContextManager {
|
|||
}
|
||||
},
|
||||
UxType::Menu => {
|
||||
let menulayout = MenuLayout::init(&gfx, &trng,
|
||||
BOOT_CONTEXT_TRUSTLEVEL, &status_canvas, canvases).expect("couldn't create menu layout");
|
||||
let mut menulayout = MenuLayout::init(&gfx, &trng,
|
||||
trust_level, canvases).expect("couldn't create menu layout");
|
||||
// default to off-screen for all layouts
|
||||
menulayout.set_visibility_state(false, canvases);
|
||||
log::debug!("debug layout: {:?}", menulayout);
|
||||
let ux_context = UxContext {
|
||||
layout: UxLayout::MenuLayout(menulayout),
|
||||
predictor: None,
|
||||
app_token: token,
|
||||
gam_token: [trng.get_u32().unwrap(), trng.get_u32().unwrap(), trng.get_u32().unwrap(), trng.get_u32().unwrap(), ],
|
||||
trust_level: BOOT_CONTEXT_TRUSTLEVEL,
|
||||
trust_level,
|
||||
listener: xous::connect(xous::SID::from_array(registration.listener)).unwrap(),
|
||||
redraw_id: registration.redraw_id,
|
||||
gotinput_id: None,
|
||||
|
|
@ -215,15 +248,91 @@ impl ContextManager {
|
|||
}
|
||||
None
|
||||
}
|
||||
pub(crate) fn activate(&mut self,
|
||||
gfx: &graphics_server::Gfx,
|
||||
canvases: &mut FnvIndexMap<Gid, Canvas, MAX_CANVASES>,
|
||||
token: [u32; 4],
|
||||
clear: bool,
|
||||
) {
|
||||
fn get_context_by_token_mut(&'_ mut self, token: [u32; 4]) -> Option<&'_ mut UxContext> {
|
||||
for maybe_context in self.contexts.iter_mut() {
|
||||
if let Some(context) = maybe_context {
|
||||
if context.app_token == token {
|
||||
return Some(context)
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
fn get_context_by_token(&'_ self, token: [u32; 4]) -> Option<&'_ UxContext> {
|
||||
for maybe_context in self.contexts.iter() {
|
||||
if let Some(context) = maybe_context {
|
||||
if context.app_token == token {
|
||||
return Some(context)
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
pub(crate) fn activate(&mut self,
|
||||
gfx: &graphics_server::Gfx,
|
||||
canvases: &mut FnvIndexMap<Gid, Canvas, MAX_CANVASES>,
|
||||
token: [u32; 4],
|
||||
clear: bool,
|
||||
) {
|
||||
let mut leaving_visibility: bool = false;
|
||||
{
|
||||
// using a temp copy of the old focus, check if we need to update any visibility state
|
||||
let maybe_leaving_focused_context = if self.focused_context.is_some() {
|
||||
if let Some(old_context) = self.get_context_by_token(self.focused_context.unwrap()) {
|
||||
Some(old_context.clone())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let maybe_new_focus = self.get_context_by_token_mut(token);
|
||||
if let Some(context) = maybe_new_focus {
|
||||
if let Some(leaving_focused_context) = maybe_leaving_focused_context {
|
||||
if token != leaving_focused_context.app_token {
|
||||
if (context.layout.behavior() == LayoutBehavior::Alert) &&
|
||||
(leaving_focused_context.layout.behavior() == LayoutBehavior::Alert) {
|
||||
context.layout.set_visibility_state(true, canvases);
|
||||
//leaving_focused_context.layout.set_visibility_state(false, canvases);
|
||||
leaving_visibility = false;
|
||||
} else if (context.layout.behavior() == LayoutBehavior::App) &&
|
||||
(leaving_focused_context.layout.behavior() == LayoutBehavior::App) {
|
||||
context.layout.set_visibility_state(true, canvases);
|
||||
//leaving_focused_context.layout.set_visibility_state(false, canvases);
|
||||
leaving_visibility = false;
|
||||
} else if (context.layout.behavior() == LayoutBehavior::Alert) &&
|
||||
(leaving_focused_context.layout.behavior() == LayoutBehavior::App) {
|
||||
context.layout.set_visibility_state(true, canvases);
|
||||
//leaving_focused_context.layout.set_visibility_state(true, canvases);
|
||||
leaving_visibility = true;
|
||||
} else if (context.layout.behavior() == LayoutBehavior::App) &&
|
||||
(leaving_focused_context.layout.behavior() == LayoutBehavior::Alert) {
|
||||
context.layout.set_visibility_state(true, canvases);
|
||||
//leaving_focused_context.layout.set_visibility_state(false, canvases);
|
||||
leaving_visibility = false;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// there was no current focus, just make the activation visible
|
||||
log::debug!("setting first-time visibility to context {:?}", token);
|
||||
context.layout.set_visibility_state(true, canvases);
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
// let all the previous operations go out of scope, so we can "check out" the old copy and modify it
|
||||
if self.focused_context.is_some() {
|
||||
if let Some(old_context) = self.get_context_by_token_mut(self.focused_context.unwrap()) {
|
||||
old_context.layout.set_visibility_state(leaving_visibility, canvases);
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
// now re-check-out the new context and finalize things
|
||||
let maybe_new_focus = self.get_context_by_token(token);
|
||||
if let Some(context) = maybe_new_focus {
|
||||
if context.predictor.is_some() {
|
||||
// only hook up the IMEF if a predictor is selected for this context
|
||||
let descriptor = ImefDescriptor {
|
||||
input_canvas: context.layout.get_input_canvas(),
|
||||
prediction_canvas: context.layout.get_prediction_canvas(),
|
||||
|
|
@ -231,20 +340,46 @@ impl ContextManager {
|
|||
token: context.gam_token,
|
||||
};
|
||||
self.imef.connect_backend(descriptor).expect("couldn't connect IMEF to the current app");
|
||||
if clear {
|
||||
context.layout.clear(gfx, canvases).expect("can't clear on context activation");
|
||||
}
|
||||
// now update the IMEF area, since we're initialized
|
||||
// note: we may need to skip this call if the context does not utilize a predictor...
|
||||
self.imef.redraw().unwrap();
|
||||
|
||||
// revert the keyboard vibe state
|
||||
self.kbd.set_vibe(context.vibe).expect("couldn't restore keyboard vibe");
|
||||
|
||||
self.focused_context = Some(context.app_token);
|
||||
self.imef_active = true;
|
||||
} else {
|
||||
self.imef_active = false;
|
||||
}
|
||||
|
||||
// now recompute the drawability of canvases, based on on-screen visibility and trust state
|
||||
let screensize = gfx.screen_size().expect("Couldn't get screen size");
|
||||
*canvases = recompute_canvases(canvases, Rectangle::new(Point::new(0, 0), screensize));
|
||||
}
|
||||
}
|
||||
{
|
||||
// now re-check-out the new context and finalize things
|
||||
let maybe_new_focus = self.get_context_by_token(token);
|
||||
if let Some(context) = maybe_new_focus {
|
||||
if clear {
|
||||
context.layout.clear(gfx, canvases).expect("can't clear on context activation");
|
||||
}
|
||||
// now update the IMEF area, since we're initialized
|
||||
// note: we may need to skip this call if the context does not utilize a predictor...
|
||||
if context.predictor.is_some() {
|
||||
self.imef.redraw().unwrap();
|
||||
}
|
||||
|
||||
// revert the keyboard vibe state
|
||||
self.kbd.set_vibe(context.vibe).expect("couldn't restore keyboard vibe");
|
||||
|
||||
let last_token = context.app_token;
|
||||
self.last_context = self.focused_context;
|
||||
self.focused_context = Some(last_token);
|
||||
self.redraw().expect("couldn't redraw the currently focused app");
|
||||
}
|
||||
}
|
||||
}
|
||||
pub(crate) fn revert_focus(&mut self,
|
||||
gfx: &graphics_server::Gfx,
|
||||
canvases: &mut FnvIndexMap<Gid, Canvas, MAX_CANVASES>,
|
||||
) {
|
||||
if let Some(last) = self.last_context {
|
||||
self.activate(gfx, canvases, last, false);
|
||||
}
|
||||
}
|
||||
pub(crate) fn redraw(&self) -> Result<(), xous::Error> { // redraws the currently focused context
|
||||
if let Some(token) = self.focused_app() {
|
||||
|
|
@ -285,29 +420,60 @@ impl ContextManager {
|
|||
}
|
||||
Err(xous::Error::ServerNotFound)
|
||||
}
|
||||
pub(crate) fn key_event(&self, keys: [char; 4]) {
|
||||
self.imef.send_keyevent(keys).expect("couldn't send keys to the IMEF");
|
||||
}
|
||||
fn focused_context(&'_ mut self) -> Option<&'_ mut UxContext> {
|
||||
if let Some(focus) = self.focused_app() {
|
||||
for maybe_context in self.contexts.iter_mut() {
|
||||
if let Some(context) = maybe_context {
|
||||
if context.app_token == focus {
|
||||
return Some(context)
|
||||
}
|
||||
pub(crate) fn key_event(&mut self, keys: [char; 4],
|
||||
gfx: &graphics_server::Gfx,
|
||||
canvases: &mut FnvIndexMap<Gid, Canvas, MAX_CANVASES>,
|
||||
) {
|
||||
// only pop up the menu if the primary key hit is the menu key (search just the first entry of keys); reject multi-key hits
|
||||
if keys[0] == '∴' {
|
||||
if let Some(menu_token) = self.find_app_token_by_name(MAIN_MENU_NAME) {
|
||||
// set the menu to the active context
|
||||
self.activate(gfx, canvases, menu_token, false);
|
||||
}
|
||||
}
|
||||
|
||||
if self.imef_active {
|
||||
// use the IMEF
|
||||
self.imef.send_keyevent(keys).expect("couldn't send keys to the IMEF");
|
||||
} else {
|
||||
// forward the keyboard hits without any IME to the current context
|
||||
log::debug!("forwarding raw key event");
|
||||
if let Some(context) = self.focused_context() {
|
||||
if let Some(rawkeys_id) = context.rawkeys_id {
|
||||
xous::send_message(context.listener,
|
||||
xous::Message::new_scalar(rawkeys_id as usize,
|
||||
keys[0] as u32 as usize,
|
||||
keys[1] as u32 as usize,
|
||||
keys[2] as u32 as usize,
|
||||
keys[3] as u32 as usize,
|
||||
)).expect("couldn't forward raw keys onto context listener");
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn focused_context(&'_ self) -> Option<&'_ UxContext> {
|
||||
if let Some(focus) = self.focused_app() {
|
||||
self.get_context_by_token(focus)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
fn focused_context_mut(&'_ mut self) -> Option<&'_ mut UxContext> {
|
||||
if let Some(focus) = self.focused_app() {
|
||||
self.get_context_by_token_mut(focus)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
pub(crate) fn set_audio_op(&mut self, audio_op: SetAudioOpcode) {
|
||||
if let Some(context) = self.focused_context() {
|
||||
if let Some(context) = self.focused_context_mut() {
|
||||
(*context).audioframe_id = Some(audio_op.opcode);
|
||||
}
|
||||
}
|
||||
pub(crate) fn vibe(&mut self, set_vibe: bool) {
|
||||
self.kbd.set_vibe(set_vibe).expect("couldn't set vibe on keyboard");
|
||||
if let Some(context) = self.focused_context() {
|
||||
if let Some(context) = self.focused_context_mut() {
|
||||
(*context).vibe = set_vibe;
|
||||
}
|
||||
}
|
||||
|
|
@ -354,7 +520,7 @@ fn xmain() -> ! {
|
|||
255, &trng, None
|
||||
).expect("couldn't create status canvas");
|
||||
canvases.insert(status_canvas.gid(), status_canvas).expect("can't store status canvus");
|
||||
canvases = recompute_canvases(canvases, Rectangle::new(Point::new(0, 0), screensize));
|
||||
canvases = recompute_canvases(&canvases, Rectangle::new(Point::new(0, 0), screensize));
|
||||
|
||||
// make a thread to manage the status bar -- this needs to start late, after the IMEF and most other things are initialized
|
||||
// the status bar is a trusted element managed by the OS, and we are chosing to domicile this in the GAM process for now
|
||||
|
|
@ -362,6 +528,10 @@ fn xmain() -> ! {
|
|||
log::trace!("starting status thread with gid {:?}", status_gid);
|
||||
xous::create_thread_4(status_thread, status_gid[0] as _, status_gid[1] as _, status_gid[2] as _, status_gid[3] as _).expect("couldn't create status thread");
|
||||
|
||||
// make a thread to manage the main menu.
|
||||
log::trace!("starting menu thread");
|
||||
xous::create_thread_0(main_menu_thread).expect("couldn't create menu thread");
|
||||
|
||||
let mut powerdown_requested = false;
|
||||
let mut last_time: u64 = ticktimer.elapsed_ms();
|
||||
log::trace!("entering main loop");
|
||||
|
|
@ -389,6 +559,7 @@ fn xmain() -> ! {
|
|||
Some(c) => {
|
||||
let mut rect = c.clip_rect();
|
||||
rect.normalize(); // normalize to 0,0 coordinates
|
||||
log::debug!("getcanvasbounds: {:?}", rect);
|
||||
xous::return_scalar2(msg.sender,
|
||||
rect.tl.into(),
|
||||
rect.br.into(),
|
||||
|
|
@ -483,7 +654,7 @@ fn xmain() -> ! {
|
|||
buffer.replace(ret).unwrap();
|
||||
canvas.do_drawn().expect("couldn't set canvas to drawn");
|
||||
} else {
|
||||
info!("attempt to draw TextView on non-drawable canvas. Not fatal, but request ignored.");
|
||||
info!("attempt to draw TextView on non-drawable canvas. Not fatal, but request ignored. {:?}", tv);
|
||||
}
|
||||
} else {
|
||||
info!("bogus GID {:?} in TextView {}, not doing anything in response to draw request.", tv.get_canvas_gid(), tv.text);
|
||||
|
|
@ -500,7 +671,7 @@ fn xmain() -> ! {
|
|||
let granted = context_mgr.set_canvas_height(&gfx, cb.token, cb.requested.y, &&status_canvas, &mut canvases);
|
||||
if granted.is_some() {
|
||||
// recompute the canvas orders based on the new layout
|
||||
canvases = recompute_canvases(canvases, Rectangle::new(Point::new(0, 0), screensize));
|
||||
canvases = recompute_canvases(&canvases, Rectangle::new(Point::new(0, 0), screensize));
|
||||
context_mgr.redraw().expect("can't redraw after new canvas bounds");
|
||||
}
|
||||
cb.granted = granted;
|
||||
|
|
@ -514,7 +685,6 @@ fn xmain() -> ! {
|
|||
log::debug!("RequestContentCanvas {:?}", req);
|
||||
|
||||
let ret = api::Return::ContentCanvasReturn(context_mgr.get_content_canvas(req));
|
||||
log::debug!("returning {:?}", ret);
|
||||
buffer.replace(ret).unwrap();
|
||||
}
|
||||
Some(Opcode::RenderObject) => {
|
||||
|
|
@ -583,12 +753,16 @@ fn xmain() -> ! {
|
|||
Some(Opcode::RegisterUx) => {
|
||||
let mut buffer = unsafe{ Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
||||
let registration = buffer.to_original::<UxRegistration, _>().unwrap();
|
||||
let token = context_mgr.register(&gfx, &trng, &status_canvas, &mut canvases, registration);
|
||||
|
||||
// note that we are currently assigning all Ux registrations a trust level consistent with a boot context (ultimately trusted)
|
||||
// this needs to be modified later on once we allow post-boot apps to be created
|
||||
let token = context_mgr.register(&gfx, &trng, &status_canvas, &mut canvases,
|
||||
BOOT_CONTEXT_TRUSTLEVEL, registration);
|
||||
|
||||
// compute what canvases are drawable
|
||||
// this _replaces_ the original canvas structure, to avoid complications of tracking mutable references through compound data structures
|
||||
// this is broken into two steps because of https://github.com/rust-lang/rust/issues/71126
|
||||
canvases = recompute_canvases(canvases, Rectangle::new(Point::new(0, 0), screensize));
|
||||
canvases = recompute_canvases(&canvases, Rectangle::new(Point::new(0, 0), screensize));
|
||||
|
||||
buffer.replace(Return::UxToken(token)).unwrap();
|
||||
},
|
||||
|
|
@ -628,21 +802,33 @@ fn xmain() -> ! {
|
|||
'\u{0000}'
|
||||
},
|
||||
];
|
||||
context_mgr.key_event(keys);
|
||||
context_mgr.key_event(keys, &gfx, &mut canvases);
|
||||
}),
|
||||
Some(Opcode::Vibe) => msg_scalar_unpack!(msg, ena, _, _, _, {
|
||||
if ena != 0 { context_mgr.vibe(true) }
|
||||
else { context_mgr.vibe(false) }
|
||||
}),
|
||||
Some(Opcode::RevertFocus) => {
|
||||
context_mgr.revert_focus(&gfx, &mut canvases);
|
||||
},
|
||||
Some(Opcode::RequestFocus) => msg_blocking_scalar_unpack!(msg, t0, t1, t2, t3, {
|
||||
// TODO: add some limitations around who can request focus
|
||||
// for now, it's the boot set so we just trust the requestor
|
||||
context_mgr.activate(&gfx, &mut canvases, [t0 as u32, t1 as u32, t2 as u32, t3 as u32], true);
|
||||
|
||||
// this is a blocking scalar, so return /something/ so we know to move on
|
||||
xous::return_scalar(msg.sender, 1).expect("couldn't confirm focus activation");
|
||||
}),
|
||||
Some(Opcode::Quit) => break,
|
||||
None => {log::error!("unhandled message {:?}", msg);}
|
||||
}
|
||||
/*
|
||||
// if we don't have a focused app, try and find the default boot app and bring it to focus.
|
||||
if context_mgr.focused_app().is_none() {
|
||||
if let Some(shellchat_token) = context_mgr.find_app_token_by_name(BOOT_APP_NAME) {
|
||||
context_mgr.activate(&gfx, &mut canvases, shellchat_token, true);
|
||||
}
|
||||
}
|
||||
}*/
|
||||
}
|
||||
// clean up our program
|
||||
log::trace!("main loop exit, destroying servers");
|
||||
|
|
|
|||
163
services/gam/src/menu.rs
Executable file
163
services/gam/src/menu.rs
Executable file
|
|
@ -0,0 +1,163 @@
|
|||
use xous_ipc::*;
|
||||
use graphics_server::*;
|
||||
use num_traits::*;
|
||||
use xous::msg_scalar_unpack;
|
||||
|
||||
const MAX_ITEMS: usize = 16;
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub enum MenuPayload {
|
||||
/// memorized scalar payload
|
||||
Scalar([u32; 4]),
|
||||
/// this a nebulous-but-TBD maybe way of bodging in a more complicated record, which would involve
|
||||
/// casting this memorized, static payload into a Buffer and passing it on. Let's not worry too much about it for now, it's mostly apirational...
|
||||
Memory(([u8; 256], usize)),
|
||||
}
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct MenuItem {
|
||||
name: String::<64>,
|
||||
action_conn: xous::CID,
|
||||
action_opcode: u32,
|
||||
action_payload: MenuPayload,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Menu {
|
||||
pub sid: xous::SID,
|
||||
pub gam: gam::Gam,
|
||||
pub xns: xous_names::XousNames,
|
||||
pub items: [Option<MenuItem>; MAX_ITEMS],
|
||||
pub index: usize, // currently selected item
|
||||
pub canvas: Gid,
|
||||
pub authtoken: [u32; 4],
|
||||
}
|
||||
|
||||
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
|
||||
pub enum MenuOpcode {
|
||||
Redraw,
|
||||
Rawkeys,
|
||||
Quit,
|
||||
}
|
||||
|
||||
impl Menu {
|
||||
pub fn new(name: &str) -> Menu {
|
||||
let xns = xous_names::XousNames::new().unwrap();
|
||||
let sid = xous::create_server().expect("can't create private menu message server");
|
||||
let gam = gam::Gam::new(&xns).expect("can't connect to GAM");
|
||||
let authtoken = gam.register_ux(
|
||||
gam::UxRegistration {
|
||||
app_name: String::<128>::from_str(name),
|
||||
ux_type: gam::UxType::Menu,
|
||||
predictor: None,
|
||||
listener: sid.to_array(),
|
||||
redraw_id: MenuOpcode::Redraw.to_u32().unwrap(),
|
||||
gotinput_id: None,
|
||||
audioframe_id: None,
|
||||
rawkeys_id: Some(MenuOpcode::Rawkeys.to_u32().unwrap()),
|
||||
}
|
||||
).expect("couldn't register my Ux element with GAM");
|
||||
log::debug!("requesting content canvas for menu");
|
||||
let canvas = gam.request_content_canvas(authtoken.unwrap()).expect("couldn't get my content canvas from GAM");
|
||||
Menu {
|
||||
sid,
|
||||
gam,
|
||||
xns,
|
||||
items: [None; MAX_ITEMS],
|
||||
index: 0,
|
||||
canvas,
|
||||
authtoken: authtoken.unwrap(),
|
||||
}
|
||||
}
|
||||
// if successful, returns None, otherwise, the menu item
|
||||
pub fn add_item(&mut self, new_item: MenuItem) -> Option<MenuItem> {
|
||||
for item in self.items.iter_mut() {
|
||||
if item.is_none() {
|
||||
*item = Some(new_item);
|
||||
return None;
|
||||
}
|
||||
}
|
||||
Some(new_item)
|
||||
}
|
||||
pub fn redraw(&mut self) {
|
||||
// for now, just draw a black rectangle
|
||||
log::trace!("menu redraw");
|
||||
let canvas_size = self.gam.get_canvas_bounds(self.canvas).unwrap();
|
||||
self.gam.draw_rounded_rectangle(self.canvas,
|
||||
RoundedRectangle::new(
|
||||
Rectangle::new_with_style(Point::new(0, 0), canvas_size,
|
||||
DrawStyle::new(PixelColor::Dark, PixelColor::Dark, 1)
|
||||
), 10
|
||||
)).unwrap();
|
||||
}
|
||||
pub fn key_event(&mut self, keys: [char; 4]) {
|
||||
for &k in keys.iter() {
|
||||
log::trace!("got key '{}'", k);
|
||||
match k {
|
||||
'∴' => {
|
||||
self.gam.relinquish_focus().expect("couldn't relinquish focus of the menu!");
|
||||
},
|
||||
'←' => {
|
||||
log::info!("got left arrow");
|
||||
}
|
||||
'→' => {
|
||||
log::info!("got right arrow");
|
||||
}
|
||||
'↑' => {
|
||||
log::info!("got up arrow");
|
||||
}
|
||||
'↓' => {
|
||||
log::info!("got down arrow");
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/////// strictly speaking this doesn't have to be in this file, but we make it part of this server so we are guaranteed to have a main menu at all times
|
||||
pub fn main_menu_thread() {
|
||||
let mut menu = Menu::new(crate::MAIN_MENU_NAME);
|
||||
loop {
|
||||
let msg = xous::receive_message(menu.sid).unwrap();
|
||||
log::trace!("|status: Message: {:?}", msg);
|
||||
match FromPrimitive::from_usize(msg.body.id()) {
|
||||
Some(MenuOpcode::Redraw) => {
|
||||
menu.redraw();
|
||||
},
|
||||
Some(MenuOpcode::Rawkeys) => msg_scalar_unpack!(msg, k1, k2, k3, k4, {
|
||||
let keys = [
|
||||
if let Some(a) = core::char::from_u32(k1 as u32) {
|
||||
a
|
||||
} else {
|
||||
'\u{0000}'
|
||||
},
|
||||
if let Some(a) = core::char::from_u32(k2 as u32) {
|
||||
a
|
||||
} else {
|
||||
'\u{0000}'
|
||||
},
|
||||
if let Some(a) = core::char::from_u32(k3 as u32) {
|
||||
a
|
||||
} else {
|
||||
'\u{0000}'
|
||||
},
|
||||
if let Some(a) = core::char::from_u32(k4 as u32) {
|
||||
a
|
||||
} else {
|
||||
'\u{0000}'
|
||||
},
|
||||
];
|
||||
menu.key_event(keys);
|
||||
}),
|
||||
Some(MenuOpcode::Quit) => {
|
||||
break;
|
||||
},
|
||||
None => {
|
||||
log::error!("unknown opcode {:?}", msg.body.id());
|
||||
}
|
||||
}
|
||||
}
|
||||
log::trace!("menu thread exit, destroying servers");
|
||||
// do we want to add a deregister_ux call to the system?
|
||||
xous::destroy_server(menu.sid).unwrap();
|
||||
}
|
||||
|
|
@ -162,7 +162,6 @@ pub fn status_thread(canvas_gid_0: usize, canvas_gid_1: usize, canvas_gid_2: usi
|
|||
info!("|status: starting main loop");
|
||||
loop {
|
||||
let msg = xous::receive_message(status_sid).unwrap();
|
||||
//let msg = xous::receive_message(status_sid).unwrap();
|
||||
log::trace!("|status: Message: {:?}", msg);
|
||||
match FromPrimitive::from_usize(msg.body.id()) {
|
||||
Some(StatusOpcode::BattStats) => msg_scalar_unpack!(msg, lo, hi, _, _, {
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ use xous_ipc::String;
|
|||
|
||||
// if you add more UxContexts, and you want them authorized by the GAM, add their names here.
|
||||
const TOKEN_SLOTS: usize = 3;
|
||||
const EXPECTED_BOOT_CONTEXTS: [&'static str; TOKEN_SLOTS] = ["shellchat", "menu", "status"];
|
||||
const EXPECTED_BOOT_CONTEXTS: [&'static str; TOKEN_SLOTS] = ["shellchat", "main menu", "status"];
|
||||
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
pub(crate) struct NamedToken {
|
||||
|
|
|
|||
|
|
@ -151,6 +151,13 @@ impl Rectangle {
|
|||
self.tl.y += offset.y;
|
||||
self.br.y += offset.y;
|
||||
}
|
||||
pub fn translate_chain(self, offset: Point) -> Rectangle {
|
||||
Rectangle {
|
||||
tl: Point::new(self.tl.x + offset.x, self.tl.y + offset.y),
|
||||
br: Point::new(self.br.x + offset.x, self.br.y + offset.y),
|
||||
style: self.style,
|
||||
}
|
||||
}
|
||||
pub fn normalize(&mut self) {
|
||||
self.br.x -= self.tl.x;
|
||||
self.br.y -= self.tl.y;
|
||||
|
|
|
|||
|
|
@ -65,10 +65,13 @@ impl Repl{
|
|||
rawkeys_id: None,
|
||||
}).expect("couldn't register Ux context for shellchat");
|
||||
|
||||
// we should be the first app running, so get the focus
|
||||
gam.request_focus(token.unwrap());
|
||||
|
||||
let content = gam.request_content_canvas(token.unwrap()).expect("couldn't get content canvas");
|
||||
log::trace!("content canvas {:?}", content);
|
||||
log::debug!("content canvas {:?}", content);
|
||||
let screensize = gam.get_canvas_bounds(content).expect("couldn't get dimensions of content canvas");
|
||||
log::trace!("size {:?}", screensize);
|
||||
log::debug!("size {:?}", screensize);
|
||||
Repl {
|
||||
input: None,
|
||||
msg: None,
|
||||
|
|
|
|||
Loading…
Reference in a new issue