update header and bindings to weechat

crates/weechat-sys/Cargo.toml

@@ -9,7 +9,7 @@ readme = "README.md"
 repository = "https://github.com/poljar/rust-weechat"
 
 [build-dependencies]
-bindgen = "0.60.1"
+bindgen = "0.70.0"
 
 [dependencies]
 libc = "0.2.132"

crates/weechat-sys/build.rs

@@ -25,7 +25,7 @@ fn build(file: &str) -> Result<Bindings, BindgenError> {
         "WEECHAT_HOOK_SIGNAL_INT",
         "WEECHAT_HOOK_SIGNAL_POINTER",
     ];
-    let mut builder = bindgen::Builder::default().rustfmt_bindings(true);
+    let mut builder = bindgen::Builder::default();
 
     builder = builder.header(file);
 

crates/weechat/src/buffer/mod.rs

@@ -759,13 +759,13 @@ impl Buffer<'_> {
     /// Display a message on the buffer.
     pub fn print(&self, message: &str) {
         let weechat = self.weechat();
-        let printf_date_tags = weechat.get().printf_date_tags.unwrap();
+        let printf_date_tags = weechat.get().printf_datetime_tags.unwrap();
 
         let fmt_str = LossyCString::new("%s");
         let c_message = LossyCString::new(message);
 
         unsafe {
-            printf_date_tags(self.ptr(), 0, ptr::null(), fmt_str.as_ptr(), c_message.as_ptr())
+            printf_date_tags(self.ptr(), 0, 0, ptr::null(), fmt_str.as_ptr(), c_message.as_ptr())
         }
     }
 
@@ -781,15 +781,15 @@ impl Buffer<'_> {
     /// * `message` - The message that will be displayed.
     pub fn print_date_tags(&self, date: i64, tags: &[&str], message: &str) {
         let weechat = self.weechat();
-        let printf_date_tags = weechat.get().printf_date_tags.unwrap();
+        let printf_date_tags = weechat.get().printf_datetime_tags.unwrap();
 
         let fmt_str = LossyCString::new("%s");
         let tags = tags.join(",");
         let tags = LossyCString::new(tags);
         let message = LossyCString::new(message);
 
         unsafe {
-            printf_date_tags(self.ptr(), date, tags.as_ptr(), fmt_str.as_ptr(), message.as_ptr())
+            printf_date_tags(self.ptr(), date, 0, tags.as_ptr(), fmt_str.as_ptr(), message.as_ptr())
         }
     }
 

crates/weechat/src/config/config.rs

@@ -20,7 +20,8 @@ use crate::{
             ConfigSection, ConfigSectionPointers, ConfigSectionSettings, SectionHandle,
             SectionHandleMut, SectionReadCbT, SectionWriteCbT,
         },
-        BaseConfigOption, BooleanOption, ColorOption, ConfigOption, IntegerOption, StringOption,
+        BaseConfigOption, BooleanOption, ColorOption, ConfigOption, EnumOption, IntegerOption,
+        StringOption,
     },
     LossyCString, Weechat,
 };
@@ -320,7 +321,12 @@ impl Config {
                 weechat_ptr,
                 _phantom: PhantomData,
             }),
-            _ => unreachable!(),
+            "enum" => ConfigOption::Enum(EnumOption {
+                ptr: option_ptr,
+                weechat_ptr,
+                _phantom: PhantomData,
+            }),
+            _ => todo!("Outdated option_from_type_and_ptr"),
         }
     }
     fn return_value_to_error(return_value: c_int) -> std::io::Result<()> {

crates/weechat/src/config/config_options.rs

@@ -4,13 +4,15 @@ use weechat_sys::{t_config_option, t_weechat_plugin};
 
 use crate::{config::OptionChanged, LossyCString, Weechat};
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Default)]
 #[allow(missing_docs)]
 pub enum OptionType {
     Boolean,
     Integer,
+    #[default]
     String,
     Color,
+    Enum,
 }
 
 impl TryFrom<&str> for OptionType {
@@ -21,6 +23,7 @@ impl TryFrom<&str> for OptionType {
             "integer" => OptionType::Integer,
             "string" => OptionType::String,
             "color" => OptionType::Color,
+            "enum" => OptionType::Enum,
             _ => return Err("Invalid option type"),
         };
 
@@ -35,16 +38,11 @@ impl OptionType {
             OptionType::Integer => "integer",
             OptionType::String => "string",
             OptionType::Color => "color",
+            OptionType::Enum => "enum",
         }
     }
 }
 
