mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
part-way through a refactor of trust levels to prevent alerts from popping over password boxes
This commit is contained in:
parent
b35f2a1d3e
commit
08421999ad
14 changed files with 155 additions and 136 deletions
|
|
@ -207,6 +207,16 @@ pub(crate) enum MenuMgrOp {
|
|||
Ok,
|
||||
Err,
|
||||
}
|
||||
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, PartialEq, Eq)]
|
||||
pub enum ActivationResult {
|
||||
Success,
|
||||
Failure,
|
||||
}
|
||||
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
|
||||
pub(crate) struct GamActivation {
|
||||
pub(crate) name: xous_ipc::String::<128>,
|
||||
pub(crate) result: Option<ActivationResult>,
|
||||
}
|
||||
|
||||
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
|
||||
pub(crate) struct MenuManagement {
|
||||
|
|
|
|||
|
|
@ -5,18 +5,22 @@ use core::cmp::Ordering;
|
|||
use graphics_server::*;
|
||||
use log::{error, info};
|
||||
|
||||
// "Drawable" vs "NotDrawable" is a security distinction.
|
||||
// "OnScreen" vs "Offscreen" is a layout distinction.
|
||||
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
|
||||
pub enum CanvasState {
|
||||
// the initial state of every Canvas. Not drawable.
|
||||
Created,
|
||||
// this state indicates the Canvas can be drawn, and may or may not need to be flushed to the screen.
|
||||
// this state indicates the Canvas is on-screen and can be drawn, and may or may not need to be flushed to the screen.
|
||||
DrawableDirty,
|
||||
// this state indicates the Canvas has been flushed to the screen.
|
||||
// this state indicates the Canvas is on-screen and has been flushed to the screen.
|
||||
DrawableDrawn,
|
||||
// indicates that the Canvas is not drawable, but needs to be defaced
|
||||
// indicates that the Canvas is on-screen but not drawable, but needs to be defaced
|
||||
NotDrawableDirty,
|
||||
// indicates that the Canvas is not drawable, and has been defaced
|
||||
// indicates that the Canvas is on-screen not drawable, and has been defaced
|
||||
NotDrawableDefaced,
|
||||
// indicates that the Canvas was drawable, but is now off-screen and should not be drawn or considered for any computations
|
||||
OffScreenDrawable,
|
||||
// indicates that the Canvas was not drawable, but is now off-screen and shouldn to be drawn or considered for any computations
|
||||
OffScreenNotDrawable,
|
||||
}
|
||||
|
||||
/// A rectangular region that defines a top-left zero relative offset for graphical items
|
||||
|
|
@ -53,25 +57,40 @@ impl Canvas {
|
|||
|
||||
Ok(if pan_offset.is_some() {
|
||||
Canvas {
|
||||
clip_rect, trust_level, state: CanvasState::Created, gid: Gid::new(gid), pan_offset: pan_offset.unwrap(),
|
||||
clip_rect, trust_level, state: CanvasState::OffScreenDrawable, gid: Gid::new(gid), pan_offset: pan_offset.unwrap(),
|
||||
canvas_type,
|
||||
}
|
||||
} else {
|
||||
Canvas {
|
||||
clip_rect, trust_level, state: CanvasState::Created, gid: Gid::new(gid), pan_offset: Point::new(0, 0),
|
||||
clip_rect, trust_level, state: CanvasState::OffScreenNotDrawable, gid: Gid::new(gid), pan_offset: Point::new(0, 0),
|
||||
canvas_type,
|
||||
}
|
||||
})
|
||||
}
|
||||
pub fn pan_offset(&self) -> Point { self.pan_offset }
|
||||
pub fn clip_rect(&self) -> Rectangle { self.clip_rect }
|
||||
pub fn set_clip(&mut self, cr: Rectangle) { self.clip_rect = cr; self.state = CanvasState::Created }
|
||||
pub fn set_clip(&mut self, cr: Rectangle) { self.clip_rect = cr; self.state = CanvasState::OffScreenNotDrawable }
|
||||
pub fn gid(&self) -> Gid { self.gid }
|
||||
pub fn trust_level(&self) -> u8 { self.trust_level }
|
||||
pub fn set_trust_level(&mut self, level: u8) {self.trust_level = level;}
|
||||
pub fn state(&self) -> CanvasState { self.state }
|
||||
pub fn is_onscreen(&self) -> bool {
|
||||
if self.state == CanvasState::OffScreenDrawable || self.state == CanvasState::OffScreenNotDrawable {
|
||||
false
|
||||
} else {
|
||||
true
|
||||
}
|
||||
}
|
||||
pub fn is_drawable(&self) -> bool {
|
||||
if self.state == CanvasState::DrawableDirty || self.state == CanvasState::DrawableDrawn {
|
||||
if self.state == CanvasState::DrawableDirty || self.state == CanvasState::DrawableDrawn || self.state == CanvasState::OffScreenDrawable {
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
pub fn is_drawable_or_offscreen(&self) -> bool {
|
||||
if self.state == CanvasState::DrawableDirty || self.state == CanvasState::DrawableDrawn
|
||||
|| self.state == CanvasState::OffScreenDrawable {
|
||||
true
|
||||
} else {
|
||||
false
|
||||
|
|
@ -79,24 +98,47 @@ impl Canvas {
|
|||
}
|
||||
pub fn set_drawable(&mut self, drawable: bool) {
|
||||
if drawable {
|
||||
if self.state != CanvasState::DrawableDrawn {
|
||||
if self.state == CanvasState::OffScreenNotDrawable {
|
||||
self.state = CanvasState::OffScreenDrawable
|
||||
} else if self.state != CanvasState::DrawableDrawn {
|
||||
self.state = CanvasState::DrawableDirty;
|
||||
}
|
||||
} else {
|
||||
if self.state != CanvasState::NotDrawableDefaced {
|
||||
if self.state == CanvasState::OffScreenDrawable {
|
||||
self.state = CanvasState::OffScreenNotDrawable
|
||||
} else if self.state != CanvasState::NotDrawableDefaced {
|
||||
self.state = CanvasState::NotDrawableDirty;
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn set_onscreen(&mut self, onscreen: bool) {
|
||||
if onscreen {
|
||||
if self.state == CanvasState::OffScreenDrawable {
|
||||
self.state = CanvasState::DrawableDirty;
|
||||
} else if self.state == CanvasState::OffScreenNotDrawable {
|
||||
self.state = CanvasState::NotDrawableDirty;
|
||||
}
|
||||
// other states are already onscreen
|
||||
} else {
|
||||
if self.state == CanvasState::DrawableDirty || self.state == CanvasState::DrawableDrawn {
|
||||
self.state = CanvasState::OffScreenDrawable;
|
||||
} else if self.state == CanvasState::NotDrawableDirty || self.state == CanvasState::NotDrawableDefaced {
|
||||
self.state = CanvasState::OffScreenNotDrawable;
|
||||
}
|
||||
// other states are already offscreen
|
||||
}
|
||||
}
|
||||
// call this after the screen has been flushed
|
||||
pub fn do_flushed(&mut self) -> Result<(), xous::Error> {
|
||||
if self.state == CanvasState::DrawableDirty || self.state == CanvasState::DrawableDrawn {
|
||||
self.state = CanvasState::DrawableDrawn;
|
||||
Ok(())
|
||||
} else if self.state == CanvasState::NotDrawableDefaced {
|
||||
} else if self.state == CanvasState::NotDrawableDefaced
|
||||
|| self.state == CanvasState::OffScreenNotDrawable
|
||||
|| self.state == CanvasState::OffScreenDrawable {
|
||||
Ok(())
|
||||
} else {
|
||||
error!("Canvas: flush happened before not drawable regions were defaced, or before initialized!");
|
||||
error!("Canvas: flush happened before not drawable regions were defaced, or before initialized! {:?}", self.state);
|
||||
Err(xous::Error::UseBeforeInit)
|
||||
}
|
||||
}
|
||||
|
|
@ -256,47 +298,67 @@ pub fn recompute_canvases(canvases: &HashMap<Gid, Canvas>, screen: Rectangle) ->
|
|||
}
|
||||
|
||||
// now, descend through trust levels and compute intersections, putting the updated drawable states into higher_clipregions
|
||||
let mut higher_clipregions: BinaryHeap<Canvas> = BinaryHeap::new();
|
||||
let mut trust_level: u8 = 255;
|
||||
let mut higher_clipregions: BinaryHeap<&Canvas> = BinaryHeap::new();
|
||||
let mut current_trust_level: u8 = 255;
|
||||
// sorted_clipregions is a Max heap keyed on trust, so popping the elements off will return them sorted from most to least trusted
|
||||
if debug{info!("CANVAS: received screen argument of {:?}", screen);}
|
||||
if debug{info!("CANVAS: now determining which regions are drawable");}
|
||||
|
||||
let mut sorted_clipregions_vec = sorted_clipregions.into_sorted_vec();
|
||||
for canvas in sorted_clipregions_vec.iter_mut() {
|
||||
if canvas.is_onscreen() {
|
||||
if canvas.trust_level() < current_trust_level {
|
||||
current_trust_level = canvas.trust_level();
|
||||
}
|
||||
for region in higher_clipregions.iter() {
|
||||
if region.is_onscreen()
|
||||
&& (region.trust_level() > current_trust_level) // regions of same trust level have arbitrary draw order
|
||||
&& region.clip_rect().intersects(canvas.clip_rect()) {
|
||||
canvas.set_drawable(false);
|
||||
} else {
|
||||
canvas.set_drawable(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
higher_clipregions.push(canvas);
|
||||
}
|
||||
/*
|
||||
loop {
|
||||
if let Some(c) = sorted_clipregions.pop() {
|
||||
if debug { info!(" CANVAS: considering {:?}", c);}
|
||||
let mut canvas = c.clone();
|
||||
|
||||
let mut drawable: bool = true;
|
||||
let clip_region = canvas.clip_rect();
|
||||
if trust_level < canvas.trust_level() {
|
||||
if canvas.trust_level() < trust_level {
|
||||
trust_level = canvas.trust_level();
|
||||
}
|
||||
if !clip_region.intersects(screen) {
|
||||
drawable = false;
|
||||
if debug { info!(" * CANVAS: not drawable, does not intersect");}
|
||||
} else { // short circuit this computation if it's not drawable because it's off screen
|
||||
//if !clip_region.intersects(screen) {
|
||||
// drawable = false;
|
||||
// if debug { info!(" * CANVAS: not drawable, does not intersect");}
|
||||
//} else { // short circuit this computation if it's not drawable because it's off screen
|
||||
// note that this .iter() is *not* sorted by trust level, but all elements will be of greater than or equal to the current trust level
|
||||
for ®ion in higher_clipregions.iter() {
|
||||
// regions of the same trust level can draw over each other. Draw order is arbitrary.
|
||||
if region.clip_rect().intersects(clip_region) && (region.trust_level() < trust_level) {
|
||||
log::info!("{:?} {:?}->false", canvas.canvas_type, canvas.state);
|
||||
drawable = false;
|
||||
if debug { info!(" * CANVAS: not drawable, lower trust intersecting with higher trust region");}
|
||||
}
|
||||
}
|
||||
}
|
||||
//}
|
||||
canvas.set_drawable(drawable);
|
||||
higher_clipregions.push(canvas);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}*/
|
||||
|
||||
// create a new index map out of the recomputed higher_clipregions
|
||||
let mut map: HashMap<Gid, Canvas> = HashMap::new();
|
||||
if debug { info!("CANVAS: reconstituting index map");}
|
||||
for &c in higher_clipregions.iter() {
|
||||
if debug { info!(" CANVAS: inserting gid {:?}, canvas {:?}", c.gid(), c);}
|
||||
map.insert(c.gid(), c);
|
||||
map.insert(c.gid(), *c);
|
||||
}
|
||||
|
||||
map
|
||||
|
|
|
|||
|
|
@ -309,7 +309,7 @@ impl ContextManager {
|
|||
canvases: &mut HashMap<Gid, Canvas>,
|
||||
token: [u32; 4],
|
||||
clear: bool,
|
||||
) {
|
||||
) -> ActivationResult {
|
||||
let mut leaving_visibility: bool = false;
|
||||
{
|
||||
// using a temp copy of the old focus, check if we need to update any visibility state
|
||||
|
|
@ -329,6 +329,8 @@ impl ContextManager {
|
|||
if token != leaving_focused_context.app_token {
|
||||
if (context.layout.behavior() == LayoutBehavior::Alert) &&
|
||||
(leaving_focused_context.layout.behavior() == LayoutBehavior::Alert) {
|
||||
// left off: determine if the currently visible context is a password field. if it is, deny the activation.
|
||||
|
||||
context.layout.set_visibility_state(true, canvases);
|
||||
//leaving_focused_context.layout.set_visibility_state(false, canvases);
|
||||
leaving_visibility = false;
|
||||
|
|
@ -438,6 +440,7 @@ impl ContextManager {
|
|||
log::trace!("activate redraw");
|
||||
self.redraw().expect("couldn't redraw the currently focused app");
|
||||
}
|
||||
ActivationResult::Success
|
||||
}
|
||||
pub(crate) fn revert_focus(&mut self,
|
||||
gfx: &graphics_server::Gfx,
|
||||
|
|
@ -565,7 +568,7 @@ impl ContextManager {
|
|||
name: &str,
|
||||
gfx: &graphics_server::Gfx,
|
||||
canvases: &mut HashMap<Gid, Canvas>,
|
||||
) {
|
||||
) -> ActivationResult {
|
||||
log::debug!("looking for menu {}", name);
|
||||
if let Some(token) = self.find_app_token_by_name(name) {
|
||||
log::debug!("found menu token: {:?}", token);
|
||||
|
|
@ -575,10 +578,11 @@ impl ContextManager {
|
|||
// but alerts can be raised without authentication
|
||||
if context.layout.behavior() == LayoutBehavior::Alert {
|
||||
log::debug!("activating context");
|
||||
self.activate(gfx, canvases, token, false);
|
||||
return self.activate(gfx, canvases, token, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
ActivationResult::Failure
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,6 @@ 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
|
||||
|
|
@ -65,7 +64,6 @@ impl ChatLayout {
|
|||
screensize,
|
||||
_small_height: small_height,
|
||||
_regular_height: regular_height,
|
||||
visible: true,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -139,32 +137,14 @@ impl LayoutApi for ChatLayout {
|
|||
]
|
||||
}
|
||||
fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut HashMap<Gid, Canvas>) {
|
||||
log::debug!("request modal to onscreen {} from 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));
|
||||
log::debug!("request modal to onscreen {}->{}", input_canvas.is_onscreen(), onscreen);
|
||||
input_canvas.set_onscreen(onscreen);
|
||||
|
||||
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));
|
||||
content_canvas.set_onscreen(onscreen);
|
||||
|
||||
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;
|
||||
predictive_canvas.set_onscreen(onscreen);
|
||||
}
|
||||
}
|
||||
|
|
@ -10,7 +10,6 @@ const TRUST_OFFSET: u8 = 4;
|
|||
pub(crate) struct Framebuffer {
|
||||
pub gid: Gid,
|
||||
screensize: Point,
|
||||
visible: bool,
|
||||
}
|
||||
impl Framebuffer {
|
||||
pub fn init(
|
||||
|
|
@ -30,7 +29,6 @@ impl Framebuffer {
|
|||
Ok(Framebuffer {
|
||||
gid: fb_canvas.gid(),
|
||||
screensize,
|
||||
visible: true,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -63,25 +61,8 @@ impl LayoutApi for Framebuffer {
|
|||
]
|
||||
}
|
||||
fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut HashMap<Gid, Canvas>) {
|
||||
log::debug!("raw fb entering set_visibilty_state, self.visible {}, onscreen {}", self.visible, onscreen);
|
||||
if onscreen == self.visible {
|
||||
// nothing to do
|
||||
return
|
||||
}
|
||||
let fb_canvas = canvases.get_mut(&self.gid).expect("couldn't find my 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)
|
||||
};
|
||||
fb_canvas.set_clip(fb_canvas.clip_rect().translate_chain(offscreen));
|
||||
self.visible = onscreen;
|
||||
log::debug!("moving raw framebuffer box by {:?}, final state: {:?}", offscreen, fb_canvas);
|
||||
log::debug!("raw fb entering set_visibilty_state, {}->{}", fb_canvas.is_onscreen(), onscreen);
|
||||
fb_canvas.set_onscreen(onscreen);
|
||||
}
|
||||
}
|
||||
|
|
@ -17,7 +17,6 @@ pub(crate) struct MenuLayout {
|
|||
menu_min_height: i16,
|
||||
screensize: Point,
|
||||
_height: i16,
|
||||
visible: bool,
|
||||
}
|
||||
impl MenuLayout {
|
||||
pub fn init(gfx: &graphics_server::Gfx, trng: &trng::Trng, canvases: &mut HashMap<Gid, Canvas>) -> Result<MenuLayout, xous::Error> {
|
||||
|
|
@ -41,7 +40,6 @@ impl MenuLayout {
|
|||
menu_min_height: height,
|
||||
screensize,
|
||||
_height: height, // start with "minimum" size and grow up as items are added
|
||||
visible: true,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -83,25 +81,8 @@ impl LayoutApi for MenuLayout {
|
|||
]
|
||||
}
|
||||
fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut HashMap<Gid, Canvas>) {
|
||||
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;
|
||||
log::debug!("menu entering set_visibilty_state, {}->{}", menu_canvas.is_onscreen(), onscreen);
|
||||
menu_canvas.set_onscreen(onscreen);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,7 +18,6 @@ pub(crate) struct ModalLayout {
|
|||
modal_min_height: i16,
|
||||
screensize: Point,
|
||||
_height: i16,
|
||||
visible: bool,
|
||||
_modal_y_max: i16,
|
||||
}
|
||||
impl ModalLayout {
|
||||
|
|
@ -43,7 +42,6 @@ impl ModalLayout {
|
|||
modal_min_height: height,
|
||||
screensize,
|
||||
_height: screensize.y - MODAL_Y_PAD, // start with the "maximum" size, and shrink down once items are known
|
||||
visible: true,
|
||||
_modal_y_max: crate::api::MODAL_Y_MAX,
|
||||
})
|
||||
}
|
||||
|
|
@ -87,25 +85,8 @@ impl LayoutApi for ModalLayout {
|
|||
}
|
||||
|
||||
fn set_visibility_state(&mut self, onscreen: bool, canvases: &mut HashMap<Gid, Canvas>) {
|
||||
log::debug!("modal box entering set_visibilty_state, self.visible {}, onscreen {}", self.visible, onscreen);
|
||||
if onscreen == self.visible {
|
||||
// nothing to do
|
||||
return
|
||||
}
|
||||
let modal_canvas = canvases.get_mut(&self.modal).expect("couldn't find modal 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)
|
||||
};
|
||||
modal_canvas.set_clip(modal_canvas.clip_rect().translate_chain(offscreen));
|
||||
self.visible = onscreen;
|
||||
log::debug!("moving modal box by {:?}, final state: {:?}", offscreen, modal_canvas);
|
||||
log::debug!("modal box entering set_visibilty_state {}->{}", modal_canvas.is_onscreen(), onscreen);
|
||||
modal_canvas.set_onscreen(onscreen);
|
||||
}
|
||||
}
|
||||
|
|
@ -343,12 +343,21 @@ impl Gam {
|
|||
let buf = Buffer::into_buf(switchapp).or(Err(xous::Error::InternalError))?;
|
||||
buf.send(self.conn, Opcode::SwitchToApp.to_u32().unwrap()).or(Err(xous::Error::InternalError)).map(|_|())
|
||||
}
|
||||
pub fn raise_menu(&self, menu_name: &str) -> Result<(), xous::Error> {
|
||||
let menu_name = String::<128>::from_str(menu_name);
|
||||
let buf = Buffer::into_buf(menu_name).or(Err(xous::Error::InternalError))?;
|
||||
buf.send(self.conn, Opcode::RaiseMenu.to_u32().unwrap()).or(Err(xous::Error::InternalError)).map(|_|())
|
||||
pub fn raise_menu(&self, menu_name: &str) -> Result<ActivationResult, xous::Error> {
|
||||
let menu_name = GamActivation {
|
||||
name: String::<128>::from_str(menu_name),
|
||||
result: None,
|
||||
};
|
||||
let mut buf = Buffer::into_buf(menu_name).or(Err(xous::Error::InternalError))?;
|
||||
buf.lend_mut(self.conn, Opcode::RaiseMenu.to_u32().unwrap()).or(Err(xous::Error::InternalError)).expect("couldn't send RaiseMenu opcode");
|
||||
let result = buf.to_original::<GamActivation, _>().unwrap();
|
||||
if let Some(code) = result.result {
|
||||
Ok(code)
|
||||
} else {
|
||||
Err(xous::Error::InternalError)
|
||||
}
|
||||
}
|
||||
pub fn raise_modal(&self, modal_name: &str) -> Result<(), xous::Error> {
|
||||
pub fn raise_modal(&self, modal_name: &str) -> Result<ActivationResult, xous::Error> {
|
||||
self.raise_menu(modal_name)
|
||||
}
|
||||
/// this is a one-way door, once you've set it, you can't unset it.
|
||||
|
|
|
|||
|
|
@ -59,12 +59,14 @@ fn xmain() -> ! {
|
|||
|
||||
let screensize = gfx.screen_size().expect("Couldn't get screen size");
|
||||
// the status canvas is special -- there can only be one, and it is ultimately trusted
|
||||
let status_canvas = Canvas::new(
|
||||
let mut status_canvas = Canvas::new(
|
||||
Rectangle::new_coords(
|
||||
0, 0, screensize.x,
|
||||
gfx.glyph_height_hint(GlyphStyle::Cjk).expect("couldn't get glyph height") as i16 * 2),
|
||||
255, &trng, None, crate::api::CanvasType::Status
|
||||
).expect("couldn't create status canvas");
|
||||
status_canvas.set_onscreen(true);
|
||||
status_canvas.set_drawable(true);
|
||||
canvases.insert(status_canvas.gid(), status_canvas);
|
||||
canvases = recompute_canvases(&canvases, Rectangle::new(Point::new(0, 0), screensize));
|
||||
|
||||
|
|
@ -193,9 +195,9 @@ fn xmain() -> ! {
|
|||
}
|
||||
|
||||
log::trace!("render request for {:?}", tv);
|
||||
tv.set_dry_run(false);
|
||||
|
||||
if let Some(canvas) = canvases.get_mut(&tv.get_canvas_gid()) {
|
||||
tv.set_dry_run(!canvas.is_onscreen());
|
||||
// if we're requesting inverted text, this better be a "trusted canvas"
|
||||
// BOOT_CONTEXT_TRUSTLEVEL is reserved for the "status bar"
|
||||
// BOOT_CONTEXT_TRUSTLEVEL - 1 is where e.g. password modal dialog boxes end up
|
||||
|
|
@ -204,7 +206,7 @@ fn xmain() -> ! {
|
|||
continue;
|
||||
}
|
||||
// first, figure out if we should even be drawing to this canvas.
|
||||
if canvas.is_drawable() { // dry runs should not move any pixels so they are OK to go through in any case
|
||||
if canvas.is_drawable() {
|
||||
// set the clip rectangle according to the canvas' location
|
||||
let base_clip_rect = canvas.clip_rect();
|
||||
tv.clip_rect = Some(base_clip_rect.into());
|
||||
|
|
@ -222,7 +224,9 @@ fn xmain() -> ! {
|
|||
|
||||
let ret = api::Return::RenderReturn(tv);
|
||||
buffer.replace(ret).unwrap();
|
||||
canvas.do_drawn().expect("couldn't set canvas to drawn");
|
||||
if canvas.is_onscreen() {
|
||||
canvas.do_drawn().expect("couldn't set canvas to drawn");
|
||||
}
|
||||
} else {
|
||||
log::debug!("attempt to draw TextView on non-drawable canvas. Not fatal, but request ignored. {:?}", tv);
|
||||
let ret = api::Return::NotCurrentlyDrawable;
|
||||
|
|
@ -299,7 +303,7 @@ fn xmain() -> ! {
|
|||
log::trace!("renderobject {:?}", obj);
|
||||
if let Some(canvas) = canvases.get_mut(&obj.canvas) {
|
||||
// first, figure out if we should even be drawing to this canvas.
|
||||
if canvas.is_drawable() {
|
||||
if canvas.is_drawable() && canvas.is_onscreen() {
|
||||
match obj.obj {
|
||||
GamObjectType::Line(mut line) => {
|
||||
line.translate(canvas.clip_rect().tl);
|
||||
|
|
@ -348,7 +352,7 @@ fn xmain() -> ! {
|
|||
let obj_ipc = buffer.to_original::<GamObjectList, _>().unwrap();
|
||||
if let Some(canvas) = canvases.get_mut(&obj_ipc.canvas) {
|
||||
// first, figure out if we should even be drawing to this canvas.
|
||||
if canvas.is_drawable() {
|
||||
if canvas.is_drawable() && canvas.is_onscreen() {
|
||||
let mut obj_list = ClipObjectList::default();
|
||||
for item in obj_ipc.list.iter() {
|
||||
if let Some(obj) = item {
|
||||
|
|
@ -508,10 +512,12 @@ fn xmain() -> ! {
|
|||
}
|
||||
},
|
||||
Some(Opcode::RaiseMenu) => {
|
||||
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||
let menu_name = buffer.to_original::<String::<128>, _>().unwrap();
|
||||
log::debug!("got request to raise menu {}", menu_name);
|
||||
context_mgr.raise_menu(menu_name.as_str().unwrap(), &gfx, &mut canvases);
|
||||
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
||||
let mut activation = buffer.to_original::<GamActivation, _>().unwrap();
|
||||
log::debug!("got request to raise context {}", activation.name);
|
||||
let result = context_mgr.raise_menu(activation.name.as_str().unwrap(), &gfx, &mut canvases);
|
||||
activation.result = Some(result);
|
||||
buffer.replace(activation).unwrap();
|
||||
},
|
||||
Some(Opcode::Devboot) => msg_scalar_unpack!(msg, ena, _, _, _, {
|
||||
if ena != 0 { gfx.set_devboot(true).expect("couldn't send devboot message"); }
|
||||
|
|
|
|||
|
|
@ -330,7 +330,11 @@ impl<'a> Modal<'a> {
|
|||
modal
|
||||
}
|
||||
pub fn activate(&self) {
|
||||
self.gam.raise_modal(self.name.to_str()).expect("couldn't activate modal");
|
||||
let tt = ticktimer_server::Ticktimer::new().unwrap();
|
||||
while self.gam.raise_modal(self.name.to_str()).expect("couldn't activate modal") != ActivationResult::Success {
|
||||
// wait a bit then try again
|
||||
tt.sleep_ms(857).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
/// this function spawns a client-side thread to forward redraw and key event
|
||||
|
|
|
|||
|
|
@ -24,4 +24,4 @@ utralib = { path = "../../utralib"}
|
|||
|
||||
[features]
|
||||
ux_tests = []
|
||||
default = []
|
||||
default = ["ux_tests"]
|
||||
|
|
|
|||
|
|
@ -387,6 +387,7 @@ fn xmain() -> ! {
|
|||
});
|
||||
|
||||
if cfg!(feature = "ux_tests") {
|
||||
tt.sleep_ms(1000).unwrap();
|
||||
tests::spawn_test();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -420,8 +420,6 @@ fn xmain() -> ! {
|
|||
let xns = xous_names::XousNames::new().unwrap();
|
||||
let pddb_sid = xns.register_name(api::SERVER_NAME_PDDB, None).expect("can't register server");
|
||||
log::trace!("registered with NS -- {:?}", pddb_sid);
|
||||
#[cfg(not(any(windows, unix)))] // avoid errors in hosted mode
|
||||
let tt = ticktimer_server::Ticktimer::new().unwrap();
|
||||
|
||||
log::trace!("ready to accept requests");
|
||||
|
||||
|
|
@ -469,7 +467,9 @@ fn xmain() -> ! {
|
|||
}
|
||||
});
|
||||
// try to mount the PDDB automatically before starting the server
|
||||
#[cfg(not(any(windows, unix)))] // skip this step if running in hosted mode, for now...
|
||||
//#[cfg(not(any(windows, unix)))] // avoid errors in hosted mode
|
||||
let tt = ticktimer_server::Ticktimer::new().unwrap();
|
||||
//#[cfg(not(any(windows, unix)))] // skip this step if running in hosted mode, for now...
|
||||
if pddb_os.rootkeys_initialized() {
|
||||
tt.sleep_ms(1000).unwrap(); // wait 1 second after boot before attempting to mount, to let the boot screen finish redrawing (cometic issue).
|
||||
match ensure_password(&modals, &mut pddb_os) {
|
||||
|
|
|
|||
|
|
@ -193,7 +193,7 @@ mod implementation {
|
|||
false
|
||||
}
|
||||
pub fn is_pcache_boot_password_valid(&self) -> bool {
|
||||
true
|
||||
false
|
||||
}
|
||||
pub fn fpga_key_source(&self) -> FpgaKeySource {
|
||||
FpgaKeySource::Efuse
|
||||
|
|
|
|||
Loading…
Reference in a new issue