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
|
use super::*;
use std::os::raw::c_char;
use std::ffi::CStr;
use std::panic;
use std::process::abort;
use std::sync::RwLock;
/// Access to the steam utils interface
pub struct Utils<Manager> {
pub(crate) utils: *mut sys::ISteamUtils,
pub(crate) _inner: Arc<Inner<Manager>>,
}
pub enum NotificationPosition {
TopLeft,
TopRight,
BottomLeft,
BottomRight,
}
lazy_static! {
/// Global rust warning callback
static ref WARNING_CALLBACK: RwLock<Option<Box<dyn Fn(i32, &CStr) + Send + Sync>>> = RwLock::new(None);
}
/// C function to pass as the real callback, which forwards to the `WARNING_CALLBACK` if any
unsafe extern "C" fn c_warning_callback(level: i32, msg: *const c_char) {
let lock = WARNING_CALLBACK.read().expect("warning func lock poisoned");
let cb = match lock.as_ref() {
Some(cb) => cb,
None => { return; }
};
let s = CStr::from_ptr(msg);
let res = panic::catch_unwind(panic::AssertUnwindSafe(||
cb(level, s)
));
if let Err(err) = res {
if let Some(err) = err.downcast_ref::<&str>() {
println!("Steam warning callback panicked: {}", err);
} else if let Some(err) = err.downcast_ref::<String>() {
println!("Steam warning callback panicked: {}", err);
} else {
println!("Steam warning callback panicked");
}
abort();
}
}
impl <Manager> Utils<Manager> {
/// Returns the app ID of the current process
pub fn app_id(&self) -> AppId {
unsafe {
AppId(sys::SteamAPI_ISteamUtils_GetAppID(self.utils))
}
}
/// Returns the language the steam client is currently
/// running in.
///
/// Generally you want `Apps::current_game_language` instead of this
pub fn ui_language(&self) -> String {
unsafe {
let lang = sys::SteamAPI_ISteamUtils_GetSteamUILanguage(self.utils);
let lang = CStr::from_ptr(lang);
lang.to_string_lossy().into_owned()
}
}
/// Sets the position on the screen where popups from the steam overlay
/// should appear and display themselves in.
pub fn set_overlay_notification_position(&self, position: NotificationPosition) {
unsafe {
let position = match position {
NotificationPosition::TopLeft => sys::ENotificationPosition::k_EPositionTopLeft,
NotificationPosition::TopRight => sys::ENotificationPosition::k_EPositionTopRight,
NotificationPosition::BottomLeft => sys::ENotificationPosition::k_EPositionBottomLeft,
NotificationPosition::BottomRight => sys::ENotificationPosition::k_EPositionBottomRight,
};
sys::SteamAPI_ISteamUtils_SetOverlayNotificationPosition(self.utils, position);
}
}
/// Sets the Steam warning callback, which is called to emit warning messages.
///
/// The passed-in function takes two arguments: a severity level (0 = info, 1 = warning) and
/// the message itself.
///
/// See [Steamwork's debugging page](https://partner.steamgames.com/doc/sdk/api/debugging) for more info.
pub fn set_warning_callback<F>(&self, cb: F)
where F: Fn(i32, &CStr) + Send + Sync + 'static
{
let mut lock = WARNING_CALLBACK.write().expect("warning func lock poisoned");
*lock = Some(Box::new(cb));
unsafe {
sys::SteamAPI_ISteamUtils_SetWarningMessageHook(self.utils, Some(c_warning_callback));
}
}
}
pub(crate) struct SteamParamStringArray(Vec<*mut i8>);
impl Drop for SteamParamStringArray {
fn drop(&mut self) {
for c_string in &self.0 {
unsafe { CString::from_raw(*c_string) };
}
}
}
impl SteamParamStringArray {
pub(crate) fn new<S: AsRef<str>>(vec: &[S]) -> SteamParamStringArray {
SteamParamStringArray(vec.into_iter().map(|s| CString::new(s.as_ref()).expect("String passed could not be converted to a c string").into_raw()).collect())
}
pub(crate) fn as_raw(&mut self) -> sys::SteamParamStringArray_t {
sys::SteamParamStringArray_t {
m_nNumStrings: self.0.len() as i32,
m_ppStrings: self.0.as_mut_ptr() as *mut *const i8
}
}
}
|