mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
just getting to the point of implementing defacement
menu now pops up. does nothing, but we can at least change contexts for the Ux into a different Ux theme.
This commit is contained in:
parent
62c9737bbc
commit
0f937037e4
8 changed files with 153 additions and 26 deletions
|
|
@ -145,7 +145,7 @@ impl PartialEq for Canvas {
|
|||
impl Eq for Canvas {}
|
||||
|
||||
|
||||
pub fn deface(gfx: &graphics_server::Gfx, canvases: &mut FnvIndexMap<Gid, Canvas, 32>) -> Result<(), xous::Error> {
|
||||
pub fn deface(gfx: &graphics_server::Gfx, tng: &trng::Trng, canvases: &mut FnvIndexMap<Gid, Canvas, 32>) -> Result<(), xous::Error> {
|
||||
// first check if any need defacing, if not, then we're done
|
||||
let mut needs_defacing = false;
|
||||
for (_, c) in canvases.iter() {
|
||||
|
|
@ -163,11 +163,12 @@ pub fn deface(gfx: &graphics_server::Gfx, canvases: &mut FnvIndexMap<Gid, Canvas
|
|||
in between states, so in the worst case we are drawing defacement with a rectangular clip
|
||||
area open in the middle of a canvas...
|
||||
*/
|
||||
//Err(xous::Error::InternalError)
|
||||
|
||||
// temporarirly clear the error so we can develop other features
|
||||
for (_, c) in canvases.iter_mut() {
|
||||
if c.needs_defacing() {
|
||||
// do the actual defacing
|
||||
|
||||
// indicate that the defacement has happened to the canvas state machine
|
||||
c.do_defaced();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -94,7 +94,7 @@ 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
|
||||
// const BOOT_APP_NAME: &'static str = "shellchat"; // this is the app to display on boot -- we will eventually need this once we have more than one app?
|
||||
pub const MAIN_MENU_NAME: &'static str = "main menu";
|
||||
const BOOT_CONTEXT_TRUSTLEVEL: u8 = 254;
|
||||
|
||||
|
|
@ -113,6 +113,7 @@ struct ContextManager {
|
|||
imef: ime_plugin_api::ImeFrontEnd,
|
||||
imef_active: bool,
|
||||
kbd: keyboard::Keyboard,
|
||||
main_menu_app_token: Option<[u32; 4]>, // app_token of the main menu, if it has been registered
|
||||
}
|
||||
impl ContextManager {
|
||||
pub fn new(xns: &xous_names::XousNames) -> Self {
|
||||
|
|
@ -131,6 +132,7 @@ impl ContextManager {
|
|||
imef,
|
||||
imef_active: false,
|
||||
kbd,
|
||||
main_menu_app_token: None,
|
||||
}
|
||||
}
|
||||
pub(crate) fn claim_token(&mut self, name: &str) -> Option<[u32; 4]> {
|
||||
|
|
@ -203,6 +205,12 @@ impl ContextManager {
|
|||
if maybe_context.is_none() {
|
||||
*maybe_context = Some(ux_context);
|
||||
found_slot = true;
|
||||
// if this is the main menu, note its app token, as we have to conjure it later on
|
||||
if registration.app_name.as_str().unwrap() == MAIN_MENU_NAME {
|
||||
log::debug!("main menu found and registered!");
|
||||
assert!(self.main_menu_app_token == None, "attempt to double-register main menu handler, this should never happen.");
|
||||
self.main_menu_app_token = Some(token);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -425,10 +433,13 @@ impl ContextManager {
|
|||
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] == '∴' {
|
||||
// only pop up the menu if it isn't already popped up
|
||||
if keys[0] == '∴' && (self.focused_context != self.main_menu_app_token) {
|
||||
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);
|
||||
// don't pass the initial key hit back to the menu app, just eat it and return
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -595,13 +606,13 @@ fn xmain() -> ! {
|
|||
if elapsed_time - last_time > 33 { // rate limit updates, no point in going faster than the eye can see
|
||||
last_time = elapsed_time;
|
||||
|
||||
deface(&gfx, &mut canvases);
|
||||
deface(&gfx, &trng, &mut canvases);
|
||||
log::trace!("flushing...");
|
||||
gfx.flush().expect("couldn't flush buffer to screen");
|
||||
/* // this throws errors right now because deface() doesn't work.
|
||||
|
||||
for (_, c) in canvases.iter_mut() {
|
||||
c.do_flushed();
|
||||
}*/
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ impl Menu {
|
|||
RoundedRectangle::new(
|
||||
Rectangle::new_with_style(Point::new(0, 0), canvas_size,
|
||||
DrawStyle::new(PixelColor::Dark, PixelColor::Dark, 1)
|
||||
), 10
|
||||
), 5
|
||||
)).unwrap();
|
||||
}
|
||||
pub fn key_event(&mut self, keys: [char; 4]) {
|
||||
|
|
@ -94,6 +94,7 @@ impl Menu {
|
|||
log::trace!("got key '{}'", k);
|
||||
match k {
|
||||
'∴' => {
|
||||
log::info!("relinquishing focus");
|
||||
self.gam.relinquish_focus().expect("couldn't relinquish focus of the menu!");
|
||||
},
|
||||
'←' => {
|
||||
|
|
|
|||
|
|
@ -34,6 +34,8 @@ struct InputTracker {
|
|||
|
||||
/// our current prediction engine
|
||||
predictor: Option<PredictionPlugin>,
|
||||
/// the name & token of our engine, so we can disconnect later on
|
||||
pub predictor_conn: Option<(String::<64>, [u32; 4])>,
|
||||
/// cached copy of the predictor's triggers for predictions. Only valid if predictor is not None
|
||||
pred_triggers: Option<PredictionTriggers>,
|
||||
/// set if we're in a state where a backspace should trigger an unpredict
|
||||
|
|
@ -66,6 +68,7 @@ impl InputTracker {
|
|||
input_canvas: None,
|
||||
pred_canvas: None,
|
||||
predictor: None,
|
||||
predictor_conn: None,
|
||||
pred_triggers: None,
|
||||
gam_token: None,
|
||||
can_unpick: false,
|
||||
|
|
@ -82,10 +85,15 @@ impl InputTracker {
|
|||
pub fn set_gam_token(&mut self, token: [u32; 4]) {
|
||||
self.gam_token = Some(token);
|
||||
}
|
||||
pub fn set_predictor(&mut self, predictor: PredictionPlugin) {
|
||||
self.predictor = Some(predictor);
|
||||
self.pred_triggers = Some(predictor.get_prediction_triggers()
|
||||
.expect("InputTracker failed to get prediction triggers from plugin"));
|
||||
pub fn set_predictor(&mut self, predictor: Option<PredictionPlugin>) {
|
||||
self.predictor = predictor;
|
||||
if let Some(pred) = predictor {
|
||||
self.pred_triggers = Some(pred.get_prediction_triggers()
|
||||
.expect("InputTracker failed to get prediction triggers from plugin"));
|
||||
}
|
||||
}
|
||||
pub fn get_predictor(&self) -> Option<PredictionPlugin> {
|
||||
self.predictor
|
||||
}
|
||||
pub fn set_input_canvas(&mut self, input: Gid) {
|
||||
self.input_canvas = Some(input);
|
||||
|
|
@ -621,10 +629,25 @@ fn xmain() -> ! {
|
|||
} else {
|
||||
tracker.clear_pred_canvas();
|
||||
}
|
||||
// disconnect any existing predictor, if we have one already
|
||||
if let Some(_pred) = tracker.get_predictor() {
|
||||
if let Some((name, token)) = tracker.predictor_conn {
|
||||
xns.disconnect_with_token(name.as_str().unwrap(), token)
|
||||
.expect("couldn't disconnect from previous predictor. Something is wrong with internal state!");
|
||||
}
|
||||
tracker.predictor_conn = None;
|
||||
tracker.set_predictor(None);
|
||||
}
|
||||
if let Some(s) = descriptor.predictor {
|
||||
log::trace!("got prediction server: {}", s.as_str().unwrap());
|
||||
match xns.request_connection(s.as_str().unwrap()) {
|
||||
Ok(pc) => tracker.set_predictor(ime_plugin_api::PredictionPlugin {connection: Some(pc)}),
|
||||
match xns.request_connection_with_token(s.as_str().unwrap()) {
|
||||
Ok((pc, token)) => {
|
||||
tracker.set_predictor( Some(ime_plugin_api::PredictionPlugin {connection: Some(pc)}) );
|
||||
tracker.predictor_conn = Some(
|
||||
(String::<64>::from_str(s.as_str().unwrap()),
|
||||
token.expect("didn't get the disconnect token!"))
|
||||
);
|
||||
},
|
||||
_ => error!("can't find predictive engine {}, retaining existing one.", s.as_str().unwrap()),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ impl Repl{
|
|||
}).expect("couldn't register Ux context for shellchat");
|
||||
|
||||
// we should be the first app running, so get the focus
|
||||
gam.request_focus(token.unwrap());
|
||||
gam.request_focus(token.unwrap()).expect("couldn't take focus");
|
||||
|
||||
let content = gam.request_content_canvas(token.unwrap()).expect("couldn't get content canvas");
|
||||
log::debug!("content canvas {:?}", content);
|
||||
|
|
|
|||
|
|
@ -13,6 +13,8 @@ pub(crate) enum Opcode {
|
|||
AuthenticatedLookup,
|
||||
/// unregister a server, given its cryptographically unique SID.
|
||||
Unregister,
|
||||
/// disconnect, given a server name and a cryptographically unique, one-time use token
|
||||
Disconnect,
|
||||
/// indicates if all inherentely trusted slots have been occupied. Should not run untrusted code until this is the case.
|
||||
TrustedInitDone,
|
||||
}
|
||||
|
|
@ -25,8 +27,10 @@ pub(crate) enum Return {
|
|||
Failure,
|
||||
/// A server was successfully created with the given SID
|
||||
SID([u32; 4]),
|
||||
/// A connection was successfully made with the given CID
|
||||
CID(xous::CID),
|
||||
/// A connection was successfully made with the given CID; an optional "disconnect token" is provided
|
||||
CID((xous::CID, Option<[u32; 4]>)),
|
||||
/// Operation requested was otherwise successful (currently only used by disconnect to ack the disconnect)
|
||||
Success,
|
||||
}
|
||||
|
||||
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
|
||||
|
|
@ -35,6 +39,12 @@ pub(crate) struct Registration {
|
|||
pub conn_limit: Option<u32>,
|
||||
}
|
||||
|
||||
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
|
||||
pub(crate) struct Disconnect {
|
||||
pub name: xous_ipc::String::<64>,
|
||||
pub token: [u32; 4],
|
||||
}
|
||||
|
||||
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
|
||||
pub(crate) struct AuthenticatedLookup {
|
||||
pub name: xous_ipc::String::<64>,
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
pub mod api;
|
||||
|
||||
use core::fmt::Write;
|
||||
use api::Disconnect;
|
||||
use xous_ipc::{String, Buffer};
|
||||
use num_traits::ToPrimitive;
|
||||
|
||||
|
|
@ -70,6 +71,40 @@ impl XousNames {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn request_connection_with_token(&self, name: &str) -> Result<(xous::CID, Option<[u32; 4]>), xous::Error> {
|
||||
let mut lookup_name = xous_ipc::String::<64>::new();
|
||||
write!(lookup_name, "{}", name).expect("name problably too long");
|
||||
let mut buf = Buffer::into_buf(lookup_name).or(Err(xous::Error::InternalError))?;
|
||||
|
||||
buf.lend_mut(
|
||||
self.conn,
|
||||
api::Opcode::Lookup.to_u32().unwrap()
|
||||
)
|
||||
.or(Err(xous::Error::InternalError))?;
|
||||
|
||||
match buf.to_original().unwrap() {
|
||||
api::Return::CID((cid, token)) => Ok((cid, token)),
|
||||
// api::Return::AuthenticateRequest(_) => Err(xous::Error::AccessDenied),
|
||||
_ => Err(xous::Error::ServerNotFound),
|
||||
}
|
||||
}
|
||||
pub fn disconnect_with_token(&self, name: &str, token: [u32; 4]) -> Result<(), xous::Error> {
|
||||
let disconnect = Disconnect {
|
||||
name: String::<64>::from_str(name),
|
||||
token,
|
||||
};
|
||||
let mut buf = Buffer::into_buf(disconnect).or(Err(xous::Error::InternalError))?;
|
||||
buf.lend_mut(
|
||||
self.conn,
|
||||
api::Opcode::Disconnect.to_u32().unwrap()
|
||||
).or(Err(xous::Error::InternalError))?;
|
||||
|
||||
match buf.to_original().unwrap() {
|
||||
api::Return::Success => Ok(()),
|
||||
_ => Err(xous::Error::ServerNotFound),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn request_connection(&self, name: &str) -> Result<xous::CID, xous::Error> {
|
||||
let mut lookup_name = xous_ipc::String::<64>::new();
|
||||
write!(lookup_name, "{}", name).expect("name problably too long");
|
||||
|
|
@ -83,7 +118,7 @@ impl XousNames {
|
|||
.or(Err(xous::Error::InternalError))?;
|
||||
|
||||
match buf.to_original().unwrap() {
|
||||
api::Return::CID(cid) => Ok(cid),
|
||||
api::Return::CID((cid, _)) => Ok(cid),
|
||||
// api::Return::AuthenticateRequest(_) => Err(xous::Error::AccessDenied),
|
||||
_ => Err(xous::Error::ServerNotFound),
|
||||
}
|
||||
|
|
|
|||
|
|
@ -81,6 +81,7 @@ struct Connection {
|
|||
pub max_conns: Option<u32>, // if None, unlimited connections allowed
|
||||
pub allow_authenticate: bool,
|
||||
pub auth_conns: u32, // number of authenticated connections
|
||||
pub token: Option<[u32; 4]>, // a random number that must be presented to allow for disconnection for single-connection servers
|
||||
}
|
||||
struct SlowMap {
|
||||
pub map: [Option<Connection>; 128],
|
||||
|
|
@ -93,6 +94,12 @@ impl SlowMap {
|
|||
}
|
||||
pub fn insert(&mut self, name: XousServerName, sid: xous::SID, max_conns: Option<u32>) -> Result<(), xous::Error> {
|
||||
let mut ok = false;
|
||||
let token = if max_conns == Some(1) {
|
||||
// for the special case of 1-connection servers, provision a one-time use token for disconnects
|
||||
Some(xous::create_server_id().expect("couldn't create token").to_array())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
for entry in self.map.iter_mut() {
|
||||
if entry.is_none() {
|
||||
*entry = Some(Connection {
|
||||
|
|
@ -102,6 +109,7 @@ impl SlowMap {
|
|||
max_conns,
|
||||
allow_authenticate: false, // for now, we don't support authenticated connections
|
||||
auth_conns: 0,
|
||||
token,
|
||||
});
|
||||
ok = true;
|
||||
break;
|
||||
|
|
@ -136,26 +144,35 @@ impl SlowMap {
|
|||
}
|
||||
return false
|
||||
}
|
||||
pub fn connect(&mut self, name: &XousServerName) -> Option<&xous::SID> {
|
||||
pub fn connect(&mut self, name: &XousServerName) -> (Option<&xous::SID>, Option<[u32; 4]>) {
|
||||
for maybe_entry in self.map.iter_mut() {
|
||||
if let Some(entry) = maybe_entry {
|
||||
if *name == entry.name {
|
||||
if Some(1) == entry.max_conns {
|
||||
// single-connection case
|
||||
if entry.current_conns < 1 {
|
||||
(*entry).current_conns = 1;
|
||||
return (Some(&entry.sid), entry.token)
|
||||
} else {
|
||||
return (None, None)
|
||||
}
|
||||
}
|
||||
if let Some(max) = entry.max_conns {
|
||||
if entry.current_conns < max {
|
||||
(*entry).current_conns += 1;
|
||||
return Some(&entry.sid);
|
||||
return (Some(&entry.sid), None);
|
||||
} else {
|
||||
return None;
|
||||
return (None, None);
|
||||
}
|
||||
} else {
|
||||
// unlimited connections allowed
|
||||
(*entry).current_conns += 1;
|
||||
return Some(&entry.sid);
|
||||
return (Some(&entry.sid), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
(None, None)
|
||||
}
|
||||
pub fn trusted_init_done(&self) -> bool {
|
||||
let mut trusted_done = true;
|
||||
|
|
@ -189,6 +206,23 @@ impl SlowMap {
|
|||
}
|
||||
None
|
||||
}
|
||||
// this is a safer version of disconnect. we track servers that allow exactly one connection at a time
|
||||
// and give them a one-time-use token that a connector can use to disconnect.
|
||||
pub fn disconnect_with_token(&mut self, name: &XousServerName, token: [u32; 4]) -> bool {
|
||||
for maybe_entry in self.map.iter_mut() {
|
||||
if let Some(entry) = maybe_entry {
|
||||
if let Some(old_token) = entry.token {
|
||||
if (*name == entry.name) && (token == old_token) && (entry.current_conns == 1) {
|
||||
(*entry).current_conns = 0;
|
||||
// generate the token -- we should never re-use these!
|
||||
(*entry).token = Some(xous::create_server_id().expect("couldn't create token").to_array());
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
#[xous::xous_main]
|
||||
|
|
@ -254,7 +288,7 @@ fn xmain() -> ! {
|
|||
let name = XousServerName::from_str(name_string.as_str().expect("couldn't convert server name to string"));
|
||||
log::trace!("Lookup request for '{}'", name);
|
||||
let response: api::Return;
|
||||
if let Some(server_sid) = name_table.connect(&name) {
|
||||
if let (Some(server_sid), token) = name_table.connect(&name) {
|
||||
let sender_pid = msg
|
||||
.sender
|
||||
.pid()
|
||||
|
|
@ -264,7 +298,7 @@ fn xmain() -> ! {
|
|||
{
|
||||
xous::Result::ConnectionID(connection_id) => {
|
||||
log::trace!("lookup success, returning connection {}", connection_id);
|
||||
response = api::Return::CID(connection_id)
|
||||
response = api::Return::CID((connection_id, token))
|
||||
}
|
||||
_ => {
|
||||
log::debug!(
|
||||
|
|
@ -317,6 +351,18 @@ fn xmain() -> ! {
|
|||
xous::return_scalar(msg.sender, 0).expect("couldn't return trusted_init_done");
|
||||
}
|
||||
}
|
||||
Some(api::Opcode::Disconnect) => {
|
||||
let mem = msg.body.memory_message_mut().unwrap();
|
||||
let mut buffer = unsafe { Buffer::from_memory_message_mut(mem) };
|
||||
let disconnect = buffer.to_original::<Disconnect, _>().unwrap();
|
||||
let name = XousServerName::from_str(disconnect.name.as_str().unwrap());
|
||||
let response = if name_table.disconnect_with_token(&name, disconnect.token) {
|
||||
api::Return::Success
|
||||
} else {
|
||||
api::Return::Failure
|
||||
};
|
||||
buffer.replace(response).expect("Can't return buffer");
|
||||
}
|
||||
None => {error!("couldn't decode message: {:?}", msg); break}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue