1#[cfg(feature = "app-basicmenu-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 bitfield32::{BitField32, IBitField32},
11 bitfieldcommon::{BitFieldCommon, IBitFieldCommon},
12 bitfieldtemplate32_1::{BitFieldTemplate32_1, IBitFieldTemplate32_1},
13 procinst::{IProcInst, ProcInst},
14 },
15 system::{
16 object::{IObject, Object},
17 r#enum::{Enum, IEnum},
18 valuetype::{IValueType, ValueType},
19 },
20 };
21
22 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/basicmenu/BasicMenu_Result.md"))]
23 #[repr(C)]
24 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
25 pub struct BasicMenu_Result {
26 pub value: i32,
27 }
28 impl ::unity::ClassIdentity for BasicMenu_Result {
29 const NAME: &'static str = "BasicMenu.Result";
30 const NAMESPACE: &'static str = "App";
31
32 fn class() -> ::unity::Class {
33 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
34 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
35 }
36 }
37 impl ::unity::IlType for BasicMenu_Result {
38 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
39 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
40 }
41 }
42 impl BasicMenu_Result {
43 pub fn close_this() -> Self {
44 Self { value: 1 }
45 }
46
47 pub fn close_parent() -> Self {
48 Self { value: 2 }
49 }
50
51 pub fn close_all() -> Self {
52 Self { value: 4 }
53 }
54
55 pub fn delete_this() -> Self {
56 Self { value: 8 }
57 }
58
59 pub fn delete_parent() -> Self {
60 Self { value: 16 }
61 }
62
63 pub fn delete_all() -> Self {
64 Self { value: 32 }
65 }
66
67 pub fn se_decide() -> Self {
68 Self { value: 128 }
69 }
70
71 pub fn se_decide2() -> Self {
72 Self { value: 256 }
73 }
74
75 pub fn se_cancel() -> Self {
76 Self { value: 512 }
77 }
78
79 pub fn se_miss() -> Self {
80 Self { value: 2048 }
81 }
82
83 pub fn se_cursor() -> Self {
84 Self { value: 4096 }
85 }
86
87 pub fn do_nothing() -> Self {
88 Self { value: 8192 }
89 }
90
91 pub fn pass() -> Self {
92 Self { value: 0 }
93 }
94
95 pub fn close_decide() -> Self {
96 Self { value: 129 }
97 }
98
99 pub fn close_parent_decide() -> Self {
100 Self { value: 130 }
101 }
102
103 pub fn close_all_decide() -> Self {
104 Self { value: 132 }
105 }
106
107 pub fn close_decide2() -> Self {
108 Self { value: 257 }
109 }
110
111 pub fn close_parent_decide2() -> Self {
112 Self { value: 258 }
113 }
114
115 pub fn close_all_decide2() -> Self {
116 Self { value: 260 }
117 }
118
119 pub fn close_cancel() -> Self {
120 Self { value: 513 }
121 }
122
123 pub fn close_parent_cancel() -> Self {
124 Self { value: 514 }
125 }
126
127 pub fn close_all_cancel() -> Self {
128 Self { value: 516 }
129 }
130
131 pub fn delete_decide() -> Self {
132 Self { value: 136 }
133 }
134
135 pub fn delete_parent_decide() -> Self {
136 Self { value: 144 }
137 }
138
139 pub fn delete_all_decide() -> Self {
140 Self { value: 160 }
141 }
142
143 pub fn delete_decide2() -> Self {
144 Self { value: 264 }
145 }
146
147 pub fn delete_parent_decide2() -> Self {
148 Self { value: 272 }
149 }
150
151 pub fn delete_all_decide2() -> Self {
152 Self { value: 288 }
153 }
154
155 pub fn delete_cancel() -> Self {
156 Self { value: 520 }
157 }
158
159 pub fn delete_parent_cancel() -> Self {
160 Self { value: 528 }
161 }
162
163 pub fn delete_all_cancel() -> Self {
164 Self { value: 544 }
165 }
166
167 pub fn failure() -> Self {
168 Self { value: 2048 }
169 }
170 }
171
172 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/basicmenu/BasicMenu_BindTypes.md"))]
173 #[repr(C)]
174 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
175 pub struct BasicMenu_BindTypes {
176 pub value: i32,
177 }
178 impl ::unity::ClassIdentity for BasicMenu_BindTypes {
179 const NAME: &'static str = "BasicMenu.BindTypes";
180 const NAMESPACE: &'static str = "App";
181
182 fn class() -> ::unity::Class {
183 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
184 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
185 }
186 }
187 impl ::unity::IlType for BasicMenu_BindTypes {
188 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
189 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
190 }
191 }
192 impl BasicMenu_BindTypes {
193 pub fn none() -> Self {
194 Self { value: 0 }
195 }
196
197 pub fn dark() -> Self {
198 Self { value: 1 }
199 }
200
201 pub fn hide() -> Self {
202 Self { value: 2 }
203 }
204 }
205
206 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/basicmenu/BasicMenu_Status.md"))]
207 #[repr(C)]
208 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
209 pub struct BasicMenu_Status {
210 pub value: i32,
211 }
212 impl ::unity::ClassIdentity for BasicMenu_Status {
213 const NAME: &'static str = "BasicMenu.Status";
214 const NAMESPACE: &'static str = "App";
215
216 fn class() -> ::unity::Class {
217 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
218 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
219 }
220 }
221 impl ::unity::IlType for BasicMenu_Status {
222 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
223 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
224 }
225 }
226 impl BasicMenu_Status {
227 pub fn cursor_hide() -> Self {
228 Self { value: 2 }
229 }
230
231 pub fn input_disable() -> Self {
232 Self { value: 4 }
233 }
234
235 pub fn input_disable_now_frame() -> Self {
236 Self { value: 8 }
237 }
238
239 pub fn bind_parent() -> Self {
240 Self { value: 16 }
241 }
242
243 pub fn rebuild() -> Self {
244 Self { value: 32 }
245 }
246
247 pub fn cursor_moved() -> Self {
248 Self { value: 64 }
249 }
250
251 pub fn close_called() -> Self {
252 Self { value: 128 }
253 }
254
255 pub fn first_blank_enable() -> Self {
256 Self { value: 256 }
257 }
258
259 pub fn side_page_move() -> Self {
260 Self { value: 512 }
261 }
262
263 pub fn rebuild_keep_index() -> Self {
264 Self { value: 1024 }
265 }
266 }
267
268 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/basicmenu/BasicMenu_StatusField.md"))]
269 #[::unity::class(namespace = "App", name = "BasicMenu.StatusField")]
270 #[parent(crate::app::bitfieldtemplate32_1::BitFieldTemplate32_1<crate::app::basicmenu::BasicMenu_Status>)]
271 pub struct BasicMenu_StatusField {}
272
273 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/basicmenu/BasicMenu.md"))]
274 #[::unity::class(namespace = "App", name = "BasicMenu")]
275 #[parent(crate::app::procinst::ProcInst)]
276 pub struct BasicMenu {
277 #[offset(112)]
278 #[rename(name = "m_menuContent")]
279 pub m_menu_content: crate::app::basicmenucontent::BasicMenuContent,
280 #[offset(120)]
281 #[rename(name = "m_menuItemList")]
282 pub m_menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
283 #[offset(128)]
284 #[rename(name = "m_fullMenuItemList")]
285 pub m_full_menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
286 #[offset(136)]
287 #[rename(name = "m_status")]
288 pub m_status: crate::app::basicmenu::BasicMenu_StatusField,
289 #[offset(144)]
290 #[rename(name = "m_result")]
291 pub m_result: crate::app::basicmenu::BasicMenu_Result,
292 #[offset(148)]
293 #[rename(name = "m_scrollPrecedeInputA")]
294 pub m_scroll_precede_input_a: bool,
295 #[offset(152)]
296 #[rename(name = "m_rowNum")]
297 pub m_row_num: i32,
298 #[offset(156)]
299 #[rename(name = "m_showRowNum")]
300 pub m_show_row_num: i32,
301 #[offset(160)]
302 #[rename(name = "m_selectIndex")]
303 pub m_select_index: i32,
304 #[offset(164)]
305 #[rename(name = "m_selectIndexOld")]
306 pub m_select_index_old: i32,
307 #[offset(168)]
308 #[rename(name = "m_scrollIndex")]
309 pub m_scroll_index: i32,
310 #[offset(172)]
311 #[rename(name = "m_scrollIndexOld")]
312 pub m_scroll_index_old: i32,
313 #[offset(176)]
314 #[rename(name = "m_reservedSelectIndex")]
315 pub m_reserved_select_index: i32,
316 #[offset(180)]
317 #[rename(name = "m_reservedScrollIndex")]
318 pub m_reserved_scroll_index: i32,
319 #[offset(184)]
320 #[rename(name = "m_reservedShowRowNum")]
321 pub m_reserved_show_row_num: i32,
322 #[offset(188)]
323 #[rename(name = "m_memoryDisplayIndex")]
324 pub m_memory_display_index: i32,
325 #[offset(192)]
326 #[rename(name = "m_suspend")]
327 pub m_suspend: i32,
328 }
329
330 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/basicmenu/BasicMenu_AnchorType.md"))]
331 #[repr(C)]
332 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
333 pub struct BasicMenu_AnchorType {
334 pub value: i32,
335 }
336 impl ::unity::ClassIdentity for BasicMenu_AnchorType {
337 const NAME: &'static str = "BasicMenu.AnchorType";
338 const NAMESPACE: &'static str = "App";
339
340 fn class() -> ::unity::Class {
341 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
342 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
343 }
344 }
345 impl ::unity::IlType for BasicMenu_AnchorType {
346 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
347 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
348 }
349 }
350 impl BasicMenu_AnchorType {
351 pub fn unity_editor() -> Self {
352 Self { value: 0 }
353 }
354
355 pub fn left_top() -> Self {
356 Self { value: 1 }
357 }
358
359 pub fn center_top() -> Self {
360 Self { value: 2 }
361 }
362
363 pub fn right_top() -> Self {
364 Self { value: 3 }
365 }
366
367 pub fn left() -> Self {
368 Self { value: 4 }
369 }
370
371 pub fn center() -> Self {
372 Self { value: 5 }
373 }
374
375 pub fn right() -> Self {
376 Self { value: 6 }
377 }
378
379 pub fn left_bottom() -> Self {
380 Self { value: 7 }
381 }
382
383 pub fn center_bottom() -> Self {
384 Self { value: 8 }
385 }
386
387 pub fn right_bottom() -> Self {
388 Self { value: 9 }
389 }
390 }
391
392 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/basicmenu/BasicMenu_Label0.md"))]
393 #[repr(C)]
394 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
395 pub struct BasicMenu_Label0 {
396 pub value: i32,
397 }
398 impl ::unity::ClassIdentity for BasicMenu_Label0 {
399 const NAME: &'static str = "BasicMenu.Label0";
400 const NAMESPACE: &'static str = "App";
401
402 fn class() -> ::unity::Class {
403 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
404 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
405 }
406 }
407 impl ::unity::IlType for BasicMenu_Label0 {
408 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
409 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
410 }
411 }
412 impl BasicMenu_Label0 {
413 pub fn build() -> Self {
414 Self { value: 0 }
415 }
416
417 pub fn after_build() -> Self {
418 Self { value: 1 }
419 }
420
421 pub fn opening() -> Self {
422 Self { value: 2 }
423 }
424
425 pub fn r#loop() -> Self {
426 Self { value: 3 }
427 }
428
429 pub fn end() -> Self {
430 Self { value: 4 }
431 }
432 }
433}
434
435#[cfg(feature = "app-basicmenu-types")]
436pub use __types::*;
437
438#[cfg(feature = "app-basicmenu")]
439pub trait IBasicMenu_StatusFieldMethods: IBasicMenu_StatusField {
440 #[doc = "`ToInt(crate::app::basicmenu::BasicMenu_Status)` overload"]
441 fn to_int(self, value: impl ::core::convert::Into<crate::app::basicmenu::BasicMenu_Status>) -> i32 {
442 unsafe {
443 let __receiver = <BasicMenu_StatusField as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
444 {
445 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
446 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
447 panic!(
448 "unity: virtual slot {}
449 out of range (vtable len {}
450) on the runtime class behind {}
451 (method `{}
452`)",
453 5usize,
454 __vt.len(),
455 <BasicMenu_StatusField as ::unity::ClassIdentity>::NAME,
456 "ToInt",
457 )
458 });
459 let __inner: extern "C" fn(BasicMenu_StatusField, crate::app::basicmenu::BasicMenu_Status, ::unity::OptionalMethod) -> i32 =
460 ::core::mem::transmute(__vi.method_ptr);
461 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
462 __inner(__receiver, ::core::convert::Into::into(value), __mi)
463 }
464 }
465 }
466 #[doc = "`.ctor()` overload"]
467 fn ctor(self) -> () {
468 unsafe {
469 let __receiver = <BasicMenu_StatusField as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
470 ::unity::il2cpp_call!((::unity::module_base()+0x1bb8670usize)as*mut u8,();
471(BasicMenu_StatusField)__receiver)
472 }
473 }
474}
475
476#[cfg(feature = "app-basicmenu")]
477impl<__T: IBasicMenu_StatusField> IBasicMenu_StatusFieldMethods for __T {}
478
479#[cfg(feature = "app-basicmenu")]
480impl BasicMenu_StatusField {
481 pub fn to_int_method_info() -> &'static ::unity::il2cpp::MethodInfo {
482 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
483 }
484
485 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
486 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
487 }
488}
489
490#[cfg(feature = "app-basicmenu")]
491impl BasicMenu_StatusField {
492 #[doc = "Direct (non-virtual) call to `BasicMenu_StatusField`'s own `ToInt`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
493 pub unsafe fn to_int(this: impl ::core::convert::Into<::unity::IlInstance>, value: crate::app::basicmenu::BasicMenu_Status) -> i32 {
494 let __mi = Self::to_int_method_info();
495 let __inner: extern "C" fn(::unity::IlInstance, crate::app::basicmenu::BasicMenu_Status, ::unity::OptionalMethod) -> i32 =
496 ::core::mem::transmute(__mi.method_ptr);
497 __inner(this.into(), value, ::core::option::Option::None)
498 }
499}
500
501#[cfg(feature = "app-basicmenu")]
502impl BasicMenu_StatusField {
503 #[doc = "`.ctor()` — no args"]
504 pub fn new() -> Self {
505 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
506 panic!(
507 "{}
508::{}
509 failed to instantiate",
510 ::core::stringify!(BasicMenu_StatusField),
511 ::core::stringify!(new),
512 )
513 });
514 <Self as IBasicMenu_StatusFieldMethods>::ctor(this);
515 this
516 }
517}
518
519#[cfg(feature = "app-basicmenu")]
520impl BasicMenu {
521 #[doc = "`AnchorPositionToAnchorType(f32, f32)` overload"]
522 pub fn anchor_position_to_anchor_type(
523 x: impl ::core::convert::Into<f32>,
524 y: impl ::core::convert::Into<f32>,
525 ) -> crate::app::basicmenu::BasicMenu_AnchorType {
526 unsafe {
527 ::unity::il2cpp_call!((::unity::module_base()+0x245e110usize)as*mut u8,crate::app::basicmenu::BasicMenu_AnchorType;
528(f32)::core::convert::Into::into(x),(f32)::core::convert::Into::into(y))
529 }
530 }
531
532 #[doc = "`CreateBasicMenuCommon(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::procinst::ProcInst, bool)` overload"]
533 pub fn create_basic_menu_common(
534 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
535 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
536 is_bind: impl ::core::convert::Into<bool>,
537 ) -> crate::app::basicmenu::BasicMenu {
538 unsafe {
539 ::unity::il2cpp_call!((::unity::module_base()+0x2462180usize)as*mut u8,crate::app::basicmenu::BasicMenu;
540(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list),(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(bool)::core::convert::Into::into(is_bind))
541 }
542 }
543
544 #[doc = "`CreateDummy()` overload"]
545 pub fn create_dummy() -> () {
546 unsafe {
547 ::unity::il2cpp_call!((::unity::module_base()+0x2462370usize)as*mut u8,();
548 )
549 }
550 }
551
552 #[doc = "`CreateBasicMenuNoBind(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::procinst::ProcInst)` overload"]
553 pub fn create_basic_menu_no_bind(
554 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
555 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
556 ) -> crate::app::basicmenu::BasicMenu {
557 unsafe {
558 ::unity::il2cpp_call!((::unity::module_base()+0x2462720usize)as*mut u8,crate::app::basicmenu::BasicMenu;
559(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list),(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
560 }
561 }
562
563 #[doc = "`CreateBasicMenuBind(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::procinst::ProcInst)` overload"]
564 pub fn create_basic_menu_bind(
565 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
566 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
567 ) -> crate::app::basicmenu::BasicMenu {
568 unsafe {
569 ::unity::il2cpp_call!((::unity::module_base()+0x2462730usize)as*mut u8,crate::app::basicmenu::BasicMenu;
570(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list),(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
571 }
572 }
573}
574
575#[cfg(feature = "app-basicmenu")]
576pub trait IBasicMenuMethods: IBasicMenu {
577 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::basicmenucontent::BasicMenuContent)` overload"]
578 fn ctor(
579 self,
580 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
581 menu_content: impl ::core::convert::Into<crate::app::basicmenucontent::BasicMenuContent>,
582 ) -> () {
583 unsafe {
584 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
585 ::unity::il2cpp_call!((::unity::module_base()+0x24533f0usize)as*mut u8,();
586(BasicMenu)__receiver,(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list),(crate::app::basicmenucontent::BasicMenuContent)::core::convert::Into::into(menu_content))
587 }
588 }
589 #[doc = "`CreateDefaultDesc()` overload"]
590 fn create_default_desc(self) -> ::unity::Array<crate::app::procdesc::ProcDesc> {
591 unsafe {
592 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
593 {
594 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
595 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
596 panic!(
597 "unity: virtual slot {}
598 out of range (vtable len {}
599) on the runtime class behind {}
600 (method `{}
601`)",
602 18usize,
603 __vt.len(),
604 <BasicMenu as ::unity::ClassIdentity>::NAME,
605 "CreateDefaultDesc",
606 )
607 });
608 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> ::unity::Array<crate::app::procdesc::ProcDesc> =
609 ::core::mem::transmute(__vi.method_ptr);
610 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
611 __inner(__receiver, __mi)
612 }
613 }
614 }
615 #[doc = "`get_BindType()` overload"]
616 fn get_bind_type(self) -> crate::app::basicmenu::BasicMenu_BindTypes {
617 unsafe {
618 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
619 {
620 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
621 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
622 panic!(
623 "unity: virtual slot {}
624 out of range (vtable len {}
625) on the runtime class behind {}
626 (method `{}
627`)",
628 19usize,
629 __vt.len(),
630 <BasicMenu as ::unity::ClassIdentity>::NAME,
631 "get_BindType",
632 )
633 });
634 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_BindTypes =
635 ::core::mem::transmute(__vi.method_ptr);
636 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
637 __inner(__receiver, __mi)
638 }
639 }
640 }
641 #[doc = "`OnBind()` overload"]
642 fn on_bind(self) -> () {
643 unsafe {
644 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
645 {
646 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
647 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
648 panic!(
649 "unity: virtual slot {}
650 out of range (vtable len {}
651) on the runtime class behind {}
652 (method `{}
653`)",
654 11usize,
655 __vt.len(),
656 <BasicMenu as ::unity::ClassIdentity>::NAME,
657 "OnBind",
658 )
659 });
660 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
661 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
662 __inner(__receiver, __mi)
663 }
664 }
665 }
666 #[doc = "`OnUnbind()` overload"]
667 fn on_unbind(self) -> () {
668 unsafe {
669 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
670 {
671 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
672 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
673 panic!(
674 "unity: virtual slot {}
675 out of range (vtable len {}
676) on the runtime class behind {}
677 (method `{}
678`)",
679 12usize,
680 __vt.len(),
681 <BasicMenu as ::unity::ClassIdentity>::NAME,
682 "OnUnbind",
683 )
684 });
685 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
686 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
687 __inner(__receiver, __mi)
688 }
689 }
690 }
691 #[doc = "`BindParentMenu()` overload"]
692 fn bind_parent_menu(self) -> () {
693 unsafe {
694 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
695 ::unity::il2cpp_call!((::unity::module_base()+0x2454310usize)as*mut u8,();
696(BasicMenu)__receiver)
697 }
698 }
699 #[doc = "`Build()` overload"]
700 fn build(self) -> () {
701 unsafe {
702 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
703 ::unity::il2cpp_call!((::unity::module_base()+0x245bb20usize)as*mut u8,();
704(BasicMenu)__receiver)
705 }
706 }
707 #[doc = "`SetActive(bool)` overload"]
708 fn set_active(self, active: impl ::core::convert::Into<bool>) -> () {
709 unsafe {
710 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
711 ::unity::il2cpp_call!((::unity::module_base()+0x245c3d0usize)as*mut u8,();
712(BasicMenu)__receiver,(bool)::core::convert::Into::into(active))
713 }
714 }
715 #[doc = "`SetActiveAll(bool)` overload"]
716 fn set_active_all(self, active: impl ::core::convert::Into<bool>) -> () {
717 unsafe {
718 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
719 ::unity::il2cpp_call!((::unity::module_base()+0x245c480usize)as*mut u8,();
720(BasicMenu)__receiver,(bool)::core::convert::Into::into(active))
721 }
722 }
723 #[doc = "`OpenAnime()` overload"]
724 fn open_anime(self) -> () {
725 unsafe {
726 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
727 {
728 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
729 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
730 panic!(
731 "unity: virtual slot {}
732 out of range (vtable len {}
733) on the runtime class behind {}
734 (method `{}
735`)",
736 20usize,
737 __vt.len(),
738 <BasicMenu as ::unity::ClassIdentity>::NAME,
739 "OpenAnime",
740 )
741 });
742 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
743 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
744 __inner(__receiver, __mi)
745 }
746 }
747 }
748 #[doc = "`OpenAnimeAll()` overload"]
749 fn open_anime_all(self) -> () {
750 unsafe {
751 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
752 {
753 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
754 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
755 panic!(
756 "unity: virtual slot {}
757 out of range (vtable len {}
758) on the runtime class behind {}
759 (method `{}
760`)",
761 21usize,
762 __vt.len(),
763 <BasicMenu as ::unity::ClassIdentity>::NAME,
764 "OpenAnimeAll",
765 )
766 });
767 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
768 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
769 __inner(__receiver, __mi)
770 }
771 }
772 }
773 #[doc = "`CloseAnime()` overload"]
774 fn close_anime(self) -> () {
775 unsafe {
776 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
777 {
778 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
779 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
780 panic!(
781 "unity: virtual slot {}
782 out of range (vtable len {}
783) on the runtime class behind {}
784 (method `{}
785`)",
786 22usize,
787 __vt.len(),
788 <BasicMenu as ::unity::ClassIdentity>::NAME,
789 "CloseAnime",
790 )
791 });
792 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
793 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
794 __inner(__receiver, __mi)
795 }
796 }
797 }
798 #[doc = "`CloseAnimeAll()` overload"]
799 fn close_anime_all(self) -> () {
800 unsafe {
801 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
802 {
803 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
804 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
805 panic!(
806 "unity: virtual slot {}
807 out of range (vtable len {}
808) on the runtime class behind {}
809 (method `{}
810`)",
811 23usize,
812 __vt.len(),
813 <BasicMenu as ::unity::ClassIdentity>::NAME,
814 "CloseAnimeAll",
815 )
816 });
817 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
818 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
819 __inner(__receiver, __mi)
820 }
821 }
822 }
823 #[doc = "`OnBuild(bool)` overload"]
824 fn on_build(self, is_first_build: impl ::core::convert::Into<bool>) -> () {
825 unsafe {
826 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
827 {
828 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
829 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
830 panic!(
831 "unity: virtual slot {}
832 out of range (vtable len {}
833) on the runtime class behind {}
834 (method `{}
835`)",
836 24usize,
837 __vt.len(),
838 <BasicMenu as ::unity::ClassIdentity>::NAME,
839 "OnBuild",
840 )
841 });
842 let __inner: extern "C" fn(BasicMenu, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
843 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
844 __inner(__receiver, ::core::convert::Into::into(is_first_build), __mi)
845 }
846 }
847 }
848 #[doc = "`AfterBuild()` overload"]
849 fn after_build(self) -> () {
850 unsafe {
851 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
852 {
853 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
854 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
855 panic!(
856 "unity: virtual slot {}
857 out of range (vtable len {}
858) on the runtime class behind {}
859 (method `{}
860`)",
861 25usize,
862 __vt.len(),
863 <BasicMenu as ::unity::ClassIdentity>::NAME,
864 "AfterBuild",
865 )
866 });
867 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
868 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
869 __inner(__receiver, __mi)
870 }
871 }
872 }
873 #[doc = "`OnClose()` overload"]
874 fn on_close(self) -> () {
875 unsafe {
876 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
877 {
878 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
879 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
880 panic!(
881 "unity: virtual slot {}
882 out of range (vtable len {}
883) on the runtime class behind {}
884 (method `{}
885`)",
886 26usize,
887 __vt.len(),
888 <BasicMenu as ::unity::ClassIdentity>::NAME,
889 "OnClose",
890 )
891 });
892 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
893 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
894 __inner(__receiver, __mi)
895 }
896 }
897 }
898 #[doc = "`OnCursorMoveEnd()` overload"]
899 fn on_cursor_move_end(self) -> () {
900 unsafe {
901 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
902 {
903 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
904 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
905 panic!(
906 "unity: virtual slot {}
907 out of range (vtable len {}
908) on the runtime class behind {}
909 (method `{}
910`)",
911 27usize,
912 __vt.len(),
913 <BasicMenu as ::unity::ClassIdentity>::NAME,
914 "OnCursorMoveEnd",
915 )
916 });
917 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
918 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
919 __inner(__receiver, __mi)
920 }
921 }
922 }
923 #[doc = "`OnResume()` overload"]
924 fn on_resume(self) -> () {
925 unsafe {
926 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
927 {
928 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
929 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
930 panic!(
931 "unity: virtual slot {}
932 out of range (vtable len {}
933) on the runtime class behind {}
934 (method `{}
935`)",
936 28usize,
937 __vt.len(),
938 <BasicMenu as ::unity::ClassIdentity>::NAME,
939 "OnResume",
940 )
941 });
942 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
943 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
944 __inner(__receiver, __mi)
945 }
946 }
947 }
948 #[doc = "`OnSuspend()` overload"]
949 fn on_suspend(self) -> () {
950 unsafe {
951 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
952 {
953 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
954 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
955 panic!(
956 "unity: virtual slot {}
957 out of range (vtable len {}
958) on the runtime class behind {}
959 (method `{}
960`)",
961 29usize,
962 __vt.len(),
963 <BasicMenu as ::unity::ClassIdentity>::NAME,
964 "OnSuspend",
965 )
966 });
967 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
968 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
969 __inner(__receiver, __mi)
970 }
971 }
972 }
973 #[doc = "`OnCreate()` overload"]
974 fn on_create(self) -> () {
975 unsafe {
976 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
977 {
978 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
979 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
980 panic!(
981 "unity: virtual slot {}
982 out of range (vtable len {}
983) on the runtime class behind {}
984 (method `{}
985`)",
986 9usize,
987 __vt.len(),
988 <BasicMenu as ::unity::ClassIdentity>::NAME,
989 "OnCreate",
990 )
991 });
992 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
993 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
994 __inner(__receiver, __mi)
995 }
996 }
997 }
998 #[doc = "`OnDispose()` overload"]
999 fn on_dispose(self) -> () {
1000 unsafe {
1001 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1002 {
1003 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1004 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
1005 panic!(
1006 "unity: virtual slot {}
1007 out of range (vtable len {}
1008) on the runtime class behind {}
1009 (method `{}
1010`)",
1011 10usize,
1012 __vt.len(),
1013 <BasicMenu as ::unity::ClassIdentity>::NAME,
1014 "OnDispose",
1015 )
1016 });
1017 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1018 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1019 __inner(__receiver, __mi)
1020 }
1021 }
1022 }
1023 #[doc = "`GetName()` overload"]
1024 fn get_name(self) -> ::unity::Il2CppString {
1025 unsafe {
1026 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1027 {
1028 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1029 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1030 panic!(
1031 "unity: virtual slot {}
1032 out of range (vtable len {}
1033) on the runtime class behind {}
1034 (method `{}
1035`)",
1036 30usize,
1037 __vt.len(),
1038 <BasicMenu as ::unity::ClassIdentity>::NAME,
1039 "GetName",
1040 )
1041 });
1042 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1043 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1044 __inner(__receiver, __mi)
1045 }
1046 }
1047 }
1048 #[doc = "`GetMenuItem(i32)` overload"]
1049 fn get_menu_item(self, item_index: impl ::core::convert::Into<i32>) -> crate::app::basicmenuitem::BasicMenuItem {
1050 unsafe {
1051 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1052 ::unity::il2cpp_call!((::unity::module_base()+0x2454ae0usize)as*mut u8,crate::app::basicmenuitem::BasicMenuItem;
1053(BasicMenu)__receiver,(i32)::core::convert::Into::into(item_index))
1054 }
1055 }
1056 #[doc = "`GetMenuItemNum()` overload"]
1057 fn get_menu_item_num(self) -> i32 {
1058 unsafe {
1059 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1060 ::unity::il2cpp_call!((::unity::module_base()+0x2455b70usize)as*mut u8,i32;
1061(BasicMenu)__receiver)
1062 }
1063 }
1064 #[doc = "`ClampMenuItemIndex(i32)` overload"]
1065 fn clamp_menu_item_index(self, item_index: impl ::core::convert::Into<i32>) -> i32 {
1066 unsafe {
1067 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1068 {
1069 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1070 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1071 panic!(
1072 "unity: virtual slot {}
1073 out of range (vtable len {}
1074) on the runtime class behind {}
1075 (method `{}
1076`)",
1077 31usize,
1078 __vt.len(),
1079 <BasicMenu as ::unity::ClassIdentity>::NAME,
1080 "ClampMenuItemIndex",
1081 )
1082 });
1083 let __inner: extern "C" fn(BasicMenu, i32, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1084 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1085 __inner(__receiver, ::core::convert::Into::into(item_index), __mi)
1086 }
1087 }
1088 }
1089 #[doc = "`GetMenuItemIndex(crate::app::basicmenuitem::BasicMenuItem)` overload"]
1090 fn get_menu_item_index(self, menu_item: impl ::core::convert::Into<crate::app::basicmenuitem::BasicMenuItem>) -> i32 {
1091 unsafe {
1092 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1093 ::unity::il2cpp_call!((::unity::module_base()+0x245cc70usize)as*mut u8,i32;
1094(BasicMenu)__receiver,(crate::app::basicmenuitem::BasicMenuItem)::core::convert::Into::into(menu_item))
1095 }
1096 }
1097 #[doc = "`GetRowNum()` overload"]
1098 fn get_row_num(self) -> i32 {
1099 unsafe {
1100 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1101 ::unity::il2cpp_call!((::unity::module_base()+0x245cd40usize)as*mut u8,i32;
1102(BasicMenu)__receiver)
1103 }
1104 }
1105 #[doc = "`GetShowRowNum()` overload"]
1106 fn get_show_row_num(self) -> i32 {
1107 unsafe {
1108 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1109 ::unity::il2cpp_call!((::unity::module_base()+0x245cd50usize)as*mut u8,i32;
1110(BasicMenu)__receiver)
1111 }
1112 }
1113 #[doc = "`SetShowRowNum(i32)` overload"]
1114 fn set_show_row_num(self, row_num: impl ::core::convert::Into<i32>) -> () {
1115 unsafe {
1116 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1117 ::unity::il2cpp_call!((::unity::module_base()+0x245cd60usize)as*mut u8,();
1118(BasicMenu)__receiver,(i32)::core::convert::Into::into(row_num))
1119 }
1120 }
1121 #[doc = "`SetShowRowAuto()` overload"]
1122 fn set_show_row_auto(self) -> () {
1123 unsafe {
1124 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1125 ::unity::il2cpp_call!((::unity::module_base()+0x245cda0usize)as*mut u8,();
1126(BasicMenu)__receiver)
1127 }
1128 }
1129 #[doc = "`GetShowRowMax()` overload"]
1130 fn get_show_row_max(self) -> i32 {
1131 unsafe {
1132 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1133 {
1134 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1135 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
1136 panic!(
1137 "unity: virtual slot {}
1138 out of range (vtable len {}
1139) on the runtime class behind {}
1140 (method `{}
1141`)",
1142 32usize,
1143 __vt.len(),
1144 <BasicMenu as ::unity::ClassIdentity>::NAME,
1145 "GetShowRowMax",
1146 )
1147 });
1148 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1149 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1150 __inner(__receiver, __mi)
1151 }
1152 }
1153 }
1154 #[doc = "`GetBuildRowNum()` overload"]
1155 fn get_build_row_num(self) -> i32 {
1156 unsafe {
1157 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1158 {
1159 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1160 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
1161 panic!(
1162 "unity: virtual slot {}
1163 out of range (vtable len {}
1164) on the runtime class behind {}
1165 (method `{}
1166`)",
1167 33usize,
1168 __vt.len(),
1169 <BasicMenu as ::unity::ClassIdentity>::NAME,
1170 "GetBuildRowNum",
1171 )
1172 });
1173 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1174 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1175 __inner(__receiver, __mi)
1176 }
1177 }
1178 }
1179 #[doc = "`GetSelectIndex()` overload"]
1180 fn get_select_index(self) -> i32 {
1181 unsafe {
1182 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1183 ::unity::il2cpp_call!((::unity::module_base()+0x245ce70usize)as*mut u8,i32;
1184(BasicMenu)__receiver)
1185 }
1186 }
1187 #[doc = "`GetSelectIndexOld()` overload"]
1188 fn get_select_index_old(self) -> i32 {
1189 unsafe {
1190 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1191 ::unity::il2cpp_call!((::unity::module_base()+0x245ce80usize)as*mut u8,i32;
1192(BasicMenu)__receiver)
1193 }
1194 }
1195 #[doc = "`SetSelectIndex(i32)` overload"]
1196 fn set_select_index(self, select_index: impl ::core::convert::Into<i32>) -> () {
1197 unsafe {
1198 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1199 {
1200 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1201 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
1202 panic!(
1203 "unity: virtual slot {}
1204 out of range (vtable len {}
1205) on the runtime class behind {}
1206 (method `{}
1207`)",
1208 34usize,
1209 __vt.len(),
1210 <BasicMenu as ::unity::ClassIdentity>::NAME,
1211 "SetSelectIndex",
1212 )
1213 });
1214 let __inner: extern "C" fn(BasicMenu, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1215 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1216 __inner(__receiver, ::core::convert::Into::into(select_index), __mi)
1217 }
1218 }
1219 }
1220 #[doc = "`UpdateSelectIndexOld()` overload"]
1221 fn update_select_index_old(self) -> () {
1222 unsafe {
1223 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1224 ::unity::il2cpp_call!((::unity::module_base()+0x245cf20usize)as*mut u8,();
1225(BasicMenu)__receiver)
1226 }
1227 }
1228 #[doc = "`AdjustSelectIndex()` overload"]
1229 fn adjust_select_index(self) -> () {
1230 unsafe {
1231 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1232 ::unity::il2cpp_call!((::unity::module_base()+0x245cfa0usize)as*mut u8,();
1233(BasicMenu)__receiver)
1234 }
1235 }
1236 #[doc = "`GetScrollIndex()` overload"]
1237 fn get_scroll_index(self) -> i32 {
1238 unsafe {
1239 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1240 ::unity::il2cpp_call!((::unity::module_base()+0x245cfc0usize)as*mut u8,i32;
1241(BasicMenu)__receiver)
1242 }
1243 }
1244 #[doc = "`GetScrollIndexOld()` overload"]
1245 fn get_scroll_index_old(self) -> i32 {
1246 unsafe {
1247 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1248 ::unity::il2cpp_call!((::unity::module_base()+0x245cfd0usize)as*mut u8,i32;
1249(BasicMenu)__receiver)
1250 }
1251 }
1252 #[doc = "`SetScrollIndex(i32)` overload"]
1253 fn set_scroll_index(self, scroll_index: impl ::core::convert::Into<i32>) -> () {
1254 unsafe {
1255 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1256 ::unity::il2cpp_call!((::unity::module_base()+0x245c0f0usize)as*mut u8,();
1257(BasicMenu)__receiver,(i32)::core::convert::Into::into(scroll_index))
1258 }
1259 }
1260 #[doc = "`UpdateScrollIndexOld()` overload"]
1261 fn update_scroll_index_old(self) -> () {
1262 unsafe {
1263 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1264 ::unity::il2cpp_call!((::unity::module_base()+0x245cfe0usize)as*mut u8,();
1265(BasicMenu)__receiver)
1266 }
1267 }
1268 #[doc = "`AdjustScrollIndex()` overload"]
1269 fn adjust_scroll_index(self) -> () {
1270 unsafe {
1271 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1272 {
1273 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1274 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
1275 panic!(
1276 "unity: virtual slot {}
1277 out of range (vtable len {}
1278) on the runtime class behind {}
1279 (method `{}
1280`)",
1281 35usize,
1282 __vt.len(),
1283 <BasicMenu as ::unity::ClassIdentity>::NAME,
1284 "AdjustScrollIndex",
1285 )
1286 });
1287 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1288 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1289 __inner(__receiver, __mi)
1290 }
1291 }
1292 }
1293 #[doc = "`SaveSelect(crate::app::basicmenuselect::BasicMenuSelect)` overload"]
1294 fn save_select(self, sel: impl ::core::convert::Into<crate::app::basicmenuselect::BasicMenuSelect>) -> () {
1295 unsafe {
1296 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1297 ::unity::il2cpp_call!((::unity::module_base()+0x245d070usize)as*mut u8,();
1298(BasicMenu)__receiver,(crate::app::basicmenuselect::BasicMenuSelect)::core::convert::Into::into(sel))
1299 }
1300 }
1301 #[doc = "`RestoreSelect(crate::app::basicmenuselect::BasicMenuSelect)` overload"]
1302 fn restore_select(self, sel: impl ::core::convert::Into<crate::app::basicmenuselect::BasicMenuSelect>) -> () {
1303 unsafe {
1304 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1305 ::unity::il2cpp_call!((::unity::module_base()+0x245d0a0usize)as*mut u8,();
1306(BasicMenu)__receiver,(crate::app::basicmenuselect::BasicMenuSelect)::core::convert::Into::into(sel))
1307 }
1308 }
1309 #[doc = "`IsOpening()` overload"]
1310 fn is_opening(self) -> bool {
1311 unsafe {
1312 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1313 ::unity::il2cpp_call!((::unity::module_base()+0x245d120usize)as*mut u8,bool;
1314(BasicMenu)__receiver)
1315 }
1316 }
1317 #[doc = "`IsClosing()` overload"]
1318 fn is_closing(self) -> bool {
1319 unsafe {
1320 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1321 ::unity::il2cpp_call!((::unity::module_base()+0x245d130usize)as*mut u8,bool;
1322(BasicMenu)__receiver)
1323 }
1324 }
1325 #[doc = "`IsClosed()` overload"]
1326 fn is_closed(self) -> bool {
1327 unsafe {
1328 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1329 ::unity::il2cpp_call!((::unity::module_base()+0x245d140usize)as*mut u8,bool;
1330(BasicMenu)__receiver)
1331 }
1332 }
1333 #[doc = "`IsCursorHide()` overload"]
1334 fn is_cursor_hide(self) -> bool {
1335 unsafe {
1336 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1337 ::unity::il2cpp_call!((::unity::module_base()+0x245d150usize)as*mut u8,bool;
1338(BasicMenu)__receiver)
1339 }
1340 }
1341 #[doc = "`SetCursorHide(bool)` overload"]
1342 fn set_cursor_hide(self, onoff: impl ::core::convert::Into<bool>) -> () {
1343 unsafe {
1344 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1345 ::unity::il2cpp_call!((::unity::module_base()+0x245d1b0usize)as*mut u8,();
1346(BasicMenu)__receiver,(bool)::core::convert::Into::into(onoff))
1347 }
1348 }
1349 #[doc = "`IsInputDisable()` overload"]
1350 fn is_input_disable(self) -> bool {
1351 unsafe {
1352 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1353 ::unity::il2cpp_call!((::unity::module_base()+0x245d230usize)as*mut u8,bool;
1354(BasicMenu)__receiver)
1355 }
1356 }
1357 #[doc = "`SetInputDisable(bool)` overload"]
1358 fn set_input_disable(self, onoff: impl ::core::convert::Into<bool>) -> () {
1359 unsafe {
1360 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1361 ::unity::il2cpp_call!((::unity::module_base()+0x245d290usize)as*mut u8,();
1362(BasicMenu)__receiver,(bool)::core::convert::Into::into(onoff))
1363 }
1364 }
1365 #[doc = "`IsInputDisableNowFrame()` overload"]
1366 fn is_input_disable_now_frame(self) -> bool {
1367 unsafe {
1368 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1369 ::unity::il2cpp_call!((::unity::module_base()+0x245d310usize)as*mut u8,bool;
1370(BasicMenu)__receiver)
1371 }
1372 }
1373 #[doc = "`SetInputDisableNowFrame(bool)` overload"]
1374 fn set_input_disable_now_frame(self, onoff: impl ::core::convert::Into<bool>) -> () {
1375 unsafe {
1376 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1377 ::unity::il2cpp_call!((::unity::module_base()+0x245d370usize)as*mut u8,();
1378(BasicMenu)__receiver,(bool)::core::convert::Into::into(onoff))
1379 }
1380 }
1381 #[doc = "`IsCursorMoved()` overload"]
1382 fn is_cursor_moved(self) -> bool {
1383 unsafe {
1384 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1385 ::unity::il2cpp_call!((::unity::module_base()+0x245d3f0usize)as*mut u8,bool;
1386(BasicMenu)__receiver)
1387 }
1388 }
1389 #[doc = "`SetCursorMoved(bool)` overload"]
1390 fn set_cursor_moved(self, onoff: impl ::core::convert::Into<bool>) -> () {
1391 unsafe {
1392 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1393 ::unity::il2cpp_call!((::unity::module_base()+0x245d450usize)as*mut u8,();
1394(BasicMenu)__receiver,(bool)::core::convert::Into::into(onoff))
1395 }
1396 }
1397 #[doc = "`IsCloseCalled()` overload"]
1398 fn is_close_called(self) -> bool {
1399 unsafe {
1400 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1401 ::unity::il2cpp_call!((::unity::module_base()+0x245d4d0usize)as*mut u8,bool;
1402(BasicMenu)__receiver)
1403 }
1404 }
1405 #[doc = "`SetCloseCalled(bool)` overload"]
1406 fn set_close_called(self, onoff: impl ::core::convert::Into<bool>) -> () {
1407 unsafe {
1408 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1409 ::unity::il2cpp_call!((::unity::module_base()+0x245d530usize)as*mut u8,();
1410(BasicMenu)__receiver,(bool)::core::convert::Into::into(onoff))
1411 }
1412 }
1413 #[doc = "`IsRebuild()` overload"]
1414 fn is_rebuild(self) -> bool {
1415 unsafe {
1416 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1417 ::unity::il2cpp_call!((::unity::module_base()+0x245d5b0usize)as*mut u8,bool;
1418(BasicMenu)__receiver)
1419 }
1420 }
1421 #[doc = "`IsSystemCall()` overload"]
1422 fn is_system_call(self) -> bool {
1423 unsafe {
1424 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1425 {
1426 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1427 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
1428 panic!(
1429 "unity: virtual slot {}
1430 out of range (vtable len {}
1431) on the runtime class behind {}
1432 (method `{}
1433`)",
1434 36usize,
1435 __vt.len(),
1436 <BasicMenu as ::unity::ClassIdentity>::NAME,
1437 "IsSystemCall",
1438 )
1439 });
1440 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1441 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1442 __inner(__receiver, __mi)
1443 }
1444 }
1445 }
1446 #[doc = "`SetCursorMoveFrame(f32)` overload"]
1447 fn set_cursor_move_frame(self, frame: impl ::core::convert::Into<f32>) -> () {
1448 unsafe {
1449 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1450 ::unity::il2cpp_call!((::unity::module_base()+0x245d620usize)as*mut u8,();
1451(BasicMenu)__receiver,(f32)::core::convert::Into::into(frame))
1452 }
1453 }
1454 #[doc = "`CursorMoveInstant()` overload"]
1455 fn cursor_move_instant(self) -> () {
1456 unsafe {
1457 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1458 ::unity::il2cpp_call!((::unity::module_base()+0x245c780usize)as*mut u8,();
1459(BasicMenu)__receiver)
1460 }
1461 }
1462 #[doc = "`SetScrollFrame(f32)` overload"]
1463 fn set_scroll_frame(self, frame: impl ::core::convert::Into<f32>) -> () {
1464 unsafe {
1465 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1466 ::unity::il2cpp_call!((::unity::module_base()+0x245d650usize)as*mut u8,();
1467(BasicMenu)__receiver,(f32)::core::convert::Into::into(frame))
1468 }
1469 }
1470 #[doc = "`ScrollInstant()` overload"]
1471 fn scroll_instant(self) -> () {
1472 unsafe {
1473 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1474 ::unity::il2cpp_call!((::unity::module_base()+0x245c330usize)as*mut u8,();
1475(BasicMenu)__receiver)
1476 }
1477 }
1478 #[doc = "`SetBackCursorColor(crate::unity_engine::color::Color)` overload"]
1479 fn set_back_cursor_color(self, c: impl ::core::convert::Into<crate::unity_engine::color::Color>) -> () {
1480 unsafe {
1481 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1482 ::unity::il2cpp_call!((::unity::module_base()+0x245d6a0usize)as*mut u8,();
1483(BasicMenu)__receiver,(crate::unity_engine::color::Color)::core::convert::Into::into(c))
1484 }
1485 }
1486 #[doc = "`SetCursorToKeepAnimatorState(bool)` overload"]
1487 fn set_cursor_to_keep_animator_state(self, keep: impl ::core::convert::Into<bool>) -> () {
1488 unsafe {
1489 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1490 ::unity::il2cpp_call!((::unity::module_base()+0x245d6c0usize)as*mut u8,();
1491(BasicMenu)__receiver,(bool)::core::convert::Into::into(keep))
1492 }
1493 }
1494 #[doc = "`MoveFrontCursorFrom(f32, f32, f32)` overload"]
1495 fn move_front_cursor_from(
1496 self,
1497 from_x: impl ::core::convert::Into<f32>,
1498 from_y: impl ::core::convert::Into<f32>,
1499 frame: impl ::core::convert::Into<f32>,
1500 ) -> () {
1501 unsafe {
1502 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1503 ::unity::il2cpp_call!((::unity::module_base()+0x245d6f0usize)as*mut u8,();
1504(BasicMenu)__receiver,(f32)::core::convert::Into::into(from_x),(f32)::core::convert::Into::into(from_y),(f32)::core::convert::Into::into(frame))
1505 }
1506 }
1507 #[doc = "`MoveFrontCursorFrom(crate::app::basicmenuitem::BasicMenuItem, f32)` overload"]
1508 fn move_front_cursor_from_2(
1509 self,
1510 from_menu_item: impl ::core::convert::Into<crate::app::basicmenuitem::BasicMenuItem>,
1511 frame: impl ::core::convert::Into<f32>,
1512 ) -> () {
1513 unsafe {
1514 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1515 ::unity::il2cpp_call!((::unity::module_base()+0x245d710usize)as*mut u8,();
1516(BasicMenu)__receiver,(crate::app::basicmenuitem::BasicMenuItem)::core::convert::Into::into(from_menu_item),(f32)::core::convert::Into::into(frame))
1517 }
1518 }
1519 #[doc = "`PutCursorInFront()` overload"]
1520 fn put_cursor_in_front(self) -> () {
1521 unsafe {
1522 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1523 ::unity::il2cpp_call!((::unity::module_base()+0x245d880usize)as*mut u8,();
1524(BasicMenu)__receiver)
1525 }
1526 }
1527 #[doc = "`PutCursorInBack()` overload"]
1528 fn put_cursor_in_back(self) -> () {
1529 unsafe {
1530 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1531 ::unity::il2cpp_call!((::unity::module_base()+0x245d990usize)as*mut u8,();
1532(BasicMenu)__receiver)
1533 }
1534 }
1535 #[doc = "`SetCursorFrontBack(bool)` overload"]
1536 fn set_cursor_front_back(self, is_front: impl ::core::convert::Into<bool>) -> () {
1537 unsafe {
1538 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1539 ::unity::il2cpp_call!((::unity::module_base()+0x245daa0usize)as*mut u8,();
1540(BasicMenu)__receiver,(bool)::core::convert::Into::into(is_front))
1541 }
1542 }
1543 #[doc = "`RestartCursorAnimation()` overload"]
1544 fn restart_cursor_animation(self) -> () {
1545 unsafe {
1546 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1547 ::unity::il2cpp_call!((::unity::module_base()+0x245dab0usize)as*mut u8,();
1548(BasicMenu)__receiver)
1549 }
1550 }
1551 #[doc = "`GetSubMenuBaseTransform()` overload"]
1552 fn get_sub_menu_base_transform(self) -> crate::unity_engine::recttransform::RectTransform {
1553 unsafe {
1554 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1555 ::unity::il2cpp_call!((::unity::module_base()+0x245db60usize)as*mut u8,crate::unity_engine::recttransform::RectTransform;
1556(BasicMenu)__receiver)
1557 }
1558 }
1559 #[doc = "`IsSuspend()` overload"]
1560 fn is_suspend(self) -> bool {
1561 unsafe {
1562 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1563 ::unity::il2cpp_call!((::unity::module_base()+0x2456a20usize)as*mut u8,bool;
1564(BasicMenu)__receiver)
1565 }
1566 }
1567 #[doc = "`IncSuspend()` overload"]
1568 fn inc_suspend(self) -> () {
1569 unsafe {
1570 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1571 ::unity::il2cpp_call!((::unity::module_base()+0x245ba50usize)as*mut u8,();
1572(BasicMenu)__receiver)
1573 }
1574 }
1575 #[doc = "`DecSuspend()` overload"]
1576 fn dec_suspend(self) -> () {
1577 unsafe {
1578 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1579 ::unity::il2cpp_call!((::unity::module_base()+0x245ca60usize)as*mut u8,();
1580(BasicMenu)__receiver)
1581 }
1582 }
1583 #[doc = "`SetPivot(f32, f32)` overload"]
1584 fn set_pivot(self, x: impl ::core::convert::Into<f32>, y: impl ::core::convert::Into<f32>) -> () {
1585 unsafe {
1586 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1587 ::unity::il2cpp_call!((::unity::module_base()+0x245dda0usize)as*mut u8,();
1588(BasicMenu)__receiver,(f32)::core::convert::Into::into(x),(f32)::core::convert::Into::into(y))
1589 }
1590 }
1591 #[doc = "`GetAnchorType()` overload"]
1592 fn get_anchor_type(self) -> crate::app::basicmenu::BasicMenu_AnchorType {
1593 unsafe {
1594 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1595 ::unity::il2cpp_call!((::unity::module_base()+0x245c120usize)as*mut u8,crate::app::basicmenu::BasicMenu_AnchorType;
1596(BasicMenu)__receiver)
1597 }
1598 }
1599 #[doc = "`SetAnchorType(crate::app::basicmenu::BasicMenu_AnchorType, f32, f32)` overload"]
1600 fn set_anchor_type(
1601 self,
1602 anchor_type: impl ::core::convert::Into<crate::app::basicmenu::BasicMenu_AnchorType>,
1603 x: impl ::core::convert::Into<f32>,
1604 y: impl ::core::convert::Into<f32>,
1605 ) -> () {
1606 unsafe {
1607 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1608 ::unity::il2cpp_call!((::unity::module_base()+0x245de20usize)as*mut u8,();
1609(BasicMenu)__receiver,(crate::app::basicmenu::BasicMenu_AnchorType)::core::convert::Into::into(anchor_type),(f32)::core::convert::Into::into(x),(f32)::core::convert::Into::into(y))
1610 }
1611 }
1612 #[doc = "`SetAnchorTypeFromScreenCoord(crate::app::basicmenu::BasicMenu_AnchorType, f32, f32)` overload"]
1613 fn set_anchor_type_from_screen_coord(
1614 self,
1615 anchor_type: impl ::core::convert::Into<crate::app::basicmenu::BasicMenu_AnchorType>,
1616 x: impl ::core::convert::Into<f32>,
1617 y: impl ::core::convert::Into<f32>,
1618 ) -> () {
1619 unsafe {
1620 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1621 ::unity::il2cpp_call!((::unity::module_base()+0x245df70usize)as*mut u8,();
1622(BasicMenu)__receiver,(crate::app::basicmenu::BasicMenu_AnchorType)::core::convert::Into::into(anchor_type),(f32)::core::convert::Into::into(x),(f32)::core::convert::Into::into(y))
1623 }
1624 }
1625 #[doc = "`GetX()` overload"]
1626 fn get_x(self) -> f32 {
1627 unsafe {
1628 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1629 ::unity::il2cpp_call!((::unity::module_base()+0x245e2a0usize)as*mut u8,f32;
1630(BasicMenu)__receiver)
1631 }
1632 }
1633 #[doc = "`GetY()` overload"]
1634 fn get_y(self) -> f32 {
1635 unsafe {
1636 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1637 ::unity::il2cpp_call!((::unity::module_base()+0x245e2c0usize)as*mut u8,f32;
1638(BasicMenu)__receiver)
1639 }
1640 }
1641 #[doc = "`SetX(f32)` overload"]
1642 fn set_x(self, x: impl ::core::convert::Into<f32>) -> () {
1643 unsafe {
1644 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1645 ::unity::il2cpp_call!((::unity::module_base()+0x245e2d0usize)as*mut u8,();
1646(BasicMenu)__receiver,(f32)::core::convert::Into::into(x))
1647 }
1648 }
1649 #[doc = "`SetY(f32)` overload"]
1650 fn set_y(self, y: impl ::core::convert::Into<f32>) -> () {
1651 unsafe {
1652 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1653 ::unity::il2cpp_call!((::unity::module_base()+0x245e2f0usize)as*mut u8,();
1654(BasicMenu)__receiver,(f32)::core::convert::Into::into(y))
1655 }
1656 }
1657 #[doc = "`GetPos()` overload"]
1658 fn get_pos(self) -> crate::unity_engine::vector2::Vector2 {
1659 unsafe {
1660 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1661 ::unity::il2cpp_call!((::unity::module_base()+0x245e310usize)as*mut u8,crate::unity_engine::vector2::Vector2;
1662(BasicMenu)__receiver)
1663 }
1664 }
1665 #[doc = "`SetPos(f32, f32)` overload"]
1666 fn set_pos(self, x: impl ::core::convert::Into<f32>, y: impl ::core::convert::Into<f32>) -> () {
1667 unsafe {
1668 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1669 ::unity::il2cpp_call!((::unity::module_base()+0x2453fd0usize)as*mut u8,();
1670(BasicMenu)__receiver,(f32)::core::convert::Into::into(x),(f32)::core::convert::Into::into(y))
1671 }
1672 }
1673 #[doc = "`SetTransformAsSubMenu(crate::app::basicmenu::BasicMenu, crate::app::basicmenuitem::BasicMenuItem)` overload"]
1674 fn set_transform_as_sub_menu(
1675 self,
1676 parent_menu: impl ::core::convert::Into<crate::app::basicmenu::BasicMenu>,
1677 parent_menu_item: impl ::core::convert::Into<crate::app::basicmenuitem::BasicMenuItem>,
1678 ) -> () {
1679 unsafe {
1680 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1681 ::unity::il2cpp_call!((::unity::module_base()+0x245e330usize)as*mut u8,();
1682(BasicMenu)__receiver,(crate::app::basicmenu::BasicMenu)::core::convert::Into::into(parent_menu),(crate::app::basicmenuitem::BasicMenuItem)::core::convert::Into::into(parent_menu_item))
1683 }
1684 }
1685 #[doc = "`SetColor(crate::unity_engine::color::Color)` overload"]
1686 fn set_color(self, color: impl ::core::convert::Into<crate::unity_engine::color::Color>) -> () {
1687 unsafe {
1688 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1689 ::unity::il2cpp_call!((::unity::module_base()+0x245e620usize)as*mut u8,();
1690(BasicMenu)__receiver,(crate::unity_engine::color::Color)::core::convert::Into::into(color))
1691 }
1692 }
1693 #[doc = "`GetW()` overload"]
1694 fn get_w(self) -> f32 {
1695 unsafe {
1696 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1697 ::unity::il2cpp_call!((::unity::module_base()+0x245e640usize)as*mut u8,f32;
1698(BasicMenu)__receiver)
1699 }
1700 }
1701 #[doc = "`GetH()` overload"]
1702 fn get_h(self) -> f32 {
1703 unsafe {
1704 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1705 ::unity::il2cpp_call!((::unity::module_base()+0x245e650usize)as*mut u8,f32;
1706(BasicMenu)__receiver)
1707 }
1708 }
1709 #[doc = "`SetAsFirstSibling()` overload"]
1710 fn set_as_first_sibling(self) -> () {
1711 unsafe {
1712 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1713 ::unity::il2cpp_call!((::unity::module_base()+0x245e780usize)as*mut u8,();
1714(BasicMenu)__receiver)
1715 }
1716 }
1717 #[doc = "`SetAsLastSibling()` overload"]
1718 fn set_as_last_sibling(self) -> () {
1719 unsafe {
1720 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1721 ::unity::il2cpp_call!((::unity::module_base()+0x245e7b0usize)as*mut u8,();
1722(BasicMenu)__receiver)
1723 }
1724 }
1725 #[doc = "`Rebuild()` overload"]
1726 fn rebuild(self) -> () {
1727 unsafe {
1728 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1729 ::unity::il2cpp_call!((::unity::module_base()+0x245e7e0usize)as*mut u8,();
1730(BasicMenu)__receiver)
1731 }
1732 }
1733 #[doc = "`RebuildInstant(bool)` overload"]
1734 fn rebuild_instant(self, is_keep_item_index: impl ::core::convert::Into<bool>) -> () {
1735 unsafe {
1736 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1737 ::unity::il2cpp_call!((::unity::module_base()+0x245e840usize)as*mut u8,();
1738(BasicMenu)__receiver,(bool)::core::convert::Into::into(is_keep_item_index))
1739 }
1740 }
1741 #[doc = "`RebuildInstant(crate::app::basicmenuselect::BasicMenuSelect)` overload"]
1742 fn rebuild_instant_2(self, menu_select: impl ::core::convert::Into<crate::app::basicmenuselect::BasicMenuSelect>) -> () {
1743 unsafe {
1744 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1745 ::unity::il2cpp_call!((::unity::module_base()+0x245e930usize)as*mut u8,();
1746(BasicMenu)__receiver,(crate::app::basicmenuselect::BasicMenuSelect)::core::convert::Into::into(menu_select))
1747 }
1748 }
1749 #[doc = "`RebuildInstant(crate::app::basicmenuselect::BasicMenuSelect, i32)` overload"]
1750 fn rebuild_instant_3(
1751 self,
1752 menu_select: impl ::core::convert::Into<crate::app::basicmenuselect::BasicMenuSelect>,
1753 display_index: impl ::core::convert::Into<i32>,
1754 ) -> () {
1755 unsafe {
1756 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1757 {
1758 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1759 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
1760 panic!(
1761 "unity: virtual slot {}
1762 out of range (vtable len {}
1763) on the runtime class behind {}
1764 (method `{}
1765`)",
1766 37usize,
1767 __vt.len(),
1768 <BasicMenu as ::unity::ClassIdentity>::NAME,
1769 "RebuildInstant",
1770 )
1771 });
1772 let __inner: extern "C" fn(BasicMenu, crate::app::basicmenuselect::BasicMenuSelect, i32, ::unity::OptionalMethod) -> () =
1773 ::core::mem::transmute(__vi.method_ptr);
1774 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1775 __inner(
1776 __receiver,
1777 ::core::convert::Into::into(menu_select),
1778 ::core::convert::Into::into(display_index),
1779 __mi,
1780 )
1781 }
1782 }
1783 }
1784 #[doc = "`Close()` overload"]
1785 fn close(self) -> () {
1786 unsafe {
1787 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1788 ::unity::il2cpp_call!((::unity::module_base()+0x245e980usize)as*mut u8,();
1789(BasicMenu)__receiver)
1790 }
1791 }
1792 #[doc = "`CloseParentMenu()` overload"]
1793 fn close_parent_menu(self) -> () {
1794 unsafe {
1795 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1796 ::unity::il2cpp_call!((::unity::module_base()+0x245e9e0usize)as*mut u8,();
1797(BasicMenu)__receiver)
1798 }
1799 }
1800 #[doc = "`DeleteParentMenu()` overload"]
1801 fn delete_parent_menu(self) -> () {
1802 unsafe {
1803 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1804 ::unity::il2cpp_call!((::unity::module_base()+0x245eab0usize)as*mut u8,();
1805(BasicMenu)__receiver)
1806 }
1807 }
1808 #[doc = "`Tick()` overload"]
1809 fn tick(self) -> () {
1810 unsafe {
1811 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1812 {
1813 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1814 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
1815 panic!(
1816 "unity: virtual slot {}
1817 out of range (vtable len {}
1818) on the runtime class behind {}
1819 (method `{}
1820`)",
1821 38usize,
1822 __vt.len(),
1823 <BasicMenu as ::unity::ClassIdentity>::NAME,
1824 "Tick",
1825 )
1826 });
1827 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1828 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1829 __inner(__receiver, __mi)
1830 }
1831 }
1832 }
1833 #[doc = "`TickInput()` overload"]
1834 fn tick_input(self) -> bool {
1835 unsafe {
1836 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1837 {
1838 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1839 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
1840 panic!(
1841 "unity: virtual slot {}
1842 out of range (vtable len {}
1843) on the runtime class behind {}
1844 (method `{}
1845`)",
1846 39usize,
1847 __vt.len(),
1848 <BasicMenu as ::unity::ClassIdentity>::NAME,
1849 "TickInput",
1850 )
1851 });
1852 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
1853 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1854 __inner(__receiver, __mi)
1855 }
1856 }
1857 }
1858 #[doc = "`KeyUp(bool)` overload"]
1859 fn key_up(self, is_trigger: impl ::core::convert::Into<bool>) -> () {
1860 unsafe {
1861 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1862 {
1863 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1864 let __vi = *__vt.get(40usize).unwrap_or_else(|| {
1865 panic!(
1866 "unity: virtual slot {}
1867 out of range (vtable len {}
1868) on the runtime class behind {}
1869 (method `{}
1870`)",
1871 40usize,
1872 __vt.len(),
1873 <BasicMenu as ::unity::ClassIdentity>::NAME,
1874 "KeyUp",
1875 )
1876 });
1877 let __inner: extern "C" fn(BasicMenu, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1878 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1879 __inner(__receiver, ::core::convert::Into::into(is_trigger), __mi)
1880 }
1881 }
1882 }
1883 #[doc = "`KeyDown(bool)` overload"]
1884 fn key_down(self, is_trigger: impl ::core::convert::Into<bool>) -> () {
1885 unsafe {
1886 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1887 {
1888 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1889 let __vi = *__vt.get(41usize).unwrap_or_else(|| {
1890 panic!(
1891 "unity: virtual slot {}
1892 out of range (vtable len {}
1893) on the runtime class behind {}
1894 (method `{}
1895`)",
1896 41usize,
1897 __vt.len(),
1898 <BasicMenu as ::unity::ClassIdentity>::NAME,
1899 "KeyDown",
1900 )
1901 });
1902 let __inner: extern "C" fn(BasicMenu, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1903 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1904 __inner(__receiver, ::core::convert::Into::into(is_trigger), __mi)
1905 }
1906 }
1907 }
1908 #[doc = "`KeyLeft(bool)` overload"]
1909 fn key_left(self, is_trigger: impl ::core::convert::Into<bool>) -> () {
1910 unsafe {
1911 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1912 {
1913 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1914 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
1915 panic!(
1916 "unity: virtual slot {}
1917 out of range (vtable len {}
1918) on the runtime class behind {}
1919 (method `{}
1920`)",
1921 42usize,
1922 __vt.len(),
1923 <BasicMenu as ::unity::ClassIdentity>::NAME,
1924 "KeyLeft",
1925 )
1926 });
1927 let __inner: extern "C" fn(BasicMenu, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1928 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1929 __inner(__receiver, ::core::convert::Into::into(is_trigger), __mi)
1930 }
1931 }
1932 }
1933 #[doc = "`KeyRight(bool)` overload"]
1934 fn key_right(self, is_trigger: impl ::core::convert::Into<bool>) -> () {
1935 unsafe {
1936 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1937 {
1938 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1939 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
1940 panic!(
1941 "unity: virtual slot {}
1942 out of range (vtable len {}
1943) on the runtime class behind {}
1944 (method `{}
1945`)",
1946 43usize,
1947 __vt.len(),
1948 <BasicMenu as ::unity::ClassIdentity>::NAME,
1949 "KeyRight",
1950 )
1951 });
1952 let __inner: extern "C" fn(BasicMenu, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1953 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1954 __inner(__receiver, ::core::convert::Into::into(is_trigger), __mi)
1955 }
1956 }
1957 }
1958 #[doc = "`MoveUp(bool)` overload"]
1959 fn move_up(self, is_trigger: impl ::core::convert::Into<bool>) -> () {
1960 unsafe {
1961 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1962 {
1963 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1964 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
1965 panic!(
1966 "unity: virtual slot {}
1967 out of range (vtable len {}
1968) on the runtime class behind {}
1969 (method `{}
1970`)",
1971 44usize,
1972 __vt.len(),
1973 <BasicMenu as ::unity::ClassIdentity>::NAME,
1974 "MoveUp",
1975 )
1976 });
1977 let __inner: extern "C" fn(BasicMenu, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1978 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1979 __inner(__receiver, ::core::convert::Into::into(is_trigger), __mi)
1980 }
1981 }
1982 }
1983 #[doc = "`MoveDown(bool)` overload"]
1984 fn move_down(self, is_trigger: impl ::core::convert::Into<bool>) -> () {
1985 unsafe {
1986 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1987 {
1988 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1989 let __vi = *__vt.get(45usize).unwrap_or_else(|| {
1990 panic!(
1991 "unity: virtual slot {}
1992 out of range (vtable len {}
1993) on the runtime class behind {}
1994 (method `{}
1995`)",
1996 45usize,
1997 __vt.len(),
1998 <BasicMenu as ::unity::ClassIdentity>::NAME,
1999 "MoveDown",
2000 )
2001 });
2002 let __inner: extern "C" fn(BasicMenu, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2003 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2004 __inner(__receiver, ::core::convert::Into::into(is_trigger), __mi)
2005 }
2006 }
2007 }
2008 #[doc = "`PageUp(bool)` overload"]
2009 fn page_up(self, is_trigger: impl ::core::convert::Into<bool>) -> () {
2010 unsafe {
2011 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2012 {
2013 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2014 let __vi = *__vt.get(46usize).unwrap_or_else(|| {
2015 panic!(
2016 "unity: virtual slot {}
2017 out of range (vtable len {}
2018) on the runtime class behind {}
2019 (method `{}
2020`)",
2021 46usize,
2022 __vt.len(),
2023 <BasicMenu as ::unity::ClassIdentity>::NAME,
2024 "PageUp",
2025 )
2026 });
2027 let __inner: extern "C" fn(BasicMenu, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2028 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2029 __inner(__receiver, ::core::convert::Into::into(is_trigger), __mi)
2030 }
2031 }
2032 }
2033 #[doc = "`PageDown(bool)` overload"]
2034 fn page_down(self, is_trigger: impl ::core::convert::Into<bool>) -> () {
2035 unsafe {
2036 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2037 {
2038 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2039 let __vi = *__vt.get(47usize).unwrap_or_else(|| {
2040 panic!(
2041 "unity: virtual slot {}
2042 out of range (vtable len {}
2043) on the runtime class behind {}
2044 (method `{}
2045`)",
2046 47usize,
2047 __vt.len(),
2048 <BasicMenu as ::unity::ClassIdentity>::NAME,
2049 "PageDown",
2050 )
2051 });
2052 let __inner: extern "C" fn(BasicMenu, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2053 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2054 __inner(__receiver, ::core::convert::Into::into(is_trigger), __mi)
2055 }
2056 }
2057 }
2058 #[doc = "`SystemCall()` overload"]
2059 fn system_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2060 unsafe {
2061 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2062 {
2063 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2064 let __vi = *__vt.get(48usize).unwrap_or_else(|| {
2065 panic!(
2066 "unity: virtual slot {}
2067 out of range (vtable len {}
2068) on the runtime class behind {}
2069 (method `{}
2070`)",
2071 48usize,
2072 __vt.len(),
2073 <BasicMenu as ::unity::ClassIdentity>::NAME,
2074 "SystemCall",
2075 )
2076 });
2077 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2078 ::core::mem::transmute(__vi.method_ptr);
2079 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2080 __inner(__receiver, __mi)
2081 }
2082 }
2083 }
2084 #[doc = "`KeyCall()` overload"]
2085 fn key_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2086 unsafe {
2087 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2088 {
2089 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2090 let __vi = *__vt.get(49usize).unwrap_or_else(|| {
2091 panic!(
2092 "unity: virtual slot {}
2093 out of range (vtable len {}
2094) on the runtime class behind {}
2095 (method `{}
2096`)",
2097 49usize,
2098 __vt.len(),
2099 <BasicMenu as ::unity::ClassIdentity>::NAME,
2100 "KeyCall",
2101 )
2102 });
2103 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2104 ::core::mem::transmute(__vi.method_ptr);
2105 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2106 __inner(__receiver, __mi)
2107 }
2108 }
2109 }
2110 #[doc = "`ACall()` overload"]
2111 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2112 unsafe {
2113 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2114 {
2115 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2116 let __vi = *__vt.get(50usize).unwrap_or_else(|| {
2117 panic!(
2118 "unity: virtual slot {}
2119 out of range (vtable len {}
2120) on the runtime class behind {}
2121 (method `{}
2122`)",
2123 50usize,
2124 __vt.len(),
2125 <BasicMenu as ::unity::ClassIdentity>::NAME,
2126 "ACall",
2127 )
2128 });
2129 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2130 ::core::mem::transmute(__vi.method_ptr);
2131 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2132 __inner(__receiver, __mi)
2133 }
2134 }
2135 }
2136 #[doc = "`BCall()` overload"]
2137 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2138 unsafe {
2139 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2140 {
2141 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2142 let __vi = *__vt.get(51usize).unwrap_or_else(|| {
2143 panic!(
2144 "unity: virtual slot {}
2145 out of range (vtable len {}
2146) on the runtime class behind {}
2147 (method `{}
2148`)",
2149 51usize,
2150 __vt.len(),
2151 <BasicMenu as ::unity::ClassIdentity>::NAME,
2152 "BCall",
2153 )
2154 });
2155 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2156 ::core::mem::transmute(__vi.method_ptr);
2157 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2158 __inner(__receiver, __mi)
2159 }
2160 }
2161 }
2162 #[doc = "`XCall()` overload"]
2163 fn x_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2164 unsafe {
2165 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2166 {
2167 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2168 let __vi = *__vt.get(52usize).unwrap_or_else(|| {
2169 panic!(
2170 "unity: virtual slot {}
2171 out of range (vtable len {}
2172) on the runtime class behind {}
2173 (method `{}
2174`)",
2175 52usize,
2176 __vt.len(),
2177 <BasicMenu as ::unity::ClassIdentity>::NAME,
2178 "XCall",
2179 )
2180 });
2181 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2182 ::core::mem::transmute(__vi.method_ptr);
2183 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2184 __inner(__receiver, __mi)
2185 }
2186 }
2187 }
2188 #[doc = "`YCall()` overload"]
2189 fn y_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2190 unsafe {
2191 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2192 {
2193 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2194 let __vi = *__vt.get(53usize).unwrap_or_else(|| {
2195 panic!(
2196 "unity: virtual slot {}
2197 out of range (vtable len {}
2198) on the runtime class behind {}
2199 (method `{}
2200`)",
2201 53usize,
2202 __vt.len(),
2203 <BasicMenu as ::unity::ClassIdentity>::NAME,
2204 "YCall",
2205 )
2206 });
2207 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2208 ::core::mem::transmute(__vi.method_ptr);
2209 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2210 __inner(__receiver, __mi)
2211 }
2212 }
2213 }
2214 #[doc = "`LCall()` overload"]
2215 fn l_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2216 unsafe {
2217 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2218 {
2219 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2220 let __vi = *__vt.get(54usize).unwrap_or_else(|| {
2221 panic!(
2222 "unity: virtual slot {}
2223 out of range (vtable len {}
2224) on the runtime class behind {}
2225 (method `{}
2226`)",
2227 54usize,
2228 __vt.len(),
2229 <BasicMenu as ::unity::ClassIdentity>::NAME,
2230 "LCall",
2231 )
2232 });
2233 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2234 ::core::mem::transmute(__vi.method_ptr);
2235 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2236 __inner(__receiver, __mi)
2237 }
2238 }
2239 }
2240 #[doc = "`RCall()` overload"]
2241 fn r_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2242 unsafe {
2243 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2244 {
2245 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2246 let __vi = *__vt.get(55usize).unwrap_or_else(|| {
2247 panic!(
2248 "unity: virtual slot {}
2249 out of range (vtable len {}
2250) on the runtime class behind {}
2251 (method `{}
2252`)",
2253 55usize,
2254 __vt.len(),
2255 <BasicMenu as ::unity::ClassIdentity>::NAME,
2256 "RCall",
2257 )
2258 });
2259 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2260 ::core::mem::transmute(__vi.method_ptr);
2261 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2262 __inner(__receiver, __mi)
2263 }
2264 }
2265 }
2266 #[doc = "`PlusCall()` overload"]
2267 fn plus_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2268 unsafe {
2269 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2270 {
2271 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2272 let __vi = *__vt.get(56usize).unwrap_or_else(|| {
2273 panic!(
2274 "unity: virtual slot {}
2275 out of range (vtable len {}
2276) on the runtime class behind {}
2277 (method `{}
2278`)",
2279 56usize,
2280 __vt.len(),
2281 <BasicMenu as ::unity::ClassIdentity>::NAME,
2282 "PlusCall",
2283 )
2284 });
2285 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2286 ::core::mem::transmute(__vi.method_ptr);
2287 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2288 __inner(__receiver, __mi)
2289 }
2290 }
2291 }
2292 #[doc = "`MinusCall()` overload"]
2293 fn minus_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2294 unsafe {
2295 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2296 {
2297 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2298 let __vi = *__vt.get(57usize).unwrap_or_else(|| {
2299 panic!(
2300 "unity: virtual slot {}
2301 out of range (vtable len {}
2302) on the runtime class behind {}
2303 (method `{}
2304`)",
2305 57usize,
2306 __vt.len(),
2307 <BasicMenu as ::unity::ClassIdentity>::NAME,
2308 "MinusCall",
2309 )
2310 });
2311 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2312 ::core::mem::transmute(__vi.method_ptr);
2313 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2314 __inner(__receiver, __mi)
2315 }
2316 }
2317 }
2318 #[doc = "`CustomCall()` overload"]
2319 fn custom_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2320 unsafe {
2321 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2322 {
2323 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2324 let __vi = *__vt.get(58usize).unwrap_or_else(|| {
2325 panic!(
2326 "unity: virtual slot {}
2327 out of range (vtable len {}
2328) on the runtime class behind {}
2329 (method `{}
2330`)",
2331 58usize,
2332 __vt.len(),
2333 <BasicMenu as ::unity::ClassIdentity>::NAME,
2334 "CustomCall",
2335 )
2336 });
2337 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2338 ::core::mem::transmute(__vi.method_ptr);
2339 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2340 __inner(__receiver, __mi)
2341 }
2342 }
2343 }
2344 #[doc = "`PlayCursorSE()` overload"]
2345 fn play_cursor_se(self) -> () {
2346 unsafe {
2347 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2348 {
2349 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2350 let __vi = *__vt.get(59usize).unwrap_or_else(|| {
2351 panic!(
2352 "unity: virtual slot {}
2353 out of range (vtable len {}
2354) on the runtime class behind {}
2355 (method `{}
2356`)",
2357 59usize,
2358 __vt.len(),
2359 <BasicMenu as ::unity::ClassIdentity>::NAME,
2360 "PlayCursorSE",
2361 )
2362 });
2363 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2364 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2365 __inner(__receiver, __mi)
2366 }
2367 }
2368 }
2369 #[doc = "`PlayDecideSE()` overload"]
2370 fn play_decide_se(self) -> () {
2371 unsafe {
2372 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2373 {
2374 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2375 let __vi = *__vt.get(60usize).unwrap_or_else(|| {
2376 panic!(
2377 "unity: virtual slot {}
2378 out of range (vtable len {}
2379) on the runtime class behind {}
2380 (method `{}
2381`)",
2382 60usize,
2383 __vt.len(),
2384 <BasicMenu as ::unity::ClassIdentity>::NAME,
2385 "PlayDecideSE",
2386 )
2387 });
2388 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2389 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2390 __inner(__receiver, __mi)
2391 }
2392 }
2393 }
2394 #[doc = "`PlayDecideBigSE()` overload"]
2395 fn play_decide_big_se(self) -> () {
2396 unsafe {
2397 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2398 {
2399 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2400 let __vi = *__vt.get(61usize).unwrap_or_else(|| {
2401 panic!(
2402 "unity: virtual slot {}
2403 out of range (vtable len {}
2404) on the runtime class behind {}
2405 (method `{}
2406`)",
2407 61usize,
2408 __vt.len(),
2409 <BasicMenu as ::unity::ClassIdentity>::NAME,
2410 "PlayDecideBigSE",
2411 )
2412 });
2413 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2414 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2415 __inner(__receiver, __mi)
2416 }
2417 }
2418 }
2419 #[doc = "`PlayCancelSE()` overload"]
2420 fn play_cancel_se(self) -> () {
2421 unsafe {
2422 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2423 {
2424 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2425 let __vi = *__vt.get(62usize).unwrap_or_else(|| {
2426 panic!(
2427 "unity: virtual slot {}
2428 out of range (vtable len {}
2429) on the runtime class behind {}
2430 (method `{}
2431`)",
2432 62usize,
2433 __vt.len(),
2434 <BasicMenu as ::unity::ClassIdentity>::NAME,
2435 "PlayCancelSE",
2436 )
2437 });
2438 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2439 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2440 __inner(__receiver, __mi)
2441 }
2442 }
2443 }
2444 #[doc = "`GetTutorial()` overload"]
2445 fn get_tutorial(self) -> ::unity::Il2CppString {
2446 unsafe {
2447 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2448 {
2449 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2450 let __vi = *__vt.get(63usize).unwrap_or_else(|| {
2451 panic!(
2452 "unity: virtual slot {}
2453 out of range (vtable len {}
2454) on the runtime class behind {}
2455 (method `{}
2456`)",
2457 63usize,
2458 __vt.len(),
2459 <BasicMenu as ::unity::ClassIdentity>::NAME,
2460 "GetTutorial",
2461 )
2462 });
2463 let __inner: extern "C" fn(BasicMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
2464 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2465 __inner(__receiver, __mi)
2466 }
2467 }
2468 }
2469 #[doc = "`TryTutorial()` overload"]
2470 fn try_tutorial(self) -> () {
2471 unsafe {
2472 let __receiver = <BasicMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2473 ::unity::il2cpp_call!((::unity::module_base()+0x24620c0usize)as*mut u8,();
2474(BasicMenu)__receiver)
2475 }
2476 }
2477}
2478
2479#[cfg(feature = "app-basicmenu")]
2480impl<__T: IBasicMenu> IBasicMenuMethods for __T {}
2481
2482#[cfg(feature = "app-basicmenu")]
2483impl BasicMenu {
2484 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2485 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2486 }
2487
2488 pub fn create_default_desc_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2489 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2490 }
2491
2492 pub fn get_bind_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2493 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2494 }
2495
2496 pub fn on_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2497 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2498 }
2499
2500 pub fn on_unbind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2501 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2502 }
2503
2504 pub fn bind_parent_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2505 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2506 }
2507
2508 pub fn build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2509 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2510 }
2511
2512 pub fn set_active_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2513 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2514 }
2515
2516 pub fn set_active_all_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2517 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2518 }
2519
2520 pub fn open_anime_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2521 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2522 }
2523
2524 pub fn open_anime_all_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2525 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2526 }
2527
2528 pub fn close_anime_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2529 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2530 }
2531
2532 pub fn close_anime_all_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2533 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2534 }
2535
2536 pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2537 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2538 }
2539
2540 pub fn after_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2541 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2542 }
2543
2544 pub fn on_close_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2545 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2546 }
2547
2548 pub fn on_cursor_move_end_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2549 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2550 }
2551
2552 pub fn on_resume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2553 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
2554 }
2555
2556 pub fn on_suspend_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2557 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
2558 }
2559
2560 pub fn on_create_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2561 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2562 }
2563
2564 pub fn on_dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2565 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2566 }
2567
2568 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2569 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2570 }
2571
2572 pub fn get_menu_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2573 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
2574 }
2575
2576 pub fn get_menu_item_num_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2577 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
2578 }
2579
2580 pub fn clamp_menu_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2581 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
2582 }
2583
2584 pub fn get_menu_item_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2585 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
2586 }
2587
2588 pub fn get_row_num_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2589 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
2590 }
2591
2592 pub fn get_show_row_num_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2593 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
2594 }
2595
2596 pub fn set_show_row_num_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2597 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
2598 }
2599
2600 pub fn set_show_row_auto_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2601 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
2602 }
2603
2604 pub fn get_show_row_max_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2605 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
2606 }
2607
2608 pub fn get_build_row_num_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2609 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
2610 }
2611
2612 pub fn get_select_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2613 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
2614 }
2615
2616 pub fn get_select_index_old_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2617 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
2618 }
2619
2620 pub fn set_select_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2621 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
2622 }
2623
2624 pub fn update_select_index_old_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2625 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
2626 }
2627
2628 pub fn adjust_select_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2629 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
2630 }
2631
2632 pub fn get_scroll_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2633 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
2634 }
2635
2636 pub fn get_scroll_index_old_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2637 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
2638 }
2639
2640 pub fn set_scroll_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2641 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
2642 }
2643
2644 pub fn update_scroll_index_old_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2645 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
2646 }
2647
2648 pub fn adjust_scroll_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2649 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
2650 }
2651
2652 pub fn save_select_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2653 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
2654 }
2655
2656 pub fn restore_select_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2657 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
2658 }
2659
2660 pub fn is_opening_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2661 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
2662 }
2663
2664 pub fn is_closing_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2665 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
2666 }
2667
2668 pub fn is_closed_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2669 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
2670 }
2671
2672 pub fn is_cursor_hide_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2673 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
2674 }
2675
2676 pub fn set_cursor_hide_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2677 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
2678 }
2679
2680 pub fn is_input_disable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2681 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
2682 }
2683
2684 pub fn set_input_disable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2685 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
2686 }
2687
2688 pub fn is_input_disable_now_frame_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2689 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[51]
2690 }
2691
2692 pub fn set_input_disable_now_frame_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2693 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[52]
2694 }
2695
2696 pub fn is_cursor_moved_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2697 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[53]
2698 }
2699
2700 pub fn set_cursor_moved_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2701 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[54]
2702 }
2703
2704 pub fn is_close_called_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2705 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[55]
2706 }
2707
2708 pub fn set_close_called_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2709 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[56]
2710 }
2711
2712 pub fn is_rebuild_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2713 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[57]
2714 }
2715
2716 pub fn is_system_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2717 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[58]
2718 }
2719
2720 pub fn set_cursor_move_frame_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2721 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[59]
2722 }
2723
2724 pub fn cursor_move_instant_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2725 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[60]
2726 }
2727
2728 pub fn set_scroll_frame_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2729 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[61]
2730 }
2731
2732 pub fn scroll_instant_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2733 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[62]
2734 }
2735
2736 pub fn set_back_cursor_color_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2737 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[63]
2738 }
2739
2740 pub fn set_cursor_to_keep_animator_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2741 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[64]
2742 }
2743
2744 pub fn move_front_cursor_from_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2745 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[65]
2746 }
2747
2748 pub fn move_front_cursor_from_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2749 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[66]
2750 }
2751
2752 pub fn put_cursor_in_front_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2753 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[67]
2754 }
2755
2756 pub fn put_cursor_in_back_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2757 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[68]
2758 }
2759
2760 pub fn set_cursor_front_back_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2761 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[69]
2762 }
2763
2764 pub fn restart_cursor_animation_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2765 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[70]
2766 }
2767
2768 pub fn get_sub_menu_base_transform_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2769 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[71]
2770 }
2771
2772 pub fn is_suspend_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2773 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[72]
2774 }
2775
2776 pub fn inc_suspend_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2777 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[73]
2778 }
2779
2780 pub fn dec_suspend_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2781 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[74]
2782 }
2783
2784 pub fn set_pivot_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2785 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[75]
2786 }
2787
2788 pub fn get_anchor_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2789 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[76]
2790 }
2791
2792 pub fn set_anchor_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2793 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[77]
2794 }
2795
2796 pub fn set_anchor_type_from_screen_coord_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2797 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[78]
2798 }
2799
2800 pub fn anchor_position_to_anchor_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2801 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[79]
2802 }
2803
2804 pub fn get_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2805 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[80]
2806 }
2807
2808 pub fn get_y_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2809 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[81]
2810 }
2811
2812 pub fn set_x_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2813 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[82]
2814 }
2815
2816 pub fn set_y_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2817 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[83]
2818 }
2819
2820 pub fn get_pos_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2821 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[84]
2822 }
2823
2824 pub fn set_pos_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2825 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[85]
2826 }
2827
2828 pub fn set_transform_as_sub_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2829 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[86]
2830 }
2831
2832 pub fn set_color_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2833 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[87]
2834 }
2835
2836 pub fn get_w_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2837 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[88]
2838 }
2839
2840 pub fn get_h_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2841 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[89]
2842 }
2843
2844 pub fn set_as_first_sibling_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2845 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[90]
2846 }
2847
2848 pub fn set_as_last_sibling_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2849 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[91]
2850 }
2851
2852 pub fn rebuild_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2853 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[92]
2854 }
2855
2856 pub fn rebuild_instant_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2857 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[93]
2858 }
2859
2860 pub fn rebuild_instant_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2861 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[94]
2862 }
2863
2864 pub fn rebuild_instant_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2865 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[95]
2866 }
2867
2868 pub fn close_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2869 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[96]
2870 }
2871
2872 pub fn close_parent_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2873 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[97]
2874 }
2875
2876 pub fn delete_parent_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2877 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[98]
2878 }
2879
2880 pub fn tick_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2881 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[99]
2882 }
2883
2884 pub fn tick_input_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2885 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[100]
2886 }
2887
2888 pub fn key_up_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2889 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[101]
2890 }
2891
2892 pub fn key_down_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2893 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[102]
2894 }
2895
2896 pub fn key_left_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2897 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[103]
2898 }
2899
2900 pub fn key_right_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2901 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[104]
2902 }
2903
2904 pub fn move_up_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2905 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[105]
2906 }
2907
2908 pub fn move_down_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2909 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[106]
2910 }
2911
2912 pub fn page_up_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2913 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[107]
2914 }
2915
2916 pub fn page_down_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2917 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[108]
2918 }
2919
2920 pub fn system_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2921 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[109]
2922 }
2923
2924 pub fn key_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2925 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[110]
2926 }
2927
2928 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2929 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[111]
2930 }
2931
2932 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2933 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[112]
2934 }
2935
2936 pub fn x_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2937 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[113]
2938 }
2939
2940 pub fn y_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2941 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[114]
2942 }
2943
2944 pub fn l_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2945 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[115]
2946 }
2947
2948 pub fn r_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2949 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[116]
2950 }
2951
2952 pub fn plus_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2953 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[117]
2954 }
2955
2956 pub fn minus_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2957 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[118]
2958 }
2959
2960 pub fn custom_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2961 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[119]
2962 }
2963
2964 pub fn play_cursor_se_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2965 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[120]
2966 }
2967
2968 pub fn play_decide_se_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2969 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[121]
2970 }
2971
2972 pub fn play_decide_big_se_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2973 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[122]
2974 }
2975
2976 pub fn play_cancel_se_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2977 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[123]
2978 }
2979
2980 pub fn get_tutorial_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2981 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[124]
2982 }
2983
2984 pub fn try_tutorial_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2985 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[125]
2986 }
2987
2988 pub fn create_basic_menu_common_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2989 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[126]
2990 }
2991
2992 pub fn create_dummy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2993 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[127]
2994 }
2995
2996 pub fn create_basic_menu_no_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2997 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[128]
2998 }
2999
3000 pub fn create_basic_menu_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3001 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[129]
3002 }
3003}
3004
3005#[cfg(feature = "app-basicmenu")]
3006impl BasicMenu {
3007 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `CreateDefaultDesc`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3008 pub unsafe fn create_default_desc(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Array<crate::app::procdesc::ProcDesc> {
3009 let __mi = Self::create_default_desc_method_info();
3010 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Array<crate::app::procdesc::ProcDesc> =
3011 ::core::mem::transmute(__mi.method_ptr);
3012 __inner(this.into(), ::core::option::Option::None)
3013 }
3014
3015 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `get_BindType`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3016 pub unsafe fn get_bind_type(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_BindTypes {
3017 let __mi = Self::get_bind_type_method_info();
3018 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_BindTypes =
3019 ::core::mem::transmute(__mi.method_ptr);
3020 __inner(this.into(), ::core::option::Option::None)
3021 }
3022
3023 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OnBind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3024 pub unsafe fn on_bind(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3025 let __mi = Self::on_bind_method_info();
3026 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3027 __inner(this.into(), ::core::option::Option::None)
3028 }
3029
3030 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OnUnbind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3031 pub unsafe fn on_unbind(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3032 let __mi = Self::on_unbind_method_info();
3033 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3034 __inner(this.into(), ::core::option::Option::None)
3035 }
3036
3037 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OpenAnime`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3038 pub unsafe fn open_anime(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3039 let __mi = Self::open_anime_method_info();
3040 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3041 __inner(this.into(), ::core::option::Option::None)
3042 }
3043
3044 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OpenAnimeAll`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3045 pub unsafe fn open_anime_all(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3046 let __mi = Self::open_anime_all_method_info();
3047 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3048 __inner(this.into(), ::core::option::Option::None)
3049 }
3050
3051 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `CloseAnime`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3052 pub unsafe fn close_anime(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3053 let __mi = Self::close_anime_method_info();
3054 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3055 __inner(this.into(), ::core::option::Option::None)
3056 }
3057
3058 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `CloseAnimeAll`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3059 pub unsafe fn close_anime_all(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3060 let __mi = Self::close_anime_all_method_info();
3061 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3062 __inner(this.into(), ::core::option::Option::None)
3063 }
3064
3065 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3066 pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>, is_first_build: bool) -> () {
3067 let __mi = Self::on_build_method_info();
3068 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3069 __inner(this.into(), is_first_build, ::core::option::Option::None)
3070 }
3071
3072 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `AfterBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3073 pub unsafe fn after_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3074 let __mi = Self::after_build_method_info();
3075 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3076 __inner(this.into(), ::core::option::Option::None)
3077 }
3078
3079 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OnClose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3080 pub unsafe fn on_close(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3081 let __mi = Self::on_close_method_info();
3082 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3083 __inner(this.into(), ::core::option::Option::None)
3084 }
3085
3086 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OnCursorMoveEnd`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3087 pub unsafe fn on_cursor_move_end(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3088 let __mi = Self::on_cursor_move_end_method_info();
3089 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3090 __inner(this.into(), ::core::option::Option::None)
3091 }
3092
3093 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OnResume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3094 pub unsafe fn on_resume(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3095 let __mi = Self::on_resume_method_info();
3096 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3097 __inner(this.into(), ::core::option::Option::None)
3098 }
3099
3100 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OnSuspend`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3101 pub unsafe fn on_suspend(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3102 let __mi = Self::on_suspend_method_info();
3103 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3104 __inner(this.into(), ::core::option::Option::None)
3105 }
3106
3107 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OnCreate`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3108 pub unsafe fn on_create(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3109 let __mi = Self::on_create_method_info();
3110 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3111 __inner(this.into(), ::core::option::Option::None)
3112 }
3113
3114 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `OnDispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3115 pub unsafe fn on_dispose(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3116 let __mi = Self::on_dispose_method_info();
3117 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3118 __inner(this.into(), ::core::option::Option::None)
3119 }
3120
3121 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3122 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3123 let __mi = Self::get_name_method_info();
3124 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3125 __inner(this.into(), ::core::option::Option::None)
3126 }
3127
3128 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `ClampMenuItemIndex`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3129 pub unsafe fn clamp_menu_item_index(this: impl ::core::convert::Into<::unity::IlInstance>, item_index: i32) -> i32 {
3130 let __mi = Self::clamp_menu_item_index_method_info();
3131 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3132 __inner(this.into(), item_index, ::core::option::Option::None)
3133 }
3134
3135 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `GetShowRowMax`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3136 pub unsafe fn get_show_row_max(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
3137 let __mi = Self::get_show_row_max_method_info();
3138 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3139 __inner(this.into(), ::core::option::Option::None)
3140 }
3141
3142 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `GetBuildRowNum`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3143 pub unsafe fn get_build_row_num(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
3144 let __mi = Self::get_build_row_num_method_info();
3145 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3146 __inner(this.into(), ::core::option::Option::None)
3147 }
3148
3149 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `SetSelectIndex`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3150 pub unsafe fn set_select_index(this: impl ::core::convert::Into<::unity::IlInstance>, select_index: i32) -> () {
3151 let __mi = Self::set_select_index_method_info();
3152 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3153 __inner(this.into(), select_index, ::core::option::Option::None)
3154 }
3155
3156 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `AdjustScrollIndex`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3157 pub unsafe fn adjust_scroll_index(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3158 let __mi = Self::adjust_scroll_index_method_info();
3159 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3160 __inner(this.into(), ::core::option::Option::None)
3161 }
3162
3163 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `IsSystemCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3164 pub unsafe fn is_system_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3165 let __mi = Self::is_system_call_method_info();
3166 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3167 __inner(this.into(), ::core::option::Option::None)
3168 }
3169
3170 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `RebuildInstant`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3171 pub unsafe fn rebuild_instant_3(
3172 this: impl ::core::convert::Into<::unity::IlInstance>,
3173 menu_select: crate::app::basicmenuselect::BasicMenuSelect,
3174 display_index: i32,
3175 ) -> () {
3176 let __mi = Self::rebuild_instant_3_method_info();
3177 let __inner: extern "C" fn(::unity::IlInstance, crate::app::basicmenuselect::BasicMenuSelect, i32, ::unity::OptionalMethod) -> () =
3178 ::core::mem::transmute(__mi.method_ptr);
3179 __inner(this.into(), menu_select, display_index, ::core::option::Option::None)
3180 }
3181
3182 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `Tick`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3183 pub unsafe fn tick(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3184 let __mi = Self::tick_method_info();
3185 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3186 __inner(this.into(), ::core::option::Option::None)
3187 }
3188
3189 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `TickInput`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3190 pub unsafe fn tick_input(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3191 let __mi = Self::tick_input_method_info();
3192 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3193 __inner(this.into(), ::core::option::Option::None)
3194 }
3195
3196 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `KeyUp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3197 pub unsafe fn key_up(this: impl ::core::convert::Into<::unity::IlInstance>, is_trigger: bool) -> () {
3198 let __mi = Self::key_up_method_info();
3199 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3200 __inner(this.into(), is_trigger, ::core::option::Option::None)
3201 }
3202
3203 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `KeyDown`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3204 pub unsafe fn key_down(this: impl ::core::convert::Into<::unity::IlInstance>, is_trigger: bool) -> () {
3205 let __mi = Self::key_down_method_info();
3206 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3207 __inner(this.into(), is_trigger, ::core::option::Option::None)
3208 }
3209
3210 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `KeyLeft`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3211 pub unsafe fn key_left(this: impl ::core::convert::Into<::unity::IlInstance>, is_trigger: bool) -> () {
3212 let __mi = Self::key_left_method_info();
3213 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3214 __inner(this.into(), is_trigger, ::core::option::Option::None)
3215 }
3216
3217 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `KeyRight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3218 pub unsafe fn key_right(this: impl ::core::convert::Into<::unity::IlInstance>, is_trigger: bool) -> () {
3219 let __mi = Self::key_right_method_info();
3220 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3221 __inner(this.into(), is_trigger, ::core::option::Option::None)
3222 }
3223
3224 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `MoveUp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3225 pub unsafe fn move_up(this: impl ::core::convert::Into<::unity::IlInstance>, is_trigger: bool) -> () {
3226 let __mi = Self::move_up_method_info();
3227 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3228 __inner(this.into(), is_trigger, ::core::option::Option::None)
3229 }
3230
3231 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `MoveDown`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3232 pub unsafe fn move_down(this: impl ::core::convert::Into<::unity::IlInstance>, is_trigger: bool) -> () {
3233 let __mi = Self::move_down_method_info();
3234 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3235 __inner(this.into(), is_trigger, ::core::option::Option::None)
3236 }
3237
3238 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `PageUp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3239 pub unsafe fn page_up(this: impl ::core::convert::Into<::unity::IlInstance>, is_trigger: bool) -> () {
3240 let __mi = Self::page_up_method_info();
3241 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3242 __inner(this.into(), is_trigger, ::core::option::Option::None)
3243 }
3244
3245 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `PageDown`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3246 pub unsafe fn page_down(this: impl ::core::convert::Into<::unity::IlInstance>, is_trigger: bool) -> () {
3247 let __mi = Self::page_down_method_info();
3248 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3249 __inner(this.into(), is_trigger, ::core::option::Option::None)
3250 }
3251
3252 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `SystemCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3253 pub unsafe fn system_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3254 let __mi = Self::system_call_method_info();
3255 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3256 ::core::mem::transmute(__mi.method_ptr);
3257 __inner(this.into(), ::core::option::Option::None)
3258 }
3259
3260 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `KeyCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3261 pub unsafe fn key_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3262 let __mi = Self::key_call_method_info();
3263 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3264 ::core::mem::transmute(__mi.method_ptr);
3265 __inner(this.into(), ::core::option::Option::None)
3266 }
3267
3268 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3269 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3270 let __mi = Self::a_call_method_info();
3271 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3272 ::core::mem::transmute(__mi.method_ptr);
3273 __inner(this.into(), ::core::option::Option::None)
3274 }
3275
3276 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3277 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3278 let __mi = Self::b_call_method_info();
3279 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3280 ::core::mem::transmute(__mi.method_ptr);
3281 __inner(this.into(), ::core::option::Option::None)
3282 }
3283
3284 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `XCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3285 pub unsafe fn x_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3286 let __mi = Self::x_call_method_info();
3287 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3288 ::core::mem::transmute(__mi.method_ptr);
3289 __inner(this.into(), ::core::option::Option::None)
3290 }
3291
3292 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `YCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3293 pub unsafe fn y_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3294 let __mi = Self::y_call_method_info();
3295 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3296 ::core::mem::transmute(__mi.method_ptr);
3297 __inner(this.into(), ::core::option::Option::None)
3298 }
3299
3300 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `LCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3301 pub unsafe fn l_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3302 let __mi = Self::l_call_method_info();
3303 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3304 ::core::mem::transmute(__mi.method_ptr);
3305 __inner(this.into(), ::core::option::Option::None)
3306 }
3307
3308 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `RCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3309 pub unsafe fn r_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3310 let __mi = Self::r_call_method_info();
3311 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3312 ::core::mem::transmute(__mi.method_ptr);
3313 __inner(this.into(), ::core::option::Option::None)
3314 }
3315
3316 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `PlusCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3317 pub unsafe fn plus_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3318 let __mi = Self::plus_call_method_info();
3319 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3320 ::core::mem::transmute(__mi.method_ptr);
3321 __inner(this.into(), ::core::option::Option::None)
3322 }
3323
3324 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `MinusCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3325 pub unsafe fn minus_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3326 let __mi = Self::minus_call_method_info();
3327 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3328 ::core::mem::transmute(__mi.method_ptr);
3329 __inner(this.into(), ::core::option::Option::None)
3330 }
3331
3332 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `CustomCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3333 pub unsafe fn custom_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3334 let __mi = Self::custom_call_method_info();
3335 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3336 ::core::mem::transmute(__mi.method_ptr);
3337 __inner(this.into(), ::core::option::Option::None)
3338 }
3339
3340 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `PlayCursorSE`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3341 pub unsafe fn play_cursor_se(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3342 let __mi = Self::play_cursor_se_method_info();
3343 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3344 __inner(this.into(), ::core::option::Option::None)
3345 }
3346
3347 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `PlayDecideSE`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3348 pub unsafe fn play_decide_se(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3349 let __mi = Self::play_decide_se_method_info();
3350 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3351 __inner(this.into(), ::core::option::Option::None)
3352 }
3353
3354 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `PlayDecideBigSE`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3355 pub unsafe fn play_decide_big_se(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3356 let __mi = Self::play_decide_big_se_method_info();
3357 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3358 __inner(this.into(), ::core::option::Option::None)
3359 }
3360
3361 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `PlayCancelSE`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3362 pub unsafe fn play_cancel_se(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3363 let __mi = Self::play_cancel_se_method_info();
3364 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3365 __inner(this.into(), ::core::option::Option::None)
3366 }
3367
3368 #[doc = "Direct (non-virtual) call to `BasicMenu`'s own `GetTutorial`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3369 pub unsafe fn get_tutorial(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3370 let __mi = Self::get_tutorial_method_info();
3371 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3372 __inner(this.into(), ::core::option::Option::None)
3373 }
3374}
3375
3376#[cfg(feature = "app-basicmenu")]
3377impl BasicMenu {
3378 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::basicmenucontent::BasicMenuContent)` — overload selector"]
3379 pub fn new(
3380 menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
3381 menu_content: crate::app::basicmenucontent::BasicMenuContent,
3382 ) -> Self {
3383 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3384 panic!(
3385 "{}
3386::{}
3387 failed to instantiate",
3388 ::core::stringify!(BasicMenu),
3389 ::core::stringify!(new),
3390 )
3391 });
3392 <Self as IBasicMenuMethods>::ctor(this, menu_item_list, menu_content);
3393 this
3394 }
3395}
3396
3397#[cfg(feature = "app-basicmenu")]
3398#[doc(hidden)]
3399pub mod prelude {
3400 pub use super::{
3401 BasicMenu, BasicMenu_AnchorType, BasicMenu_BindTypes, BasicMenu_Label0, BasicMenu_Result, BasicMenu_Status, BasicMenu_StatusField,
3402 IBasicMenu, IBasicMenuMethods, IBasicMenu_StatusField, IBasicMenu_StatusFieldMethods,
3403 };
3404 #[cfg(feature = "app-bitfield32")]
3405 pub use crate::app::bitfield32::IBitField32Methods;
3406 #[cfg(feature = "app-bitfieldcommon")]
3407 pub use crate::app::bitfieldcommon::IBitFieldCommonMethods;
3408 #[cfg(feature = "app-bitfieldtemplate32_1")]
3409 pub use crate::app::bitfieldtemplate32_1::IBitFieldTemplate32_1Methods;
3410 #[cfg(feature = "app-procinst")]
3411 pub use crate::app::procinst::IProcInstMethods;
3412 #[cfg(feature = "system-object")]
3413 pub use crate::system::object::IObjectMethods;
3414 #[cfg(feature = "system-enum")]
3415 pub use crate::system::r#enum::IEnumMethods;
3416 #[cfg(feature = "system-valuetype")]
3417 pub use crate::system::valuetype::IValueTypeMethods;
3418 pub use crate::{
3419 app::{bitfield32::IBitField32, bitfieldcommon::IBitFieldCommon, bitfieldtemplate32_1::IBitFieldTemplate32_1, procinst::IProcInst},
3420 system::{object::IObject, r#enum::IEnum, valuetype::IValueType},
3421 };
3422}