screen-selector 0.1.1

A reimplementation of Unity’s ScreenSelector.so plugin, using GTK 4
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

// SPDX-License-Identifier: GPL-3.0-only

//! A Unity plugin replacing the proprietary ScreenSelector.so.
//!
//! It is built using GTK 4, and released under the GNU GPL 3.0 only license.
//!
//! Once built, you should rename the shared object to ScreenSelector.so, and either drop it in
//! your game’s plugins directory, or install it system-wide and symlink it in each game you want
//! to use it in.

use core::ffi::c_void;
use once_cell::sync::OnceCell;
use std::ffi::CStr;

mod callbacks;
mod cpp_vector;

#[cfg(not(feature = "gui"))]
mod cli;
#[cfg(feature = "gui")]
mod gtk;

use cpp_vector::CppVector;

type GetAxisDescription = extern "C" fn(i32, *mut i8, *mut i8, *mut i8) -> i32;
type ConfigureAxis = extern "C" fn(i32, i32);
type GetResolutions = extern "C" fn(u32) -> *mut CppVector<(u32, u32)>;
type GetSelectedResolution = extern "C" fn(*mut u32, *mut u32, *mut bool);
type SetSelectedResolution = extern "C" fn(u32, u32, bool);
type GetQualityLevels = extern "C" fn() -> *mut CppVector<*const i8>;
type GetSelectedQualityLevel = extern "C" fn() -> i32;
type SetSelectedQualityLevel = extern "C" fn(i32);
type GetDisplays = extern "C" fn() -> *mut CppVector<*const i8>;
type GetSelectedDisplay = extern "C" fn() -> u32;
type SetSelectedDisplay = extern "C" fn(u32);

static GET_AXIS_DESCRIPTION: OnceCell<GetAxisDescription> = OnceCell::new();
static CONFIGURE_AXIS: OnceCell<ConfigureAxis> = OnceCell::new();
static GET_RESOLUTIONS: OnceCell<GetResolutions> = OnceCell::new();
static GET_SELECTED_RESOLUTION: OnceCell<GetSelectedResolution> = OnceCell::new();
static SET_SELECTED_RESOLUTION: OnceCell<SetSelectedResolution> = OnceCell::new();
static GET_QUALITY_LEVELS: OnceCell<GetQualityLevels> = OnceCell::new();
static GET_SELECTED_QUALITY_LEVEL: OnceCell<GetSelectedQualityLevel> = OnceCell::new();
static SET_SELECTED_QUALITY_LEVEL: OnceCell<SetSelectedQualityLevel> = OnceCell::new();
static GET_DISPLAYS: OnceCell<GetDisplays> = OnceCell::new();
static GET_SELECTED_DISPLAY: OnceCell<GetSelectedDisplay> = OnceCell::new();
static SET_SELECTED_DISPLAY: OnceCell<SetSelectedDisplay> = OnceCell::new();

/// Sets the callbacks from Unity.
#[no_mangle]
pub extern "C" fn SetupUnityCallbacks(
    get_axis_description: GetAxisDescription,
    configure_axis: ConfigureAxis,
    get_resolutions: GetResolutions,
    get_selected_resolution: GetSelectedResolution,
    set_selected_resolution: SetSelectedResolution,
    get_quality_levels: GetQualityLevels,
    get_selected_quality_level: GetSelectedQualityLevel,
    set_selected_quality_level: SetSelectedQualityLevel,
    get_displays: GetDisplays,
    get_selected_display: GetSelectedDisplay,
    set_selected_display: SetSelectedDisplay,
) {
    println!(
        "SetupUnityCallbacks({:p}, {:p}, {:p}, {:p}, {:p}, {:p}, {:p}, {:p}, {:p}, {:p}, {:p})",
        get_axis_description,
        configure_axis,
        get_resolutions,
        get_selected_resolution,
        set_selected_resolution,
        get_quality_levels,
        get_selected_quality_level,
        set_selected_quality_level,
        get_displays,
        get_selected_display,
        set_selected_display
    );
    GET_AXIS_DESCRIPTION.set(get_axis_description).unwrap();
    CONFIGURE_AXIS.set(configure_axis).unwrap();
    GET_RESOLUTIONS.set(get_resolutions).unwrap();
    GET_SELECTED_RESOLUTION
        .set(get_selected_resolution)
        .unwrap();
    SET_SELECTED_RESOLUTION
        .set(set_selected_resolution)
        .unwrap();
    GET_QUALITY_LEVELS.set(get_quality_levels).unwrap();
    GET_SELECTED_QUALITY_LEVEL
        .set(get_selected_quality_level)
        .unwrap();
    SET_SELECTED_QUALITY_LEVEL
        .set(set_selected_quality_level)
        .unwrap();
    GET_DISPLAYS.set(get_displays).unwrap();
    GET_SELECTED_DISPLAY.set(get_selected_display).unwrap();
    SET_SELECTED_DISPLAY.set(set_selected_display).unwrap();
}

/// Main entrypoint of this plugin.
#[no_mangle]
pub extern "C" fn LoadScreenSelectorWindow(
    _module: *const c_void,
    title: *const i8,
    icon: *const i8,
    pixbuf_path: *const i8,
) -> i32 {
    let title = unsafe { CStr::from_ptr(title) }
        .to_string_lossy()
        .to_string();
    let icon = unsafe { CStr::from_ptr(icon) }
        .to_string_lossy()
        .to_string();
    let pixbuf_path = unsafe { CStr::from_ptr(pixbuf_path) }
        .to_string_lossy()
        .to_string();

    #[cfg(not(feature = "gui"))]
    let ret = cli::load_screen_selector_window(title, icon, pixbuf_path);
    #[cfg(feature = "gui")]
    let ret = gtk::load_screen_selector_window(title, icon, pixbuf_path);
    ret
}