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 scroll_length: [f32; 2],
393
394 pub scroll_progress: [f32; 2],
398
399 pub last_frame_mouse_status: Option<([f32; 2], ClickAim, [f32; 2])>,
403
404 pub scrolled: [bool; 2],
408
409 pub scroll_bar_alpha: [u8; 2],
413
414 pub resource_storage: Vec<PanelStorage>,
418
419 pub tags: Vec<[String; 2]>,
423}
424
425impl RustConstructorResource for ResourcePanel {
426 fn as_any(&self) -> &dyn Any {
427 self
428 }
429
430 fn as_any_mut(&mut self) -> &mut dyn Any {
431 self
432 }
433
434 fn display_display_info(&self) -> Option<DisplayInfo> {
435 None
436 }
437
438 fn modify_display_info(&mut self, _display_info: DisplayInfo) {}
439
440 fn display_tags(&self) -> Vec<[String; 2]> {
441 self.tags.clone()
442 }
443
444 fn modify_tags(&mut self, tags: &[[String; 2]], replace: bool) {
445 if replace {
446 self.tags = tags.to_owned();
447 } else {
448 for tag in tags {
449 if let Some(index) = self.tags.iter().position(|x| x[0] == tag[0]) {
450 self.tags.remove(index);
451 };
452 }
453 self.tags.extend(tags.iter().cloned());
454 };
455 }
456}
457
458impl Default for ResourcePanel {
459 fn default() -> Self {
460 Self {
461 resizable: [true, true, true, true],
462 background: BackgroundType::default(),
463 min_size: [10_f32, 10_f32],
464 max_size: None,
465 movable: [true, true],
466 scroll_length_method: [None, None],
467 scroll_sensitivity: 0_f32,
468 use_smooth_scroll_delta: true,
469 scroll_bar_display_method: ScrollBarDisplayMethod::OnlyScroll(
470 BackgroundType::default(),
471 [4_f32, 2_f32],
472 4_f32,
473 ),
474 overall_layout: (PanelLayout {
475 panel_margin: PanelMargin::Vertical([0_f32, 0_f32, 0_f32, 0_f32], false),
476 panel_location: PanelLocation::Absolute([0_f32, 0_f32]),
477 }),
478 custom_layout: Vec::new(),
479 hidden: false,
480 reverse_scroll_direction: [false, false],
481 inner_margin: [6_f32, 6_f32, 6_f32, 6_f32],
482 scroll_length: [0_f32, 0_f32],
483 scroll_progress: [0_f32, 0_f32],
484 last_frame_mouse_status: None,
485 scrolled: [false, false],
486 scroll_bar_alpha: [0, 0],
487 resource_storage: Vec::new(),
488 tags: Vec::new(),
489 }
490 }
491}
492
493impl ResourcePanel {
494 #[inline]
495 pub fn resizable(mut self, top: bool, bottom: bool, left: bool, right: bool) -> Self {
496 self.resizable = [top, bottom, left, right];
497 self
498 }
499
500 #[inline]
501 pub fn background(mut self, background: &BackgroundType) -> Self {
502 self.background = background.clone();
503 self
504 }
505
506 #[inline]
507 pub fn min_size(mut self, width: f32, height: f32) -> Self {
508 self.min_size = [width, height];
509 self
510 }
511
512 #[inline]
513 pub fn max_size(mut self, max_size: Option<[f32; 2]>) -> Self {
514 self.max_size = max_size;
515 self
516 }
517
518 #[inline]
519 pub fn movable(mut self, horizontal: bool, vertical: bool) -> Self {
520 self.movable = [horizontal, vertical];
521 self
522 }
523
524 #[inline]
525 pub fn scroll_length_method(
526 mut self,
527 horizontal: Option<ScrollLengthMethod>,
528 vertical: Option<ScrollLengthMethod>,
529 ) -> Self {
530 self.scroll_length_method = [horizontal, vertical];
531 self
532 }
533
534 #[inline]
535 pub fn scroll_sensitivity(mut self, scroll_sensitivity: f32) -> Self {
536 self.scroll_sensitivity = scroll_sensitivity;
537 self
538 }
539
540 #[inline]
541 pub fn use_smooth_scroll_delta(mut self, use_smooth_scroll_delta: bool) -> Self {
542 self.use_smooth_scroll_delta = use_smooth_scroll_delta;
543 self
544 }
545
546 #[inline]
547 pub fn scroll_bar_display_method(
548 mut self,
549 scroll_bar_display_method: ScrollBarDisplayMethod,
550 ) -> Self {
551 self.scroll_bar_display_method = scroll_bar_display_method;
552 self
553 }
554
555 #[inline]
556 pub fn overall_layout(mut self, overall_layout: PanelLayout) -> Self {
557 self.overall_layout = overall_layout;
558 self
559 }
560
561 #[inline]
562 pub fn push_custom_layout(mut self, custom_layout: CustomPanelLayout) -> Self {
563 self.custom_layout.push(custom_layout);
564 self
565 }
566
567 #[inline]
568 pub fn custom_layout(mut self, custom_layout: &[CustomPanelLayout]) -> Self {
569 self.custom_layout = custom_layout.to_owned();
570 self
571 }
572
573 #[inline]
574 pub fn hidden(mut self, hidden: bool) -> Self {
575 self.hidden = hidden;
576 self
577 }
578
579 #[inline]
580 pub fn reverse_scroll_direction(mut self, horizontal: bool, vertical: bool) -> Self {
581 self.reverse_scroll_direction = [horizontal, vertical];
582 self
583 }
584
585 #[inline]
586 pub fn inner_margin(mut self, top: f32, bottom: f32, left: f32, right: f32) -> Self {
587 self.inner_margin = [top, bottom, left, right];
588 self
589 }
590
591 #[inline]
592 pub fn tags(mut self, tags: &[[String; 2]], replace: bool) -> Self {
593 if replace {
594 self.tags = tags.to_owned();
595 } else {
596 for tag in tags {
597 if let Some(index) = self.tags.iter().position(|x| x[0] == tag[0]) {
598 self.tags.remove(index);
599 };
600 }
601 self.tags.extend(tags.iter().cloned());
602 };
603 self
604 }
605}
606
607#[derive(Clone, Debug, Default, PartialEq)]
611pub struct SwitchAppearanceConfig {
612 pub background_config: BackgroundType,
616
617 pub text_config: TextConfig,
621
622 pub hint_text_config: TextConfig,
626}
627
628#[derive(Debug, Clone, Copy, PartialEq, Eq)]
632pub struct SwitchClickConfig {
633 pub click_method: PointerButton,
637
638 pub action: bool,
642}
643
644#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
648pub struct SwitchData {
649 pub switched: bool,
653
654 pub last_frame_clicked: Option<usize>,
658
659 pub state: u32,
663}
664
665#[derive(Debug, Clone, PartialEq)]
669pub struct Switch {
670 pub appearance: Vec<SwitchAppearanceConfig>,
674
675 pub background_type: BackgroundType,
679
680 pub text_config: TextConfig,
684
685 pub hint_text_config: TextConfig,
689
690 pub enable_animation: [bool; 2],
694
695 pub state_amount: u32,
699
700 pub click_method: Vec<SwitchClickConfig>,
704
705 pub enable: bool,
709
710 pub state: u32,
714
715 pub last_frame_hovered: bool,
719
720 pub last_frame_clicked: Option<usize>,
724
725 pub switched: bool,
729
730 pub use_switch_tags: bool,
734
735 pub tags: Vec<[String; 2]>,
739}
740
741impl RustConstructorResource for Switch {
742 fn as_any(&self) -> &dyn Any {
743 self
744 }
745
746 fn as_any_mut(&mut self) -> &mut dyn Any {
747 self
748 }
749
750 fn display_display_info(&self) -> Option<DisplayInfo> {
751 None
752 }
753
754 fn modify_display_info(&mut self, _display_info: DisplayInfo) {}
755
756 fn display_tags(&self) -> Vec<[String; 2]> {
757 self.tags.clone()
758 }
759
760 fn modify_tags(&mut self, tags: &[[String; 2]], replace: bool) {
761 if replace {
762 self.tags = tags.to_owned();
763 } else {
764 for tag in tags {
765 if let Some(index) = self.tags.iter().position(|x| x[0] == tag[0]) {
766 self.tags.remove(index);
767 };
768 }
769 self.tags.extend(tags.iter().cloned());
770 };
771 }
772}
773
774impl Default for Switch {
775 fn default() -> Self {
776 Self {
777 appearance: vec![],
778 background_type: BackgroundType::default(),
779 text_config: TextConfig::default(),
780 hint_text_config: TextConfig::default(),
781 enable_animation: [false, false],
782 state_amount: 0,
783 click_method: vec![],
784 enable: true,
785 state: 0,
786 last_frame_hovered: false,
787 last_frame_clicked: None,
788 switched: false,
789 use_switch_tags: false,
790 tags: Vec::new(),
791 }
792 }
793}
794
795impl Switch {
796 #[inline]
797 pub fn appearance(mut self, appearance: &[SwitchAppearanceConfig]) -> Self {
798 self.appearance = appearance.to_owned();
799 self
800 }
801
802 #[inline]
803 pub fn background_type(mut self, background_type: &BackgroundType) -> Self {
804 self.background_type = background_type.clone();
805 self
806 }
807
808 #[inline]
809 pub fn text_config(mut self, text_config: &TextConfig) -> Self {
810 self.text_config = text_config.clone();
811 self
812 }
813
814 #[inline]
815 pub fn hint_text_config(mut self, hint_text_config: &TextConfig) -> Self {
816 self.hint_text_config = hint_text_config.clone();
817 self
818 }
819
820 #[inline]
821 pub fn enable_animation(mut self, enable_hover: bool, enable_click: bool) -> Self {
822 self.enable_animation = [enable_hover, enable_click];
823 self
824 }
825
826 #[inline]
827 pub fn state_amount(mut self, state_amount: u32) -> Self {
828 self.state_amount = state_amount;
829 self
830 }
831
832 #[inline]
833 pub fn click_method(mut self, click_method: Vec<SwitchClickConfig>) -> Self {
834 self.click_method = click_method;
835 self
836 }
837
838 #[inline]
839 pub fn enable(mut self, enable: bool) -> Self {
840 self.enable = enable;
841 self
842 }
843
844 #[inline]
845 pub fn state(mut self, state: u32) -> Self {
846 self.state = state;
847 self
848 }
849
850 #[inline]
851 pub fn use_switch_tags(mut self, use_switch_tags: bool) -> Self {
852 self.use_switch_tags = use_switch_tags;
853 self
854 }
855
856 #[inline]
857 pub fn tags(mut self, tags: &[[String; 2]], replace: bool) -> Self {
858 if replace {
859 self.tags = tags.to_owned();
860 } else {
861 for tag in tags {
862 if let Some(index) = self.tags.iter().position(|x| x[0] == tag[0]) {
863 self.tags.remove(index);
864 };
865 }
866 self.tags.extend(tags.iter().cloned());
867 };
868 self
869 }
870}