tsuki/radar-g
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

change: open file just create one layer. Add a function which is ElementImpl Trait FROM<PluginResult> BY<PluginResultType & CoordType>

Browse Source
This commit is contained in:
Tsuki 2024-03-06 11:25:16 +08:00
parent 3d57f61196
commit 28fd066050
13 changed files with 107 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/components/app.rs
View File

@ -187,6 +187,8 @@ impl Component for AppModel {
root: &Self::Root,
sender: ComponentSender<Self>,
) -> ComponentParts<Self> {
let layers = Rc::new(RefCell::new(Vec::with_capacity(20)));
let control = ControlPanelModel::builder().launch(0).forward(
sender.input_sender(),
|msg| match msg {
@ -198,7 +200,7 @@ impl Component for AppModel {
);
let render =
MonitorModel::builder()
.launch(())
.launch(layers.clone())
.forward(sender.input_sender(), |a| match a {
MonitorOutputMsg::LayerRenderFinished => AppMsg::Close,
_ => AppMsg::Close,
@ -224,9 +226,11 @@ impl Component for AppModel {
let mut canvas = renderer.create_canvas();
let mut cms_ref = dialog_cms.lock().unwrap();
let data = element_impl.render(&data,&mut canvas,&mut (*cms_ref));
let mut data_target = element_impl.render(&data,&mut canvas,&mut (*cms_ref));
data_target.data = Some(Arc::new(data) as Arc<dyn Any + Send + Sync + 'static>);
let element = Element::create_instant(
InstantElementDrawerType::Prepared(data),
InstantElementDrawerType::Prepared(data_target),
dialog_dispatcher.clone(),
"New Element".to_string(),
).get_instance();
@ -246,7 +250,7 @@ impl Component for AppModel {
open_dialog: dialog,
control,
render,
layers: Rc::new(RefCell::new(Vec::with_capacity(20))),
layers ,
setting,
tracker: 0,
};
@ -282,6 +286,7 @@ impl Component for AppModel {
}
AppMsg::NewLayer(layer) => {
(*self.layers).borrow_mut().push(layer);
self.render.sender().send(MonitorInputMsg::RefreshLayerList);
}
AppMsg::CloseRequest => {
relm4::main_application().quit();
@ -292,6 +297,7 @@ impl Component for AppModel {
}
_ => {}
}
self.update_view(widgets, _sender);
}
fn update_cmd(

2
src/components/monitor/messages.rs
View File

@ -16,12 +16,14 @@ pub enum MonitorInputMsg {
ClearMetaItems,
UpdateMetaItem(HashMap<String, String>),
UpdateLayer((String, Box<dyn Fn(&mut Layer) + 'static>)),
RefreshLayerList,
None,
}
impl Debug for MonitorInputMsg {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
MonitorInputMsg::RefreshLayerList => write!(f, "MonitorInputMsg::RefreshLayerList"),
MonitorInputMsg::NewElement(_) => write!(f, "MonitorInputMsg::NewElement"),
MonitorInputMsg::AddLayer(_) => write!(f, "MonitorInputMsg::AddLayer"),
MonitorInputMsg::RemoveLayer(_) => write!(f, "MonitorInputMsg::RemoveLayer"),

79
src/components/monitor/monitor.rs
View File

@ -50,7 +50,7 @@ pub struct MonitorWidgets {
impl Component for MonitorModel {
type CommandOutput = MonitorCommand;
type Input = MonitorInputMsg;
type Init = ();
type Init = Rc<RefCell<Vec<Layer>>>;
type Output = MonitorOutputMsg;
view! {
@ -76,6 +76,7 @@ impl Component for MonitorModel {
set_margin_all: 5,
#[name="widget_layer"]
gtk::Overlay{
#[name = "renderer"]
#[wrap(Some)]
set_child = &Render{
// #[track = "model.changed(MonitorModel::new_layer())"]
@ -86,7 +87,8 @@ impl Component for MonitorModel {
set_view: model.render_range,
connect_render_status_notify[sender] => move |r| {
sender.output(MonitorOutputMsg::LayerRenderFinished);
}
},
set_interior_layers: model.layers.clone(),
},
add_overlay=&gtk::Button{
set_label:"Add",
@ -107,7 +109,8 @@ impl Component for MonitorModel {
}
}
fn update(&mut self, message: Self::Input, sender: ComponentSender<Self>, root: &Self::Root) {
fn update_with_view(&mut self, widgets: &mut Self::Widgets, message: Self::Input, sender: ComponentSender<Self>, root: &Self::Root) {
self.reset();
match message {
MonitorInputMsg::AddLayer(layer) => {
@ -115,51 +118,10 @@ impl Component for MonitorModel {
let raw_id = self.get_new_layer();
self.set_new_layer(*raw_id + 1);
self.sidebar.sender().send(SideBarInputMsg::RefreshList);
// let need_prepare = { layer.get_prepare().lock().unwrap().is_some() };
// {
// let mut layers = self.layers.borrow_mut();
// if !layers.contains_key(layer.name.as_str()) {
// let mut widgets = layer.widgets.lock().unwrap();
// if widgets.is_some() {
// let ws = widgets.take().unwrap();
// ws.into_iter().for_each(|w| {
// sender.input(MonitorInputMsg::AddWidget(w));
// });
// }
// }
// }
// if need_prepare {
// sender.oneshot_command(async move {
// let mut back = OffscreenRenderer::new(3000, 3000).unwrap();
// let canvas = back.create_canvas();
// let f = {
// let p = layer.get_prepare();
// let mut _p = p.lock().unwrap();
// _p.take().unwrap()
// };
// let imp = layer.get_imp().unwrap();
// let map: Mapper = Mercator::default().into();
// let cms = CMS::new(map, (3000.0, 3000.0));
// let canvas = Arc::new(Mutex::new(canvas));
// let target = f(imp, canvas, cms);
// layer.set_render_target(target);
// MonitorCommand::NewLayer(layer)
// });
// } else {
// {
// let mut layers = self.layers.borrow_mut();
// if layers.contains_key(layer.name.as_str()) {
// let p = layers.get_mut(layer.name.as_str()).unwrap();
// *p = layer;
// } else {
// layers.insert(layer.name.clone(), layer);
// }
// }
// let raw_id = self.get_new_layer();
// self.set_new_layer(*raw_id + 1);
// self.sidebar.sender().send(SideBarInputMsg::RefreshList);
// }
}
MonitorInputMsg::RefreshLayerList => {
self.sidebar.sender().send(SideBarInputMsg::RefreshList);
widgets.renderer.queue_render();
}
MonitorInputMsg::AddMetaItem(map) => {
self.sidebar.emit(SideBarInputMsg::AddMetaItems(map))
@ -169,20 +131,6 @@ impl Component for MonitorModel {
self.sidebar.emit(SideBarInputMsg::ClearMetaItems);
self.sidebar.emit(SideBarInputMsg::AddMetaItems(map))
}
// MonitorInputMsg::RemoveLayer(k) => {
// self.layers.borrow_mut().remove(&k);
// sender
// .output_sender()
// .send(MonitorOutputMsg::LayerRemoved(0))
// .unwrap();
// }
// MonitorInputMsg::UpdateLayer((k, f)) => {
// f(&mut (*self.layers.borrow_mut().get_mut(&k).unwrap()));
// sender
// .output_sender()
// .send(MonitorOutputMsg::LayerUpdated(0))
// .unwrap();
// }
MonitorInputMsg::AddWidget(widget) => match widget.widget_type() {
WidgetType::Cairo => {
let frame = WidgetFrame::new();
@ -196,6 +144,8 @@ impl Component for MonitorModel {
MonitorInputMsg::None => {}
_ => {}
}
self.update_view(widgets, sender);
}
fn init(
@ -203,9 +153,8 @@ impl Component for MonitorModel {
root: &Self::Root,
sender: ComponentSender<Self>,
) -> ComponentParts<Self> {
let layers = Rc::new(RefCell::new(Vec::new()));
let sidebar: Controller<SideBarModel> = SideBarModel::builder()
.launch(layers.clone())
.launch(init.clone())
.forward(sender.input_sender(), |msg| match msg {
SideBarOutputMsg::NewLayer(layer) => MonitorInputMsg::AddLayer(layer),
_ => MonitorInputMsg::None,
@ -222,7 +171,7 @@ impl Component for MonitorModel {
render_cfg,
sidebar_open: true,
sidebar_width: 400,
layers: layers,
layers: init,
sidebar,
tracker: 0,
};

39
src/pipeline/element.rs
View File

@ -23,12 +23,14 @@ use std::{
pin::Pin,
sync::{Arc, Mutex},
};
use core_extensions::SelfOps;
use radarg_plugin_interface::PluginResult;
use tokio::sync::{
oneshot::{channel, Receiver, Sender},
Notify,
};
use tracing::Instrument;
use crate::widgets::Render;
pub type ElementID = usize;
static ELEMENT_ID: AtomicUsize = AtomicUsize::new(0);
@ -36,7 +38,7 @@ static ELEMENT_ID: AtomicUsize = AtomicUsize::new(0);
pub type Data = Box<dyn Any + Send + Sync>;
pub type Buffer =
Arc<Mutex<BTreeMap<DateTime<Utc>, (Option<Data>, Option<RenderResult>)>>>;
type DrawFunc = Arc<Box<dyn Fn(&mut CanvasWrapper, &CMS)>>;
type DrawFunc = Rc<Box<dyn Fn(&Render)>>;
type IResult<T> = Result<T, PipelineError>;
#[derive(Debug)]
@ -134,13 +136,31 @@ impl InstantElement {
dispatcher,
}
}
pub fn render(&self, canvas: &mut CanvasWrapper, cms: &CMS) {
pub fn render(&mut self, render: &Render) {
match self.draw_type {
InstantElementDrawerType::Draw(ref func) => {
func(canvas, cms);
func(render);
}
InstantElementDrawerType::Prepared(ref mut target) => {
let mut canvas = render.get_canvas();
let mut canvas = canvas.as_mut().unwrap();
let (ox,oy) = target.origin(render);
let (x,y) = target.size(render);
let result_id = match target.target {
TargetType::ImageId(id) => id,
TargetType::Mem(ref mem) => {
let converted = canvas.load_image_mem(mem, femtovg::ImageFlags::empty()).unwrap();
target.set_target(TargetType::ImageId(converted));
converted
}
};
let paint = femtovg::Paint::image(result_id,ox,oy,x,y,0.0,1.0 );
let mut path = femtovg::Path::new();
path.rect(ox,oy,x,y);
canvas.fill_path(&path, &paint);
}
InstantElementDrawerType::Prepared(ref target) => {}
}
}
}
@ -280,13 +300,14 @@ impl RenderResult {
}
}
#[derive(Clone, Debug, PartialEq, PartialOrd)]
#[derive(Clone, Debug)]
pub struct Target {
pub target: TargetType,
pub thumbnail: Option<gtk::gdk::Texture>,
pub width: f32,
pub height: f32,
pub bounds: (Range, Range),
pub data: Option<Arc<dyn Any + Send + Sync + 'static>>
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord)]
@ -302,6 +323,7 @@ impl Target {
height: f32,
bounds: (Range, Range),
thumbnail: Option<gtk::gdk::Texture>,
data: Option<Arc<dyn Any + Send + Sync + 'static>>,
) -> Self {
Self {
target,
@ -309,10 +331,11 @@ impl Target {
height,
bounds,
thumbnail,
data
}
}
pub fn size(&self, cms: &CMS) -> (f32, f32) {
pub fn size(&self, cms: &Render) -> (f32, f32) {
let (x, y) = self.bounds;
let p1 = (x.0, y.0);
@ -324,7 +347,7 @@ impl Target {
((x2 - x1).abs(), (y2 - y1).abs())
}
pub fn origin(&self, cms: &CMS) -> (f32, f32) {
pub fn origin(&self, cms: &Render) -> (f32, f32) {
let (x, y) = self.bounds;
let p1 = (x.0, y.1);
cms.map(p1).unwrap()

2
src/pipeline/element_impl.rs
View File

@ -4,7 +4,7 @@ use crate::data::Radar2d;
use crate::pipeline::element::{ElementImpl, Target};
use crate::pipeline::offscreen_renderer::CanvasWrapper;
use crate::widgets::predefined::color_mapper::ColorMapper;
use crate::widgets::{LayerImpl, CMS};
use crate::widgets::{LayerImpl};
use num_traits::{AsPrimitive, FromPrimitive, Num, NumOps};
use std::any::Any;
use std::fmt::Debug;

28
src/pipeline/offscreen_renderer.rs
View File

@ -1,20 +1,20 @@
use super::utils::*;
use crate::pipeline::element::Target;
use euclid::Size2D;
use femtovg::{renderer::OpenGl, Canvas};
use gl;
use gl::types::{GLchar, GLenum, GLint, GLuint, GLvoid};
use glow::HasContext;
use std::borrow::{Borrow, BorrowMut};
use std::fmt::{Debug, Formatter};
use std::num::NonZeroU32;
use std::ops::{Deref, DerefMut};
use std::sync::{Mutex, RwLock};
use std::{cell::RefCell, sync::Arc};
use std::fmt::{Debug, Formatter};
use surfman::{
device, Adapter, Connection, Context, ContextAttributeFlags, Device, Error, GLApi,
NativeConnection, NativeDevice,
};
use crate::pipeline::element::Target;
pub struct OffscreenRenderer {
context: Arc<RwLock<Context>>,
@ -110,8 +110,7 @@ impl OffscreenRenderer {
CanvasWrapper::new(canvas)
}
pub fn get_img(&self, target: Target) {
}
pub fn get_img(&self, target: Target) {}
pub fn get_mem_img(&self) -> Vec<u8> {
let (w, h) = self.size;
@ -151,7 +150,6 @@ impl Debug for CanvasWrapper {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("CanvasWrapper").finish()
}
}
impl CanvasWrapper {
@ -181,3 +179,21 @@ impl Drop for CanvasWrapper {
let _ = self;
}
}
impl From<Canvas<OpenGl>> for CanvasWrapper {
fn from(canvas: Canvas<OpenGl>) -> Self {
Self(canvas)
}
}
impl Borrow<Canvas<OpenGl>> for CanvasWrapper {
fn borrow(&self) -> &Canvas<OpenGl> {
&self
}
}
impl BorrowMut<Canvas<OpenGl>> for CanvasWrapper {
fn borrow_mut(&mut self) -> &mut Canvas<OpenGl> {
self
}
}

3
src/pipeline/predefined/grid_field_renderer.rs
View File

@ -13,6 +13,7 @@ use image::{imageops::resize, ImageBuffer, Rgba};
use ndarray::ArrayView2;
use num_traits::{AsPrimitive, FromPrimitive, Num, NumOps};
use std::{fmt::Debug, io::Cursor, marker::PhantomData};
use gtk::ResponseType::No;
#[derive(Debug)]
pub struct GridFieldRenderer<CMAP, T>
@ -171,6 +172,7 @@ where
let d2_start = data.dim2.view().first().unwrap().clone();
let d2_end = data.dim2.view().last().unwrap().clone();
canvas.set_render_target(RenderTarget::Screen);
Target::new(
TargetType::Mem(png_data),
@ -178,6 +180,7 @@ where
h,
((d1_start, d1_end).into(), (d2_start, d2_end).into()),
Some(thumbnail_tex),
None
)
}
}

9
src/widgets/render/imp.rs
View File

@ -9,6 +9,8 @@ use gtk::subclass::prelude::*;
use gtk::traits::{GLAreaExt, WidgetExt};
use std::cell::{Cell, RefCell};
use std::num::NonZeroU32;
use std::rc::Rc;
use std::sync::{Arc, Mutex};
#[derive(Debug, Default, Clone, Copy, PartialEq)]
pub struct RenderConfig {
@ -52,7 +54,7 @@ pub struct Render {
pub config: RefCell<RenderConfig>,
pub status: RefCell<RenderStatus>,
pub mapper: RefCell<Mapper>,
pub(super) interior_layers: RefCell<Vec<Layer>>,
pub(super) interior_layers: RefCell<Rc<RefCell<Vec<Layer>>>>,
}
impl Default for Render {
@ -61,7 +63,7 @@ impl Default for Render {
render_status: Cell::new(0),
exterior: RefCell::new(ExteriorWidget::default()),
interior: RefCell::new(InteriorWidget::default()),
interior_layers: RefCell::new(Vec::new()),
interior_layers: RefCell::new(Rc::new(RefCell::new(Vec::new()))),
config: RefCell::new(RenderConfig::default()),
status: RefCell::new(RenderStatus::default()),
mapper: RefCell::new(Mercator::default().into()),
@ -198,7 +200,8 @@ impl GLAreaImpl for Render {
}
}
let c = &(*self.interior_layers.borrow());
let c = self.interior_layers.borrow();
let c = &mut *c.borrow_mut();
self.interior
.borrow()
.draw(c, &self.obj(), self.status.borrow(), configs);

21
src/widgets/render/interior/layers.rs
View File

@ -12,6 +12,7 @@ use std::{
pin::Pin,
sync::{Arc, Mutex},
};
use core_extensions::SelfOps;
type PrepareFunc = Arc<
Mutex<
@ -59,20 +60,14 @@ impl Layer {
}
}
pub fn draw(&self, render: &Render, window_size: (f32, f32)) {
pub fn draw(&mut self, render: &Render, window_size: (f32, f32)) {
if self.visiable {
// if let Some(element) = &self.associated_element {
// let element = element.lock().unwrap();
// match *element {
// Element::TimeSeries(ref e) => {
// if self.time.is_none() {
// return;
// }
// let time = self.time.unwrap();
// }
// Element::Instant(ref e) => {}
// }
// }
match self.associated_element{
AssoElement::Instant(ref mut e) => {
e.render(render);
}
AssoElement::TimeSeries(ref e) => {}
}
}
}

4
src/widgets/render/interior/mod.rs
View File

@ -25,12 +25,12 @@ impl InteriorWidget {
pub fn draw(
&self,
layers: &Vec<Layer>,
layers: &mut Vec<Layer>,
render: &Render,
status: Ref<'_, RenderStatus>,
_c: Ref<'_, RenderConfig>,
) {
for layer in layers.iter().filter(|x| x.visiable) {
for layer in layers.iter_mut().filter(|x| x.visiable) {
layer.draw(render, (1000.0, 1000.0));
}
}

9
src/widgets/render/mod.rs
View File

@ -5,7 +5,8 @@ mod interior;
pub mod predefined;
pub mod renders;
pub mod widget;
pub use self::cms::CMS;
// pub use self::cms::CMS;
use crate::coords::cms::CMS;
pub use self::imp::{RenderConfig, RenderMotion, RenderStatus};
use crate::coords::Mapper;
use adw::prelude::{GLAreaExt, GestureDragExt};
@ -15,7 +16,9 @@ pub use glib::subclass::prelude::*;
use gtk::traits::WidgetExt;
use gtk::{EventControllerScrollFlags, Inhibit};
pub use interior::*;
use std::cell::{Ref, RefMut};
use std::cell::{Ref, RefCell, RefMut};
use std::rc::Rc;
use std::sync::{Arc, Mutex};
pub type WindowCoord = (f32, f32);
@ -124,7 +127,7 @@ impl Render {
self.imp().mapper.replace(mapper);
}
pub fn set_interior_layers(&self, layers: Vec<Layer>) {
pub fn set_interior_layers(&self, layers: Rc<RefCell<Vec<Layer>>>) {
self.imp().interior_layers.replace(layers);
self.queue_render();
self.set_render_status(0);

1
src/widgets/render/predefined/widgets.rs
View File

@ -3,7 +3,6 @@ use super::{
super::Layer,
color_mapper::ColorMapper,
};
use crate::widgets::CMS;
use femtovg::{renderer::OpenGl, Canvas, Color, Paint, Path};
use num_traits::*;
#[derive(Debug)]

3
src/widgets/render/widget/widget.rs
View File

@ -1,7 +1,8 @@
use crate::widgets::{Layer, LayerImpl, Render, CMS};
use crate::widgets::{Layer, LayerImpl, Render};
use femtovg::{renderer::OpenGl, Canvas};
use gtk::Align;
use std::{fmt::Debug, rc::Rc};
use crate::coords::cms::CMS;
pub enum WidgetType {
OpenGl,