1use crate::{
5 DisplayInfo, RustConstructorId, RustConstructorResource,
6 basic_front::{CustomRectConfig, ImageConfig, TextConfig},
7};
8use eframe::egui::PointerButton;
9use std::any::Any;
10
11#[derive(Clone, Debug, PartialEq)]
15pub enum BackgroundType {
16 Image(ImageConfig),
20
21 CustomRect(CustomRectConfig),
25}
26
27impl Default for BackgroundType {
28 fn default() -> Self {
29 BackgroundType::CustomRect(CustomRectConfig::default())
30 }
31}
32
33#[derive(Clone, Debug, Default, PartialEq)]
37pub struct Background {
38 pub background_type: BackgroundType,
42
43 pub auto_update: bool,
47
48 pub use_background_tags: bool,
52
53 pub tags: Vec<[String; 2]>,
57}
58
59impl RustConstructorResource for Background {
60 fn as_any(&self) -> &dyn Any {
61 self
62 }
63
64 fn as_any_mut(&mut self) -> &mut dyn Any {
65 self
66 }
67
68 fn display_display_info(&self) -> Option<DisplayInfo> {
69 None
70 }
71
72 fn modify_display_info(&mut self, _display_info: DisplayInfo) {}
73
74 fn display_tags(&self) -> Vec<[String; 2]> {
75 self.tags.clone()
76 }
77
78 fn modify_tags(&mut self, tags: &[[String; 2]], replace: bool) {
79 if replace {
80 self.tags = tags.to_owned();
81 } else {
82 for tag in tags {
83 if let Some(index) = self.tags.iter().position(|x| x[0] == tag[0]) {
84 self.tags.remove(index);
85 };
86 }
87 self.tags.extend(tags.iter().cloned());
88 };
89 }
90}
91
92impl Background {
93 #[inline]
94 pub fn background_type(mut self, background_type: &BackgroundType) -> Self {
95 self.background_type = background_type.clone();
96 self
97 }
98
99 #[inline]
100 pub fn auto_update(mut self, auto_update: bool) -> Self {
101 self.auto_update = auto_update;
102 self
103 }
104
105 #[inline]
106 pub fn use_background_tags(mut self, use_background_tags: bool) -> Self {
107 self.use_background_tags = use_background_tags;
108 self
109 }
110
111 #[inline]
112 pub fn tags(mut self, tags: &[[String; 2]], replace: bool) -> Self {
113 if replace {
114 self.tags = tags.to_owned();
115 } else {
116 for tag in tags {
117 if let Some(index) = self.tags.iter().position(|x| x[0] == tag[0]) {
118 self.tags.remove(index);
119 };
120 }
121 self.tags.extend(tags.iter().cloned());
122 };
123 self
124 }
125}
126
127#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
131pub enum ScrollLengthMethod {
132 Fixed(f32),
136 AutoFit(f32),
140}
141
142#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
150pub enum ClickAim {
151 Move,
155 TopResize,
159 BottomResize,
163 LeftResize,
167 RightResize,
171 LeftTopResize,
175 RightTopResize,
179 LeftBottomResize,
183 RightBottomResize,
187}
188
189#[derive(Debug, Clone, PartialEq)]
197pub enum ScrollBarDisplayMethod {
198 Always(BackgroundType, [f32; 2], f32),
202 OnlyScroll(BackgroundType, [f32; 2], f32),
206 Hidden,
210}
211
212#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
220pub enum PanelMargin {
221 Vertical([f32; 4], bool),
225 Horizontal([f32; 4], bool),
229 None([f32; 4], bool),
233}
234
235#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
239pub struct PanelLayout {
240 pub panel_margin: PanelMargin,
244 pub panel_location: PanelLocation,
248}
249
250#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
258pub enum PanelLocation {
259 Absolute([f32; 2]),
263 Relative([[f32; 2]; 2]),
267}
268
269#[derive(Debug, Clone, PartialEq, PartialOrd)]
273pub enum CustomPanelLayout {
274 Type(String, PanelLayout),
278 Id(RustConstructorId, PanelLayout),
282}
283
284#[derive(Debug, Default, Clone, PartialEq, PartialOrd)]
293pub struct PanelStorage {
294 pub id: RustConstructorId,
298
299 pub ignore_render_layer: bool,
303
304 pub hidden: bool,
308}
309
310#[derive(Debug, Clone, PartialEq)]
314pub struct ResourcePanel {
315 pub resizable: [bool; 4],
319
320 pub background: BackgroundType,
324
325 pub min_size: [f32; 2],
329
330 pub max_size: Option<[f32; 2]>,
334
335 pub movable: [bool; 2],
339
340 pub scroll_length_method: [Option<ScrollLengthMethod>; 2],
344
345 pub scroll_sensitivity: f32,
349
350 pub use_smooth_scroll_delta: bool,
354
355 pub scroll_bar_display_method: ScrollBarDisplayMethod,
359
360 pub overall_layout: PanelLayout,
364
365 pub custom_layout: Vec<CustomPanelLayout>,
369
370 pub hidden: bool,
374
375 pub reverse_scroll_direction: [bool; 2],
379
380 pub inner_margin: [f32; 4],
388
389 pub raise_on_focus: bool,
393
394 pub scroll_length: [f32; 2],
398
399 pub scroll_progress: [f32; 2],
403
404 pub last_frame_mouse_status: Option<([f32; 2], ClickAim, [f32; 2])>,
408
409 pub scrolled: [bool; 2],
413
414 pub scroll_bar_alpha: [u8; 2],
418
419 pub resource_storage: Vec<PanelStorage>,
423
424 pub tags: Vec<[String; 2]>,
428}
429
430impl RustConstructorResource for ResourcePanel {
431 fn as_any(&self) -> &dyn Any {
432 self
433 }
434
435 fn as_any_mut(&mut self) -> &mut dyn Any {
436 self
437 }
438
439 fn display_display_info(&self) -> Option<DisplayInfo> {
440 None
441 }
442
443 fn modify_display_info(&mut self, _display_info: DisplayInfo) {}
444
445 fn display_tags(&self) -> Vec<[String; 2]> {
446 self.tags.clone()
447 }
448
449 fn modify_tags(&mut self, tags: &[[String; 2]], replace: bool) {
450 if replace {
451 self.tags = tags.to_owned();
452 } else {
453 for tag in tags {
454 if let Some(index) = self.tags.iter().position(|x| x[0] == tag[0]) {
455 self.tags.remove(index);
456 };
457 }
458 self.tags.extend(tags.iter().cloned());
459 };
460 }
461}
462
463impl Default for ResourcePanel {
464 fn default() -> Self {
465 Self {
466 resizable: [true, true, true, true],
467 background: BackgroundType::default(),
468 min_size: [10_f32, 10_f32],
469 max_size: None,
470 movable: [true, true],
471 scroll_length_method: [None, None],
472 scroll_sensitivity: 0_f32,
473 use_smooth_scroll_delta: true,
474 scroll_bar_display_method: ScrollBarDisplayMethod::OnlyScroll(
475 BackgroundType::default(),
476 [4_f32, 2_f32],
477 4_f32,
478 ),
479 overall_layout: (PanelLayout {
480 panel_margin: PanelMargin::Vertical([0_f32, 0_f32, 0_f32, 0_f32], false),
481 panel_location: PanelLocation::Absolute([0_f32, 0_f32]),
482 }),
483 custom_layout: Vec::new(),
484 hidden: false,
485 reverse_scroll_direction: [false, false],
486 inner_margin: [6_f32, 6_f32, 6_f32, 6_f32],
487 raise_on_focus: true,
488 scroll_length: [0_f32, 0_f32],
489 scroll_progress: [0_f32, 0_f32],
490 last_frame_mouse_status: None,
491 scrolled: [false, false],
492 scroll_bar_alpha: [0, 0],
493 resource_storage: Vec::new(),
494 tags: Vec::new(),
495 }
496 }
497}
498
499impl ResourcePanel {
500 #[inline]
501 pub fn resizable(mut self, top: bool, bottom: bool, left: bool, right: bool) -> Self {
502 self.resizable = [top, bottom, left, right];
503 self
504 }
505
506 #[inline]
507 pub fn background(mut self, background: &BackgroundType) -> Self {
508 self.background = background.clone();
509 self
510 }
511
512 #[inline]
513 pub fn min_size(mut self, width: f32, height: f32) -> Self {
514 self.min_size = [width, height];
515 self
516 }
517
518 #[inline]
519 pub fn max_size(mut self, max_size: Option<[f32; 2]>) -> Self {
520 self.max_size = max_size;
521 self
522 }
523
524 #[inline]
525 pub fn movable(mut self, horizontal: bool, vertical: bool) -> Self {
526 self.movable = [horizontal, vertical];
527 self
528 }
529
530 #[inline]
531 pub fn scroll_length_method(
532 mut self,
533 horizontal: Option<ScrollLengthMethod>,
534 vertical: Option<ScrollLengthMethod>,
535 ) -> Self {
536 self.scroll_length_method = [horizontal, vertical];
537 self
538 }
539
540 #[inline]
541 pub fn scroll_sensitivity(mut self, scroll_sensitivity: f32) -> Self {
542 self.scroll_sensitivity = scroll_sensitivity;
543 self
544 }
545
546 #[inline]
547 pub fn use_smooth_scroll_delta(mut self, use_smooth_scroll_delta: bool) -> Self {
548 self.use_smooth_scroll_delta = use_smooth_scroll_delta;
549 self
550 }
551
552 #[inline]
553 pub fn scroll_bar_display_method(
554 mut self,
555 scroll_bar_display_method: ScrollBarDisplayMethod,
556 ) -> Self {
557 self.scroll_bar_display_method = scroll_bar_display_method;
558 self
559 }
560
561 #[inline]
562 pub fn overall_layout(mut self, overall_layout: PanelLayout) -> Self {
563 self.overall_layout = overall_layout;
564 self
565 }
566
567 #[inline]
568 pub fn push_custom_layout(mut self, custom_layout: CustomPanelLayout) -> Self {
569 self.custom_layout.push(custom_layout);
570 self
571 }
572
573 #[inline]
574 pub fn custom_layout(mut self, custom_layout: &[CustomPanelLayout]) -> Self {
575 self.custom_layout = custom_layout.to_owned();
576 self
577 }
578
579 #[inline]
580 pub fn hidden(mut self, hidden: bool) -> Self {
581 self.hidden = hidden;
582 self
583 }
584
585 #[inline]
586 pub fn reverse_scroll_direction(mut self, horizontal: bool, vertical: bool) -> Self {
587 self.reverse_scroll_direction = [horizontal, vertical];
588 self
589 }
590
591 #[inline]
592 pub fn inner_margin(mut self, top: f32, bottom: f32, left: f32, right: f32) -> Self {
593 self.inner_margin = [top, bottom, left, right];
594 self
595 }
596
597 #[inline]
598 pub fn raise_on_focus(mut self, raise_on_focus: bool) -> Self {
599 self.raise_on_focus = raise_on_focus;
600 self
601 }
602
603 #[inline]
604 pub fn tags(mut self, tags: &[[String; 2]], replace: bool) -> Self {
605 if replace {
606 self.tags = tags.to_owned();
607 } else {
608 for tag in tags {
609 if let Some(index) = self.tags.iter().position(|x| x[0] == tag[0]) {
610 self.tags.remove(index);
611 };
612 }
613 self.tags.extend(tags.iter().cloned());
614 };
615 self
616 }
617}
618
619#[derive(Clone, Debug, Default, PartialEq)]
623pub struct SwitchAppearanceConfig {
624 pub background_config: BackgroundType,
628
629 pub text_config: TextConfig,
633
634 pub hint_text_config: TextConfig,
638}
639
640#[derive(Debug, Clone, Copy, PartialEq, Eq)]
644pub struct SwitchClickConfig {
645 pub click_method: PointerButton,
649
650 pub action: bool,
654}
655
656#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
660pub struct SwitchData {
661 pub switched: bool,
665
666 pub last_frame_clicked: Option<usize>,
670
671 pub state: usize,
675}
676
677#[derive(Debug, Clone, PartialEq)]
681pub struct Switch {
682 pub appearance: Vec<SwitchAppearanceConfig>,
686
687 pub background_type: BackgroundType,
691
692 pub text_config: TextConfig,
696
697 pub hint_text_config: TextConfig,
701
702 pub enable_animation: [bool; 2],
706
707 pub state_amount: u32,
711
712 pub click_method: Vec<SwitchClickConfig>,
716
717 pub radio_group: String,
725
726 pub enable: bool,
730
731 pub state: usize,
735
736 pub last_frame_hovered: bool,
740
741 pub last_frame_clicked: Option<usize>,
745
746 pub switched: bool,
750
751 pub use_switch_tags: bool,
755
756 pub tags: Vec<[String; 2]>,
760}
761
762impl RustConstructorResource for Switch {
763 fn as_any(&self) -> &dyn Any {
764 self
765 }
766
767 fn as_any_mut(&mut self) -> &mut dyn Any {
768 self
769 }
770
771 fn display_display_info(&self) -> Option<DisplayInfo> {
772 None
773 }
774
775 fn modify_display_info(&mut self, _display_info: DisplayInfo) {}
776
777 fn display_tags(&self) -> Vec<[String; 2]> {
778 self.tags.clone()
779 }
780
781 fn modify_tags(&mut self, tags: &[[String; 2]], replace: bool) {
782 if replace {
783 self.tags = tags.to_owned();
784 } else {
785 for tag in tags {
786 if let Some(index) = self.tags.iter().position(|x| x[0] == tag[0]) {
787 self.tags.remove(index);
788 };
789 }
790 self.tags.extend(tags.iter().cloned());
791 };
792 }
793}
794
795impl Default for Switch {
796 fn default() -> Self {
797 Self {
798 appearance: vec![],
799 background_type: BackgroundType::default(),
800 text_config: TextConfig::default(),
801 hint_text_config: TextConfig::default(),
802 enable_animation: [false, false],
803 state_amount: 0,
804 click_method: vec![],
805 radio_group: String::new(),
806 enable: true,
807 state: 0,
808 last_frame_hovered: false,
809 last_frame_clicked: None,
810 switched: false,
811 use_switch_tags: false,
812 tags: Vec::new(),
813 }
814 }
815}
816
817impl Switch {
818 #[inline]
819 pub fn appearance(mut self, appearance: &[SwitchAppearanceConfig]) -> Self {
820 self.appearance = appearance.to_owned();
821 self
822 }
823
824 #[inline]
825 pub fn background_type(mut self, background_type: &BackgroundType) -> Self {
826 self.background_type = background_type.clone();
827 self
828 }
829
830 #[inline]
831 pub fn text_config(mut self, text_config: &TextConfig) -> Self {
832 self.text_config = text_config.clone();
833 self
834 }
835
836 #[inline]
837 pub fn hint_text_config(mut self, hint_text_config: &TextConfig) -> Self {
838 self.hint_text_config = hint_text_config.clone();
839 self
840 }
841
842 #[inline]
843 pub fn enable_animation(mut self, enable_hover: bool, enable_click: bool) -> Self {
844 self.enable_animation = [enable_hover, enable_click];
845 self
846 }
847
848 #[inline]
849 pub fn state_amount(mut self, state_amount: u32) -> Self {
850 self.state_amount = state_amount;
851 self
852 }
853
854 #[inline]
855 pub fn click_method(mut self, click_method: Vec<SwitchClickConfig>) -> Self {
856 self.click_method = click_method;
857 self
858 }
859
860 #[inline]
861 pub fn radio_group(mut self, radio_group: &str) -> Self {
862 self.radio_group = radio_group.to_string();
863 self
864 }
865
866 #[inline]
867 pub fn enable(mut self, enable: bool) -> Self {
868 self.enable = enable;
869 self
870 }
871
872 #[inline]
873 pub fn state(mut self, state: usize) -> Self {
874 self.state = state;
875 self
876 }
877
878 #[inline]
879 pub fn use_switch_tags(mut self, use_switch_tags: bool) -> Self {
880 self.use_switch_tags = use_switch_tags;
881 self
882 }
883
884 #[inline]
885 pub fn tags(mut self, tags: &[[String; 2]], replace: bool) -> Self {
886 if replace {
887 self.tags = tags.to_owned();
888 } else {
889 for tag in tags {
890 if let Some(index) = self.tags.iter().position(|x| x[0] == tag[0]) {
891 self.tags.remove(index);
892 };
893 }
894 self.tags.extend(tags.iter().cloned());
895 };
896 self
897 }
898}