fix docu types, add table special filtering, show mutlivalues

Author: xdobry

Readme.md

@@ -22,11 +22,11 @@ It provides a user-friendly interface to explore the relationships and propertie
 The application is suitable for developers, researchers, and anyone interested in working with semantic web technologies.
 
 My primary goal was to ensure the program runs as fast as possible and maintains high performance even when handling large datasets.
-Therefore, the program has been optimized to efficiently process and manage large amount of triples and records.
+Therefore, the program has been optimized to efficiently process and manage large number of triples and records.
 
 ![screenshot](documentation/screeshots/rdf-glance_anim.gif)
 
-Individualy styled visualisation of nodes and edges
+Individually styled visualization of nodes and edges
 
 ![screenshot](documentation/screeshots/milenium_falcon_pilot_movies.png)
 
@@ -45,7 +45,7 @@ The RDF Data can be loaded by using following formats:
 
 - ttl
 - rdf/xml
-- trig - namded graphs are ignored
+- trig - named graphs are ignored
 - nt (n-tuples)
 - nq (n-quads) - named graphs are ignored
 
@@ -118,7 +118,7 @@ For more information on how to use RDFGlance, refer to the documentation provide
 ## Known Problems
 
 - Some RDF files can not be read. You will see the error messages in the std output. It seems that the used oxrdf parser is quite sensitive.
-- If loading big rdf files the gui may freeze for a while. There is no seperate worker thread for it
+- If loading big rdf files the gui may freeze for a while. There is no separate worker thread for it
 - The is no limitations to shown size of elements in visual graph. If you have more than 10000 Elements the ui may be not very responsible
 
 I still hope that the application can be useful for others.
@@ -133,7 +133,7 @@ Unlike traditional web applications that rely on HTML and React, `egui` allows f
 RDFGlance uses some oxigraph rust libraries. 
 
 I have developed the application because my frustration about low performance of existing rdf solutions and I wanted to learn and test Rust and egui framework.
-It is learn and hobby project.
+It is a learning and hobby project.
 
 ## Releases
 

documentation/manual.md

@@ -1,11 +1,11 @@
 # General Information
 
-At this time the application may not be self-explained. So here some screenshot with additional informations.
+At this time the application may not be self-explained. So here some screenshot with additional information.
 
 First you should load some rdf data. The application supports ttl (turtle) and rdf/xml formats.
 There is some sample rdf data in the [sample-rdf-data](../sample-rdf-data/programming_languages.ttl) directory
 
-After it you may chosse 3 possilbe note tabs: Table, Visual Graph and Browser
+After it you may chose 3 possible note tabs: Table, Visual Graph and Browser
 The good point is to start is table view.
 
 # Table Tab
@@ -15,17 +15,17 @@ The good point is to start is table view.
 RDFGlance sort all nodes by types.
 First you can see some statistics of RDF Date.
 
-Then you can see the list of all types with some statistice
+Then you can see the list of all types with some statistic
 - count of all instances of this type
 - count of unique data properties of all instances of this type
-- count of unique object properties of all isntances of this type
-- count of unique referenced object properties of all isntance of this type
+- count of unique object properties of all instances of this type
+- count of unique referenced object properties of all instances of this type
 
 Remember that in rdfs an instance can have multiple types. 
 
 After selecting the type you can see all instances as a table.
 You can sort the instances by some data property.
-The out/in columns shown the cound of outgoing and ingoing edges (object properties).
+The out/in columns shown the count of outgoing and ingoing edges (object properties).
 By clicking of the out/in cell you can browser all references in pop-up windows.
 
 You can click on the cell to see the whole value of the data property or other values of the same predicate.
@@ -37,12 +37,12 @@ Remember in rdf one node can have multiple objects of same predicate.
 
 In the browser you can see all properties of one node.
 
-Following informations are show:
+Following information are show:
 
 - type of the node (as label). You can click the type to change to table view and see all instances of clicked type
 - all data properties
 - all object properties (references)
-- all objects that references this node (referenced by)
+- all objects that reference this node (referenced by)
 
 # Visual Graph
 

src/drawing.rs

