rimrs 0.1.4

RimWorld mod manager
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
127
128
129
130
131
132
133
134
135
136
137

use crate::{helpers::fetch_inc_id, widgets::PathLabel, ModMetaData};
use eframe::egui::{widgets::Label, Response, ScrollArea, Ui, Widget};
use egui_extras::{Column, TableBuilder};
use std::{
    cell::RefCell,
    collections::HashMap,
    rc::Rc,
    sync::{
        atomic::{AtomicUsize, Ordering},
        Arc, Mutex, TryLockError,
    },
};

/// The info panel to the left of the mods lists that shows more details on a selected mod.
#[derive(Debug)]
pub struct ModInfo {
    mmd: Arc<Mutex<HashMap<String, ModMetaData>>>,
    selected: Rc<RefCell<Option<String>>>,
    last_selected: Option<String>,
    path_lab: Option<PathLabel>,
    id: AtomicUsize,
}

impl ModInfo {
    #[must_use]
    pub fn new(
        mmd: Arc<Mutex<HashMap<String, ModMetaData>>>,
        selected: Rc<RefCell<Option<String>>>,
    ) -> Self {
        Self {
            mmd,
            selected,
            last_selected: None,
            path_lab: None,
            id: AtomicUsize::new(fetch_inc_id()),
        }
    }

    fn render(
        ui: &mut Ui,
        selected: &str,
        mmd: &ModMetaData,
        last_selected: &mut Option<String>,
        path_lab: &mut Option<PathLabel>,
        id: &AtomicUsize,
    ) -> Response {
        // get data
        *last_selected = Some(String::from(selected));
        *path_lab = Some(PathLabel::new(mmd.path.clone().unwrap_or_default()));
        id.store(fetch_inc_id(), Ordering::Release);

        if path_lab.is_none() {
            *path_lab = Some(PathLabel::new(mmd.path.clone().unwrap_or_default()));
        }

        let name = mmd.name.clone().unwrap_or_default();
        let description = mmd.description.clone();

        let mut authors: Vec<String> = Vec::new();
        if let Some(author) = mmd.author.as_ref() {
            authors.push(author.clone());
        }
        if let Some(auths) = mmd.authors.as_ref() {
            authors.append(&mut auths.clone());
        }
        let authors = authors.join(", ");

        // make widgets
        let name_widget = Label::new(format!("Name: {name}"));
        let authors_widget = Label::new(format!("Authors: {authors}"));
        let path_widget = path_lab.as_ref().unwrap();
        let description_widget = description.map(Label::new);

        // add widgets to ui
        ui.push_id(id.load(Ordering::Acquire), |ui| {
            let w = ui.available_width() / 2.0;
            let desc_height = ui.available_height() - 100.0;

            // name + authors
            TableBuilder::new(ui)
                .column(Column::exact(w))
                .column(Column::remainder())
                .body(|mut body| {
                    body.row(f32::NAN, |mut row| {
                        row.col(|ui| {
                            ui.add(name_widget);
                        });
                        row.col(|ui| {
                            ui.add(authors_widget);
                        });
                    });
                });

            // path
            ui.add(path_widget);

            // desc
            if let Some(description_widget) = description_widget {
                ui.group(|ui| {
                    ScrollArea::vertical()
                        .max_height(desc_height)
                        .show(ui, |ui| ui.add(description_widget));
                });
            }
        })
        .response
    }
}

impl Widget for &mut ModInfo {
    fn ui(self, ui: &mut Ui) -> Response {
        let sel = self.selected.borrow_mut();
        if let Some(sel) = sel.as_deref() {
            let map = self.mmd.try_lock();
            match map.as_ref().map(|map| map.get(sel)) {
                Ok(Some(mmd)) => {
                    return ModInfo::render(
                        ui,
                        sel,
                        mmd,
                        &mut self.last_selected,
                        &mut self.path_lab,
                        &self.id,
                    )
                }
                Ok(None) => log::warn!("No ModMetaData found for {sel}"),
                Err(TryLockError::Poisoned(_)) => {
                    log::error!("Couldn't get lock for ModMetaData map: mutex poisoned");
                }
                Err(TryLockError::WouldBlock) => {
                    log::warn!("Couldn't get lock for ModMetaData map: already taken.");
                }
            }
        }
        ui.scope(|_| {}).response
    }
}