1#[cfg(feature = "app-menuitem-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::{
9 object::{IObject, Object},
10 r#enum::{Enum, IEnum},
11 valuetype::{IValueType, ValueType},
12 };
13
14 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/menuitem/MenuItem_Result.md"))]
15 #[repr(C)]
16 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
17 pub struct MenuItem_Result {
18 pub value: i32,
19 }
20 impl ::unity::ClassIdentity for MenuItem_Result {
21 const NAME: &'static str = "MenuItem.Result";
22 const NAMESPACE: &'static str = "App";
23
24 fn class() -> ::unity::Class {
25 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
26 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
27 }
28 }
29 impl ::unity::IlType for MenuItem_Result {
30 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
31 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
32 }
33 }
34 impl MenuItem_Result {
35 pub fn pass() -> Self {
36 Self { value: 0 }
37 }
38
39 pub fn do_nothing() -> Self {
40 Self { value: 1 }
41 }
42
43 pub fn decide() -> Self {
44 Self { value: 2 }
45 }
46
47 pub fn cancel() -> Self {
48 Self { value: 3 }
49 }
50
51 pub fn close() -> Self {
52 Self { value: 4 }
53 }
54
55 pub fn close_all() -> Self {
56 Self { value: 5 }
57 }
58
59 pub fn rebuild() -> Self {
60 Self { value: 6 }
61 }
62
63 pub fn parent_rebuild() -> Self {
64 Self { value: 7 }
65 }
66 }
67
68 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/menuitem/MenuItem_Kind.md"))]
69 #[repr(C)]
70 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
71 pub struct MenuItem_Kind {
72 pub value: i32,
73 }
74 impl ::unity::ClassIdentity for MenuItem_Kind {
75 const NAME: &'static str = "MenuItem.Kind";
76 const NAMESPACE: &'static str = "App";
77
78 fn class() -> ::unity::Class {
79 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
80 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
81 }
82 }
83 impl ::unity::IlType for MenuItem_Kind {
84 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
85 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
86 }
87 }
88 impl MenuItem_Kind {
89 pub fn none() -> Self {
90 Self { value: 0 }
91 }
92
93 pub fn group_begin() -> Self {
94 Self { value: 1 }
95 }
96
97 pub fn group_end() -> Self {
98 Self { value: 2 }
99 }
100 }
101
102 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/menuitem/MenuItem_Align.md"))]
103 #[repr(C)]
104 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
105 pub struct MenuItem_Align {
106 pub value: i32,
107 }
108 impl ::unity::ClassIdentity for MenuItem_Align {
109 const NAME: &'static str = "MenuItem.Align";
110 const NAMESPACE: &'static str = "App";
111
112 fn class() -> ::unity::Class {
113 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
114 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
115 }
116 }
117 impl ::unity::IlType for MenuItem_Align {
118 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
119 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
120 }
121 }
122 impl MenuItem_Align {
123 pub fn left() -> Self {
124 Self { value: 0 }
125 }
126
127 pub fn center() -> Self {
128 Self { value: 1 }
129 }
130
131 pub fn right() -> Self {
132 Self { value: 2 }
133 }
134 }
135
136 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/menuitem/MenuItem.md"))]
137 #[::unity::class(namespace = "App", name = "MenuItem")]
138 #[parent(crate::system::object::Object)]
139 pub struct MenuItem {
140 #[offset(16)]
141 #[rename(name = "m_Menu")]
142 pub m_menu: crate::app::debugmenu::DebugMenu,
143 #[offset(24)]
144 #[rename(name = "m_State")]
145 pub m_state: crate::app::menuitem::MenuItem_State,
146 #[offset(28)]
147 #[rename(name = "m_Bind")]
148 pub m_bind: i32,
149 }
150
151 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/menuitem/MenuItem_State.md"))]
152 #[repr(C)]
153 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
154 pub struct MenuItem_State {
155 pub value: i32,
156 }
157 impl ::unity::ClassIdentity for MenuItem_State {
158 const NAME: &'static str = "MenuItem.State";
159 const NAMESPACE: &'static str = "App";
160
161 fn class() -> ::unity::Class {
162 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
163 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
164 }
165 }
166 impl ::unity::IlType for MenuItem_State {
167 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
168 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
169 }
170 }
171 impl MenuItem_State {
172 pub fn none() -> Self {
173 Self { value: 0 }
174 }
175
176 pub fn open() -> Self {
177 Self { value: 1 }
178 }
179
180 pub fn close() -> Self {
181 Self { value: 2 }
182 }
183 }
184}
185
186#[cfg(feature = "app-menuitem-types")]
187pub use __types::*;
188
189#[cfg(feature = "app-menuitem")]
190impl MenuItem {
191 #[doc = "`op_Implicit(crate::app::menuitem::MenuItem)` overload"]
192 pub fn op_implicit(p: impl ::core::convert::Into<crate::app::menuitem::MenuItem>) -> crate::app::debugmenu::DebugMenu {
193 unsafe {
194 ::unity::il2cpp_call!((::unity::module_base()+0x25d0840usize)as*mut u8,crate::app::debugmenu::DebugMenu;
195(crate::app::menuitem::MenuItem)::core::convert::Into::into(p))
196 }
197 }
198}
199
200#[cfg(feature = "app-menuitem")]
201pub trait IMenuItemMethods: IMenuItem {
202 #[doc = "`GetName()` overload"]
203 fn get_name(self) -> ::unity::Il2CppString {
204 unsafe {
205 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
206 {
207 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
208 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
209 panic!(
210 "unity: virtual slot {}
211 out of range (vtable len {}
212) on the runtime class behind {}
213 (method `{}
214`)",
215 5usize,
216 __vt.len(),
217 <MenuItem as ::unity::ClassIdentity>::NAME,
218 "GetName",
219 )
220 });
221 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
222 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
223 __inner(__receiver, __mi)
224 }
225 }
226 }
227 #[doc = "`GetNameEnglish()` overload"]
228 fn get_name_english(self) -> ::unity::Il2CppString {
229 unsafe {
230 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
231 {
232 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
233 let __vi = *__vt.get(6usize).unwrap_or_else(|| {
234 panic!(
235 "unity: virtual slot {}
236 out of range (vtable len {}
237) on the runtime class behind {}
238 (method `{}
239`)",
240 6usize,
241 __vt.len(),
242 <MenuItem as ::unity::ClassIdentity>::NAME,
243 "GetNameEnglish",
244 )
245 });
246 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
247 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
248 __inner(__receiver, __mi)
249 }
250 }
251 }
252 #[doc = "`GetHelp()` overload"]
253 fn get_help(self) -> ::unity::Il2CppString {
254 unsafe {
255 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
256 {
257 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
258 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
259 panic!(
260 "unity: virtual slot {}
261 out of range (vtable len {}
262) on the runtime class behind {}
263 (method `{}
264`)",
265 7usize,
266 __vt.len(),
267 <MenuItem as ::unity::ClassIdentity>::NAME,
268 "GetHelp",
269 )
270 });
271 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
272 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
273 __inner(__receiver, __mi)
274 }
275 }
276 }
277 #[doc = "`GetHelpEnglish()` overload"]
278 fn get_help_english(self) -> ::unity::Il2CppString {
279 unsafe {
280 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
281 {
282 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
283 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
284 panic!(
285 "unity: virtual slot {}
286 out of range (vtable len {}
287) on the runtime class behind {}
288 (method `{}
289`)",
290 8usize,
291 __vt.len(),
292 <MenuItem as ::unity::ClassIdentity>::NAME,
293 "GetHelpEnglish",
294 )
295 });
296 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
297 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
298 __inner(__receiver, __mi)
299 }
300 }
301 }
302 #[doc = "`GetHelpWidth()` overload"]
303 fn get_help_width(self) -> f32 {
304 unsafe {
305 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
306 {
307 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
308 let __vi = *__vt.get(9usize).unwrap_or_else(|| {
309 panic!(
310 "unity: virtual slot {}
311 out of range (vtable len {}
312) on the runtime class behind {}
313 (method `{}
314`)",
315 9usize,
316 __vt.len(),
317 <MenuItem as ::unity::ClassIdentity>::NAME,
318 "GetHelpWidth",
319 )
320 });
321 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
322 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
323 __inner(__receiver, __mi)
324 }
325 }
326 }
327 #[doc = "`GetHelpHeight()` overload"]
328 fn get_help_height(self) -> f32 {
329 unsafe {
330 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
331 {
332 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
333 let __vi = *__vt.get(10usize).unwrap_or_else(|| {
334 panic!(
335 "unity: virtual slot {}
336 out of range (vtable len {}
337) on the runtime class behind {}
338 (method `{}
339`)",
340 10usize,
341 __vt.len(),
342 <MenuItem as ::unity::ClassIdentity>::NAME,
343 "GetHelpHeight",
344 )
345 });
346 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
347 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
348 __inner(__receiver, __mi)
349 }
350 }
351 }
352 #[doc = "`GetKind()` overload"]
353 fn get_kind(self) -> crate::app::menuitem::MenuItem_Kind {
354 unsafe {
355 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
356 {
357 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
358 let __vi = *__vt.get(11usize).unwrap_or_else(|| {
359 panic!(
360 "unity: virtual slot {}
361 out of range (vtable len {}
362) on the runtime class behind {}
363 (method `{}
364`)",
365 11usize,
366 __vt.len(),
367 <MenuItem as ::unity::ClassIdentity>::NAME,
368 "GetKind",
369 )
370 });
371 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Kind =
372 ::core::mem::transmute(__vi.method_ptr);
373 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
374 __inner(__receiver, __mi)
375 }
376 }
377 }
378 #[doc = "`ACall()` overload"]
379 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
380 unsafe {
381 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
382 {
383 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
384 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
385 panic!(
386 "unity: virtual slot {}
387 out of range (vtable len {}
388) on the runtime class behind {}
389 (method `{}
390`)",
391 12usize,
392 __vt.len(),
393 <MenuItem as ::unity::ClassIdentity>::NAME,
394 "ACall",
395 )
396 });
397 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
398 ::core::mem::transmute(__vi.method_ptr);
399 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
400 __inner(__receiver, __mi)
401 }
402 }
403 }
404 #[doc = "`BCall()` overload"]
405 fn b_call(self) -> crate::app::menuitem::MenuItem_Result {
406 unsafe {
407 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
408 {
409 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
410 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
411 panic!(
412 "unity: virtual slot {}
413 out of range (vtable len {}
414) on the runtime class behind {}
415 (method `{}
416`)",
417 13usize,
418 __vt.len(),
419 <MenuItem as ::unity::ClassIdentity>::NAME,
420 "BCall",
421 )
422 });
423 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
424 ::core::mem::transmute(__vi.method_ptr);
425 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
426 __inner(__receiver, __mi)
427 }
428 }
429 }
430 #[doc = "`XCall()` overload"]
431 fn x_call(self) -> crate::app::menuitem::MenuItem_Result {
432 unsafe {
433 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
434 {
435 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
436 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
437 panic!(
438 "unity: virtual slot {}
439 out of range (vtable len {}
440) on the runtime class behind {}
441 (method `{}
442`)",
443 14usize,
444 __vt.len(),
445 <MenuItem as ::unity::ClassIdentity>::NAME,
446 "XCall",
447 )
448 });
449 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
450 ::core::mem::transmute(__vi.method_ptr);
451 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
452 __inner(__receiver, __mi)
453 }
454 }
455 }
456 #[doc = "`YCall()` overload"]
457 fn y_call(self) -> crate::app::menuitem::MenuItem_Result {
458 unsafe {
459 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
460 {
461 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
462 let __vi = *__vt.get(15usize).unwrap_or_else(|| {
463 panic!(
464 "unity: virtual slot {}
465 out of range (vtable len {}
466) on the runtime class behind {}
467 (method `{}
468`)",
469 15usize,
470 __vt.len(),
471 <MenuItem as ::unity::ClassIdentity>::NAME,
472 "YCall",
473 )
474 });
475 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
476 ::core::mem::transmute(__vi.method_ptr);
477 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
478 __inner(__receiver, __mi)
479 }
480 }
481 }
482 #[doc = "`LCall()` overload"]
483 fn l_call(self) -> crate::app::menuitem::MenuItem_Result {
484 unsafe {
485 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
486 {
487 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
488 let __vi = *__vt.get(16usize).unwrap_or_else(|| {
489 panic!(
490 "unity: virtual slot {}
491 out of range (vtable len {}
492) on the runtime class behind {}
493 (method `{}
494`)",
495 16usize,
496 __vt.len(),
497 <MenuItem as ::unity::ClassIdentity>::NAME,
498 "LCall",
499 )
500 });
501 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
502 ::core::mem::transmute(__vi.method_ptr);
503 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
504 __inner(__receiver, __mi)
505 }
506 }
507 }
508 #[doc = "`RCall()` overload"]
509 fn r_call(self) -> crate::app::menuitem::MenuItem_Result {
510 unsafe {
511 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
512 {
513 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
514 let __vi = *__vt.get(17usize).unwrap_or_else(|| {
515 panic!(
516 "unity: virtual slot {}
517 out of range (vtable len {}
518) on the runtime class behind {}
519 (method `{}
520`)",
521 17usize,
522 __vt.len(),
523 <MenuItem as ::unity::ClassIdentity>::NAME,
524 "RCall",
525 )
526 });
527 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
528 ::core::mem::transmute(__vi.method_ptr);
529 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
530 __inner(__receiver, __mi)
531 }
532 }
533 }
534 #[doc = "`PlusCall()` overload"]
535 fn plus_call(self) -> crate::app::menuitem::MenuItem_Result {
536 unsafe {
537 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
538 {
539 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
540 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
541 panic!(
542 "unity: virtual slot {}
543 out of range (vtable len {}
544) on the runtime class behind {}
545 (method `{}
546`)",
547 18usize,
548 __vt.len(),
549 <MenuItem as ::unity::ClassIdentity>::NAME,
550 "PlusCall",
551 )
552 });
553 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
554 ::core::mem::transmute(__vi.method_ptr);
555 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
556 __inner(__receiver, __mi)
557 }
558 }
559 }
560 #[doc = "`MinusCall()` overload"]
561 fn minus_call(self) -> crate::app::menuitem::MenuItem_Result {
562 unsafe {
563 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
564 {
565 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
566 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
567 panic!(
568 "unity: virtual slot {}
569 out of range (vtable len {}
570) on the runtime class behind {}
571 (method `{}
572`)",
573 19usize,
574 __vt.len(),
575 <MenuItem as ::unity::ClassIdentity>::NAME,
576 "MinusCall",
577 )
578 });
579 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
580 ::core::mem::transmute(__vi.method_ptr);
581 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
582 __inner(__receiver, __mi)
583 }
584 }
585 }
586 #[doc = "`LeftCall()` overload"]
587 fn left_call(self) -> crate::app::menuitem::MenuItem_Result {
588 unsafe {
589 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
590 {
591 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
592 let __vi = *__vt.get(20usize).unwrap_or_else(|| {
593 panic!(
594 "unity: virtual slot {}
595 out of range (vtable len {}
596) on the runtime class behind {}
597 (method `{}
598`)",
599 20usize,
600 __vt.len(),
601 <MenuItem as ::unity::ClassIdentity>::NAME,
602 "LeftCall",
603 )
604 });
605 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
606 ::core::mem::transmute(__vi.method_ptr);
607 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
608 __inner(__receiver, __mi)
609 }
610 }
611 }
612 #[doc = "`RightCall()` overload"]
613 fn right_call(self) -> crate::app::menuitem::MenuItem_Result {
614 unsafe {
615 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
616 {
617 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
618 let __vi = *__vt.get(21usize).unwrap_or_else(|| {
619 panic!(
620 "unity: virtual slot {}
621 out of range (vtable len {}
622) on the runtime class behind {}
623 (method `{}
624`)",
625 21usize,
626 __vt.len(),
627 <MenuItem as ::unity::ClassIdentity>::NAME,
628 "RightCall",
629 )
630 });
631 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
632 ::core::mem::transmute(__vi.method_ptr);
633 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
634 __inner(__receiver, __mi)
635 }
636 }
637 }
638 #[doc = "`IsEnable()` overload"]
639 fn is_enable(self) -> bool {
640 unsafe {
641 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
642 {
643 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
644 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
645 panic!(
646 "unity: virtual slot {}
647 out of range (vtable len {}
648) on the runtime class behind {}
649 (method `{}
650`)",
651 22usize,
652 __vt.len(),
653 <MenuItem as ::unity::ClassIdentity>::NAME,
654 "IsEnable",
655 )
656 });
657 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
658 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
659 __inner(__receiver, __mi)
660 }
661 }
662 }
663 #[doc = "`IsVisible()` overload"]
664 fn is_visible(self) -> bool {
665 unsafe {
666 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
667 {
668 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
669 let __vi = *__vt.get(23usize).unwrap_or_else(|| {
670 panic!(
671 "unity: virtual slot {}
672 out of range (vtable len {}
673) on the runtime class behind {}
674 (method `{}
675`)",
676 23usize,
677 __vt.len(),
678 <MenuItem as ::unity::ClassIdentity>::NAME,
679 "IsVisible",
680 )
681 });
682 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
683 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
684 __inner(__receiver, __mi)
685 }
686 }
687 }
688 #[doc = "`IsSelectable()` overload"]
689 fn is_selectable(self) -> bool {
690 unsafe {
691 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
692 {
693 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
694 let __vi = *__vt.get(24usize).unwrap_or_else(|| {
695 panic!(
696 "unity: virtual slot {}
697 out of range (vtable len {}
698) on the runtime class behind {}
699 (method `{}
700`)",
701 24usize,
702 __vt.len(),
703 <MenuItem as ::unity::ClassIdentity>::NAME,
704 "IsSelectable",
705 )
706 });
707 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__vi.method_ptr);
708 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
709 __inner(__receiver, __mi)
710 }
711 }
712 }
713 #[doc = "`GetWidth()` overload"]
714 fn get_width(self) -> f32 {
715 unsafe {
716 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
717 {
718 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
719 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
720 panic!(
721 "unity: virtual slot {}
722 out of range (vtable len {}
723) on the runtime class behind {}
724 (method `{}
725`)",
726 25usize,
727 __vt.len(),
728 <MenuItem as ::unity::ClassIdentity>::NAME,
729 "GetWidth",
730 )
731 });
732 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
733 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
734 __inner(__receiver, __mi)
735 }
736 }
737 }
738 #[doc = "`GetHeight()` overload"]
739 fn get_height(self) -> f32 {
740 unsafe {
741 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
742 {
743 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
744 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
745 panic!(
746 "unity: virtual slot {}
747 out of range (vtable len {}
748) on the runtime class behind {}
749 (method `{}
750`)",
751 26usize,
752 __vt.len(),
753 <MenuItem as ::unity::ClassIdentity>::NAME,
754 "GetHeight",
755 )
756 });
757 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
758 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
759 __inner(__receiver, __mi)
760 }
761 }
762 }
763 #[doc = "`GetFontColor()` overload"]
764 fn get_font_color(self) -> crate::unity_engine::color::Color {
765 unsafe {
766 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
767 {
768 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
769 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
770 panic!(
771 "unity: virtual slot {}
772 out of range (vtable len {}
773) on the runtime class behind {}
774 (method `{}
775`)",
776 27usize,
777 __vt.len(),
778 <MenuItem as ::unity::ClassIdentity>::NAME,
779 "GetFontColor",
780 )
781 });
782 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
783 ::core::mem::transmute(__vi.method_ptr);
784 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
785 __inner(__receiver, __mi)
786 }
787 }
788 }
789 #[doc = "`GetBackColor()` overload"]
790 fn get_back_color(self) -> crate::unity_engine::color::Color {
791 unsafe {
792 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
793 {
794 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
795 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
796 panic!(
797 "unity: virtual slot {}
798 out of range (vtable len {}
799) on the runtime class behind {}
800 (method `{}
801`)",
802 28usize,
803 __vt.len(),
804 <MenuItem as ::unity::ClassIdentity>::NAME,
805 "GetBackColor",
806 )
807 });
808 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
809 ::core::mem::transmute(__vi.method_ptr);
810 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
811 __inner(__receiver, __mi)
812 }
813 }
814 }
815 #[doc = "`GetColumnCount()` overload"]
816 fn get_column_count(self) -> i32 {
817 unsafe {
818 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
819 {
820 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
821 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
822 panic!(
823 "unity: virtual slot {}
824 out of range (vtable len {}
825) on the runtime class behind {}
826 (method `{}
827`)",
828 29usize,
829 __vt.len(),
830 <MenuItem as ::unity::ClassIdentity>::NAME,
831 "GetColumnCount",
832 )
833 });
834 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
835 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
836 __inner(__receiver, __mi)
837 }
838 }
839 }
840 #[doc = "`GetColumnWidth(i32)` overload"]
841 fn get_column_width(self, i: impl ::core::convert::Into<i32>) -> f32 {
842 unsafe {
843 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
844 {
845 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
846 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
847 panic!(
848 "unity: virtual slot {}
849 out of range (vtable len {}
850) on the runtime class behind {}
851 (method `{}
852`)",
853 30usize,
854 __vt.len(),
855 <MenuItem as ::unity::ClassIdentity>::NAME,
856 "GetColumnWidth",
857 )
858 });
859 let __inner: extern "C" fn(MenuItem, i32, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
860 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
861 __inner(__receiver, ::core::convert::Into::into(i), __mi)
862 }
863 }
864 }
865 #[doc = "`GetColumnWidth0()` overload"]
866 fn get_column_width0(self) -> f32 {
867 unsafe {
868 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
869 {
870 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
871 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
872 panic!(
873 "unity: virtual slot {}
874 out of range (vtable len {}
875) on the runtime class behind {}
876 (method `{}
877`)",
878 31usize,
879 __vt.len(),
880 <MenuItem as ::unity::ClassIdentity>::NAME,
881 "GetColumnWidth0",
882 )
883 });
884 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
885 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
886 __inner(__receiver, __mi)
887 }
888 }
889 }
890 #[doc = "`GetColumnWidth1()` overload"]
891 fn get_column_width1(self) -> f32 {
892 unsafe {
893 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
894 {
895 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
896 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
897 panic!(
898 "unity: virtual slot {}
899 out of range (vtable len {}
900) on the runtime class behind {}
901 (method `{}
902`)",
903 32usize,
904 __vt.len(),
905 <MenuItem as ::unity::ClassIdentity>::NAME,
906 "GetColumnWidth1",
907 )
908 });
909 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
910 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
911 __inner(__receiver, __mi)
912 }
913 }
914 }
915 #[doc = "`GetColumnWidth2()` overload"]
916 fn get_column_width2(self) -> f32 {
917 unsafe {
918 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
919 {
920 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
921 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
922 panic!(
923 "unity: virtual slot {}
924 out of range (vtable len {}
925) on the runtime class behind {}
926 (method `{}
927`)",
928 33usize,
929 __vt.len(),
930 <MenuItem as ::unity::ClassIdentity>::NAME,
931 "GetColumnWidth2",
932 )
933 });
934 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
935 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
936 __inner(__receiver, __mi)
937 }
938 }
939 }
940 #[doc = "`GetColumnWidth3()` overload"]
941 fn get_column_width3(self) -> f32 {
942 unsafe {
943 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
944 {
945 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
946 let __vi = *__vt.get(34usize).unwrap_or_else(|| {
947 panic!(
948 "unity: virtual slot {}
949 out of range (vtable len {}
950) on the runtime class behind {}
951 (method `{}
952`)",
953 34usize,
954 __vt.len(),
955 <MenuItem as ::unity::ClassIdentity>::NAME,
956 "GetColumnWidth3",
957 )
958 });
959 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
960 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
961 __inner(__receiver, __mi)
962 }
963 }
964 }
965 #[doc = "`GetColumnWidth4()` overload"]
966 fn get_column_width4(self) -> f32 {
967 unsafe {
968 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
969 {
970 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
971 let __vi = *__vt.get(35usize).unwrap_or_else(|| {
972 panic!(
973 "unity: virtual slot {}
974 out of range (vtable len {}
975) on the runtime class behind {}
976 (method `{}
977`)",
978 35usize,
979 __vt.len(),
980 <MenuItem as ::unity::ClassIdentity>::NAME,
981 "GetColumnWidth4",
982 )
983 });
984 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
985 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
986 __inner(__receiver, __mi)
987 }
988 }
989 }
990 #[doc = "`GetColumnHeight(i32)` overload"]
991 fn get_column_height(self, i: impl ::core::convert::Into<i32>) -> f32 {
992 unsafe {
993 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
994 {
995 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
996 let __vi = *__vt.get(36usize).unwrap_or_else(|| {
997 panic!(
998 "unity: virtual slot {}
999 out of range (vtable len {}
1000) on the runtime class behind {}
1001 (method `{}
1002`)",
1003 36usize,
1004 __vt.len(),
1005 <MenuItem as ::unity::ClassIdentity>::NAME,
1006 "GetColumnHeight",
1007 )
1008 });
1009 let __inner: extern "C" fn(MenuItem, i32, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1010 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1011 __inner(__receiver, ::core::convert::Into::into(i), __mi)
1012 }
1013 }
1014 }
1015 #[doc = "`GetColumnHeight0()` overload"]
1016 fn get_column_height0(self) -> f32 {
1017 unsafe {
1018 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1019 {
1020 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1021 let __vi = *__vt.get(37usize).unwrap_or_else(|| {
1022 panic!(
1023 "unity: virtual slot {}
1024 out of range (vtable len {}
1025) on the runtime class behind {}
1026 (method `{}
1027`)",
1028 37usize,
1029 __vt.len(),
1030 <MenuItem as ::unity::ClassIdentity>::NAME,
1031 "GetColumnHeight0",
1032 )
1033 });
1034 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1035 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1036 __inner(__receiver, __mi)
1037 }
1038 }
1039 }
1040 #[doc = "`GetColumnHeight1()` overload"]
1041 fn get_column_height1(self) -> f32 {
1042 unsafe {
1043 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1044 {
1045 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1046 let __vi = *__vt.get(38usize).unwrap_or_else(|| {
1047 panic!(
1048 "unity: virtual slot {}
1049 out of range (vtable len {}
1050) on the runtime class behind {}
1051 (method `{}
1052`)",
1053 38usize,
1054 __vt.len(),
1055 <MenuItem as ::unity::ClassIdentity>::NAME,
1056 "GetColumnHeight1",
1057 )
1058 });
1059 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1060 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1061 __inner(__receiver, __mi)
1062 }
1063 }
1064 }
1065 #[doc = "`GetColumnHeight2()` overload"]
1066 fn get_column_height2(self) -> f32 {
1067 unsafe {
1068 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1069 {
1070 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1071 let __vi = *__vt.get(39usize).unwrap_or_else(|| {
1072 panic!(
1073 "unity: virtual slot {}
1074 out of range (vtable len {}
1075) on the runtime class behind {}
1076 (method `{}
1077`)",
1078 39usize,
1079 __vt.len(),
1080 <MenuItem as ::unity::ClassIdentity>::NAME,
1081 "GetColumnHeight2",
1082 )
1083 });
1084 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1085 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1086 __inner(__receiver, __mi)
1087 }
1088 }
1089 }
1090 #[doc = "`GetColumnHeight3()` overload"]
1091 fn get_column_height3(self) -> f32 {
1092 unsafe {
1093 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1094 {
1095 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1096 let __vi = *__vt.get(40usize).unwrap_or_else(|| {
1097 panic!(
1098 "unity: virtual slot {}
1099 out of range (vtable len {}
1100) on the runtime class behind {}
1101 (method `{}
1102`)",
1103 40usize,
1104 __vt.len(),
1105 <MenuItem as ::unity::ClassIdentity>::NAME,
1106 "GetColumnHeight3",
1107 )
1108 });
1109 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1110 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1111 __inner(__receiver, __mi)
1112 }
1113 }
1114 }
1115 #[doc = "`GetColumnHeight4()` overload"]
1116 fn get_column_height4(self) -> f32 {
1117 unsafe {
1118 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1119 {
1120 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1121 let __vi = *__vt.get(41usize).unwrap_or_else(|| {
1122 panic!(
1123 "unity: virtual slot {}
1124 out of range (vtable len {}
1125) on the runtime class behind {}
1126 (method `{}
1127`)",
1128 41usize,
1129 __vt.len(),
1130 <MenuItem as ::unity::ClassIdentity>::NAME,
1131 "GetColumnHeight4",
1132 )
1133 });
1134 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1135 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1136 __inner(__receiver, __mi)
1137 }
1138 }
1139 }
1140 #[doc = "`GetColumnName0()` overload"]
1141 fn get_column_name0(self) -> ::unity::Il2CppString {
1142 unsafe {
1143 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1144 {
1145 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1146 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
1147 panic!(
1148 "unity: virtual slot {}
1149 out of range (vtable len {}
1150) on the runtime class behind {}
1151 (method `{}
1152`)",
1153 42usize,
1154 __vt.len(),
1155 <MenuItem as ::unity::ClassIdentity>::NAME,
1156 "GetColumnName0",
1157 )
1158 });
1159 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1160 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1161 __inner(__receiver, __mi)
1162 }
1163 }
1164 }
1165 #[doc = "`GetColumnName1()` overload"]
1166 fn get_column_name1(self) -> ::unity::Il2CppString {
1167 unsafe {
1168 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1169 {
1170 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1171 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
1172 panic!(
1173 "unity: virtual slot {}
1174 out of range (vtable len {}
1175) on the runtime class behind {}
1176 (method `{}
1177`)",
1178 43usize,
1179 __vt.len(),
1180 <MenuItem as ::unity::ClassIdentity>::NAME,
1181 "GetColumnName1",
1182 )
1183 });
1184 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1185 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1186 __inner(__receiver, __mi)
1187 }
1188 }
1189 }
1190 #[doc = "`GetColumnName2()` overload"]
1191 fn get_column_name2(self) -> ::unity::Il2CppString {
1192 unsafe {
1193 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1194 {
1195 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1196 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
1197 panic!(
1198 "unity: virtual slot {}
1199 out of range (vtable len {}
1200) on the runtime class behind {}
1201 (method `{}
1202`)",
1203 44usize,
1204 __vt.len(),
1205 <MenuItem as ::unity::ClassIdentity>::NAME,
1206 "GetColumnName2",
1207 )
1208 });
1209 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1210 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1211 __inner(__receiver, __mi)
1212 }
1213 }
1214 }
1215 #[doc = "`GetColumnName3()` overload"]
1216 fn get_column_name3(self) -> ::unity::Il2CppString {
1217 unsafe {
1218 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1219 {
1220 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1221 let __vi = *__vt.get(45usize).unwrap_or_else(|| {
1222 panic!(
1223 "unity: virtual slot {}
1224 out of range (vtable len {}
1225) on the runtime class behind {}
1226 (method `{}
1227`)",
1228 45usize,
1229 __vt.len(),
1230 <MenuItem as ::unity::ClassIdentity>::NAME,
1231 "GetColumnName3",
1232 )
1233 });
1234 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1235 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1236 __inner(__receiver, __mi)
1237 }
1238 }
1239 }
1240 #[doc = "`GetColumnName4()` overload"]
1241 fn get_column_name4(self) -> ::unity::Il2CppString {
1242 unsafe {
1243 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1244 {
1245 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1246 let __vi = *__vt.get(46usize).unwrap_or_else(|| {
1247 panic!(
1248 "unity: virtual slot {}
1249 out of range (vtable len {}
1250) on the runtime class behind {}
1251 (method `{}
1252`)",
1253 46usize,
1254 __vt.len(),
1255 <MenuItem as ::unity::ClassIdentity>::NAME,
1256 "GetColumnName4",
1257 )
1258 });
1259 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1260 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1261 __inner(__receiver, __mi)
1262 }
1263 }
1264 }
1265 #[doc = "`GetColumnEnglish0()` overload"]
1266 fn get_column_english0(self) -> ::unity::Il2CppString {
1267 unsafe {
1268 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1269 {
1270 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1271 let __vi = *__vt.get(47usize).unwrap_or_else(|| {
1272 panic!(
1273 "unity: virtual slot {}
1274 out of range (vtable len {}
1275) on the runtime class behind {}
1276 (method `{}
1277`)",
1278 47usize,
1279 __vt.len(),
1280 <MenuItem as ::unity::ClassIdentity>::NAME,
1281 "GetColumnEnglish0",
1282 )
1283 });
1284 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1285 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1286 __inner(__receiver, __mi)
1287 }
1288 }
1289 }
1290 #[doc = "`GetColumnEnglish1()` overload"]
1291 fn get_column_english1(self) -> ::unity::Il2CppString {
1292 unsafe {
1293 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1294 {
1295 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1296 let __vi = *__vt.get(48usize).unwrap_or_else(|| {
1297 panic!(
1298 "unity: virtual slot {}
1299 out of range (vtable len {}
1300) on the runtime class behind {}
1301 (method `{}
1302`)",
1303 48usize,
1304 __vt.len(),
1305 <MenuItem as ::unity::ClassIdentity>::NAME,
1306 "GetColumnEnglish1",
1307 )
1308 });
1309 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1310 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1311 __inner(__receiver, __mi)
1312 }
1313 }
1314 }
1315 #[doc = "`GetColumnEnglish2()` overload"]
1316 fn get_column_english2(self) -> ::unity::Il2CppString {
1317 unsafe {
1318 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1319 {
1320 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1321 let __vi = *__vt.get(49usize).unwrap_or_else(|| {
1322 panic!(
1323 "unity: virtual slot {}
1324 out of range (vtable len {}
1325) on the runtime class behind {}
1326 (method `{}
1327`)",
1328 49usize,
1329 __vt.len(),
1330 <MenuItem as ::unity::ClassIdentity>::NAME,
1331 "GetColumnEnglish2",
1332 )
1333 });
1334 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1335 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1336 __inner(__receiver, __mi)
1337 }
1338 }
1339 }
1340 #[doc = "`GetColumnEnglish3()` overload"]
1341 fn get_column_english3(self) -> ::unity::Il2CppString {
1342 unsafe {
1343 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1344 {
1345 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1346 let __vi = *__vt.get(50usize).unwrap_or_else(|| {
1347 panic!(
1348 "unity: virtual slot {}
1349 out of range (vtable len {}
1350) on the runtime class behind {}
1351 (method `{}
1352`)",
1353 50usize,
1354 __vt.len(),
1355 <MenuItem as ::unity::ClassIdentity>::NAME,
1356 "GetColumnEnglish3",
1357 )
1358 });
1359 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1360 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1361 __inner(__receiver, __mi)
1362 }
1363 }
1364 }
1365 #[doc = "`GetColumnEnglish4()` overload"]
1366 fn get_column_english4(self) -> ::unity::Il2CppString {
1367 unsafe {
1368 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1369 {
1370 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1371 let __vi = *__vt.get(51usize).unwrap_or_else(|| {
1372 panic!(
1373 "unity: virtual slot {}
1374 out of range (vtable len {}
1375) on the runtime class behind {}
1376 (method `{}
1377`)",
1378 51usize,
1379 __vt.len(),
1380 <MenuItem as ::unity::ClassIdentity>::NAME,
1381 "GetColumnEnglish4",
1382 )
1383 });
1384 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
1385 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1386 __inner(__receiver, __mi)
1387 }
1388 }
1389 }
1390 #[doc = "`GetColumnAlign(i32)` overload"]
1391 fn get_column_align(self, i: impl ::core::convert::Into<i32>) -> crate::app::menuitem::MenuItem_Align {
1392 unsafe {
1393 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1394 {
1395 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1396 let __vi = *__vt.get(52usize).unwrap_or_else(|| {
1397 panic!(
1398 "unity: virtual slot {}
1399 out of range (vtable len {}
1400) on the runtime class behind {}
1401 (method `{}
1402`)",
1403 52usize,
1404 __vt.len(),
1405 <MenuItem as ::unity::ClassIdentity>::NAME,
1406 "GetColumnAlign",
1407 )
1408 });
1409 let __inner: extern "C" fn(MenuItem, i32, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
1410 ::core::mem::transmute(__vi.method_ptr);
1411 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1412 __inner(__receiver, ::core::convert::Into::into(i), __mi)
1413 }
1414 }
1415 }
1416 #[doc = "`GetColumnAlign0()` overload"]
1417 fn get_column_align0(self) -> crate::app::menuitem::MenuItem_Align {
1418 unsafe {
1419 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1420 {
1421 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1422 let __vi = *__vt.get(53usize).unwrap_or_else(|| {
1423 panic!(
1424 "unity: virtual slot {}
1425 out of range (vtable len {}
1426) on the runtime class behind {}
1427 (method `{}
1428`)",
1429 53usize,
1430 __vt.len(),
1431 <MenuItem as ::unity::ClassIdentity>::NAME,
1432 "GetColumnAlign0",
1433 )
1434 });
1435 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
1436 ::core::mem::transmute(__vi.method_ptr);
1437 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1438 __inner(__receiver, __mi)
1439 }
1440 }
1441 }
1442 #[doc = "`GetColumnAlign1()` overload"]
1443 fn get_column_align1(self) -> crate::app::menuitem::MenuItem_Align {
1444 unsafe {
1445 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1446 {
1447 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1448 let __vi = *__vt.get(54usize).unwrap_or_else(|| {
1449 panic!(
1450 "unity: virtual slot {}
1451 out of range (vtable len {}
1452) on the runtime class behind {}
1453 (method `{}
1454`)",
1455 54usize,
1456 __vt.len(),
1457 <MenuItem as ::unity::ClassIdentity>::NAME,
1458 "GetColumnAlign1",
1459 )
1460 });
1461 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
1462 ::core::mem::transmute(__vi.method_ptr);
1463 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1464 __inner(__receiver, __mi)
1465 }
1466 }
1467 }
1468 #[doc = "`GetColumnAlign2()` overload"]
1469 fn get_column_align2(self) -> crate::app::menuitem::MenuItem_Align {
1470 unsafe {
1471 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1472 {
1473 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1474 let __vi = *__vt.get(55usize).unwrap_or_else(|| {
1475 panic!(
1476 "unity: virtual slot {}
1477 out of range (vtable len {}
1478) on the runtime class behind {}
1479 (method `{}
1480`)",
1481 55usize,
1482 __vt.len(),
1483 <MenuItem as ::unity::ClassIdentity>::NAME,
1484 "GetColumnAlign2",
1485 )
1486 });
1487 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
1488 ::core::mem::transmute(__vi.method_ptr);
1489 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1490 __inner(__receiver, __mi)
1491 }
1492 }
1493 }
1494 #[doc = "`GetColumnAlign3()` overload"]
1495 fn get_column_align3(self) -> crate::app::menuitem::MenuItem_Align {
1496 unsafe {
1497 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1498 {
1499 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1500 let __vi = *__vt.get(56usize).unwrap_or_else(|| {
1501 panic!(
1502 "unity: virtual slot {}
1503 out of range (vtable len {}
1504) on the runtime class behind {}
1505 (method `{}
1506`)",
1507 56usize,
1508 __vt.len(),
1509 <MenuItem as ::unity::ClassIdentity>::NAME,
1510 "GetColumnAlign3",
1511 )
1512 });
1513 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
1514 ::core::mem::transmute(__vi.method_ptr);
1515 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1516 __inner(__receiver, __mi)
1517 }
1518 }
1519 }
1520 #[doc = "`GetColumnAlign4()` overload"]
1521 fn get_column_align4(self) -> crate::app::menuitem::MenuItem_Align {
1522 unsafe {
1523 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1524 {
1525 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1526 let __vi = *__vt.get(57usize).unwrap_or_else(|| {
1527 panic!(
1528 "unity: virtual slot {}
1529 out of range (vtable len {}
1530) on the runtime class behind {}
1531 (method `{}
1532`)",
1533 57usize,
1534 __vt.len(),
1535 <MenuItem as ::unity::ClassIdentity>::NAME,
1536 "GetColumnAlign4",
1537 )
1538 });
1539 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
1540 ::core::mem::transmute(__vi.method_ptr);
1541 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1542 __inner(__receiver, __mi)
1543 }
1544 }
1545 }
1546 #[doc = "`GetColumnColor(i32)` overload"]
1547 fn get_column_color(self, i: impl ::core::convert::Into<i32>) -> crate::unity_engine::color::Color {
1548 unsafe {
1549 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1550 {
1551 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1552 let __vi = *__vt.get(58usize).unwrap_or_else(|| {
1553 panic!(
1554 "unity: virtual slot {}
1555 out of range (vtable len {}
1556) on the runtime class behind {}
1557 (method `{}
1558`)",
1559 58usize,
1560 __vt.len(),
1561 <MenuItem as ::unity::ClassIdentity>::NAME,
1562 "GetColumnColor",
1563 )
1564 });
1565 let __inner: extern "C" fn(MenuItem, i32, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
1566 ::core::mem::transmute(__vi.method_ptr);
1567 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1568 __inner(__receiver, ::core::convert::Into::into(i), __mi)
1569 }
1570 }
1571 }
1572 #[doc = "`GetColumnColor0()` overload"]
1573 fn get_column_color0(self) -> crate::unity_engine::color::Color {
1574 unsafe {
1575 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1576 {
1577 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1578 let __vi = *__vt.get(59usize).unwrap_or_else(|| {
1579 panic!(
1580 "unity: virtual slot {}
1581 out of range (vtable len {}
1582) on the runtime class behind {}
1583 (method `{}
1584`)",
1585 59usize,
1586 __vt.len(),
1587 <MenuItem as ::unity::ClassIdentity>::NAME,
1588 "GetColumnColor0",
1589 )
1590 });
1591 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
1592 ::core::mem::transmute(__vi.method_ptr);
1593 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1594 __inner(__receiver, __mi)
1595 }
1596 }
1597 }
1598 #[doc = "`GetColumnColor1()` overload"]
1599 fn get_column_color1(self) -> crate::unity_engine::color::Color {
1600 unsafe {
1601 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1602 {
1603 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1604 let __vi = *__vt.get(60usize).unwrap_or_else(|| {
1605 panic!(
1606 "unity: virtual slot {}
1607 out of range (vtable len {}
1608) on the runtime class behind {}
1609 (method `{}
1610`)",
1611 60usize,
1612 __vt.len(),
1613 <MenuItem as ::unity::ClassIdentity>::NAME,
1614 "GetColumnColor1",
1615 )
1616 });
1617 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
1618 ::core::mem::transmute(__vi.method_ptr);
1619 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1620 __inner(__receiver, __mi)
1621 }
1622 }
1623 }
1624 #[doc = "`GetColumnColor2()` overload"]
1625 fn get_column_color2(self) -> crate::unity_engine::color::Color {
1626 unsafe {
1627 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1628 {
1629 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1630 let __vi = *__vt.get(61usize).unwrap_or_else(|| {
1631 panic!(
1632 "unity: virtual slot {}
1633 out of range (vtable len {}
1634) on the runtime class behind {}
1635 (method `{}
1636`)",
1637 61usize,
1638 __vt.len(),
1639 <MenuItem as ::unity::ClassIdentity>::NAME,
1640 "GetColumnColor2",
1641 )
1642 });
1643 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
1644 ::core::mem::transmute(__vi.method_ptr);
1645 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1646 __inner(__receiver, __mi)
1647 }
1648 }
1649 }
1650 #[doc = "`GetColumnColor3()` overload"]
1651 fn get_column_color3(self) -> crate::unity_engine::color::Color {
1652 unsafe {
1653 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1654 {
1655 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1656 let __vi = *__vt.get(62usize).unwrap_or_else(|| {
1657 panic!(
1658 "unity: virtual slot {}
1659 out of range (vtable len {}
1660) on the runtime class behind {}
1661 (method `{}
1662`)",
1663 62usize,
1664 __vt.len(),
1665 <MenuItem as ::unity::ClassIdentity>::NAME,
1666 "GetColumnColor3",
1667 )
1668 });
1669 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
1670 ::core::mem::transmute(__vi.method_ptr);
1671 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1672 __inner(__receiver, __mi)
1673 }
1674 }
1675 }
1676 #[doc = "`GetColumnColor4()` overload"]
1677 fn get_column_color4(self) -> crate::unity_engine::color::Color {
1678 unsafe {
1679 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1680 {
1681 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1682 let __vi = *__vt.get(63usize).unwrap_or_else(|| {
1683 panic!(
1684 "unity: virtual slot {}
1685 out of range (vtable len {}
1686) on the runtime class behind {}
1687 (method `{}
1688`)",
1689 63usize,
1690 __vt.len(),
1691 <MenuItem as ::unity::ClassIdentity>::NAME,
1692 "GetColumnColor4",
1693 )
1694 });
1695 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
1696 ::core::mem::transmute(__vi.method_ptr);
1697 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1698 __inner(__receiver, __mi)
1699 }
1700 }
1701 }
1702 #[doc = "`GetDisableColor()` overload"]
1703 fn get_disable_color(self) -> crate::unity_engine::color::Color {
1704 unsafe {
1705 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1706 {
1707 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1708 let __vi = *__vt.get(64usize).unwrap_or_else(|| {
1709 panic!(
1710 "unity: virtual slot {}
1711 out of range (vtable len {}
1712) on the runtime class behind {}
1713 (method `{}
1714`)",
1715 64usize,
1716 __vt.len(),
1717 <MenuItem as ::unity::ClassIdentity>::NAME,
1718 "GetDisableColor",
1719 )
1720 });
1721 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
1722 ::core::mem::transmute(__vi.method_ptr);
1723 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1724 __inner(__receiver, __mi)
1725 }
1726 }
1727 }
1728 #[doc = "`GetMarginWidth()` overload"]
1729 fn get_margin_width(self) -> f32 {
1730 unsafe {
1731 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1732 {
1733 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1734 let __vi = *__vt.get(65usize).unwrap_or_else(|| {
1735 panic!(
1736 "unity: virtual slot {}
1737 out of range (vtable len {}
1738) on the runtime class behind {}
1739 (method `{}
1740`)",
1741 65usize,
1742 __vt.len(),
1743 <MenuItem as ::unity::ClassIdentity>::NAME,
1744 "GetMarginWidth",
1745 )
1746 });
1747 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1748 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1749 __inner(__receiver, __mi)
1750 }
1751 }
1752 }
1753 #[doc = "`GetMarginHeight()` overload"]
1754 fn get_margin_height(self) -> f32 {
1755 unsafe {
1756 let __receiver = <MenuItem 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(66usize).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 66usize,
1767 __vt.len(),
1768 <MenuItem as ::unity::ClassIdentity>::NAME,
1769 "GetMarginHeight",
1770 )
1771 });
1772 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
1773 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1774 __inner(__receiver, __mi)
1775 }
1776 }
1777 }
1778 #[doc = "`GetKey(i32)` overload"]
1779 fn get_key(self, index: impl ::core::convert::Into<i32>) -> i32 {
1780 unsafe {
1781 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1782 {
1783 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1784 let __vi = *__vt.get(67usize).unwrap_or_else(|| {
1785 panic!(
1786 "unity: virtual slot {}
1787 out of range (vtable len {}
1788) on the runtime class behind {}
1789 (method `{}
1790`)",
1791 67usize,
1792 __vt.len(),
1793 <MenuItem as ::unity::ClassIdentity>::NAME,
1794 "GetKey",
1795 )
1796 });
1797 let __inner: extern "C" fn(MenuItem, i32, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__vi.method_ptr);
1798 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1799 __inner(__receiver, ::core::convert::Into::into(index), __mi)
1800 }
1801 }
1802 }
1803 #[doc = "`GetMenu()` overload"]
1804 fn get_menu(self) -> crate::app::debugmenu::DebugMenu {
1805 unsafe {
1806 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1807 ::unity::il2cpp_call!((::unity::module_base()+0x25d0480usize)as*mut u8,crate::app::debugmenu::DebugMenu;
1808(MenuItem)__receiver)
1809 }
1810 }
1811 #[doc = "`GetTextWidth(i32)` overload"]
1812 fn get_text_width(self, i: impl ::core::convert::Into<i32>) -> f32 {
1813 unsafe {
1814 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1815 ::unity::il2cpp_call!((::unity::module_base()+0x25cfdb0usize)as*mut u8,f32;
1816(MenuItem)__receiver,(i32)::core::convert::Into::into(i))
1817 }
1818 }
1819 #[doc = "`GetTextHeight(i32)` overload"]
1820 fn get_text_height(self, i: impl ::core::convert::Into<i32>) -> f32 {
1821 unsafe {
1822 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1823 ::unity::il2cpp_call!((::unity::module_base()+0x25cffa0usize)as*mut u8,f32;
1824(MenuItem)__receiver,(i32)::core::convert::Into::into(i))
1825 }
1826 }
1827 #[doc = "`SetMenu(crate::app::debugmenu::DebugMenu)` overload"]
1828 fn set_menu(self, menu: impl ::core::convert::Into<crate::app::debugmenu::DebugMenu>) -> () {
1829 unsafe {
1830 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1831 ::unity::il2cpp_call!((::unity::module_base()+0x25d06b0usize)as*mut u8,();
1832(MenuItem)__receiver,(crate::app::debugmenu::DebugMenu)::core::convert::Into::into(menu))
1833 }
1834 }
1835 #[doc = "`GetState()` overload"]
1836 fn get_state(self) -> crate::app::menuitem::MenuItem_State {
1837 unsafe {
1838 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1839 ::unity::il2cpp_call!((::unity::module_base()+0x25d06c0usize)as*mut u8,crate::app::menuitem::MenuItem_State;
1840(MenuItem)__receiver)
1841 }
1842 }
1843 #[doc = "`SetState(crate::app::menuitem::MenuItem_State)` overload"]
1844 fn set_state(self, state: impl ::core::convert::Into<crate::app::menuitem::MenuItem_State>) -> () {
1845 unsafe {
1846 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1847 ::unity::il2cpp_call!((::unity::module_base()+0x25d06d0usize)as*mut u8,();
1848(MenuItem)__receiver,(crate::app::menuitem::MenuItem_State)::core::convert::Into::into(state))
1849 }
1850 }
1851 #[doc = "`GetBind()` overload"]
1852 fn get_bind(self) -> i32 {
1853 unsafe {
1854 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1855 ::unity::il2cpp_call!((::unity::module_base()+0x25d06e0usize)as*mut u8,i32;
1856(MenuItem)__receiver)
1857 }
1858 }
1859 #[doc = "`SetBind(i32)` overload"]
1860 fn set_bind(self, bind: impl ::core::convert::Into<i32>) -> () {
1861 unsafe {
1862 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1863 ::unity::il2cpp_call!((::unity::module_base()+0x25d06f0usize)as*mut u8,();
1864(MenuItem)__receiver,(i32)::core::convert::Into::into(bind))
1865 }
1866 }
1867 #[doc = "`GetRoot()` overload"]
1868 fn get_root(self) -> crate::app::procinst::ProcInst {
1869 unsafe {
1870 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1871 ::unity::il2cpp_call!((::unity::module_base()+0x25d0700usize)as*mut u8,crate::app::procinst::ProcInst;
1872(MenuItem)__receiver)
1873 }
1874 }
1875 #[doc = "`OnTick()` overload"]
1876 fn on_tick(self) -> () {
1877 unsafe {
1878 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1879 {
1880 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1881 let __vi = *__vt.get(68usize).unwrap_or_else(|| {
1882 panic!(
1883 "unity: virtual slot {}
1884 out of range (vtable len {}
1885) on the runtime class behind {}
1886 (method `{}
1887`)",
1888 68usize,
1889 __vt.len(),
1890 <MenuItem as ::unity::ClassIdentity>::NAME,
1891 "OnTick",
1892 )
1893 });
1894 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1895 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1896 __inner(__receiver, __mi)
1897 }
1898 }
1899 }
1900 #[doc = "`OnSelect()` overload"]
1901 fn on_select(self) -> () {
1902 unsafe {
1903 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1904 {
1905 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1906 let __vi = *__vt.get(69usize).unwrap_or_else(|| {
1907 panic!(
1908 "unity: virtual slot {}
1909 out of range (vtable len {}
1910) on the runtime class behind {}
1911 (method `{}
1912`)",
1913 69usize,
1914 __vt.len(),
1915 <MenuItem as ::unity::ClassIdentity>::NAME,
1916 "OnSelect",
1917 )
1918 });
1919 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1920 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1921 __inner(__receiver, __mi)
1922 }
1923 }
1924 }
1925 #[doc = "`OnLeftRight(i32, bool)` overload"]
1926 fn on_left_right(self, step: impl ::core::convert::Into<i32>, is_trigger: impl ::core::convert::Into<bool>) -> () {
1927 unsafe {
1928 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1929 {
1930 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1931 let __vi = *__vt.get(70usize).unwrap_or_else(|| {
1932 panic!(
1933 "unity: virtual slot {}
1934 out of range (vtable len {}
1935) on the runtime class behind {}
1936 (method `{}
1937`)",
1938 70usize,
1939 __vt.len(),
1940 <MenuItem as ::unity::ClassIdentity>::NAME,
1941 "OnLeftRight",
1942 )
1943 });
1944 let __inner: extern "C" fn(MenuItem, i32, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1945 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1946 __inner(
1947 __receiver,
1948 ::core::convert::Into::into(step),
1949 ::core::convert::Into::into(is_trigger),
1950 __mi,
1951 )
1952 }
1953 }
1954 }
1955 #[doc = "`CreateMenuBind()` overload"]
1956 fn create_menu_bind(self) -> crate::app::debugmenu::DebugMenu {
1957 unsafe {
1958 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1959 ::unity::il2cpp_call!((::unity::module_base()+0x25d07c0usize)as*mut u8,crate::app::debugmenu::DebugMenu;
1960(MenuItem)__receiver)
1961 }
1962 }
1963 #[doc = "`Dispose()` overload"]
1964 fn dispose(self) -> () {
1965 unsafe {
1966 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1967 {
1968 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1969 let __vi = *__vt.get(71usize).unwrap_or_else(|| {
1970 panic!(
1971 "unity: virtual slot {}
1972 out of range (vtable len {}
1973) on the runtime class behind {}
1974 (method `{}
1975`)",
1976 71usize,
1977 __vt.len(),
1978 <MenuItem as ::unity::ClassIdentity>::NAME,
1979 "Dispose",
1980 )
1981 });
1982 let __inner: extern "C" fn(MenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1983 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1984 __inner(__receiver, __mi)
1985 }
1986 }
1987 }
1988 #[doc = "`GetLangName(i32)` overload"]
1989 fn get_lang_name(self, i: impl ::core::convert::Into<i32>) -> ::unity::Il2CppString {
1990 unsafe {
1991 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1992 ::unity::il2cpp_call!((::unity::module_base()+0x25d0490usize)as*mut u8, ::unity::Il2CppString;
1993(MenuItem)__receiver,(i32)::core::convert::Into::into(i))
1994 }
1995 }
1996 #[doc = "`GetLangHelp()` overload"]
1997 fn get_lang_help(self) -> ::unity::Il2CppString {
1998 unsafe {
1999 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2000 ::unity::il2cpp_call!((::unity::module_base()+0x25cf910usize)as*mut u8, ::unity::Il2CppString;
2001(MenuItem)__receiver)
2002 }
2003 }
2004 #[doc = "`.ctor()` overload"]
2005 fn ctor(self) -> () {
2006 unsafe {
2007 let __receiver = <MenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2008 ::unity::il2cpp_call!((::unity::module_base()+0x25d0850usize)as*mut u8,();
2009(MenuItem)__receiver)
2010 }
2011 }
2012}
2013
2014#[cfg(feature = "app-menuitem")]
2015impl<__T: IMenuItem> IMenuItemMethods for __T {}
2016
2017#[cfg(feature = "app-menuitem")]
2018impl MenuItem {
2019 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2020 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2021 }
2022
2023 pub fn get_name_english_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2024 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2025 }
2026
2027 pub fn get_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2028 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2029 }
2030
2031 pub fn get_help_english_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2032 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2033 }
2034
2035 pub fn get_help_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2036 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2037 }
2038
2039 pub fn get_help_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2040 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2041 }
2042
2043 pub fn get_kind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2044 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2045 }
2046
2047 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2048 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2049 }
2050
2051 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2052 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2053 }
2054
2055 pub fn x_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2056 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2057 }
2058
2059 pub fn y_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2060 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2061 }
2062
2063 pub fn l_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2064 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2065 }
2066
2067 pub fn r_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2068 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2069 }
2070
2071 pub fn plus_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2072 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2073 }
2074
2075 pub fn minus_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2076 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2077 }
2078
2079 pub fn left_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2080 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2081 }
2082
2083 pub fn right_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2084 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2085 }
2086
2087 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2088 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
2089 }
2090
2091 pub fn is_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2092 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
2093 }
2094
2095 pub fn is_selectable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2096 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2097 }
2098
2099 pub fn get_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2100 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2101 }
2102
2103 pub fn get_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2104 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2105 }
2106
2107 pub fn get_font_color_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2108 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
2109 }
2110
2111 pub fn get_back_color_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2112 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
2113 }
2114
2115 pub fn get_column_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2116 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
2117 }
2118
2119 pub fn get_column_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2120 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
2121 }
2122
2123 pub fn get_column_width0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2124 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
2125 }
2126
2127 pub fn get_column_width1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2128 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
2129 }
2130
2131 pub fn get_column_width2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2132 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
2133 }
2134
2135 pub fn get_column_width3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2136 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
2137 }
2138
2139 pub fn get_column_width4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2140 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
2141 }
2142
2143 pub fn get_column_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2144 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
2145 }
2146
2147 pub fn get_column_height0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2148 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
2149 }
2150
2151 pub fn get_column_height1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2152 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
2153 }
2154
2155 pub fn get_column_height2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2156 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
2157 }
2158
2159 pub fn get_column_height3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2160 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
2161 }
2162
2163 pub fn get_column_height4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2164 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
2165 }
2166
2167 pub fn get_column_name0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2168 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
2169 }
2170
2171 pub fn get_column_name1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2172 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
2173 }
2174
2175 pub fn get_column_name2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2176 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
2177 }
2178
2179 pub fn get_column_name3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2180 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
2181 }
2182
2183 pub fn get_column_name4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2184 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
2185 }
2186
2187 pub fn get_column_english0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2188 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
2189 }
2190
2191 pub fn get_column_english1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2192 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
2193 }
2194
2195 pub fn get_column_english2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2196 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
2197 }
2198
2199 pub fn get_column_english3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2200 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
2201 }
2202
2203 pub fn get_column_english4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2204 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
2205 }
2206
2207 pub fn get_column_align_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2208 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
2209 }
2210
2211 pub fn get_column_align0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2212 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
2213 }
2214
2215 pub fn get_column_align1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2216 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
2217 }
2218
2219 pub fn get_column_align2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2220 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
2221 }
2222
2223 pub fn get_column_align3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2224 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[51]
2225 }
2226
2227 pub fn get_column_align4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2228 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[52]
2229 }
2230
2231 pub fn get_column_color_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2232 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[53]
2233 }
2234
2235 pub fn get_column_color0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2236 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[54]
2237 }
2238
2239 pub fn get_column_color1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2240 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[55]
2241 }
2242
2243 pub fn get_column_color2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2244 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[56]
2245 }
2246
2247 pub fn get_column_color3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2248 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[57]
2249 }
2250
2251 pub fn get_column_color4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2252 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[58]
2253 }
2254
2255 pub fn get_disable_color_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2256 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[59]
2257 }
2258
2259 pub fn get_margin_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2260 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[60]
2261 }
2262
2263 pub fn get_margin_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2264 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[61]
2265 }
2266
2267 pub fn get_key_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2268 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[62]
2269 }
2270
2271 pub fn get_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2272 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[63]
2273 }
2274
2275 pub fn get_text_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2276 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[64]
2277 }
2278
2279 pub fn get_text_height_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2280 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[65]
2281 }
2282
2283 pub fn set_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2284 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[66]
2285 }
2286
2287 pub fn get_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2288 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[67]
2289 }
2290
2291 pub fn set_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2292 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[68]
2293 }
2294
2295 pub fn get_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2296 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[69]
2297 }
2298
2299 pub fn set_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2300 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[70]
2301 }
2302
2303 pub fn get_root_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2304 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[71]
2305 }
2306
2307 pub fn on_tick_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2308 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[72]
2309 }
2310
2311 pub fn on_select_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2312 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[73]
2313 }
2314
2315 pub fn on_left_right_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2316 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[74]
2317 }
2318
2319 pub fn create_menu_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2320 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[75]
2321 }
2322
2323 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2324 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[76]
2325 }
2326
2327 pub fn get_lang_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2328 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[77]
2329 }
2330
2331 pub fn get_lang_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2332 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[78]
2333 }
2334
2335 pub fn op_implicit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2336 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[79]
2337 }
2338
2339 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2340 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[80]
2341 }
2342}
2343
2344#[cfg(feature = "app-menuitem")]
2345impl MenuItem {
2346 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2347 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2348 let __mi = Self::get_name_method_info();
2349 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2350 __inner(this.into(), ::core::option::Option::None)
2351 }
2352
2353 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetNameEnglish`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2354 pub unsafe fn get_name_english(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2355 let __mi = Self::get_name_english_method_info();
2356 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2357 __inner(this.into(), ::core::option::Option::None)
2358 }
2359
2360 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2361 pub unsafe fn get_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2362 let __mi = Self::get_help_method_info();
2363 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2364 __inner(this.into(), ::core::option::Option::None)
2365 }
2366
2367 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetHelpEnglish`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2368 pub unsafe fn get_help_english(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2369 let __mi = Self::get_help_english_method_info();
2370 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2371 __inner(this.into(), ::core::option::Option::None)
2372 }
2373
2374 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetHelpWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2375 pub unsafe fn get_help_width(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2376 let __mi = Self::get_help_width_method_info();
2377 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2378 __inner(this.into(), ::core::option::Option::None)
2379 }
2380
2381 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetHelpHeight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2382 pub unsafe fn get_help_height(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2383 let __mi = Self::get_help_height_method_info();
2384 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2385 __inner(this.into(), ::core::option::Option::None)
2386 }
2387
2388 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetKind`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2389 pub unsafe fn get_kind(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Kind {
2390 let __mi = Self::get_kind_method_info();
2391 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Kind =
2392 ::core::mem::transmute(__mi.method_ptr);
2393 __inner(this.into(), ::core::option::Option::None)
2394 }
2395
2396 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2397 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2398 let __mi = Self::a_call_method_info();
2399 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2400 ::core::mem::transmute(__mi.method_ptr);
2401 __inner(this.into(), ::core::option::Option::None)
2402 }
2403
2404 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2405 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2406 let __mi = Self::b_call_method_info();
2407 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2408 ::core::mem::transmute(__mi.method_ptr);
2409 __inner(this.into(), ::core::option::Option::None)
2410 }
2411
2412 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `XCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2413 pub unsafe fn x_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2414 let __mi = Self::x_call_method_info();
2415 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2416 ::core::mem::transmute(__mi.method_ptr);
2417 __inner(this.into(), ::core::option::Option::None)
2418 }
2419
2420 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `YCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2421 pub unsafe fn y_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2422 let __mi = Self::y_call_method_info();
2423 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2424 ::core::mem::transmute(__mi.method_ptr);
2425 __inner(this.into(), ::core::option::Option::None)
2426 }
2427
2428 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `LCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2429 pub unsafe fn l_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2430 let __mi = Self::l_call_method_info();
2431 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2432 ::core::mem::transmute(__mi.method_ptr);
2433 __inner(this.into(), ::core::option::Option::None)
2434 }
2435
2436 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `RCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2437 pub unsafe fn r_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2438 let __mi = Self::r_call_method_info();
2439 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2440 ::core::mem::transmute(__mi.method_ptr);
2441 __inner(this.into(), ::core::option::Option::None)
2442 }
2443
2444 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `PlusCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2445 pub unsafe fn plus_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2446 let __mi = Self::plus_call_method_info();
2447 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2448 ::core::mem::transmute(__mi.method_ptr);
2449 __inner(this.into(), ::core::option::Option::None)
2450 }
2451
2452 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `MinusCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2453 pub unsafe fn minus_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2454 let __mi = Self::minus_call_method_info();
2455 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2456 ::core::mem::transmute(__mi.method_ptr);
2457 __inner(this.into(), ::core::option::Option::None)
2458 }
2459
2460 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `LeftCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2461 pub unsafe fn left_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2462 let __mi = Self::left_call_method_info();
2463 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2464 ::core::mem::transmute(__mi.method_ptr);
2465 __inner(this.into(), ::core::option::Option::None)
2466 }
2467
2468 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `RightCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2469 pub unsafe fn right_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2470 let __mi = Self::right_call_method_info();
2471 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2472 ::core::mem::transmute(__mi.method_ptr);
2473 __inner(this.into(), ::core::option::Option::None)
2474 }
2475
2476 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2477 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2478 let __mi = Self::is_enable_method_info();
2479 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2480 __inner(this.into(), ::core::option::Option::None)
2481 }
2482
2483 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `IsVisible`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2484 pub unsafe fn is_visible(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2485 let __mi = Self::is_visible_method_info();
2486 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2487 __inner(this.into(), ::core::option::Option::None)
2488 }
2489
2490 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `IsSelectable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2491 pub unsafe fn is_selectable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2492 let __mi = Self::is_selectable_method_info();
2493 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2494 __inner(this.into(), ::core::option::Option::None)
2495 }
2496
2497 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2498 pub unsafe fn get_width(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2499 let __mi = Self::get_width_method_info();
2500 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2501 __inner(this.into(), ::core::option::Option::None)
2502 }
2503
2504 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetHeight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2505 pub unsafe fn get_height(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2506 let __mi = Self::get_height_method_info();
2507 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2508 __inner(this.into(), ::core::option::Option::None)
2509 }
2510
2511 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetFontColor`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2512 pub unsafe fn get_font_color(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::color::Color {
2513 let __mi = Self::get_font_color_method_info();
2514 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
2515 ::core::mem::transmute(__mi.method_ptr);
2516 __inner(this.into(), ::core::option::Option::None)
2517 }
2518
2519 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetBackColor`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2520 pub unsafe fn get_back_color(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::color::Color {
2521 let __mi = Self::get_back_color_method_info();
2522 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
2523 ::core::mem::transmute(__mi.method_ptr);
2524 __inner(this.into(), ::core::option::Option::None)
2525 }
2526
2527 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnCount`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2528 pub unsafe fn get_column_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
2529 let __mi = Self::get_column_count_method_info();
2530 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
2531 __inner(this.into(), ::core::option::Option::None)
2532 }
2533
2534 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2535 pub unsafe fn get_column_width(this: impl ::core::convert::Into<::unity::IlInstance>, i: i32) -> f32 {
2536 let __mi = Self::get_column_width_method_info();
2537 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2538 __inner(this.into(), i, ::core::option::Option::None)
2539 }
2540
2541 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnWidth0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2542 pub unsafe fn get_column_width0(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2543 let __mi = Self::get_column_width0_method_info();
2544 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2545 __inner(this.into(), ::core::option::Option::None)
2546 }
2547
2548 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnWidth1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2549 pub unsafe fn get_column_width1(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2550 let __mi = Self::get_column_width1_method_info();
2551 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2552 __inner(this.into(), ::core::option::Option::None)
2553 }
2554
2555 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnWidth2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2556 pub unsafe fn get_column_width2(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2557 let __mi = Self::get_column_width2_method_info();
2558 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2559 __inner(this.into(), ::core::option::Option::None)
2560 }
2561
2562 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnWidth3`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2563 pub unsafe fn get_column_width3(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2564 let __mi = Self::get_column_width3_method_info();
2565 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2566 __inner(this.into(), ::core::option::Option::None)
2567 }
2568
2569 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnWidth4`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2570 pub unsafe fn get_column_width4(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2571 let __mi = Self::get_column_width4_method_info();
2572 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2573 __inner(this.into(), ::core::option::Option::None)
2574 }
2575
2576 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnHeight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2577 pub unsafe fn get_column_height(this: impl ::core::convert::Into<::unity::IlInstance>, i: i32) -> f32 {
2578 let __mi = Self::get_column_height_method_info();
2579 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2580 __inner(this.into(), i, ::core::option::Option::None)
2581 }
2582
2583 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnHeight0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2584 pub unsafe fn get_column_height0(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2585 let __mi = Self::get_column_height0_method_info();
2586 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2587 __inner(this.into(), ::core::option::Option::None)
2588 }
2589
2590 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnHeight1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2591 pub unsafe fn get_column_height1(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2592 let __mi = Self::get_column_height1_method_info();
2593 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2594 __inner(this.into(), ::core::option::Option::None)
2595 }
2596
2597 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnHeight2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2598 pub unsafe fn get_column_height2(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2599 let __mi = Self::get_column_height2_method_info();
2600 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2601 __inner(this.into(), ::core::option::Option::None)
2602 }
2603
2604 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnHeight3`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2605 pub unsafe fn get_column_height3(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2606 let __mi = Self::get_column_height3_method_info();
2607 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2608 __inner(this.into(), ::core::option::Option::None)
2609 }
2610
2611 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnHeight4`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2612 pub unsafe fn get_column_height4(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2613 let __mi = Self::get_column_height4_method_info();
2614 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2615 __inner(this.into(), ::core::option::Option::None)
2616 }
2617
2618 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnName0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2619 pub unsafe fn get_column_name0(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2620 let __mi = Self::get_column_name0_method_info();
2621 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2622 __inner(this.into(), ::core::option::Option::None)
2623 }
2624
2625 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnName1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2626 pub unsafe fn get_column_name1(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2627 let __mi = Self::get_column_name1_method_info();
2628 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2629 __inner(this.into(), ::core::option::Option::None)
2630 }
2631
2632 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnName2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2633 pub unsafe fn get_column_name2(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2634 let __mi = Self::get_column_name2_method_info();
2635 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2636 __inner(this.into(), ::core::option::Option::None)
2637 }
2638
2639 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnName3`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2640 pub unsafe fn get_column_name3(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2641 let __mi = Self::get_column_name3_method_info();
2642 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2643 __inner(this.into(), ::core::option::Option::None)
2644 }
2645
2646 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnName4`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2647 pub unsafe fn get_column_name4(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2648 let __mi = Self::get_column_name4_method_info();
2649 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2650 __inner(this.into(), ::core::option::Option::None)
2651 }
2652
2653 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnEnglish0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2654 pub unsafe fn get_column_english0(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2655 let __mi = Self::get_column_english0_method_info();
2656 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2657 __inner(this.into(), ::core::option::Option::None)
2658 }
2659
2660 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnEnglish1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2661 pub unsafe fn get_column_english1(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2662 let __mi = Self::get_column_english1_method_info();
2663 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2664 __inner(this.into(), ::core::option::Option::None)
2665 }
2666
2667 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnEnglish2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2668 pub unsafe fn get_column_english2(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2669 let __mi = Self::get_column_english2_method_info();
2670 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2671 __inner(this.into(), ::core::option::Option::None)
2672 }
2673
2674 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnEnglish3`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2675 pub unsafe fn get_column_english3(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2676 let __mi = Self::get_column_english3_method_info();
2677 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2678 __inner(this.into(), ::core::option::Option::None)
2679 }
2680
2681 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnEnglish4`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2682 pub unsafe fn get_column_english4(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2683 let __mi = Self::get_column_english4_method_info();
2684 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2685 __inner(this.into(), ::core::option::Option::None)
2686 }
2687
2688 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnAlign`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2689 pub unsafe fn get_column_align(this: impl ::core::convert::Into<::unity::IlInstance>, i: i32) -> crate::app::menuitem::MenuItem_Align {
2690 let __mi = Self::get_column_align_method_info();
2691 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
2692 ::core::mem::transmute(__mi.method_ptr);
2693 __inner(this.into(), i, ::core::option::Option::None)
2694 }
2695
2696 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnAlign0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2697 pub unsafe fn get_column_align0(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Align {
2698 let __mi = Self::get_column_align0_method_info();
2699 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
2700 ::core::mem::transmute(__mi.method_ptr);
2701 __inner(this.into(), ::core::option::Option::None)
2702 }
2703
2704 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnAlign1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2705 pub unsafe fn get_column_align1(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Align {
2706 let __mi = Self::get_column_align1_method_info();
2707 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
2708 ::core::mem::transmute(__mi.method_ptr);
2709 __inner(this.into(), ::core::option::Option::None)
2710 }
2711
2712 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnAlign2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2713 pub unsafe fn get_column_align2(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Align {
2714 let __mi = Self::get_column_align2_method_info();
2715 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
2716 ::core::mem::transmute(__mi.method_ptr);
2717 __inner(this.into(), ::core::option::Option::None)
2718 }
2719
2720 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnAlign3`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2721 pub unsafe fn get_column_align3(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Align {
2722 let __mi = Self::get_column_align3_method_info();
2723 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
2724 ::core::mem::transmute(__mi.method_ptr);
2725 __inner(this.into(), ::core::option::Option::None)
2726 }
2727
2728 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnAlign4`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2729 pub unsafe fn get_column_align4(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Align {
2730 let __mi = Self::get_column_align4_method_info();
2731 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Align =
2732 ::core::mem::transmute(__mi.method_ptr);
2733 __inner(this.into(), ::core::option::Option::None)
2734 }
2735
2736 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnColor`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2737 pub unsafe fn get_column_color(this: impl ::core::convert::Into<::unity::IlInstance>, i: i32) -> crate::unity_engine::color::Color {
2738 let __mi = Self::get_column_color_method_info();
2739 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
2740 ::core::mem::transmute(__mi.method_ptr);
2741 __inner(this.into(), i, ::core::option::Option::None)
2742 }
2743
2744 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnColor0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2745 pub unsafe fn get_column_color0(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::color::Color {
2746 let __mi = Self::get_column_color0_method_info();
2747 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
2748 ::core::mem::transmute(__mi.method_ptr);
2749 __inner(this.into(), ::core::option::Option::None)
2750 }
2751
2752 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnColor1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2753 pub unsafe fn get_column_color1(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::color::Color {
2754 let __mi = Self::get_column_color1_method_info();
2755 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
2756 ::core::mem::transmute(__mi.method_ptr);
2757 __inner(this.into(), ::core::option::Option::None)
2758 }
2759
2760 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnColor2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2761 pub unsafe fn get_column_color2(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::color::Color {
2762 let __mi = Self::get_column_color2_method_info();
2763 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
2764 ::core::mem::transmute(__mi.method_ptr);
2765 __inner(this.into(), ::core::option::Option::None)
2766 }
2767
2768 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnColor3`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2769 pub unsafe fn get_column_color3(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::color::Color {
2770 let __mi = Self::get_column_color3_method_info();
2771 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
2772 ::core::mem::transmute(__mi.method_ptr);
2773 __inner(this.into(), ::core::option::Option::None)
2774 }
2775
2776 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetColumnColor4`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2777 pub unsafe fn get_column_color4(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::color::Color {
2778 let __mi = Self::get_column_color4_method_info();
2779 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
2780 ::core::mem::transmute(__mi.method_ptr);
2781 __inner(this.into(), ::core::option::Option::None)
2782 }
2783
2784 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetDisableColor`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2785 pub unsafe fn get_disable_color(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::color::Color {
2786 let __mi = Self::get_disable_color_method_info();
2787 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
2788 ::core::mem::transmute(__mi.method_ptr);
2789 __inner(this.into(), ::core::option::Option::None)
2790 }
2791
2792 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetMarginWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2793 pub unsafe fn get_margin_width(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2794 let __mi = Self::get_margin_width_method_info();
2795 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2796 __inner(this.into(), ::core::option::Option::None)
2797 }
2798
2799 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetMarginHeight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2800 pub unsafe fn get_margin_height(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
2801 let __mi = Self::get_margin_height_method_info();
2802 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
2803 __inner(this.into(), ::core::option::Option::None)
2804 }
2805
2806 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `GetKey`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2807 pub unsafe fn get_key(this: impl ::core::convert::Into<::unity::IlInstance>, index: i32) -> i32 {
2808 let __mi = Self::get_key_method_info();
2809 let __inner: extern "C" fn(::unity::IlInstance, i32, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
2810 __inner(this.into(), index, ::core::option::Option::None)
2811 }
2812
2813 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `OnTick`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2814 pub unsafe fn on_tick(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2815 let __mi = Self::on_tick_method_info();
2816 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2817 __inner(this.into(), ::core::option::Option::None)
2818 }
2819
2820 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `OnSelect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2821 pub unsafe fn on_select(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2822 let __mi = Self::on_select_method_info();
2823 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2824 __inner(this.into(), ::core::option::Option::None)
2825 }
2826
2827 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `OnLeftRight`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2828 pub unsafe fn on_left_right(this: impl ::core::convert::Into<::unity::IlInstance>, step: i32, is_trigger: bool) -> () {
2829 let __mi = Self::on_left_right_method_info();
2830 let __inner: extern "C" fn(::unity::IlInstance, i32, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2831 __inner(this.into(), step, is_trigger, ::core::option::Option::None)
2832 }
2833
2834 #[doc = "Direct (non-virtual) call to `MenuItem`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2835 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2836 let __mi = Self::dispose_method_info();
2837 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2838 __inner(this.into(), ::core::option::Option::None)
2839 }
2840}
2841
2842#[cfg(feature = "app-menuitem")]
2843impl MenuItem {
2844 #[doc = "`.ctor()` — no args"]
2845 pub fn new() -> Self {
2846 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2847 panic!(
2848 "{}
2849::{}
2850 failed to instantiate",
2851 ::core::stringify!(MenuItem),
2852 ::core::stringify!(new),
2853 )
2854 });
2855 <Self as IMenuItemMethods>::ctor(this);
2856 this
2857 }
2858}
2859
2860#[cfg(feature = "app-menuitem")]
2861#[doc(hidden)]
2862pub mod prelude {
2863 pub use super::{IMenuItem, IMenuItemMethods, MenuItem, MenuItem_Align, MenuItem_Kind, MenuItem_Result, MenuItem_State};
2864 #[cfg(feature = "system-object")]
2865 pub use crate::system::object::IObjectMethods;
2866 #[cfg(feature = "system-enum")]
2867 pub use crate::system::r#enum::IEnumMethods;
2868 #[cfg(feature = "system-valuetype")]
2869 pub use crate::system::valuetype::IValueTypeMethods;
2870 pub use crate::system::{object::IObject, r#enum::IEnum, valuetype::IValueType};
2871}