Add ChannelType type

src/types/channel_type.rs

@@ -0,0 +1,105 @@
+use crate::bindings;
+
+#[derive(Debug, Clone, Copy)]
+pub enum ChannelType {
+    Undefined,
+    RedChannel,
+    GrayChannel,
+    CyanChannel,
+    LChannel,
+    GreenChannel,
+    MagentaChannel,
+    aChannel,
+    BlueChannel,
+    bChannel,
+    YellowChannel,
+    BlackChannel,
+    AlphaChannel,
+    OpacityChannel,
+    IndexChannel,
+    ReadMaskChannel,
+    WriteMaskChannel,
+    MetaChannel,
+    CompositeMaskChannel,
+    CompositeChannels,
+    AllChannels,
+    TrueAlphaChannel,
+    RGBChannels,
+    GrayChannels,
+    SyncChannels,
+    DefaultChannels,
+}
+
+impl Default for ChannelType {
+    fn default() -> Self {
+        return ChannelType::DefaultChannels;
+    }
+}
+
+impl From<ChannelType> for bindings::ChannelType {
+    fn from(value: ChannelType) -> Self {
+        match value {
+            ChannelType::Undefined            => { bindings::ChannelType_UndefinedChannel     },
+            ChannelType::RedChannel           => { bindings::ChannelType_RedChannel           },
+            ChannelType::GrayChannel          => { bindings::ChannelType_GrayChannel          },
+            ChannelType::CyanChannel          => { bindings::ChannelType_CyanChannel          },
+            ChannelType::LChannel             => { bindings::ChannelType_LChannel             },
+            ChannelType::GreenChannel         => { bindings::ChannelType_GreenChannel         },
+            ChannelType::MagentaChannel       => { bindings::ChannelType_MagentaChannel       },
+            ChannelType::aChannel             => { bindings::ChannelType_aChannel             },
+            ChannelType::BlueChannel          => { bindings::ChannelType_BlueChannel          },
+            ChannelType::bChannel             => { bindings::ChannelType_bChannel             },
+            ChannelType::YellowChannel        => { bindings::ChannelType_YellowChannel        },
+            ChannelType::BlackChannel         => { bindings::ChannelType_BlackChannel         },
+            ChannelType::AlphaChannel         => { bindings::ChannelType_AlphaChannel         },
+            ChannelType::OpacityChannel       => { bindings::ChannelType_OpacityChannel       },
+            ChannelType::IndexChannel         => { bindings::ChannelType_IndexChannel         },
+            ChannelType::ReadMaskChannel      => { bindings::ChannelType_ReadMaskChannel      },
+            ChannelType::WriteMaskChannel     => { bindings::ChannelType_WriteMaskChannel     },
+            ChannelType::MetaChannel          => { bindings::ChannelType_MetaChannel          },
+            ChannelType::CompositeMaskChannel => { bindings::ChannelType_CompositeMaskChannel },
+            ChannelType::CompositeChannels    => { bindings::ChannelType_CompositeChannels    },
+            ChannelType::AllChannels          => { bindings::ChannelType_AllChannels          },
+            ChannelType::TrueAlphaChannel     => { bindings::ChannelType_TrueAlphaChannel     },
+            ChannelType::RGBChannels          => { bindings::ChannelType_RGBChannels          },
+            ChannelType::GrayChannels         => { bindings::ChannelType_GrayChannels         },
+            ChannelType::SyncChannels         => { bindings::ChannelType_SyncChannels         },
+            ChannelType::DefaultChannels      => { bindings::ChannelType_DefaultChannels      },
+        }
+    }
+}
+
+impl From<bindings::ChannelType> for ChannelType {
+    fn from(value: bindings::ChannelType) -> Self {
+        // Unreachable match arms commented out
+        match value {
+            bindings::ChannelType_UndefinedChannel     => { ChannelType::Undefined            },
+            bindings::ChannelType_RedChannel           => { ChannelType::RedChannel           },
+            // bindings::ChannelType_GrayChannel          => { ChannelType::GrayChannel          },
+            // bindings::ChannelType_CyanChannel          => { ChannelType::CyanChannel          },
+            // bindings::ChannelType_LChannel             => { ChannelType::LChannel             },
+            bindings::ChannelType_GreenChannel         => { ChannelType::GreenChannel         },
+            // bindings::ChannelType_MagentaChannel       => { ChannelType::MagentaChannel       },
+            // bindings::ChannelType_aChannel             => { ChannelType::aChannel             },
+            bindings::ChannelType_BlueChannel          => { ChannelType::BlueChannel          },
+            // bindings::ChannelType_bChannel             => { ChannelType::bChannel             },
+            // bindings::ChannelType_YellowChannel        => { ChannelType::YellowChannel        },
+            bindings::ChannelType_BlackChannel         => { ChannelType::BlackChannel         },
+            bindings::ChannelType_AlphaChannel         => { ChannelType::AlphaChannel         },
+            // bindings::ChannelType_OpacityChannel       => { ChannelType::OpacityChannel       },
+            bindings::ChannelType_IndexChannel         => { ChannelType::IndexChannel         },
+            bindings::ChannelType_ReadMaskChannel      => { ChannelType::ReadMaskChannel      },
+            bindings::ChannelType_WriteMaskChannel     => { ChannelType::WriteMaskChannel     },
+            bindings::ChannelType_MetaChannel          => { ChannelType::MetaChannel          },
+            bindings::ChannelType_CompositeMaskChannel => { ChannelType::CompositeMaskChannel },
+            bindings::ChannelType_CompositeChannels    => { ChannelType::CompositeChannels    },
+            bindings::ChannelType_AllChannels          => { ChannelType::AllChannels          },
+            // bindings::ChannelType_TrueAlphaChannel     => { ChannelType::TrueAlphaChannel     },
+            // bindings::ChannelType_RGBChannels          => { ChannelType::RGBChannels          },
+            bindings::ChannelType_GrayChannels         => { ChannelType::GrayChannels         },
+            bindings::ChannelType_SyncChannels         => { ChannelType::SyncChannels         },
+            // bindings::ChannelType_DefaultChannels      => { ChannelType::DefaultChannels      },
+            _ => { ChannelType::Undefined },
+        }
+    }
+}

