network_graph 0.1.0

Network-style graph utilities and egui widget
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use eframe::egui;
use egui::{Color32, Sense, pos2};
use egui_network_map::{EdgeData, EdgeStyle, GraphWidget, NodeData, NodeStyle};
use rand::random_range;
use uuid::Uuid;

const CANVAS_SIZE: f32 = 5000.0;
const N_NODES: usize = 100;
const N_CONNS: usize = 100;

pub struct BasicNode {
    hover: bool,
}

impl NodeData for BasicNode {
    fn style(&self) -> NodeStyle {
        let mut style = NodeStyle::default();
        if self.hover {
            style.fill_color = Color32::RED;
            style.border_color = Color32::RED;
        }
        return style;
    }

    fn uuid(&self) -> Uuid {
        return Uuid::new_v4();
    }

    fn fixed(&self) -> bool {
        return false;
    }

    fn sense(&self) -> Option<Sense> {
        return Some(Sense::hover());
    }

    fn update(&mut self, sense_response: Option<egui::Response>) {
        self.hover = match sense_response {
            Some(response) => response.hovered(),
            None => false,
        };
    }
}

impl Default for BasicNode {
    fn default() -> Self {
        return BasicNode { hover: false };
    }
}

pub struct BasicEdge {
    hover: bool,
}

impl EdgeData<BasicNode> for BasicEdge {
    fn style(&self) -> EdgeStyle {
        let mut style = EdgeStyle::default();
        if self.hover {
            style.line_color = Color32::RED;
        }
        return style;
    }

    fn update(&mut self, node_1_data: &BasicNode, node_2_data: &BasicNode)
    where
        BasicNode: NodeData,
    {
        self.hover = node_1_data.hover || node_2_data.hover;
    }
}

impl Default for BasicEdge {
    fn default() -> Self {
        return BasicEdge { hover: false };
    }
}

fn main() -> eframe::Result<()> {
    let options = eframe::NativeOptions {
        run_and_return: true,
        viewport: egui::ViewportBuilder::default().with_inner_size([800.0, 800.0]),
        ..Default::default()
    };

    let mut graph: GraphWidget<BasicNode, BasicEdge> = GraphWidget::default();

    let min = CANVAS_SIZE / -2.0;
    let max = CANVAS_SIZE / 2.0;
    let node_uuids: Vec<Uuid> = (0..N_NODES)
        .map(|_| {
            graph.new_node(
                BasicNode::default(),
                pos2(random_range(min..max), random_range(min..max)),
            )
        })
        .collect();
    let _edge_uuids: Vec<Uuid> = (0..N_CONNS)
        .map(|_| {
            graph
                .new_connection(
                    BasicEdge::default(),
                    *node_uuids.get(random_range(0..node_uuids.len())).unwrap(),
                    *node_uuids.get(random_range(0..node_uuids.len())).unwrap(),
                )
                .unwrap()
        })
        .collect();

    eframe::run_native(
        "First window",
        options.clone(),
        Box::new(|_cc| Ok(Box::new(ExampleApp { graph }))),
    )?;

    return Ok(());
}

pub struct ExampleApp {
    graph: GraphWidget<BasicNode, BasicEdge>,
}

impl eframe::App for ExampleApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        egui::CentralPanel::default().show(ctx, |ui| ui.add(&mut self.graph));
    }
}