@@ -268,7 +268,7 @@ pub fn draw_node_label(
     };
     let node_rect = if show_labels {
         let stroke = if type_style.border_width > 0.0 {
-            Stroke::new(type_style.border_width, fade_color(type_style.color,faded))
+            Stroke::new(type_style.border_width, fade_color(type_style.border_color,faded))
         } else {
             Stroke::NONE
         };

src/graph_view.rs

@@ -16,6 +16,52 @@ struct ReferencesState {
     pub visible: u32,
 }
 
+enum NodeContextAction {
+    None,
+    Hide,
+    HideThisType,
+    HideOther,
+    HideOtherTypes,
+    HideUnrelated,
+    Expand,
+    ExpandReferenced,
+    ExpandReferencedBy,
+    ExpandThisType,
+}
+
+impl NodeContextAction {
+    fn show_menu(ui: &mut egui::Ui) -> NodeContextAction {
+        if ui.button("Hide").clicked() {
+            return NodeContextAction::Hide;
+        }
+        if ui.button("Hide this type").clicked() {
+            return NodeContextAction::HideThisType;
+        }
+        if ui.button("Hide other").clicked() {
+            return NodeContextAction::HideOther;
+        }
+        if ui.button("Hide other types").clicked() {
+            return NodeContextAction::HideOtherTypes;
+        }
+        if ui.button("Hide unrelated").clicked() {
+            return NodeContextAction::HideUnrelated;
+        }
+        if ui.button("Expand").clicked() {
+            return NodeContextAction::Expand;
+        }
+        if ui.button("Expand Referenced").clicked() {
+            return NodeContextAction::ExpandReferenced;
+        }
+        if ui.button("Expand Referenced By").clicked() {
+            return NodeContextAction::ExpandReferencedBy;
+        }
+        if ui.button("Expand this type").clicked() {
+            return NodeContextAction::ExpandThisType;
+        }
+        return NodeContextAction::None;
+    }
+}
+
 impl RdfGlanceApp {
     pub fn show_graph(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) -> NodeAction {
         let mut node_to_click: NodeAction = NodeAction::None;
@@ -562,54 +608,77 @@ impl RdfGlanceApp {
                     let mut close_menu = false;
                     let current_index = *node_index;
                     // TODO need to clone the types to release the mutable borrow from current_node (node_data)
-                    let types = current_node.types.clone();
-                    if ui.button("Hide").clicked() {
-                        self.visible_nodes.remove(current_index);
-                        self.ui_state.compute_layout = true;
-                        close_menu = true;
-                    }
-                    if ui.button("Hide this Type").clicked() {
-                        self.ui_state.compute_layout = true;
-                        self.visible_nodes.remove(current_index);
-                        self.visible_nodes.nodes.retain(|x| {
-                            let node = self.node_data.get_node_by_index(x.node_index);
-                            if let Some((_,node)) = node {
-                                !node.has_same_type(&types)
-                            } else {
-                                true
-                            }
-                        });
-                        close_menu = true;
-                    }
-                    if ui.button("Hide other").clicked() {
-                        self.ui_state.compute_layout = true;
-                        self.visible_nodes.nodes.clear();
-                        self.visible_nodes.add_by_index(current_index);
-                        close_menu = true;
-                    }
-                    if ui.button("Hide other Types").clicked() {
-                        self.ui_state.compute_layout = true;
-                        self.visible_nodes.nodes.retain(|x| {
-                            let node = self.node_data.get_node_by_index(x.node_index);
-                            if let Some((_,node)) = node {
-                                node.has_same_type(&types)
-                            } else {
-                                false
-                            }
-                        });
-                        close_menu = true;
-                    }
-                    if ui.button("Expand").clicked() {
-                        self.expand_node(current_index, ExpandType::Both);
-                        close_menu = true;
-                    }
-                    if ui.button("Expand Referenced").clicked() {
-                        self.expand_node(current_index, ExpandType::References);
-                        close_menu = true;
-                    }
-                    if ui.button("Expand Referenced By").clicked() {
-                        self.expand_node(current_index, ExpandType::ReverseReferences);
-                        close_menu = true;
+                    let node_action = NodeContextAction::show_menu(ui);
+                    match node_action {
+                        NodeContextAction::Hide => {
+                            self.visible_nodes.remove(current_index);
+                            self.ui_state.compute_layout = true;
+                            close_menu = true;
+                        },
+                        NodeContextAction::HideThisType => {
+                            let types = current_node.types.clone();
+                            self.ui_state.compute_layout = true;
+                            self.visible_nodes.remove(current_index);
+                            self.visible_nodes.nodes.retain(|x| {
+                                let node = self.node_data.get_node_by_index(x.node_index);
+                                if let Some((_,node)) = node {
+                                    !node.has_same_type(&types)
+                                } else {
+                                    true
+                                }
+                            });
+                            close_menu = true;
+                        },
+                        NodeContextAction::HideOther => {
+                            self.ui_state.compute_layout = true;
+                            self.visible_nodes.nodes.clear();
+                            self.visible_nodes.add_by_index(current_index);
+                            close_menu = true;
+                        },
+                        NodeContextAction::HideOtherTypes => {
+                            let types = current_node.types.clone();
+                            self.ui_state.compute_layout = true;
+                            self.visible_nodes.nodes.retain(|x| {
+                                let node = self.node_data.get_node_by_index(x.node_index);
+                                if let Some((_,node)) = node {
+                                    node.has_same_type(&types)
+                                } else {
+                                    false
+                                }
+                            });
+                            close_menu = true;
+                        },
+                        NodeContextAction::HideUnrelated => {
+                            self.visible_nodes.nodes.retain(|x| {
+                                if x.node_index == *node_index {
+                                    return true;
+                                }
+                                current_node.references.iter().any(| (_predicate_index, ref_iri)| *ref_iri == x.node_index) ||
+                                current_node.reverse_references.iter().any(| (_predicate_index, ref_iri)| *ref_iri == x.node_index)
+                            });
+                            self.ui_state.compute_layout = true;
+                            close_menu = true;
+                        },
+                        NodeContextAction::Expand => {
+                            self.expand_node(current_index, ExpandType::Both);
+                            close_menu = true;
+                        },
+                        NodeContextAction::ExpandReferenced => {
+                            self.expand_node(current_index, ExpandType::References);
+                            close_menu = true;
+                        },
+                        NodeContextAction::ExpandReferencedBy => {
+                            self.expand_node(current_index, ExpandType::ReverseReferences);
+                            close_menu = true;
+                        },
+                        NodeContextAction::ExpandThisType => {
+                            let types = current_node.types.clone();
+                            self.expand_all_by_types(&types);
+                            close_menu = true;
+                        },
+                        NodeContextAction::None => {
+                            // do nothing
+                        }
                     }
                     if close_menu {
                         self.ui_state.context_menu_node = None;

src/lib.rs

@@ -500,6 +500,39 @@ impl RdfGlanceApp {
         }
         npos.position(&mut self.visible_nodes);
     }
+    fn expand_all_by_types(&mut self, types: &Vec<IriIndex>) {
+        let mut refs_to_expand: HashSet<IriIndex> = HashSet::new();
+        let mut parent_ref : Vec<(IriIndex,IriIndex)> = Vec::new();
+        for visible_index in &self.visible_nodes.nodes {
+            if let Some((_,nnode)) = self.node_data.get_node_by_index(visible_index.node_index) {
+                for (_, ref_iri) in nnode.references.iter() {
+                    if let Some((_,nnode)) = self.node_data.get_node_by_index(*ref_iri) {
+                        if nnode.match_types(types) {
+                            if refs_to_expand.insert(*ref_iri) {
+                                parent_ref.push((visible_index.node_index,*ref_iri));
+                            }
+                        }
+                    }
+                }
+                for (_, ref_iri) in nnode.reverse_references.iter() {
+                    if let Some((_,nnode)) = self.node_data.get_node_by_index(*ref_iri) {
+                        if nnode.match_types(types) {
+                            if refs_to_expand.insert(*ref_iri) {
+                                parent_ref.push((visible_index.node_index,*ref_iri));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        let mut npos = NeighbourPos::new();
+        for (parent_index,ref_index) in parent_ref {
+            if !self.visible_nodes.contains(ref_index) && self.load_object_by_index(ref_index) {
+                npos.insert(parent_index, ref_index);
+            }
+        }
+        npos.position(&mut self.visible_nodes);
+    }
     pub fn load_ttl(&mut self, file_name: &str) {
         let language_filter = self.persistent_data.config_data.language_filter();
         let rdfttl = rdfwrap::RDFWrap::load_file(file_name, &mut self.node_data, &language_filter, &mut self.prefix_manager);

src/nobject.rs

@@ -1,5 +1,6 @@
 use indexmap::IndexMap;
 use oxrdf::vocab::rdf;
+use rand::rand_core::le;
 
 use crate::{config::IriDisplay, prefix_manager::PrefixManager, string_indexer::{IndexSpan, StringCache, StringIndexer}, GVisualisationStyle};
 
@@ -168,6 +169,44 @@ impl NObject {
         None
     }
 
+    pub fn get_property_count(&self, predicate_index: IriIndex, language_index: LangIndex) -> Option<(&ObjectType,u32)> {
+        let mut no_lang: Option<&ObjectType> = None;
+        let mut fallback_lang: Option<&ObjectType> = None;
+        let mut lang_value: Option<&ObjectType> = None;
+        let mut count: u32 = 0;
+        for (predicate, value) in &self.properties {
+            if predicate == &predicate_index {
+                count += 1;
+                match value {
+                    ObjectType::LangString(lang, _) => {
+                        if *lang==language_index && lang_value.is_none() {
+                            lang_value = Some(value);
+                        }
+                        if *lang == 0 && fallback_lang.is_none() {
+                            fallback_lang = Some(value);
+                        }
+                    }
+                    ObjectType::String(_) | ObjectType::TypedString(_, _) | ObjectType::StringShort(_)=> {
+                        if no_lang.is_none() {
+                            no_lang = Some(value);
+                        }
+                    }
+                }
+            }
+        }
+        if let Some(lang) = lang_value {
+            return Some((lang,count));
+        }
+        if let Some(fallback_lang) = fallback_lang {
+            return Some((fallback_lang,count));
+        }
+        if let Some(no_lang) = no_lang {
+            return Some((no_lang, count));
+        }
+        None
+    }
+
+
     pub fn apply_filter(&self, filter: &str, iri: &str, indexers: &Indexers) -> bool {
         if iri.contains(filter) {
             return true;
@@ -179,6 +218,24 @@ impl NObject {
         }
         false
     }
+
+    pub fn match_types(&self, types: &Vec<IriIndex>) -> bool {
+        for type_index in self.types.iter() {
+            if types.contains(type_index) {
+                return true;
+            }
+        }
+        false
+    }
+
+    pub fn has_property(&self, predicate_index: IriIndex) -> bool {
+        for (predicate, _value) in &self.properties {
+            if predicate == &predicate_index {
+                return true;
+            }
+        }
+        false
+    }
 }
 
 impl Default for Indexers {