src/types/mod.rs

@@ -1,6 +1,7 @@
 mod align_type;
 mod alpha_channel_option;
 mod auto_threshold_method;
+mod channel_type;
 mod clip_path_units;
 mod colorspace_type;
 mod composite_operator;
@@ -31,6 +32,7 @@ mod style_type;
 pub use self::align_type::AlignType;
 pub use self::alpha_channel_option::AlphaChannelOption;
 pub use self::auto_threshold_method::AutoThresholdMethod;
+pub use self::channel_type::ChannelType;
 pub use self::clip_path_units::ClipPathUnits;
 pub use self::colorspace_type::ColorspaceType;
 pub use self::composite_operator::CompositeOperator;

src/wand/magick.rs

@@ -33,6 +33,7 @@ use super::{DrawingWand, PixelWand};
 use crate::{
     AlphaChannelOption,
     AutoThresholdMethod,
+    ChannelType,
     ColorspaceType,
     CompositeOperator,
     CompressionType,
@@ -1052,8 +1053,8 @@ impl MagickWand {
     }
 
     /// Implodes the image towards the center by the specified percentage
-    pub fn implode(&self, amount: f64, method: bindings::PixelInterpolateMethod) -> Result<()> {
+    pub fn implode(&self, amount: f64, method: PixelInterpolateMethod) -> Result<()> {
-        match unsafe { bindings::MagickImplodeImage(self.wand, amount, method) } {
+        match unsafe { bindings::MagickImplodeImage(self.wand, amount, method.into()) } {
             MagickTrue => Ok(()),
             _ => Err(MagickError("failed to implode image")),
         }
@@ -1191,9 +1192,9 @@ impl MagickWand {
     /// Set image channel mask
     pub fn set_image_channel_mask(
         &mut self,
-        option: bindings::ChannelType,
+        option: ChannelType,
-    ) -> bindings::ChannelType {
+    ) -> ChannelType {
-        unsafe { bindings::MagickSetImageChannelMask(self.wand, option) }
+        unsafe { bindings::MagickSetImageChannelMask(self.wand, option.into()).into() }
     }
 
     /// Apply an arithmetic, relational, or logical