use crate::enums::{Color, Font, FrameType, Key};
use crate::image::Image;
use crate::prelude::*;
use crate::utils::FlString;
use crate::widget::Widget;
use fltk_sys::tree::*;
use std::{
ffi::{CStr, CString},
mem,
os::raw,
};
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum TreeSort {
None = 0,
Ascending = 1,
Descending = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum TreeConnectorStyle {
None = 0,
Dotted = 1,
Solid = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum TreeSelect {
None = 0,
Single = 1,
Multi = 2,
SingleDraggable = 3,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum TreeItemSelect {
Deselect = 0,
Select = 1,
Toggle = 2,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum TreeReason {
None = 0,
Selected,
Deselected,
Reselected,
Opened,
Closed,
Dragged,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum TreeItemReselectMode {
Once = 0,
Always,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum TreeItemDrawMode {
Default = 0,
LabelAndWidget = 1,
HeightFromWidget = 2,
}
#[derive(Debug)]
pub struct Tree {
inner: *mut Fl_Tree,
tracker: *mut fltk_sys::fl::Fl_Widget_Tracker,
is_derived: bool,
}
crate::macros::widget::impl_widget_ext!(Tree, Fl_Tree);
crate::macros::widget::impl_widget_base!(Tree, Fl_Tree);
crate::macros::widget::impl_widget_default!(Tree);
#[derive(Debug, Clone)]
pub struct TreeItem {
inner: *mut Fl_Tree_Item,
parent: *const Fl_Tree_Item,
tree: Tree,
is_root: bool,
is_derived: bool,
}
#[derive(Debug)]
struct TreeItemArray {
inner: *mut Fl_Tree_Item_Array,
}
impl Tree {
pub unsafe fn from_raw(ptr: *mut Fl_Tree) -> Option<Tree> {
if ptr.is_null() {
None
} else {
let tracker = fltk_sys::fl::Fl_Widget_Tracker_new(ptr as *mut fltk_sys::fl::Fl_Widget);
if tracker.is_null() {
return None;
}
let x = Tree {
inner: ptr,
tracker,
is_derived: false,
};
Some(x)
}
}
pub fn begin(&self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_begin(self.inner) }
}
pub fn end(&self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_end(self.inner) }
}
pub fn show_self(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_show_self(self.inner) }
}
pub fn set_root_label(&mut self, new_label: &str) {
assert!(!self.was_deleted());
let new_label = CString::safe_new(new_label);
unsafe { Fl_Tree_root_label(self.inner, new_label.as_ptr()) }
}
pub fn root(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_root(self.inner)) }
}
pub fn set_root(&mut self, new_item: Option<TreeItem>) {
assert!(!self.was_deleted());
let ptr = match new_item {
None => std::ptr::null_mut(),
Some(item) => item.inner,
};
unsafe { Fl_Tree_set_root(self.inner, ptr) }
}
pub fn add(&mut self, path: &str) -> Option<TreeItem> {
assert!(!self.was_deleted());
let path = CString::safe_new(path);
unsafe {
let x = Fl_Tree_add(self.inner, path.as_ptr() as *mut raw::c_char);
TreeItem::from_raw(x)
}
}
pub fn add_item(&mut self, path: &str, item: &TreeItem) -> Option<TreeItem> {
assert!(!self.was_deleted());
let path = CString::safe_new(path);
unsafe {
let x = Fl_Tree_add_item(self.inner, path.as_ptr() as *mut raw::c_char, item.inner);
TreeItem::from_raw(x)
}
}
pub fn insert_above(&mut self, above: &TreeItem, name: &str) -> Option<TreeItem> {
assert!(!self.was_deleted());
if above.inner.is_null() {
return None;
}
let name = CString::safe_new(name);
unsafe {
let x =
Fl_Tree_insert_above(self.inner, above.inner, name.as_ptr() as *mut raw::c_char);
TreeItem::from_raw(x)
}
}
pub fn insert(&mut self, item: &TreeItem, name: &str, pos: i32) -> Option<TreeItem> {
assert!(!self.was_deleted());
if item.inner.is_null() {
return None;
}
let name = CString::safe_new(name);
unsafe {
let x = Fl_Tree_insert(
self.inner,
item.inner,
name.as_ptr() as *mut raw::c_char,
pos,
);
TreeItem::from_raw(x)
}
}
pub fn remove(&mut self, item: &TreeItem) -> Result<(), FltkError> {
assert!(!self.was_deleted());
if item.inner.is_null() {
return Err(FltkError::Internal(FltkErrorKind::FailedOperation));
}
unsafe {
match Fl_Tree_remove(self.inner, item.inner) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn clear(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_clear(self.inner) }
}
pub fn clear_children(&mut self, item: &TreeItem) {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_clear_children(self.inner as *mut Fl_Tree, item.inner) }
}
pub fn find_item(&self, path: &str) -> Option<TreeItem> {
assert!(!self.was_deleted());
let path = CString::safe_new(path);
unsafe {
let x = Fl_Tree_find_item(self.inner, path.as_ptr() as *mut raw::c_char);
if x.is_null() {
None
} else {
TreeItem::from_raw(x as *mut Fl_Tree_Item)
}
}
}
pub fn find_clicked(&self, yonly: bool) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe {
TreeItem::from_raw(Fl_Tree_find_clicked(self.inner, yonly as i32) as *mut Fl_Tree_Item)
}
}
#[deprecated(since = "1.2.21", note = "use callback_item() instead")]
pub fn set_item_clicked(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_item_clicked(self.inner)) }
}
pub fn first(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_first(self.inner)) }
}
pub fn first_visible_item(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_first_visible_item(self.inner)) }
}
pub fn next(&self, item: &TreeItem) -> Option<TreeItem> {
assert!(!self.was_deleted());
if item.inner.is_null() {
return None;
}
unsafe { TreeItem::from_raw(Fl_Tree_next(self.inner, item.inner)) }
}
pub fn prev(&self, item: &TreeItem) -> Option<TreeItem> {
assert!(!self.was_deleted());
if item.inner.is_null() {
return None;
}
unsafe { TreeItem::from_raw(Fl_Tree_prev(self.inner, item.inner)) }
}
pub fn last(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_last(self.inner)) }
}
pub fn last_visible_item(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_last_visible_item(self.inner)) }
}
pub fn next_visible_item(&self, start: &TreeItem, direction_key: Key) -> Option<TreeItem> {
assert!(!self.was_deleted());
if start.inner.is_null() {
return None;
}
unsafe {
TreeItem::from_raw(Fl_Tree_next_visible_item(
self.inner,
start.inner,
direction_key.bits(),
))
}
}
pub fn first_selected_item(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_first_selected_item(self.inner)) }
}
pub fn last_selected_item(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_last_selected_item(self.inner)) }
}
pub fn next_item(
&self,
item: &TreeItem,
direction_key: Key,
visible: bool,
) -> Option<TreeItem> {
assert!(!self.was_deleted());
if item.inner.is_null() {
return None;
}
unsafe {
TreeItem::from_raw(Fl_Tree_next_item(
self.inner,
item.inner,
direction_key.bits(),
visible as i32,
))
}
}
pub fn next_selected_item(&mut self, item: &TreeItem, direction_key: Key) -> Option<TreeItem> {
assert!(!self.was_deleted());
if item.inner.is_null() {
return None;
}
unsafe {
TreeItem::from_raw(Fl_Tree_next_selected_item(
self.inner,
item.inner,
direction_key.bits(),
))
}
}
pub fn get_selected_items(&self) -> Option<Vec<TreeItem>> {
assert!(!self.was_deleted());
unsafe {
let mut items = TreeItemArray {
inner: std::ptr::null_mut(),
};
let ret = Fl_Tree_get_selected_items(self.inner, &mut items.inner);
if ret == 0 {
None
} else {
items.into_vec()
}
}
}
pub fn get_items(&self) -> Option<Vec<TreeItem>> {
assert!(!self.was_deleted());
unsafe {
let mut items = TreeItemArray {
inner: std::ptr::null_mut(),
};
let ret = Fl_Tree_get_items(self.inner, &mut items.inner);
if ret == 0 {
None
} else {
items.into_vec()
}
}
}
pub fn open(&mut self, path: &str, do_callback: bool) -> Result<(), FltkError> {
assert!(!self.was_deleted());
let path = CString::safe_new(path);
unsafe {
match Fl_Tree_open(
self.inner,
path.as_ptr() as *mut raw::c_char,
do_callback as i32,
) {
0 | 1 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn open_toggle(&mut self, item: &TreeItem, do_callback: bool) {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_open_toggle(self.inner, item.inner, do_callback as i32) }
}
pub fn close(&mut self, path: &str, do_callback: bool) -> Result<(), FltkError> {
assert!(!self.was_deleted());
let path = CString::safe_new(path);
unsafe {
match Fl_Tree_close(
self.inner,
path.as_ptr() as *mut raw::c_char,
do_callback as i32,
) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn is_open(&self, path: &str) -> bool {
assert!(!self.was_deleted());
let path = CString::safe_new(path);
unsafe { Fl_Tree_is_open(self.inner, path.as_ptr() as *mut raw::c_char) != 0 }
}
pub fn is_close(&self, path: &str) -> bool {
assert!(!self.was_deleted());
let path = CString::safe_new(path);
unsafe { Fl_Tree_is_close(self.inner, path.as_ptr() as *mut raw::c_char) != 0 }
}
pub fn select(&mut self, path: &str, do_callback: bool) -> Result<(), FltkError> {
assert!(!self.was_deleted());
let path = CString::safe_new(path);
unsafe {
match Fl_Tree_select(
self.inner,
path.as_ptr() as *mut raw::c_char,
do_callback as i32,
) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn select_toggle(&mut self, item: &TreeItem, do_callback: bool) {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_select_toggle(self.inner, item.inner, do_callback as i32) }
}
pub fn deselect(&mut self, path: &str, do_callback: bool) -> Result<(), FltkError> {
assert!(!self.was_deleted());
let path = CString::safe_new(path);
unsafe {
match Fl_Tree_deselect(
self.inner,
path.as_ptr() as *mut raw::c_char,
do_callback as i32,
) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn deselect_all(&mut self, item: &TreeItem, do_callback: bool) -> Result<(), FltkError> {
assert!(!self.was_deleted());
if item.inner.is_null() {
return Err(FltkError::Internal(FltkErrorKind::FailedOperation));
}
unsafe {
match Fl_Tree_deselect_all(self.inner, item.inner, do_callback as i32) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn select_only(
&mut self,
selected_item: &TreeItem,
do_callback: bool,
) -> Result<(), FltkError> {
assert!(!self.was_deleted());
if selected_item.inner.is_null() {
return Err(FltkError::Internal(FltkErrorKind::FailedOperation));
}
unsafe {
match Fl_Tree_select_only(self.inner, selected_item.inner, do_callback as i32) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn select_all(&mut self, item: &TreeItem, do_callback: bool) -> Result<(), FltkError> {
assert!(!self.was_deleted());
if item.inner.is_null() {
return Err(FltkError::Internal(FltkErrorKind::FailedOperation));
}
unsafe {
match Fl_Tree_select_all(self.inner, item.inner, do_callback as i32) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn extend_selection_dir(
&mut self,
from: &TreeItem,
to: &TreeItem,
direction_key: Key,
val: TreeItemSelect,
visible: bool,
) -> Result<(), FltkError> {
assert!(!self.was_deleted());
if from.inner.is_null() || to.inner.is_null() {
return Err(FltkError::Internal(FltkErrorKind::FailedOperation));
}
unsafe {
match Fl_Tree_extend_selection_dir(
self.inner,
from.inner,
to.inner,
direction_key.bits(),
val as i32,
visible as i32,
) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn extend_selection(
&mut self,
from: &TreeItem,
to: &TreeItem,
val: TreeItemSelect,
visible: bool,
) -> Result<(), FltkError> {
assert!(!self.was_deleted());
if from.inner.is_null() || to.inner.is_null() {
return Err(FltkError::Internal(FltkErrorKind::FailedOperation));
}
unsafe {
match Fl_Tree_extend_selection(
self.inner,
from.inner,
to.inner,
val as i32,
visible as i32,
) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn set_item_focus(&mut self, item: &TreeItem) {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_set_item_focus(self.inner, item.inner) }
}
pub fn get_item_focus(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_get_item_focus(self.inner)) }
}
pub fn is_selected(&self, path: &str) -> bool {
assert!(!self.was_deleted());
let path = CString::safe_new(path);
unsafe { Fl_Tree_is_selected(self.inner, path.as_ptr() as *mut raw::c_char) != 0 }
}
pub fn item_label_font(&self) -> Font {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_item_labelfont(self.inner)) }
}
pub fn set_item_label_font(&mut self, val: Font) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_item_labelfont(self.inner, val.bits()) }
}
pub fn item_label_size(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_item_labelsize(self.inner) }
}
pub fn set_item_label_size(&mut self, val: i32) {
assert!(!self.was_deleted());
let val = if val < 1 { 1 } else { val };
unsafe { Fl_Tree_set_item_labelsize(self.inner, val) }
}
pub fn item_label_fgcolor(&self) -> Color {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_item_labelfgcolor(self.inner)) }
}
pub fn set_item_label_fgcolor(&mut self, val: Color) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_item_labelfgcolor(self.inner, val.bits()) }
}
pub fn item_label_bgcolor(&self) -> Color {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_item_labelbgcolor(self.inner)) }
}
pub fn set_item_label_bgcolor(&mut self, val: Color) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_item_labelbgcolor(self.inner, val.bits()) }
}
pub fn connector_color(&self) -> Color {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_connectorcolor(self.inner)) }
}
pub fn set_connector_color(&mut self, val: Color) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_connectorcolor(self.inner, val.bits()) }
}
pub fn margin_left(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_marginleft(self.inner) }
}
pub fn set_margin_left(&mut self, val: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_marginleft(self.inner, val) }
}
pub fn margin_top(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_margintop(self.inner) }
}
pub fn set_margin_top(&mut self, val: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_margintop(self.inner, val) }
}
pub fn margin_bottom(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_marginbottom(self.inner) }
}
pub fn set_margin_bottom(&mut self, val: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_marginbottom(self.inner, val) }
}
pub fn line_spacing(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_linespacing(self.inner) }
}
pub fn set_line_spacing(&mut self, val: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_linespacing(self.inner, val) }
}
pub fn open_child_margin_bottom(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_openchild_marginbottom(self.inner) }
}
pub fn set_open_child_margin_bottom(&mut self, val: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_openchild_marginbottom(self.inner, val) }
}
pub fn user_icon_margin_left(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_usericonmarginleft(self.inner) }
}
pub fn set_user_icon_margin_left(&mut self, val: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_usericonmarginleft(self.inner, val) }
}
pub fn label_margin_left(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_labelmarginleft(self.inner) }
}
pub fn set_label_margin_left(&mut self, val: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_labelmarginleft(self.inner, val) }
}
pub fn widget_margin_left(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_widgetmarginleft(self.inner) }
}
pub fn set_widget_margin_left(&mut self, val: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_widgetmarginleft(self.inner, val) }
}
pub fn connector_width(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_connectorwidth(self.inner) }
}
pub fn set_connector_width(&mut self, val: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_connectorwidth(self.inner, val) }
}
pub fn user_icon(&self) -> Option<Box<dyn ImageExt>> {
assert!(!self.was_deleted());
unsafe {
let image_ptr = Fl_Tree_usericon(self.inner);
if image_ptr.is_null() {
None
} else {
Some(Box::new(Image::from_image_ptr(
image_ptr as *mut fltk_sys::image::Fl_Image,
)))
}
}
}
pub fn set_user_icon<Img: ImageExt>(&mut self, image: Option<Img>) {
assert!(!self.was_deleted());
if let Some(image) = image {
assert!(!image.was_deleted());
unsafe { Fl_Tree_set_usericon(self.inner, image.as_image_ptr() as *mut _) }
} else {
unsafe { Fl_Tree_set_usericon(self.inner, std::ptr::null_mut::<raw::c_void>()) }
}
}
pub fn open_icon(&self) -> Option<Box<dyn ImageExt>> {
assert!(!self.was_deleted());
unsafe {
let image_ptr = Fl_Tree_openicon(self.inner);
if image_ptr.is_null() {
None
} else {
Some(Box::new(Image::from_image_ptr(
image_ptr as *mut fltk_sys::image::Fl_Image,
)))
}
}
}
pub fn set_open_icon<Img: ImageExt>(&mut self, image: Option<Img>) {
assert!(!self.was_deleted());
if let Some(image) = image {
assert!(!image.was_deleted());
unsafe { Fl_Tree_set_openicon(self.inner, image.as_image_ptr() as *mut _) }
} else {
unsafe { Fl_Tree_set_openicon(self.inner, std::ptr::null_mut::<raw::c_void>()) }
}
}
pub fn close_icon(&self) -> Option<Box<dyn ImageExt>> {
assert!(!self.was_deleted());
unsafe {
let image_ptr = Fl_Tree_closeicon(self.inner);
if image_ptr.is_null() {
None
} else {
Some(Box::new(Image::from_image_ptr(
image_ptr as *mut fltk_sys::image::Fl_Image,
)))
}
}
}
pub fn set_close_icon<Img: ImageExt>(&mut self, image: Option<Img>) {
assert!(!self.was_deleted());
if let Some(image) = image {
assert!(!image.was_deleted());
unsafe { Fl_Tree_set_closeicon(self.inner, image.as_image_ptr() as *mut _) }
} else {
unsafe { Fl_Tree_set_closeicon(self.inner, std::ptr::null_mut::<raw::c_void>()) }
}
}
pub fn show_collapse(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_showcollapse(self.inner) != 0 }
}
pub fn set_show_collapse(&mut self, flag: bool) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_showcollapse(self.inner, flag as i32) }
}
pub fn show_root(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_showroot(self.inner) != 0 }
}
pub fn set_show_root(&mut self, flag: bool) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_showroot(self.inner, flag as i32) }
}
pub fn connector_style(&self) -> TreeConnectorStyle {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_connectorstyle(self.inner)) }
}
pub fn set_connector_style(&mut self, val: TreeConnectorStyle) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_connectorstyle(self.inner, val as i32) }
}
pub fn sort_order(&self) -> TreeSort {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_sortorder(self.inner)) }
}
pub fn set_sort_order(&mut self, val: TreeSort) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_sortorder(self.inner, val as i32) }
}
pub fn select_frame(&self) -> FrameType {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_selectbox(self.inner)) }
}
pub fn set_select_frame(&mut self, val: FrameType) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_selectbox(self.inner, val as i32) }
}
pub fn select_mode(&self) -> TreeSelect {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_selectmode(self.inner)) }
}
pub fn set_select_mode(&mut self, val: TreeSelect) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_selectmode(self.inner, val as i32) }
}
pub fn item_reselect_mode(&self) -> TreeItemReselectMode {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_item_reselect_mode(self.inner)) }
}
pub fn set_item_reselect_mode(&mut self, mode: TreeItemReselectMode) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_item_reselect_mode(self.inner, mode as i32) }
}
pub fn item_draw_mode(&self) -> TreeItemDrawMode {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_item_draw_mode(self.inner)) }
}
pub fn set_item_draw_mode(&mut self, mode: TreeItemDrawMode) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_item_draw_mode(self.inner, mode as i32) }
}
pub fn calc_dimensions(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_calc_dimensions(self.inner) }
}
pub fn calc_tree(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_calc_tree(self.inner) }
}
pub fn recalc_tree(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_recalc_tree(self.inner) }
}
pub fn displayed(&mut self, item: &TreeItem) -> bool {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_displayed(self.inner, item.inner) != 0 }
}
pub fn show_item(&mut self, item: &TreeItem, y_offset: i32) {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_show_item(self.inner, item.inner, y_offset) }
}
pub fn show_item_top(&mut self, item: &TreeItem) {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_show_item_top(self.inner, item.inner) }
}
pub fn show_item_middle(&mut self, item: &TreeItem) {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_show_item_middle(self.inner, item.inner) }
}
pub fn show_item_bottom(&mut self, item: &TreeItem) {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_show_item_bottom(self.inner, item.inner) }
}
pub fn display(&mut self, item: &TreeItem) {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_display(self.inner, item.inner) }
}
pub fn vposition(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_vposition(self.inner) }
}
pub fn set_vposition(&mut self, pos: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_vposition(self.inner, pos) }
}
pub fn hposition(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_hposition(self.inner) }
}
pub fn set_hposition(&mut self, pos: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_hposition(self.inner, pos) }
}
pub fn is_scrollbar<W: WidgetExt>(&mut self, w: &W) -> bool {
assert!(!w.was_deleted());
assert!(!self.was_deleted());
unsafe { Fl_Tree_is_scrollbar(self.inner, w.as_widget_ptr() as *mut Fl_Widget) != 0 }
}
pub fn scrollbar_size(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_scrollbar_size(self.inner) }
}
pub fn set_scrollbar_size(&mut self, sz: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_scrollbar_size(self.inner, sz) }
}
pub fn is_vscroll_visible(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_is_vscroll_visible(self.inner) != 0 }
}
pub fn is_hscroll_visible(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_is_hscroll_visible(self.inner) != 0 }
}
pub fn set_callback_item(&mut self, item: &TreeItem) {
assert!(!self.was_deleted());
assert!(!item.inner.is_null());
unsafe { Fl_Tree_set_callback_item(self.inner, item.inner) }
}
pub fn callback_item(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_callback_item(self.inner)) }
}
pub fn set_callback_reason(&mut self, reason: TreeReason) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_set_callback_reason(self.inner, reason as i32) }
}
pub fn callback_reason(&self) -> TreeReason {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_callback_reason(self.inner)) }
}
pub fn item_pathname(&self, item: &TreeItem) -> Result<String, FltkError> {
assert!(!self.was_deleted());
let mut temp = vec![0u8; 256];
unsafe {
let ret = Fl_Tree_item_pathname(self.inner, temp.as_mut_ptr() as _, 256, item.inner);
if ret == 0 {
if let Some(pos) = temp.iter().position(|x| *x == 0) {
temp = temp.split_at(pos).0.to_vec();
}
Ok(String::from_utf8_lossy(&temp).to_string())
} else {
Err(FltkError::Internal(FltkErrorKind::FailedOperation))
}
}
}
}
impl IntoIterator for Tree {
type Item = TreeItem;
type IntoIter = std::vec::IntoIter<Self::Item>;
fn into_iter(self) -> Self::IntoIter {
self.get_items().map_or_else(
|| Vec::with_capacity(0).into_iter(),
std::iter::IntoIterator::into_iter,
)
}
}
impl TreeItem {
pub unsafe fn from_raw(ptr: *mut Fl_Tree_Item) -> Option<TreeItem> {
if ptr.is_null() {
None
} else {
let inner = Fl_Tree_Item_tree(ptr) as *mut _;
let tracker =
fltk_sys::fl::Fl_Widget_Tracker_new(inner as *mut fltk_sys::fl::Fl_Widget);
assert!(!tracker.is_null());
let tree = Tree {
inner,
tracker,
is_derived: false,
};
let parent = Fl_Tree_Item_parent(ptr);
let is_root = Fl_Tree_Item_is_root(ptr) != 0;
Some(TreeItem {
inner: ptr,
parent,
tree,
is_root,
is_derived: false,
})
}
}
pub fn new(tree: &Tree, label: &str) -> Self {
let label = CString::safe_new(label);
unsafe {
let ptr = Fl_Tree_Item_new(tree.inner, label.as_ptr());
assert!(!ptr.is_null());
Self {
inner: ptr,
parent: ptr,
tree: tree.clone(),
is_root: true,
is_derived: true,
}
}
}
pub fn draw_item_content<F: FnMut(&mut Self, bool) -> i32>(&mut self, cb: F) {
assert!(!self.was_deleted());
assert!(self.is_derived);
unsafe {
unsafe extern "C" fn shim(
item: *mut Fl_Tree_Item,
render: i32,
data: *mut raw::c_void,
) -> i32 {
let mut item = TreeItem::from_raw(item).unwrap();
let a = data as *mut Box<dyn FnMut(&mut TreeItem, bool) -> i32>;
let f: &mut (dyn FnMut(&mut TreeItem, bool) -> i32) = &mut **a;
if let Ok(ret) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
f(&mut item, render != 0)
})) {
ret
} else {
0
}
}
let a: *mut Box<dyn FnMut(&mut Self, bool) -> i32> =
Box::into_raw(Box::new(Box::new(cb)));
let data: *mut raw::c_void = a as *mut raw::c_void;
let callback: Option<
unsafe extern "C" fn(
self_: *mut Fl_Tree_Item,
arg1: i32,
arg2: *mut raw::c_void,
) -> i32,
> = Some(shim);
Fl_Tree_Item_draw_item_content(self.inner, callback, data);
}
}
pub fn set_user_data<T: Clone + 'static>(&mut self, data: T) {
assert!(!self.was_deleted());
unsafe {
Fl_Tree_Item_set_user_data(self.inner, Box::into_raw(Box::from(data)) as _);
}
}
pub unsafe fn user_data<T: Clone + 'static>(&self) -> Option<T> {
assert!(!self.was_deleted());
let ptr = Fl_Tree_Item_user_data(self.inner);
if ptr.is_null() {
None
} else {
let data = ptr as *const _ as *mut T;
Some((*data).clone())
}
}
pub fn x(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_x(self.inner) }
}
pub fn y(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_y(self.inner) }
}
pub fn w(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_w(self.inner) }
}
pub fn h(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_h(self.inner) }
}
pub fn label_x(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_label_x(self.inner) }
}
pub fn label_y(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_label_y(self.inner) }
}
pub fn label_w(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_label_w(self.inner) }
}
pub fn label_h(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_label_h(self.inner) }
}
pub fn show_self(&self, indent: &str) {
assert!(!self.was_deleted());
let indent = CString::safe_new(indent);
unsafe { Fl_Tree_Item_show_self(self.inner, indent.as_ptr() as *mut raw::c_char) }
}
pub fn set_label(&mut self, val: &str) {
assert!(!self.was_deleted());
let val = CString::safe_new(val);
unsafe { Fl_Tree_set_Item_label(self.inner, val.as_ptr() as *mut raw::c_char) }
}
pub fn label(&self) -> Option<String> {
assert!(!self.was_deleted());
unsafe {
let x = Fl_Tree_Item_label(self.inner);
if x.is_null() {
None
} else {
Some(
CStr::from_ptr(x as *mut raw::c_char)
.to_string_lossy()
.to_string(),
)
}
}
}
pub fn set_label_font(&mut self, val: Font) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_set_labelfont(self.inner, val.bits()) }
}
pub fn label_font(&self) -> Font {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_Item_labelfont(self.inner)) }
}
pub fn set_label_size(&mut self, sz: i32) {
assert!(!self.was_deleted());
let sz = if sz < 1 { 1 } else { sz };
unsafe { Fl_Tree_Item_set_labelsize(self.inner, sz) }
}
pub fn label_size(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_labelsize(self.inner) }
}
pub fn set_label_fgcolor(&mut self, val: Color) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_set_labelfgcolor(self.inner, val.bits()) }
}
pub fn label_fgcolor(&self) -> Color {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_Item_labelfgcolor(self.inner)) }
}
#[deprecated(since = "1.2.19", note = "please use `set_label_fgcolor` instead")]
pub fn set_label_fg_color(&mut self, val: Color) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_set_labelfgcolor(self.inner, val.bits()) }
}
#[deprecated(since = "1.2.19", note = "please use `label_fgcolor` instead")]
pub fn label_fg_color(&self) -> Color {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_Item_labelfgcolor(self.inner)) }
}
pub fn set_label_color(&mut self, val: Color) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_set_labelcolor(self.inner, val.bits()) }
}
pub fn label_color(&self) -> Color {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_Item_labelcolor(self.inner)) }
}
pub fn set_label_bgcolor(&mut self, val: Color) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_set_labelbgcolor(self.inner, val.bits()) }
}
pub fn label_bgcolor(&self) -> Color {
assert!(!self.was_deleted());
unsafe { mem::transmute(Fl_Tree_Item_labelbgcolor(self.inner)) }
}
pub fn set_widget<W: WidgetExt>(&mut self, val: &W) {
assert!(!val.was_deleted());
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_set_widget(self.inner, val.as_widget_ptr() as *mut Fl_Widget) }
}
#[deprecated(since = "1.2.18", note = "please use `try_widget` instead")]
pub fn widget(&self) -> Widget {
assert!(!self.was_deleted());
unsafe {
let ptr = Fl_Tree_Item_widget(self.inner) as *mut fltk_sys::widget::Fl_Widget;
assert!(!ptr.is_null());
Widget::from_widget_ptr(ptr)
}
}
pub fn try_widget(&self) -> Option<impl WidgetExt> {
assert!(!self.was_deleted());
unsafe {
let ptr = Fl_Tree_Item_widget(self.inner) as *mut fltk_sys::widget::Fl_Widget;
if ptr.is_null() {
None
} else {
Some(Widget::from_widget_ptr(ptr))
}
}
}
pub fn children(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_children(self.inner) }
}
pub fn child(&self, idx: i32) -> Option<TreeItem> {
if idx < 0 || idx >= self.children() {
return None;
}
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_Item_child(self.inner, idx) as *mut Fl_Tree_Item) }
}
pub fn has_children(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_has_children(self.inner) != 0 }
}
pub fn find_child(&mut self, name: &str) -> Result<i32, FltkError> {
assert!(!self.was_deleted());
let name = CString::safe_new(name);
unsafe {
let x = Fl_Tree_Item_find_child(self.inner, name.as_ptr());
if x == -1 {
Err(FltkError::Internal(FltkErrorKind::FailedOperation))
} else {
Ok(x)
}
}
}
pub fn remove_child(&mut self, new_label: &str) -> Result<(), FltkError> {
assert!(!self.was_deleted());
let new_label = CString::safe_new(new_label);
unsafe {
match Fl_Tree_Item_remove_child(self.inner, new_label.as_ptr()) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn clear_children(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_clear_children(self.inner) }
}
pub fn swap_children(&mut self, a: &TreeItem, b: &TreeItem) -> Result<(), FltkError> {
assert!(!self.was_deleted() && !a.was_deleted() && !b.was_deleted());
unsafe {
match Fl_Tree_Item_swap_children(self.inner, a.inner, b.inner) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn find_child_item(&self, name: &str) -> Option<TreeItem> {
assert!(!self.was_deleted());
let name = CString::safe_new(name);
unsafe {
TreeItem::from_raw(
Fl_Tree_Item_find_child_item(self.inner, name.as_ptr()) as *mut Fl_Tree_Item
)
}
}
pub fn replace(&mut self, new_item: &TreeItem) -> Option<TreeItem> {
assert!(!self.was_deleted() && !new_item.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_Item_replace(self.inner, new_item.inner)) }
}
pub fn replace_child(&mut self, old_item: &TreeItem, new_item: &TreeItem) -> Option<TreeItem> {
assert!(!self.was_deleted() && !old_item.was_deleted() && !new_item.was_deleted());
unsafe {
TreeItem::from_raw(Fl_Tree_Item_replace_child(
self.inner,
old_item.inner,
new_item.inner,
))
}
}
pub fn deparent(&mut self, index: i32) -> Option<TreeItem> {
assert!(!self.was_deleted());
if index < 0 || index >= self.children() {
return None;
}
unsafe { TreeItem::from_raw(Fl_Tree_Item_deparent(self.inner, index)) }
}
pub fn reparent(&mut self, new_child: &TreeItem, index: i32) -> Result<(), FltkError> {
assert!(!self.was_deleted() && !new_child.was_deleted());
if index < 0 || index >= self.children() {
return Err(FltkError::Internal(FltkErrorKind::FailedOperation));
}
unsafe {
match Fl_Tree_Item_reparent(self.inner, new_child.inner, index) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn move_item(&mut self, to: i32, from: i32) -> Result<(), FltkError> {
assert!(!self.was_deleted());
unsafe {
match Fl_Tree_Item_move(self.inner, to, from) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn move_above(&mut self, item: &TreeItem) -> Result<(), FltkError> {
assert!(!self.was_deleted() && !item.was_deleted());
unsafe {
match Fl_Tree_Item_move_above(self.inner, item.inner) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn move_below(&mut self, item: &TreeItem) -> Result<(), FltkError> {
assert!(!self.was_deleted() && !item.was_deleted());
unsafe {
match Fl_Tree_Item_move_below(self.inner, item.inner) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn move_into(&mut self, item: &TreeItem, pos: i32) -> Result<(), FltkError> {
assert!(!self.was_deleted() && !item.was_deleted());
unsafe {
match Fl_Tree_Item_move_into(self.inner, item.inner, pos) {
0 => Ok(()),
_ => Err(FltkError::Internal(FltkErrorKind::FailedOperation)),
}
}
}
pub fn depth(&self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_depth(self.inner) }
}
pub fn prev(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_Item_prev(self.inner)) }
}
pub fn next(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_Item_next(self.inner)) }
}
pub fn next_sibling(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_Item_next_sibling(self.inner)) }
}
pub fn prev_sibling(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_Item_prev_sibling(self.inner)) }
}
pub fn update_prev_next(&mut self, index: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_update_prev_next(self.inner, index) }
}
pub fn parent(&self) -> Option<TreeItem> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_Item_parent(self.inner) as *mut Fl_Tree_Item) }
}
pub fn set_parent(&mut self, val: &TreeItem) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_set_parent(self.inner, val.inner) }
}
pub fn tree(&self) -> Option<Tree> {
assert!(!self.was_deleted());
unsafe { Tree::from_raw(Fl_Tree_Item_tree(self.inner) as *mut Fl_Tree) }
}
pub fn open(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_open(self.inner) }
}
pub fn close(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_close(self.inner) }
}
pub fn is_open(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_is_open(self.inner) != 0 }
}
pub fn is_close(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_is_close(self.inner) != 0 }
}
pub fn open_toggle(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_open_toggle(self.inner) }
}
pub fn select(&mut self, index: i32) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_select(self.inner, index) }
}
pub fn select_toggle(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_select_toggle(self.inner) }
}
pub fn select_all(&mut self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_select_all(self.inner) }
}
pub fn deselect(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_deselect(self.inner) }
}
pub fn deselect_all(&mut self) -> i32 {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_deselect_all(self.inner) }
}
pub fn is_root(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_is_root(self.inner) != 0 }
}
pub fn is_visible(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_is_visible(self.inner) != 0 }
}
pub fn is_active(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_is_active(self.inner) != 0 }
}
pub fn is_activated(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_is_activated(self.inner) != 0 }
}
pub fn deactivate(&mut self) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_deactivate(self.inner) }
}
pub fn activate(&mut self, val: bool) {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_activate(self.inner, val as i32) }
}
pub fn is_selected(&self) -> bool {
assert!(!self.was_deleted());
unsafe { Fl_Tree_Item_is_selected(self.inner) != 0 }
}
pub fn was_deleted(&self) -> bool {
unsafe {
let parent = self.parent;
let is_root = self.is_root;
if self.tree.was_deleted() {
return true;
}
if is_root {
self.tree.root().is_none() || self.inner.is_null()
} else {
Fl_Tree_Item_children(parent) == 0 || self.inner.is_null()
}
}
}
pub fn user_icon(&self) -> Option<Box<dyn ImageExt>> {
assert!(!self.was_deleted());
unsafe {
let image_ptr = Fl_Tree_Item_usericon(self.inner);
if image_ptr.is_null() {
None
} else {
Some(Box::new(Image::from_image_ptr(
image_ptr as *mut fltk_sys::image::Fl_Image,
)))
}
}
}
pub fn set_user_icon<Img: ImageExt>(&mut self, image: Option<Img>) {
assert!(!self.was_deleted());
if let Some(image) = image {
assert!(!image.was_deleted());
unsafe { Fl_Tree_Item_set_usericon(self.inner, image.as_image_ptr() as *mut _) }
} else {
unsafe { Fl_Tree_Item_set_usericon(self.inner, std::ptr::null_mut::<raw::c_void>()) }
}
}
pub fn as_ptr(&self) -> *mut Fl_Tree_Item {
self.inner
}
}
impl Iterator for TreeItem {
type Item = TreeItem;
fn next(&mut self) -> Option<Self::Item> {
assert!(!self.was_deleted());
unsafe { TreeItem::from_raw(Fl_Tree_Item_next(self.inner)) }
}
}
impl TreeItemArray {
fn total(&self) -> i32 {
unsafe { Fl_Tree_Item_Array_total(self.inner) }
}
#[allow(dead_code)]
fn swap(&mut self, ax: i32, bx: i32) {
unsafe { Fl_Tree_Item_Array_swap(self.inner, ax, bx) }
}
#[allow(dead_code)]
fn move_item(&mut self, to: i32, from: i32) -> i32 {
unsafe { Fl_Tree_Item_Array_move(self.inner, to, from) }
}
#[allow(dead_code)]
fn deparent(&mut self, pos: i32) -> i32 {
unsafe { Fl_Tree_Item_Array_deparent(self.inner, pos) }
}
#[allow(dead_code)]
fn reparent(&mut self, item: &TreeItem, newparent: &TreeItem, pos: i32) -> i32 {
unsafe { Fl_Tree_Item_Array_reparent(self.inner, item.inner, newparent.inner, pos) }
}
#[allow(dead_code)]
fn clear(&mut self) {
unsafe { Fl_Tree_Item_Array_clear(self.inner) }
}
#[allow(dead_code)]
fn add(&mut self, val: &TreeItem) {
unsafe { Fl_Tree_Item_Array_add(self.inner, val.inner) }
}
#[allow(dead_code)]
fn insert(&mut self, pos: i32, new_item: &TreeItem) {
unsafe { Fl_Tree_Item_Array_insert(self.inner, pos, new_item.inner) }
}
#[allow(dead_code)]
fn replace(&mut self, pos: i32, new_item: &TreeItem) {
unsafe { Fl_Tree_Item_Array_replace(self.inner, pos, new_item.inner) }
}
#[allow(dead_code)]
fn remove(&mut self, index: i32) {
unsafe { Fl_Tree_Item_Array_remove(self.inner, index) }
}
#[allow(dead_code)]
fn remove_item(&mut self, item: &TreeItem) -> i32 {
unsafe { Fl_Tree_Item_Array_remove_item(self.inner, item.inner) }
}
fn at(&self, idx: i32) -> Option<TreeItem> {
unsafe { TreeItem::from_raw(Fl_Tree_Item_Array_at(self.inner, idx)) }
}
fn into_vec(self) -> Option<Vec<TreeItem>> {
let c = self.total();
let mut v: Vec<TreeItem> = vec![];
if c == 0 {
None
} else {
for i in 0..c {
let val = self.at(i);
val.as_ref()?;
v.push(val.unwrap());
}
Some(v)
}
}
}
impl IntoIterator for TreeItemArray {
type Item = TreeItem;
type IntoIter = std::vec::IntoIter<Self::Item>;
fn into_iter(self) -> Self::IntoIter {
self.into_vec().map_or_else(
|| Vec::with_capacity(0).into_iter(),
std::iter::IntoIterator::into_iter,
)
}
}
unsafe impl Send for TreeItem {}
unsafe impl Sync for TreeItem {}
impl PartialEq for TreeItem {
fn eq(&self, other: &Self) -> bool {
self.inner == other.inner
}
}
impl Eq for TreeItem {}
impl Drop for TreeItemArray {
fn drop(&mut self) {
unsafe { Fl_Tree_Item_Array_delete(self.inner) }
}
}