garnet/bin/terminal/src/view_controller.rs - fuchsia - Git at Google

 use carnelian::{
     Canvas, Color, FontDescription, FontFace, IntSize, MappingPixelSink, Paint, Point, Size,
 };
 use failure::Error;
 use fidl::endpoints::{create_endpoints, ServerEnd};
 use fidl_fuchsia_images as images;
 use fidl_fuchsia_ui_gfx as gfx;
 use fidl_fuchsia_ui_input::{
     ImeServiceMarker, InputEvent, InputMethodAction, InputMethodEditorClientMarker,
     InputMethodEditorClientRequest, InputMethodEditorMarker, KeyboardEventPhase, KeyboardType,
     TextAffinity, TextInputState, TextRange, TextSelection,
 };
 use fidl_fuchsia_ui_scenic::{self as scenic, SessionListenerMarker, SessionListenerRequest};
 use fidl_fuchsia_ui_views::ViewToken;
 use fuchsia_async as fasync;
 use fuchsia_component::client::connect_to_service;
 use fuchsia_scenic::{EntityNode, HostImageCycler, SessionPtr, View};
 use futures::{FutureExt, TryFutureExt, TryStreamExt};
 use parking_lot::Mutex;
 use std::sync::Arc;
 use term_model::ansi::Processor;
 use term_model::config::Config;
 use term_model::term::{SizeInfo, Term};

 pub type FontFacePtr = Arc<Mutex<FontFace<'static>>>;

 pub struct ViewController {
     face: FontFacePtr,
     session: SessionPtr,
     view: View,
     root_node: EntityNode,
     image_cycler: HostImageCycler,
     metrics: Option<gfx::Metrics>,
     logical_size: Option<gfx::Vec3>,
     term: Option<Term>,
     parser: Processor,
 }

 pub type ViewControllerPtr = Arc<Mutex<ViewController>>;

 impl ViewController {
     pub fn new(
         face: FontFacePtr,
         view_token: ViewToken,
         session: SessionPtr,
         session_listener_request: ServerEnd<SessionListenerMarker>,
     ) -> Result<ViewControllerPtr, Error> {
         let ime_service = connect_to_service::<ImeServiceMarker>()?;
         let (ime_listener, ime_listener_request) = create_endpoints::<InputMethodEditorMarker>()?;
         let (ime_client_listener, ime_client_listener_request) =
             create_endpoints::<InputMethodEditorClientMarker>()?;
         let mut text_input_state = TextInputState {
             revision: 0,
             text: "".to_string(),
             selection: TextSelection { base: 0, extent: 0, affinity: TextAffinity::Upstream },
             composing: TextRange { start: 0, end: 0 },
         };
         ime_service.get_input_method_editor(
             KeyboardType::Text,
             InputMethodAction::None,
             &mut text_input_state,
             ime_client_listener,
             ime_listener_request,
         )?;

         let view = View::new(session.clone(), view_token, Some(String::from("Terminal")));
         let root_node = EntityNode::new(session.clone());
         view.add_child(&root_node);

         let view_controller = ViewController {
             face,
             session: session.clone(),
             view: view,
             root_node: root_node,
             image_cycler: HostImageCycler::new(session.clone()),
             metrics: None,
             logical_size: None,
             term: None,
             parser: Processor::new(),
         };
         view_controller.setup_scene();
         view_controller.present();

         let view_controller = Arc::new(Mutex::new(view_controller));
         {
             let view_controller = view_controller.clone();
             fasync::spawn(
                 async move {
                     // In order to keep the channel alive, we need to move ime_listener into this block.
                     // Otherwise it's unused, which closes the channel immediately.
                     let _dummy = ime_listener;
                     let mut stream = ime_client_listener_request.into_stream()?;
                     while let Some(request) = await!(stream.try_next())? {
                         match request {
                             InputMethodEditorClientRequest::DidUpdateState {
                                 event: Some(event),
                                 ..
                             } => view_controller.lock().handle_input_event(*event),
                             _ => (),
                         }
                     }
                     Ok(())
                 }
                     .unwrap_or_else(|e: failure::Error| eprintln!("input listener error: {:?}", e)),
             );
         }
         {
             let view_controller = view_controller.clone();
             fasync::spawn(
                 async move {
                     let mut stream = session_listener_request.into_stream()?;
                     while let Some(request) = await!(stream.try_next())? {
                         match request {
                             SessionListenerRequest::OnScenicEvent { events, control_handle: _ } => {
                                 view_controller.lock().handle_session_events(events)
                             }
                             _ => (),
                         }
                     }
                     Ok(())
                 }
                     .unwrap_or_else(|e: failure::Error| eprintln!("view listener error: {:?}", e)),
             );
         }
         Ok(view_controller)
     }

     fn setup_scene(&self) {
         self.root_node.resource().set_event_mask(gfx::METRICS_EVENT_MASK);
         self.root_node.add_child(self.image_cycler.node());
     }

     fn invalidate(&mut self) {
         self.begin_frame();
     }

     fn begin_frame(&mut self) {
         let (metrics, logical_size) = match (self.metrics.as_ref(), self.logical_size.as_ref()) {
             (Some(metrics), Some(logical_size)) => (metrics, logical_size),
             _ => return,
         };
         let physical_width = (logical_size.x * metrics.scale_x) as u32;
         let physical_height = (logical_size.y * metrics.scale_y) as u32;
         let stride = physical_width * 4;
         let info = images::ImageInfo {
             transform: images::Transform::Normal,
             width: physical_width,
             height: physical_height,
             stride,
             pixel_format: images::PixelFormat::Bgra8,
             color_space: images::ColorSpace::Srgb,
             tiling: images::Tiling::Linear,
             alpha_format: images::AlphaFormat::Opaque,
         };
         {
             let guard = self.image_cycler.acquire(info).expect("failed to allocate buffer");
             let mut face = self.face.lock();
             let mut canvas = Canvas::<MappingPixelSink>::new(
                 IntSize::new(physical_width as i32, physical_height as i32),
                 guard.image().mapping().clone(),
                 stride,
                 4,
             );
             let size = Size::new(14.0, 22.0);
             let mut font = FontDescription { face: &mut face, size: 20, baseline: 18 };
             let parser = &mut self.parser;
             let term = self.term.get_or_insert_with(|| {
                 let mut term = Term::new(
                     &Config::default(),
                     SizeInfo {
                         width: physical_width as f32,
                         height: physical_height as f32,
                         cell_width: size.width as f32,
                         cell_height: size.height as f32,
                         padding_x: 0.,
                         padding_y: 0.,
                     },
                 );
                 for byte in "$ echo \"\u{001b}[31mhello, world!\u{001b}[0m\"".as_bytes() {
                     parser.advance(&mut term, *byte, &mut ::std::io::sink());
                 }
                 term
             });
             for cell in term.renderable_cells(&Config::default(), None, true) {
                 let mut buffer: [u8; 4] = [0, 0, 0, 0];
                 canvas.fill_text_cells(
                     cell.c.encode_utf8(&mut buffer),
                     Point::new(size.width * cell.column.0 as f32, size.height * cell.line.0 as f32),
                     size,
                     &mut font,
                     &Paint {
                         fg: Color { r: cell.fg.r, g: cell.fg.g, b: cell.fg.b, a: 0xFF },
                         bg: Color { r: cell.bg.r, g: cell.bg.g, b: cell.bg.b, a: 0xFF },
                     },
                 )
             }
         }

         let node = self.image_cycler.node();
         node.set_scale(1.0 / metrics.scale_x, 1.0 / metrics.scale_y, 1.0);
         node.set_translation(logical_size.x / 2.0, logical_size.y / 2.0, 0.0);
         self.present();
     }

     fn present(&self) {
         fasync::spawn(self.session.lock().present(0).map(|_| ()));
     }

     fn handle_session_events(&mut self, events: Vec<scenic::Event>) {
         events.iter().for_each(|event| match event {
             scenic::Event::Gfx(event) => match event {
                 gfx::Event::Metrics(event) => {
                     assert!(event.node_id == self.root_node.id());
                     self.metrics = Some(gfx::Metrics { ..event.metrics });
                     self.invalidate();
                 }
                 gfx::Event::ViewPropertiesChanged(event) => {
                     assert!(event.view_id == self.view.id());
                     self.logical_size = Some(gfx::Vec3 {
                         x: event.properties.bounding_box.max.x
                             - event.properties.bounding_box.min.x,
                         y: event.properties.bounding_box.max.y
                             - event.properties.bounding_box.min.y,
                         z: event.properties.bounding_box.max.z
                             - event.properties.bounding_box.min.z,
                     });
                     self.invalidate();
                 }
                 _ => (),
             },
             _ => (),
         });
     }

     fn handle_input_event(&mut self, event: InputEvent) {
         if let (Some(term), InputEvent::Keyboard(event)) = (&mut self.term, &event) {
             if event.phase == KeyboardEventPhase::Pressed
                 || event.phase == KeyboardEventPhase::Repeat
             {
                 if let Some(c) = std::char::from_u32(event.code_point) {
                     if c != '\0' {
                         // The API that parses escape sequences (the vte library) takes as input a
                         // stream of bytes  in utf8, rather than taking a stream of codepoints. Thus,
                         // we need to  convert each codepoint into a ut8 byte stream, which it will
                         // then convert back to codepoints.
                         // There is an issue on the vte github to address this:
                         // https://github.com/jwilm/vte/issues/19
                         let mut buffer: [u8; 4] = [0, 0, 0, 0];
                         c.encode_utf8(&mut buffer);
                         for i in 0..c.len_utf8() {
                             self.parser.advance(term, buffer[i], &mut ::std::io::sink());
                         }
                         self.invalidate();
                     }
                 }
             }
         }
     }
 }
	use carnelian::{
	Canvas, Color, FontDescription, FontFace, IntSize, MappingPixelSink, Paint, Point, Size,
	};
	use failure::Error;
	use fidl::endpoints::{create_endpoints, ServerEnd};
	use fidl_fuchsia_images as images;
	use fidl_fuchsia_ui_gfx as gfx;
	use fidl_fuchsia_ui_input::{
	ImeServiceMarker, InputEvent, InputMethodAction, InputMethodEditorClientMarker,
	InputMethodEditorClientRequest, InputMethodEditorMarker, KeyboardEventPhase, KeyboardType,
	TextAffinity, TextInputState, TextRange, TextSelection,
	};
	use fidl_fuchsia_ui_scenic::{self as scenic, SessionListenerMarker, SessionListenerRequest};
	use fidl_fuchsia_ui_views::ViewToken;
	use fuchsia_async as fasync;
	use fuchsia_component::client::connect_to_service;
	use fuchsia_scenic::{EntityNode, HostImageCycler, SessionPtr, View};
	use futures::{FutureExt, TryFutureExt, TryStreamExt};
	use parking_lot::Mutex;
	use std::sync::Arc;
	use term_model::ansi::Processor;
	use term_model::config::Config;
	use term_model::term::{SizeInfo, Term};

	pub type FontFacePtr = Arc<Mutex<FontFace<'static>>>;

	pub struct ViewController {
	face: FontFacePtr,
	session: SessionPtr,
	view: View,
	root_node: EntityNode,
	image_cycler: HostImageCycler,
	metrics: Option<gfx::Metrics>,
	logical_size: Option<gfx::Vec3>,
	term: Option<Term>,
	parser: Processor,
	}

	pub type ViewControllerPtr = Arc<Mutex<ViewController>>;

	impl ViewController {
	pub fn new(
	face: FontFacePtr,
	view_token: ViewToken,
	session: SessionPtr,
	session_listener_request: ServerEnd<SessionListenerMarker>,
	) -> Result<ViewControllerPtr, Error> {
	let ime_service = connect_to_service::<ImeServiceMarker>()?;
	let (ime_listener, ime_listener_request) = create_endpoints::<InputMethodEditorMarker>()?;
	let (ime_client_listener, ime_client_listener_request) =
	create_endpoints::<InputMethodEditorClientMarker>()?;
	let mut text_input_state = TextInputState {
	revision: 0,
	text: "".to_string(),
	selection: TextSelection { base: 0, extent: 0, affinity: TextAffinity::Upstream },
	composing: TextRange { start: 0, end: 0 },
	};
	ime_service.get_input_method_editor(
	KeyboardType::Text,
	InputMethodAction::None,
	&mut text_input_state,
	ime_client_listener,
	ime_listener_request,
	)?;

	let view = View::new(session.clone(), view_token, Some(String::from("Terminal")));
	let root_node = EntityNode::new(session.clone());
	view.add_child(&root_node);

	let view_controller = ViewController {
	face,
	session: session.clone(),
	view: view,
	root_node: root_node,
	image_cycler: HostImageCycler::new(session.clone()),
	metrics: None,
	logical_size: None,
	term: None,
	parser: Processor::new(),
	};
	view_controller.setup_scene();
	view_controller.present();

	let view_controller = Arc::new(Mutex::new(view_controller));
	{
	let view_controller = view_controller.clone();
	fasync::spawn(
	async move {
	// In order to keep the channel alive, we need to move ime_listener into this block.
	// Otherwise it's unused, which closes the channel immediately.
	let _dummy = ime_listener;
	let mut stream = ime_client_listener_request.into_stream()?;
	while let Some(request) = await!(stream.try_next())? {
	match request {
	InputMethodEditorClientRequest::DidUpdateState {
	event: Some(event),
	..
	} => view_controller.lock().handle_input_event(*event),
	_ => (),
	}
	}
	Ok(())
	}
	.unwrap_or_else(\|e: failure::Error\| eprintln!("input listener error: {:?}", e)),
	);
	}
	{
	let view_controller = view_controller.clone();
	fasync::spawn(
	async move {
	let mut stream = session_listener_request.into_stream()?;
	while let Some(request) = await!(stream.try_next())? {
	match request {
	SessionListenerRequest::OnScenicEvent { events, control_handle: _ } => {
	view_controller.lock().handle_session_events(events)
	}
	_ => (),
	}
	}
	Ok(())
	}
	.unwrap_or_else(\|e: failure::Error\| eprintln!("view listener error: {:?}", e)),
	);
	}
	Ok(view_controller)
	}

	fn setup_scene(&self) {
	self.root_node.resource().set_event_mask(gfx::METRICS_EVENT_MASK);
	self.root_node.add_child(self.image_cycler.node());
	}

	fn invalidate(&mut self) {
	self.begin_frame();
	}

	fn begin_frame(&mut self) {
	let (metrics, logical_size) = match (self.metrics.as_ref(), self.logical_size.as_ref()) {
	(Some(metrics), Some(logical_size)) => (metrics, logical_size),
	_ => return,
	};
	let physical_width = (logical_size.x * metrics.scale_x) as u32;
	let physical_height = (logical_size.y * metrics.scale_y) as u32;
	let stride = physical_width * 4;
	let info = images::ImageInfo {
	transform: images::Transform::Normal,
	width: physical_width,
	height: physical_height,
	stride,
	pixel_format: images::PixelFormat::Bgra8,
	color_space: images::ColorSpace::Srgb,
	tiling: images::Tiling::Linear,
	alpha_format: images::AlphaFormat::Opaque,
	};
	{
	let guard = self.image_cycler.acquire(info).expect("failed to allocate buffer");
	let mut face = self.face.lock();
	let mut canvas = Canvas::<MappingPixelSink>::new(
	IntSize::new(physical_width as i32, physical_height as i32),
	guard.image().mapping().clone(),
	stride,
	4,
	);
	let size = Size::new(14.0, 22.0);
	let mut font = FontDescription { face: &mut face, size: 20, baseline: 18 };
	let parser = &mut self.parser;
	let term = self.term.get_or_insert_with(\|\| {
	let mut term = Term::new(
	&Config::default(),
	SizeInfo {
	width: physical_width as f32,
	height: physical_height as f32,
	cell_width: size.width as f32,
	cell_height: size.height as f32,
	padding_x: 0.,
	padding_y: 0.,
	},
	);
	for byte in "$ echo \"\u{001b}[31mhello, world!\u{001b}[0m\"".as_bytes() {
	parser.advance(&mut term, *byte, &mut ::std::io::sink());
	}
	term
	});
	for cell in term.renderable_cells(&Config::default(), None, true) {
	let mut buffer: [u8; 4] = [0, 0, 0, 0];
	canvas.fill_text_cells(
	cell.c.encode_utf8(&mut buffer),
	Point::new(size.width * cell.column.0 as f32, size.height * cell.line.0 as f32),
	size,
	&mut font,
	&Paint {
	fg: Color { r: cell.fg.r, g: cell.fg.g, b: cell.fg.b, a: 0xFF },
	bg: Color { r: cell.bg.r, g: cell.bg.g, b: cell.bg.b, a: 0xFF },
	},
	)
	}
	}

	let node = self.image_cycler.node();
	node.set_scale(1.0 / metrics.scale_x, 1.0 / metrics.scale_y, 1.0);
	node.set_translation(logical_size.x / 2.0, logical_size.y / 2.0, 0.0);
	self.present();
	}

	fn present(&self) {
	fasync::spawn(self.session.lock().present(0).map(\|_\| ()));
	}

	fn handle_session_events(&mut self, events: Vec<scenic::Event>) {
	events.iter().for_each(\|event\| match event {
	scenic::Event::Gfx(event) => match event {
	gfx::Event::Metrics(event) => {
	assert!(event.node_id == self.root_node.id());
	self.metrics = Some(gfx::Metrics { ..event.metrics });
	self.invalidate();
	}
	gfx::Event::ViewPropertiesChanged(event) => {
	assert!(event.view_id == self.view.id());
	self.logical_size = Some(gfx::Vec3 {
	x: event.properties.bounding_box.max.x
	- event.properties.bounding_box.min.x,
	y: event.properties.bounding_box.max.y
	- event.properties.bounding_box.min.y,
	z: event.properties.bounding_box.max.z
	- event.properties.bounding_box.min.z,
	});
	self.invalidate();
	}
	_ => (),
	},
	_ => (),
	});
	}

	fn handle_input_event(&mut self, event: InputEvent) {
	if let (Some(term), InputEvent::Keyboard(event)) = (&mut self.term, &event) {
	if event.phase == KeyboardEventPhase::Pressed
	\|\| event.phase == KeyboardEventPhase::Repeat
	{
	if let Some(c) = std::char::from_u32(event.code_point) {
	if c != '\0' {
	// The API that parses escape sequences (the vte library) takes as input a
	// stream of bytes in utf8, rather than taking a stream of codepoints. Thus,
	// we need to convert each codepoint into a ut8 byte stream, which it will
	// then convert back to codepoints.
	// There is an issue on the vte github to address this:
	// https://github.com/jwilm/vte/issues/19
	let mut buffer: [u8; 4] = [0, 0, 0, 0];
	c.encode_utf8(&mut buffer);
	for i in 0..c.len_utf8() {
	self.parser.advance(term, buffer[i], &mut ::std::io::sink());
	}
	self.invalidate();
	}
	}
	}
	}
	}
	}