-impl Default for OptionType {
-    fn default() -> Self {
-        OptionType::String
-    }
-}
-
 pub trait FromPtrs {
     /// Returns the raw pointer to the config option.
     fn from_ptrs(option_ptr: *mut t_config_option, weechat_ptr: *mut t_weechat_plugin) -> Self;

crates/weechat/src/config/enum.rs

@@ -0,0 +1,167 @@
+use std::marker::PhantomData;
+
+use weechat_sys::{t_config_option, t_weechat_plugin};
+
+use crate::{
+    config::{
+        config_options::{ConfigOptions, FromPtrs, HiddenConfigOptionT},
+        BaseConfigOption, ConfigSection,
+    },
+    Weechat,
+};
+
+/// Settings for a new enum option.
+#[derive(Default)]
+pub struct EnumOptionSettings {
+    pub(crate) name: String,
+
+    pub(crate) description: String,
+
+    pub(crate) default_value: i32,
+
+    pub(crate) min: i32,
+
+    pub(crate) max: i32,
+
+    pub(crate) string_values: String,
+
+    pub(crate) change_cb: Option<Box<dyn FnMut(&Weechat, &EnumOption)>>,
+}
+
+impl EnumOptionSettings {
+    /// Create new settings that can be used to create a new enum option.
+    ///
+    /// An enum option is represented as integer (index of enum value) internally
+    ///
+    /// # Arguments
+    ///
+    /// * `name` - The name of the new option.
+    pub fn new<N: Into<String>>(name: N) -> Self {
+        EnumOptionSettings { name: name.into(), ..Default::default() }
+    }
+
+    /// Set the description of the option.
+    ///
+    /// # Arguments
+    ///
+    /// * `description` - The description of the new option.
+    pub fn description<D: Into<String>>(mut self, description: D) -> Self {
+        self.description = description.into();
+        self
+    }
+
+    /// Set the default value of the option.
+    ///
+    /// This is the value the option will have if it isn't set by the user. If
+    /// the option is reset, the option will take this value.
+    ///
+    /// # Arguments
+    ///
+    /// * `value` - The value that should act as the default value.
+    pub fn default_value<V: Into<i32>>(mut self, value: V) -> Self {
+        self.default_value = value.into();
+        self
+    }
+
+    /// Set minimal value of the enum option.
+    ///
+    /// # Arguments
+    ///
+    /// * `value` - The values that should act as minimal valid value.
+    pub fn min(mut self, value: i32) -> Self {
+        self.min = value;
+        self
+    }
+
+    /// Set maximum value of the enum option.
+    ///
+    /// # Arguments
+    ///
+    /// * `value` - The values that should act as maximal valid value.
+    pub fn max(mut self, value: i32) -> Self {
+        self.max = value;
+        self
+    }
+
+    /// Set the string values of the option.
+    ///
+    /// # Arguments
+    ///
+    /// * `values` - The values that should act as the symbolic values.
+    ///
+    /// # Examples
+    /// ```no_run
+    /// use weechat::config::EnumOptionSettings;
+    ///
+    /// let settings = EnumOptionSettings::new("server_buffer")
+    ///     .string_values(vec!["independent", "merged"]);
+    /// ```
+    pub fn string_values<I, T>(mut self, values: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+        T: Into<String>,
+    {
+        let vec: Vec<String> = values.into_iter().map(Into::into).collect();
+        self.string_values = vec.join("|");
+        self
+    }
+
+    /// Set the callback that will run when the value of the option changes.
+    ///
+    /// # Arguments
+    ///
+    /// * `callback` - The callback that will be run.
+    ///
+    /// # Examples
+    /// ```
+    /// use weechat::Weechat;
+    /// use weechat::config::EnumOptionSettings;
+    ///
+    /// let settings = EnumOptionSettings::new("address")
+    ///     .set_change_callback(|weechat, option| {
+    ///         Weechat::print("Option changed");
+    ///     });
+    /// ```
+    pub fn set_change_callback(
+        mut self,
+        callback: impl FnMut(&Weechat, &EnumOption) + 'static,
+    ) -> Self {
+        self.change_cb = Some(Box::new(callback));
+        self
+    }
+}
+
+/// A config option with a enum value.
+pub struct EnumOption<'a> {
+    pub(crate) ptr: *mut t_config_option,
+    pub(crate) weechat_ptr: *mut t_weechat_plugin,
+    pub(crate) _phantom: PhantomData<&'a ConfigSection>,
+}
+
+impl<'a> EnumOption<'a> {
+    /// Get the value of the option.
+    pub fn value(&self) -> i32 {
+        let weechat = self.get_weechat();
+        let config_enum = weechat.get().config_enum.unwrap();
+        unsafe { config_enum(self.get_ptr()) }
+    }
+}
+
+impl<'a> FromPtrs for EnumOption<'a> {
+    fn from_ptrs(option_ptr: *mut t_config_option, weechat_ptr: *mut t_weechat_plugin) -> Self {
+        EnumOption { ptr: option_ptr, weechat_ptr, _phantom: PhantomData }
+    }
+}
+
+impl<'a> HiddenConfigOptionT for EnumOption<'a> {
+    fn get_ptr(&self) -> *mut t_config_option {
+        self.ptr
+    }
+
+    fn get_weechat(&self) -> Weechat {
+        Weechat::from_ptr(self.weechat_ptr)
+    }
+}
+
+impl<'a> BaseConfigOption for EnumOption<'a> {}
+impl<'a> ConfigOptions for EnumOption<'_> {}

crates/weechat/src/config/integer.rs

@@ -23,8 +23,6 @@ pub struct IntegerOptionSettings {
 
     pub(crate) max: i32,
 
-    pub(crate) string_values: String,
-
     pub(crate) change_cb: Option<Box<dyn FnMut(&Weechat, &IntegerOption)>>,
 }
 
@@ -61,32 +59,6 @@ impl IntegerOptionSettings {
         self
     }
 
-    /// Set the string values of the option.
-    ///
-    /// This setting decides if the integer option should act as an enum taking
-    /// symbolic values.
-    ///
-    /// # Arguments
-    ///
-    /// * `values` - The values that should act as the symbolic values.
-    ///
-    /// # Examples
-    /// ```no_run
-    /// use weechat::config::IntegerOptionSettings;
-    ///
-    /// let settings = IntegerOptionSettings::new("server_buffer")
-    ///     .string_values(vec!["independent", "merged"]);
-    /// ```
-    pub fn string_values<I, T>(mut self, values: I) -> Self
-    where
-        I: IntoIterator<Item = T>,
-        T: Into<String>,
-    {
-        let vec: Vec<String> = values.into_iter().map(Into::into).collect();
-        self.string_values = vec.join("|");
-        self
-    }
-
     /// Set minimal value of the integer option.
     ///
     /// # Arguments

crates/weechat/src/config/mod.rs

@@ -28,6 +28,7 @@ mod color;
 #[allow(clippy::module_inception)]
 mod config;
 mod config_options;
+mod r#enum;
 mod integer;
 mod section;
 mod string;
@@ -38,6 +39,7 @@ pub use crate::config::{
     config::{Conf, Config, ConfigReloadCallback, OptionChanged},
     config_options::{BaseConfigOption, ConfigOptions, OptionType},
     integer::{IntegerOption, IntegerOptionSettings},
+    r#enum::{EnumOption, EnumOptionSettings},
     section::{
         ConfigOption, ConfigSection, ConfigSectionSettings, SectionHandle, SectionHandleMut,
         SectionReadCallback, SectionWriteCallback, SectionWriteDefaultCallback,