[rgui] impl Into<String> -> &str

raylib/src/rgui/safe.rs

@@ -76,8 +76,8 @@ impl RaylibHandle {
     }
     /// Load style file (.rgs)
     #[inline]
-    pub fn gui_load_style(&mut self, filename: impl Into<String>) {
-        let c_filename = CString::new(filename.into()).unwrap();
+    pub fn gui_load_style(&mut self, filename: &str) {
+        let c_filename = CString::new(filename).unwrap();
         unsafe { ffi::GuiLoadStyle(c_filename.as_ptr()) }
     }
     /// Load style default over global style
@@ -100,8 +100,8 @@ impl RaylibHandle {
 
     /// Set tooltip string
     #[inline]
-    pub fn gui_set_tooltip(&mut self, tooltip: impl Into<String>) {
-        let c_text = CString::new(tooltip.into()).unwrap();
+    pub fn gui_set_tooltip(&mut self, tooltip: &str) {
+        let c_text = CString::new(tooltip).unwrap();
         unsafe {
             ffi::GuiSetTooltip(c_text.as_ptr());
         }
@@ -188,8 +188,8 @@ pub trait RaylibDrawGui {
     }
     /// Load style file (.rgs)
     #[inline]
-    fn gui_load_style(&mut self, filename: impl Into<String>) {
-        let c_filename = CString::new(filename.into()).unwrap();
+    fn gui_load_style(&mut self, filename: &str) {
+        let c_filename = CString::new(filename).unwrap();
         unsafe { ffi::GuiLoadStyle(c_filename.as_ptr()) }
     }
     /// Load style default over global style
@@ -199,49 +199,41 @@ pub trait RaylibDrawGui {
     }
     /// Window Box control, shows a window that can be closed
     #[inline]
-    fn gui_window_box(
-        &mut self,
-        bounds: impl Into<ffi::Rectangle>,
-        title: impl Into<String>,
-    ) -> bool {
-        let c_filename = CString::new(title.into()).unwrap();
+    fn gui_window_box(&mut self, bounds: impl Into<ffi::Rectangle>, title: &str) -> bool {
+        let c_filename = CString::new(title).unwrap();
         unsafe { ffi::GuiWindowBox(bounds.into(), c_filename.as_ptr()) > 0 }
     }
     /// Group Box control with text name
     #[inline]
-    fn gui_group_box(
-        &mut self,
-        bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
-    ) -> bool {
-        let c_filename = CString::new(text.into()).unwrap();
+    fn gui_group_box(&mut self, bounds: impl Into<ffi::Rectangle>, text: &str) -> bool {
+        let c_filename = CString::new(text).unwrap();
         unsafe { ffi::GuiGroupBox(bounds.into(), c_filename.as_ptr()) > 0 }
     }
     /// Line separator control, could contain text
     #[inline]
-    fn gui_line(&mut self, bounds: impl Into<ffi::Rectangle>, text: impl Into<String>) -> bool {
-        let c_filename = CString::new(text.into()).unwrap();
+    fn gui_line(&mut self, bounds: impl Into<ffi::Rectangle>, text: &str) -> bool {
+        let c_filename = CString::new(text).unwrap();
         unsafe { ffi::GuiLine(bounds.into(), c_filename.as_ptr()) > 0 }
     }
     /// Panel control, useful to group controls
     #[inline]
-    fn gui_panel(&mut self, bounds: impl Into<ffi::Rectangle>, text: impl Into<String>) -> bool {
-        let c_filename = CString::new(text.into()).unwrap();
+    fn gui_panel(&mut self, bounds: impl Into<ffi::Rectangle>, text: &str) -> bool {
+        let c_filename = CString::new(text).unwrap();
         unsafe { ffi::GuiPanel(bounds.into(), c_filename.as_ptr()) > 0 }
     }
     /// Scroll Panel control
     #[inline]
     fn gui_scroll_panel(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         content: impl Into<ffi::Rectangle>,
         scroll: impl Into<ffi::Vector2>,
         view: impl Into<ffi::Rectangle>,
     ) -> (bool, Rectangle, Vector2) {
         let mut scroll = scroll.into();
         let mut view = view.into();
-        let c_filename = CString::new(text.into()).unwrap();
+        let c_filename = CString::new(text).unwrap();
         let result = unsafe {
             ffi::GuiScrollPanel(
                 bounds.into(),
@@ -255,94 +247,90 @@ pub trait RaylibDrawGui {
     }
     /// Label control, shows text
     #[inline]
-    fn gui_label(&mut self, bounds: impl Into<ffi::Rectangle>, text: impl Into<String>) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+    fn gui_label(&mut self, bounds: impl Into<ffi::Rectangle>, text: &str) -> bool {
+        let c_text = CString::new(text).unwrap();
         unsafe { ffi::GuiLabel(bounds.into(), c_text.as_ptr()) > 0 }
     }
     /// Button control, returns true when clicked
     #[inline]
-    fn gui_button(&mut self, bounds: impl Into<ffi::Rectangle>, text: impl Into<String>) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+    fn gui_button(&mut self, bounds: impl Into<ffi::Rectangle>, text: &str) -> bool {
+        let c_text = CString::new(text).unwrap();
         unsafe { ffi::GuiButton(bounds.into(), c_text.as_ptr()) > 0 }
     }
     /// Label button control, show true when clicked
     #[inline]
-    fn gui_label_button(
-        &mut self,
-        bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
-    ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+    fn gui_label_button(&mut self, bounds: impl Into<ffi::Rectangle>, text: &str) -> bool {
+        let c_text = CString::new(text).unwrap();
         unsafe { ffi::GuiLabelButton(bounds.into(), c_text.as_ptr()) > 0 }
     }
     /// Toggle Button control, returns true when active
     #[inline]
     fn gui_toggle(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         active: &mut bool,
     ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
         unsafe { ffi::GuiToggle(bounds.into(), c_text.as_ptr(), active) > 0 }
     }
     /// Toggle Group control, returns active toggle index
     #[inline]
     fn gui_toggle_group(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         active: &mut i32,
     ) -> i32 {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
         unsafe { ffi::GuiToggleGroup(bounds.into(), c_text.as_ptr(), active) }
     }
     /// Check Box control, returns true when active
     #[inline]
     fn gui_check_box(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         checked: &mut bool,
     ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
         unsafe { ffi::GuiCheckBox(bounds.into(), c_text.as_ptr(), checked) > 0 }
     }
     /// Combo Box control, returns selected item index
     #[inline]
     fn gui_combo_box(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         active: &mut i32,
     ) -> i32 {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
         unsafe { ffi::GuiComboBox(bounds.into(), c_text.as_ptr(), active) }
     }
     /// Dropdown Box control, returns selected item
     #[inline]
     fn gui_dropdown_box(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         active: &mut i32,
         edit_mode: bool,
     ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
         unsafe { ffi::GuiDropdownBox(bounds.into(), c_text.as_ptr(), active, edit_mode) > 0 }
     }
     /// Spinner control, returns selected value
     #[inline]
     fn gui_spinner(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         value: &mut i32,
         min_value: i32,
         max_value: i32,
         edit_mode: bool,
     ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
         unsafe {
             ffi::GuiSpinner(
                 bounds.into(),
@@ -360,13 +348,13 @@ pub trait RaylibDrawGui {
     fn gui_value_box(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         value: &mut i32,
         min_value: i32,
         max_value: i32,
         edit_mode: bool,
     ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
         unsafe {
             ffi::GuiValueBox(
                 bounds.into(),
@@ -403,14 +391,14 @@ pub trait RaylibDrawGui {
     fn gui_slider(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text_left: impl Into<String>,
-        text_right: impl Into<String>,
+        text_left: &str,
+        text_right: &str,
         value: &mut f32,
         min_value: f32,
         max_value: f32,
     ) -> bool {
-        let c_text_left = CString::new(text_left.into()).unwrap();
-        let c_text_right = CString::new(text_right.into()).unwrap();
+        let c_text_left = CString::new(text_left).unwrap();
+        let c_text_right = CString::new(text_right).unwrap();
         unsafe {
             ffi::GuiSlider(
                 bounds.into(),
@@ -427,14 +415,14 @@ pub trait RaylibDrawGui {
     fn gui_slider_bar(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text_left: impl Into<String>,
-        text_right: impl Into<String>,
+        text_left: &str,
+        text_right: &str,
         value: &mut f32,
         min_value: f32,
         max_value: f32,
     ) -> bool {
-        let c_text_left = CString::new(text_left.into()).unwrap();
-        let c_text_right = CString::new(text_right.into()).unwrap();
+        let c_text_left = CString::new(text_left).unwrap();
+        let c_text_right = CString::new(text_right).unwrap();
         unsafe {
             ffi::GuiSliderBar(
                 bounds.into(),
@@ -451,14 +439,14 @@ pub trait RaylibDrawGui {
     fn gui_progress_bar(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text_left: impl Into<String>,
-        text_right: impl Into<String>,
+        text_left: &str,
+        text_right: &str,
         value: &mut f32,
         min_value: f32,
         max_value: f32,
     ) -> bool {
-        let c_text_left = CString::new(text_left.into()).unwrap();
-        let c_text_right = CString::new(text_right.into()).unwrap();
+        let c_text_left = CString::new(text_left).unwrap();
+        let c_text_right = CString::new(text_right).unwrap();
         unsafe {
             ffi::GuiProgressBar(
                 bounds.into(),
@@ -472,12 +460,8 @@ pub trait RaylibDrawGui {
     }
     /// Status Bar control, shows info text
     #[inline]
-    fn gui_status_bar(
-        &mut self,
-        bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
-    ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+    fn gui_status_bar(&mut self, bounds: impl Into<ffi::Rectangle>, text: &str) -> bool {
+        let c_text = CString::new(text).unwrap();
         unsafe { ffi::GuiStatusBar(bounds.into(), c_text.as_ptr()) > 0 }
     }
 
@@ -486,11 +470,11 @@ pub trait RaylibDrawGui {
     fn gui_grid(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         spacing: f32,
         subdivs: i32,
     ) -> (bool, Vector2) {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
         let mut mouseCell = ffi::Vector2 { x: 0.0, y: 0.0 };
         (
             unsafe {
@@ -510,11 +494,11 @@ pub trait RaylibDrawGui {
     fn gui_list_view(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         scroll_index: &mut i32,
         active: &mut i32,
     ) -> i32 {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
         unsafe { ffi::GuiListView(bounds.into(), c_text.as_ptr(), scroll_index, active) }
     }
     /// List View with extended parameters
@@ -547,13 +531,13 @@ pub trait RaylibDrawGui {
     fn gui_message_box(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
-        message: impl Into<String>,
-        buttons: impl Into<String>,
+        text: &str,
+        message: &str,
+        buttons: &str,
     ) -> i32 {
-        let c_text = CString::new(text.into()).unwrap();
-        let c_message = CString::new(message.into()).unwrap();
-        let c_buttons = CString::new(buttons.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
+        let c_message = CString::new(message).unwrap();
+        let c_buttons = CString::new(buttons).unwrap();
         unsafe {
             ffi::GuiMessageBox(
                 bounds.into(),
@@ -568,18 +552,18 @@ pub trait RaylibDrawGui {
     fn gui_text_input_box(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        title: impl Into<String>,
-        message: impl Into<String>,
-        buttons: impl Into<String>,
+        title: &str,
+        message: &str,
+        buttons: &str,
         text: &mut String,
         text_max_size: i32,
         secret_view_active: &mut bool,
     ) -> i32 {
         // rgui.h: line 3699 MAX_FILENAME_LEN
         text.reserve((256 - text.len()).max(0) as usize);
-        let c_title = CString::new(title.into()).unwrap();
-        let c_message = CString::new(message.into()).unwrap();
-        let c_buttons = CString::new(buttons.into()).unwrap();
+        let c_title = CString::new(title).unwrap();
+        let c_message = CString::new(message).unwrap();
+        let c_buttons = CString::new(buttons).unwrap();
         let btn_index = unsafe {
             ffi::GuiTextInputBox(
                 bounds.into(),
@@ -600,11 +584,11 @@ pub trait RaylibDrawGui {
     fn gui_color_picker(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         color: impl Into<ffi::Color>,
     ) -> Color {
         let mut out = color.into();
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
 
         let result = unsafe { ffi::GuiColorPicker(bounds.into(), c_text.as_ptr(), &mut out) };
         return out.into();
@@ -613,12 +597,8 @@ pub trait RaylibDrawGui {
     // NOTE: Useful to add icons by name id (enum) instead of
     // a number that can change between ricon versions
     #[inline]
-    fn gui_icon_text(
-        &mut self,
-        icon_id: crate::consts::GuiIconName,
-        text: impl Into<String>,
-    ) -> String {
-        let c_text = CString::new(text.into()).unwrap();
+    fn gui_icon_text(&mut self, icon_id: crate::consts::GuiIconName, text: &str) -> String {
+        let c_text = CString::new(text).unwrap();
         let buffer = unsafe { ffi::GuiIconText(icon_id as i32, c_text.as_ptr()) };
         if buffer.is_null() {
             let ptr = c_text.as_ptr();
@@ -640,10 +620,10 @@ pub trait RaylibDrawGui {
     fn gui_color_bar_alpha(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         alpha: &mut f32,
     ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
 
         unsafe { ffi::GuiColorBarAlpha(bounds.into(), c_text.as_ptr(), alpha) > 0 }
     }
@@ -653,22 +633,18 @@ pub trait RaylibDrawGui {
     fn gui_toggle_slider(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         active: &mut i32,
     ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
 
         unsafe { ffi::GuiToggleSlider(bounds.into(), c_text.as_ptr(), active) > 0 }
     }
 
     /// Dummy control for placeholders
     #[inline]
-    fn gui_dummy_rec(
-        &mut self,
-        bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
-    ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+    fn gui_dummy_rec(&mut self, bounds: impl Into<ffi::Rectangle>, text: &str) -> bool {
+        let c_text = CString::new(text).unwrap();
 
         unsafe { ffi::GuiDummyRec(bounds.into(), c_text.as_ptr()) > 0 }
     }
@@ -678,15 +654,19 @@ pub trait RaylibDrawGui {
     fn gui_color_bar_hue(
         &mut self,
         bounds: impl Into<ffi::Rectangle>,
-        text: impl Into<String>,
+        text: &str,
         value: &mut f32,
     ) -> bool {
-        let c_text = CString::new(text.into()).unwrap();
+        let c_text = CString::new(text).unwrap();
 
         unsafe { ffi::GuiColorBarHue(bounds.into(), c_text.as_ptr(), value) > 0 }
     }
 }
 
+#[diagnostic::on_unimplemented(
+    message = "{Self} is not a gui property, or does not implement the GuiProperty trait.",
+    note = "As of Raylib 5.5, raygui functions that once took \"property enum as i32\" now just take the enum."
+)]
 pub trait GuiProperty {
     fn as_i32(self) -> i32;
 }
@@ -751,9 +731,3 @@ impl GuiProperty for crate::consts::GuiToggleProperty {
         self as i32
     }
 }
-
-impl GuiProperty for i32 {
-    fn as_i32(self) -> i32 {
-        self
-    }
-}