uniui_layout_linear_layout 0.0.10

Label widget for uniui_* crate family.
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use crate::ItemsAlignment;

use uniui_gui::{
	implz::qt5::Qt5OptionalNative,
	AlignmentHorizontal,
	AlignmentVertical,
	Color,
	NativeWidget,
	Orientation,
	Widget,
	WidgetGenerator,
	Wrap,
};

use std::ffi::c_void;

extern "C" {
	static UniUiLayoutLinearLayoutOrientationHorizontal: i32;
	static UniUiLayoutLinearLayoutOrientationVertical: i32;


	fn uniui_layout_linear_layout_create(orientation: i32) -> *mut c_void;
	fn uniui_layout_linear_layout_add_widget(
		layout: *mut c_void,
		widget: *mut c_void,
	);
	fn uniui_layout_linear_layout_create_widget_with_layout(
		layout: *mut c_void
	) -> *mut c_void;
	fn uniui_layout_linear_layout_set_widget_background(
		widget: *mut c_void,
		red: u8,
		green: u8,
		blue: u8,
	);
}

pub struct Qt5LinearLayout {
	native: Qt5OptionalNative,
}

impl Qt5LinearLayout {
	pub fn new() -> Qt5LinearLayout {
		return Qt5LinearLayout {
			native: Qt5OptionalNative::new(),
		};
	}

	pub fn set_background(
		&mut self,
		color: &Color,
	) {
		if let Some(p) = self.native.as_mut() {
			unsafe {
				uniui_layout_linear_layout_set_widget_background(
					p,
					color.red,
					color.green,
					color.blue,
				);
			};
		}
	}

	pub fn to_native(
		&mut self,
		widget_generator: &mut dyn WidgetGenerator,
		childs: &mut Vec<Box<dyn Widget>>,
		orientation: &Orientation,
		wrap: &Wrap,
		alignment_horizontal: &AlignmentHorizontal,
		alignment_vertical: &AlignmentVertical,
		alignment: &ItemsAlignment,
	) -> Result<NativeWidget, ()> {
		let native_layout = unsafe {
			let orientation = Qt5LinearLayout::convert_orientation(orientation);
			uniui_layout_linear_layout_create(orientation)
		};

		for c in childs.iter_mut() {
			match c.to_native(widget_generator) {
				Ok(native_widget) => unsafe {
					uniui_layout_linear_layout_add_widget(native_layout, native_widget);
				},
				Err(e) => log::error!("child's to_native err:{:?}", e),
			}
		}

		let native_widget = unsafe {
			uniui_layout_linear_layout_create_widget_with_layout(native_layout)
		};

		unsafe {
			self.native.replace(native_widget);
		};

		self.update_wrap(wrap);
		self.update_alignment_horizontal(alignment_horizontal);
		self.update_alignment_vertical(alignment_vertical);
		self.update_alignment(alignment);

		return Ok(native_widget);
	}

	pub fn update_alignment(
		&mut self,
		_alignment: &ItemsAlignment,
	) {
		log::error!("ItemsAlignment not implemented for Qt5. Yet.");
	}

	pub fn update_wrap(
		&mut self,
		_wrap: &Wrap,
	) {
		log::error!("Wrap not implemented for Qt5. Yet.");
	}

	pub fn update_alignment_horizontal(
		&mut self,
		_alignment_horizontal: &AlignmentHorizontal,
	) {
		log::error!("Alignment_horizontal not implemented for Qt5. Yet.");
	}

	pub fn update_alignment_vertical(
		&mut self,
		_alignment_vertical: &AlignmentVertical,
	) {
		log::error!("Alignment_vertical not implemented for Qt5. Yet.");
	}

	unsafe fn convert_orientation(o: &Orientation) -> i32 {
		return match o {
			Orientation::Horizontal => UniUiLayoutLinearLayoutOrientationHorizontal,
			Orientation::Vertical => UniUiLayoutLinearLayoutOrientationVertical,
		};
	}
}