mirrors/GstPipelineStudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/dabrain34/GstPipelineStudio.git synced 2024-12-18 22:16:33 +00:00
Code Issues Projects Releases Packages Wiki Activity

app: display the caps as a tooltip on port

Browse source 
The port can now display a tooltip
with the port
This commit is contained in:
Stéphane Cerveau 2022-01-24 14:28:42 +01:00
parent 375d01c0cd
commit 13421b4d5b
3 changed files with 96 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

108
src/app.rs
View file

@ -40,12 +40,13 @@ use crate::ui as GPSUI;
use crate::{GPS_DEBUG, GPS_ERROR, GPS_INFO, GPS_TRACE, GPS_WARN}; use crate::{GPS_DEBUG, GPS_ERROR, GPS_INFO, GPS_TRACE, GPS_WARN};
use crate::graphmanager::{GraphView, PortDirection, PortPresence, PropertyExt}; use crate::graphmanager as GM;
use crate::graphmanager::PropertyExt;
#[derive(Debug)] #[derive(Debug)]
pub struct GPSAppInner { pub struct GPSAppInner {
pub window: gtk::ApplicationWindow, pub window: gtk::ApplicationWindow,
pub graphview: RefCell<GraphView>, pub graphview: RefCell<GM::GraphView>,
pub builder: Builder, pub builder: Builder,
pub pipeline: RefCell<GPS::Pipeline>, pub pipeline: RefCell<GPS::Pipeline>,
pub plugin_list_initialized: OnceCell<bool>, pub plugin_list_initialized: OnceCell<bool>,
@ -113,7 +114,7 @@ impl GPSApp {
let pipeline = GPS::Pipeline::new().expect("Unable to initialize GStreamer subsystem"); let pipeline = GPS::Pipeline::new().expect("Unable to initialize GStreamer subsystem");
let app = GPSApp(Rc::new(GPSAppInner { let app = GPSApp(Rc::new(GPSAppInner {
window, window,
graphview: RefCell::new(GraphView::new()), graphview: RefCell::new(GM::GraphView::new()),
builder, builder,
pipeline: RefCell::new(pipeline), pipeline: RefCell::new(pipeline),
plugin_list_initialized: OnceCell::new(), plugin_list_initialized: OnceCell::new(),
@ -465,6 +466,32 @@ impl GPSApp {
if let Some(node) = app.graphview.borrow().node(node_id) { if let Some(node) = app.graphview.borrow().node(node_id) {
let description = GPS::ElementInfo::element_description(&node.name()).ok(); let description = GPS::ElementInfo::element_description(&node.name()).ok();
node.set_tooltip_markup(description.as_deref()); node.set_tooltip_markup(description.as_deref());
for port in node.all_ports(GM::PortDirection::All) {
let caps = PropertyExt::property(&port, "caps");
GPS_TRACE!("caps={} for port id {}", caps.clone().unwrap_or_else(|| "caps unknown".to_string()), port.id());
port.set_tooltip_markup(caps.as_deref());
}
}
None
}),
);
let app_weak = self.downgrade();
self.graphview.borrow().connect_local(
"port-added",
false,
glib::clone!(@weak application => @default-return None, move |values: &[Value]| {
let app = upgrade_weak!(app_weak, None);
let graph_id = values[1].get::<u32>().expect("graph id in args[1]");
let node_id = values[2].get::<u32>().expect("node id in args[2]");
let port_id = values[3].get::<u32>().expect("port id in args[3]");
GPS_INFO!("Port added port id={} to node id={} in graph id={}", port_id, node_id, graph_id);
if let Some(node) = app.graphview.borrow().node(node_id) {
if let Some(port) = node.port(port_id) {
let caps = PropertyExt::property(&port, "caps");
GPS_TRACE!("caps={} for port id {}", caps.clone().unwrap_or_else(|| "caps unknown".to_string()), port.id());
port.set_tooltip_markup(caps.as_deref());
}
} }
None None
}), }),
@ -600,30 +627,42 @@ impl GPSApp {
} }
); );
if GPS::ElementInfo::element_supports_new_pad_request(&node.name(), PortDirection::Input) { if let Some(input) = GPS::ElementInfo::element_supports_new_pad_request(&node.name(), GM::PortDirection::Input) {
let app_weak = app.downgrade(); let app_weak = app.downgrade();
app.connect_app_menu_action("node.request-pad-input", app.connect_app_menu_action("node.request-pad-input",
move |_,_| { move |_,_| {
let app = upgrade_weak!(app_weak); let app = upgrade_weak!(app_weak);
let graphview = app.graphview.borrow();
GPS_DEBUG!("node.request-pad-input {}", node_id); GPS_DEBUG!("node.request-pad-input {}", node_id);
let port_id = app.graphview.borrow().next_port_id(); let properties: HashMap<String, String> = HashMap::from([
app.graphview.borrow().add_port(node_id, port_id, "in", PortDirection::Input, PortPresence::Sometimes); ("caps".to_string(), input.caps().to_string())]);
let port = graphview.create_port("in", GM::PortDirection::Input, GM::PortPresence::Sometimes);
port.update_properties(&properties);
if let Some(mut node) = graphview.node(node_id) {
graphview.add_port_to_node(&mut node, port);
}
} }
); );
} else { } else {
app.disconnect_app_menu_action("node.request-pad-input"); app.disconnect_app_menu_action("node.request-pad-input");
} }
if GPS::ElementInfo::element_supports_new_pad_request(&node.name(), PortDirection::Output) { if let Some(output) = GPS::ElementInfo::element_supports_new_pad_request(&node.name(), GM::PortDirection::Output) {
let app_weak = app.downgrade(); let app_weak = app.downgrade();
app.connect_app_menu_action("node.request-pad-output", app.connect_app_menu_action("node.request-pad-output",
move |_,_| { move |_,_| {
let app = upgrade_weak!(app_weak); let app = upgrade_weak!(app_weak);
GPS_DEBUG!("node.request-pad-output {}", node_id); let graphview = app.graphview.borrow();
let port_id = app.graphview.borrow_mut().next_port_id(); GPS_DEBUG!("node.request-pad-output {}", node_id);
app.graphview.borrow().add_port(node_id, port_id, "out", PortDirection::Output, PortPresence::Sometimes); let properties: HashMap<String, String> = HashMap::from([
("caps".to_string(), output.caps().to_string())]);
let port = graphview.create_port("out", GM::PortDirection::Output, GM::PortPresence::Sometimes);
port.update_properties(&properties);
if let Some(mut node) = graphview.node(node_id) {
graphview.add_port_to_node(&mut node, port);
}
} }
); );
} else { } else {
app.disconnect_app_menu_action("node.request-pad-output"); app.disconnect_app_menu_action("node.request-pad-output");
} }
@ -668,25 +707,40 @@ impl GPSApp {
fn drop(self) {} fn drop(self) {}
pub fn add_new_element(&self, element_name: &str) { pub fn add_new_element(&self, element_name: &str) {
let graph_view = self.graphview.borrow(); let graphview = self.graphview.borrow();
let node_id = graph_view.next_node_id();
let (inputs, outputs) = GPS::PadInfo::pads(element_name, false); let (inputs, outputs) = GPS::PadInfo::pads(element_name, false);
let mut node =
graphview.create_node(element_name, GPS::ElementInfo::element_type(element_name));
let node_id = node.id();
if GPS::ElementInfo::element_is_uri_src_handler(element_name) { if GPS::ElementInfo::element_is_uri_src_handler(element_name) {
GPSApp::get_file_from_dialog(self, false, move |app, filename| { GPSApp::get_file_from_dialog(self, false, move |app, filename| {
GPS_DEBUG!("Open file {}", filename); GPS_DEBUG!("Open file {}", filename);
let node = app.graphview.borrow().node(node_id).unwrap(); let graphview = app.graphview.borrow();
let mut properties: HashMap<String, String> = HashMap::new(); let mut properties: HashMap<String, String> = HashMap::new();
properties.insert(String::from("location"), filename); properties.insert(String::from("location"), filename);
node.update_properties(&properties); if let Some(node) = graphview.node(node_id) {
node.update_properties(&properties);
}
}); });
} }
graph_view.create_node_with_port(
node_id, for input in inputs {
element_name, let properties: HashMap<String, String> =
GPS::ElementInfo::element_type(element_name), HashMap::from([("caps".to_string(), input.caps().to_string())]);
inputs.len() as u32, let port =
outputs.len() as u32, graphview.create_port("in", GM::PortDirection::Input, GM::PortPresence::Always);
); port.update_properties(&properties);
graphview.add_port_to_node(&mut node, port);
}
for output in outputs {
let properties: HashMap<String, String> =
HashMap::from([("caps".to_string(), output.caps().to_string())]);
let port =
graphview.create_port("out", GM::PortDirection::Output, GM::PortPresence::Always);
port.update_properties(&properties);
graphview.add_port_to_node(&mut node, port);
}
graphview.add_node(node);
} }
pub fn update_element_properties(&self, node_id: u32, properties: &HashMap<String, String>) { pub fn update_element_properties(&self, node_id: u32, properties: &HashMap<String, String>) {

11
src/gps/element.rs
View file

@ -186,23 +186,26 @@ impl ElementInfo {
} }
} }
pub fn element_supports_new_pad_request(element_name: &str, direction: PortDirection) -> bool { pub fn element_supports_new_pad_request(
element_name: &str,
direction: PortDirection,
) -> Option<PadInfo> {
let (inputs, outputs) = PadInfo::pads(element_name, true); let (inputs, outputs) = PadInfo::pads(element_name, true);
if direction == PortDirection::Input { if direction == PortDirection::Input {
for input in inputs { for input in inputs {
if input.presence() == PortPresence::Sometimes { if input.presence() == PortPresence::Sometimes {
return true; return Some(input);
} }
} }
} else if direction == PortDirection::Output { } else if direction == PortDirection::Output {
for output in outputs { for output in outputs {
if output.presence() == PortPresence::Sometimes { if output.presence() == PortPresence::Sometimes {
return true; return Some(output);
} }
} }
} else { } else {
GPS_ERROR!("Port direction unknown"); GPS_ERROR!("Port direction unknown");
} }
false None
} }
} }

8
src/gps/pad.rs
View file

@ -32,6 +32,7 @@ pub struct PadInfo {
element_name: Option<String>, element_name: Option<String>,
direction: PortDirection, direction: PortDirection,
presence: PortPresence, presence: PortPresence,
caps: Option<String>,
} }
impl Default for PadInfo { impl Default for PadInfo {
@ -41,6 +42,7 @@ impl Default for PadInfo {
element_name: None, element_name: None,
direction: PortDirection::Unknown, direction: PortDirection::Unknown,
presence: PortPresence::Unknown, presence: PortPresence::Unknown,
caps: None,
} }
} }
} }
@ -58,6 +60,10 @@ impl PadInfo {
} }
} }
pub fn caps(&self) -> &str {
self.caps.as_ref().unwrap()
}
pub fn pads(element_name: &str, include_on_request: bool) -> (Vec<PadInfo>, Vec<PadInfo>) { pub fn pads(element_name: &str, include_on_request: bool) -> (Vec<PadInfo>, Vec<PadInfo>) {
let feature = ElementInfo::element_feature(element_name).expect("Unable to get feature"); let feature = ElementInfo::element_feature(element_name).expect("Unable to get feature");
let mut input = vec![]; let mut input = vec![];
@ -79,6 +85,7 @@ impl PadInfo {
element_name: Some(element_name.to_string()), element_name: Some(element_name.to_string()),
direction: PortDirection::Output, direction: PortDirection::Output,
presence: PadInfo::pad_to_port_presence(pad.presence()), presence: PadInfo::pad_to_port_presence(pad.presence()),
caps: Some(pad.caps().to_string()),
}); });
} else if pad.direction() == gst::PadDirection::Sink { } else if pad.direction() == gst::PadDirection::Sink {
input.push(PadInfo { input.push(PadInfo {
@ -86,6 +93,7 @@ impl PadInfo {
element_name: Some(element_name.to_string()), element_name: Some(element_name.to_string()),
direction: PortDirection::Input, direction: PortDirection::Input,
presence: PadInfo::pad_to_port_presence(pad.presence()), presence: PadInfo::pad_to_port_presence(pad.presence()),
caps: Some(pad.caps().to_string()),
}); });
} }
} }