1#[cfg(feature = "app-debugunititemmenu-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 debugmenu::{DebugMenu, IDebugMenu},
11 menuitem::{IMenuItem, MenuItem},
12 procinst::{IProcInst, ProcInst},
13 },
14 system::object::{IObject, Object},
15 };
16
17 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu.md"))]
18 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu")]
19 #[parent(crate::system::object::Object)]
20 pub struct DebugUnitItemMenu_SubMenu {}
21
22 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_SellingMenuItem.md"))]
23 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.SellingMenuItem")]
24 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_ItemBaseMenuItem)]
25 pub struct DebugUnitItemMenu_SubMenu_SellingMenuItem {}
26
27 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_PriceMenuItem.md"))]
28 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.PriceMenuItem")]
29 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_ItemBaseMenuItem)]
30 pub struct DebugUnitItemMenu_SubMenu_PriceMenuItem {}
31
32 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_EnchantHashMenuItem.md"))]
33 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.EnchantHashMenuItem")]
34 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_ItemBaseMenuItem)]
35 pub struct DebugUnitItemMenu_SubMenu_EnchantHashMenuItem {}
36
37 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_ItemBaseMenuItem.md"))]
38 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.ItemBaseMenuItem")]
39 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_BaseMenuItem)]
40 pub struct DebugUnitItemMenu_SubMenu_ItemBaseMenuItem {}
41
42 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_BaseMenuItem.md"))]
43 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.BaseMenuItem")]
44 #[parent(crate::app::menuitem::MenuItem)]
45 pub struct DebugUnitItemMenu_SubMenu_BaseMenuItem {
46 #[offset(32)]
47 #[rename(name = "m_Unit")]
48 pub m_unit: crate::app::unit::Unit,
49 #[offset(40)]
50 #[rename(name = "m_UnitItemIndex")]
51 pub m_unit_item_index: i32,
52 #[offset(48)]
53 #[rename(name = "m_UnitItem")]
54 pub m_unit_item: crate::app::unititem::UnitItem,
55 }
56
57 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_EnchantMenuItem.md"))]
58 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.EnchantMenuItem")]
59 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_FlagMenuItem)]
60 pub struct DebugUnitItemMenu_SubMenu_EnchantMenuItem {}
61
62 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_ItemListMenu_ItemMenuItem.md"))]
63 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.ItemListMenu.ItemMenuItem")]
64 #[parent(crate::app::menuitem::MenuItem)]
65 pub struct DebugUnitItemMenu_ItemListMenu_ItemMenuItem {
66 #[offset(32)]
67 #[rename(name = "m_Unit")]
68 pub m_unit: crate::app::unit::Unit,
69 #[offset(40)]
70 #[rename(name = "m_UnitItem")]
71 pub m_unit_item: crate::app::unititem::UnitItem,
72 #[offset(48)]
73 #[rename(name = "m_Index")]
74 pub m_index: i32,
75 #[offset(52)]
76 #[rename(name = "m_IsEnable")]
77 pub m_is_enable: bool,
78 }
79
80 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_RefineMenu_EvolveMenuItem.md"))]
81 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.RefineMenu.EvolveMenuItem")]
82 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_RefineMenu_BaseMenuItem)]
83 pub struct DebugUnitItemMenu_RefineMenu_EvolveMenuItem {
84 #[offset(56)]
85 #[rename(name = "m_DataIndex")]
86 pub m_data_index: i32,
87 #[offset(64)]
88 #[rename(name = "m_Data")]
89 pub m_data: crate::app::itemevolvedata::ItemEvolveData,
90 }
91
92 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_EquipMenuItem.md"))]
93 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.EquipMenuItem")]
94 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_FlagMenuItem)]
95 pub struct DebugUnitItemMenu_SubMenu_EquipMenuItem {}
96
97 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_EngraveMenu_BaseMenuItem.md"))]
98 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.EngraveMenu.BaseMenuItem")]
99 #[parent(crate::app::menuitem::MenuItem)]
100 pub struct DebugUnitItemMenu_EngraveMenu_BaseMenuItem {
101 #[offset(32)]
102 #[rename(name = "m_Unit")]
103 pub m_unit: crate::app::unit::Unit,
104 #[offset(40)]
105 #[rename(name = "m_UnitItemIndex")]
106 pub m_unit_item_index: i32,
107 #[offset(48)]
108 #[rename(name = "m_UnitItem")]
109 pub m_unit_item: crate::app::unititem::UnitItem,
110 }
111
112 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu.md"))]
113 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu")]
114 #[parent(crate::system::object::Object)]
115 pub struct DebugUnitItemMenu {}
116
117 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem.md"))]
118 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.EngraveMenu.ClearEngraveMenuItem")]
119 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_EngraveMenu_BaseMenuItem)]
120 pub struct DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem {}
121
122 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_FlagMenuItem.md"))]
123 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.FlagMenuItem")]
124 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_BaseMenuItem)]
125 pub struct DebugUnitItemMenu_SubMenu_FlagMenuItem {}
126
127 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_EngraveMenu.md"))]
128 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.EngraveMenu")]
129 #[parent(crate::system::object::Object)]
130 pub struct DebugUnitItemMenu_EngraveMenu {}
131
132 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_RefineMenuItem.md"))]
133 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.RefineMenuItem")]
134 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_BaseMenuItem)]
135 pub struct DebugUnitItemMenu_SubMenu_RefineMenuItem {}
136
137 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_EngraveMenu_EngraveMenuItem.md"))]
138 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.EngraveMenu.EngraveMenuItem")]
139 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_EngraveMenu_BaseMenuItem)]
140 pub struct DebugUnitItemMenu_EngraveMenu_EngraveMenuItem {
141 #[offset(56)]
142 #[rename(name = "m_GodData")]
143 pub m_god_data: crate::app::goddata::GodData,
144 }
145
146 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_EditItemMenuItem.md"))]
147 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.EditItemMenuItem")]
148 #[parent(crate::app::menuitem::MenuItem)]
149 pub struct DebugUnitItemMenu_EditItemMenuItem {
150 #[static_field]
151 #[rename(name = "MinIndex")]
152 pub min_index: i32,
153 #[offset(32)]
154 #[rename(name = "m_Unit")]
155 pub m_unit: crate::app::unit::Unit,
156 #[offset(40)]
157 #[rename(name = "m_UnitItemIndex")]
158 pub m_unit_item_index: i32,
159 #[offset(48)]
160 #[rename(name = "m_UnitItem")]
161 pub m_unit_item: crate::app::unititem::UnitItem,
162 }
163
164 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_EngraveMenuItem.md"))]
165 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.EngraveMenuItem")]
166 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_BaseMenuItem)]
167 pub struct DebugUnitItemMenu_SubMenu_EngraveMenuItem {}
168
169 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_UnitDebugMenu.md"))]
170 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.UnitDebugMenu")]
171 #[parent(crate::app::debugmenu::DebugMenu)]
172 pub struct DebugUnitItemMenu_UnitDebugMenu {
173 #[offset(224)]
174 #[rename(name = "m_Unit")]
175 pub m_unit: crate::app::unit::Unit,
176 }
177
178 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_ItemListMenu.md"))]
179 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.ItemListMenu")]
180 #[parent(crate::system::object::Object)]
181 pub struct DebugUnitItemMenu_ItemListMenu {}
182
183 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_RefineMenu_RefineMenuItem.md"))]
184 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.RefineMenu.RefineMenuItem")]
185 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_RefineMenu_BaseMenuItem)]
186 pub struct DebugUnitItemMenu_RefineMenu_RefineMenuItem {
187 #[offset(56)]
188 #[rename(name = "m_Level")]
189 pub m_level: i32,
190 #[offset(64)]
191 #[rename(name = "m_Data")]
192 pub m_data: crate::app::itemrefinedata::ItemRefineData,
193 }
194
195 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_RefineMenu_BaseMenuItem.md"))]
196 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.RefineMenu.BaseMenuItem")]
197 #[parent(crate::app::menuitem::MenuItem)]
198 pub struct DebugUnitItemMenu_RefineMenu_BaseMenuItem {
199 #[offset(32)]
200 #[rename(name = "m_Unit")]
201 pub m_unit: crate::app::unit::Unit,
202 #[offset(40)]
203 #[rename(name = "m_UnitItemIndex")]
204 pub m_unit_item_index: i32,
205 #[offset(48)]
206 #[rename(name = "m_UnitItem")]
207 pub m_unit_item: crate::app::unititem::UnitItem,
208 }
209
210 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_NameMenuItem.md"))]
211 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.NameMenuItem")]
212 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_BaseMenuItem)]
213 pub struct DebugUnitItemMenu_SubMenu_NameMenuItem {}
214
215 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_RefineMenu.md"))]
216 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.RefineMenu")]
217 #[parent(crate::system::object::Object)]
218 pub struct DebugUnitItemMenu_RefineMenu {}
219
220 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugunititemmenu/DebugUnitItemMenu_SubMenu_DropMenuItem.md"))]
221 #[::unity::class(namespace = "App", name = "DebugUnitItemMenu.SubMenu.DropMenuItem")]
222 #[parent(crate::app::debugunititemmenu::DebugUnitItemMenu_SubMenu_FlagMenuItem)]
223 pub struct DebugUnitItemMenu_SubMenu_DropMenuItem {}
224}
225
226#[cfg(feature = "app-debugunititemmenu-types")]
227pub use __types::*;
228
229#[cfg(feature = "app-debugunititemmenu")]
230impl DebugUnitItemMenu_SubMenu {
231 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::unit::Unit, i32)` overload"]
232 pub fn create_bind(
233 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
234 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
235 unit_item_index: impl ::core::convert::Into<i32>,
236 ) -> () {
237 unsafe {
238 ::unity::il2cpp_call!((::unity::module_base()+0x1bbc120usize)as*mut u8,();
239(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
240 }
241 }
242}
243
244#[cfg(feature = "app-debugunititemmenu")]
245pub trait IDebugUnitItemMenu_SubMenuMethods: IDebugUnitItemMenu_SubMenu {
246 #[doc = "`.ctor()` overload"]
247 fn ctor(self) -> () {
248 unsafe {
249 let __receiver =
250 <DebugUnitItemMenu_SubMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
251 ::unity::il2cpp_call!((::unity::module_base()+0x1bbdfe0usize)as*mut u8,();
252(DebugUnitItemMenu_SubMenu)__receiver)
253 }
254 }
255}
256
257#[cfg(feature = "app-debugunititemmenu")]
258impl<__T: IDebugUnitItemMenu_SubMenu> IDebugUnitItemMenu_SubMenuMethods for __T {}
259
260#[cfg(feature = "app-debugunititemmenu")]
261impl DebugUnitItemMenu_SubMenu {
262 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
263 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
264 }
265
266 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
267 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
268 }
269}
270
271#[cfg(feature = "app-debugunititemmenu")]
272impl DebugUnitItemMenu_SubMenu {
273 #[doc = "`.ctor()` — no args"]
274 pub fn new() -> Self {
275 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
276 panic!(
277 "{}
278::{}
279 failed to instantiate",
280 ::core::stringify!(DebugUnitItemMenu_SubMenu),
281 ::core::stringify!(new),
282 )
283 });
284 <Self as IDebugUnitItemMenu_SubMenuMethods>::ctor(this);
285 this
286 }
287}
288
289#[cfg(feature = "app-debugunititemmenu")]
290pub trait IDebugUnitItemMenu_SubMenu_SellingMenuItemMethods: IDebugUnitItemMenu_SubMenu_SellingMenuItem {
291 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
292 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
293 unsafe {
294 let __receiver = <DebugUnitItemMenu_SubMenu_SellingMenuItem as ::unity::FromIlInstance>::from_il_instance(
295 <Self as ::unity::SystemObject>::as_instance(self),
296 );
297 ::unity::il2cpp_call!((::unity::module_base()+0x1b35b20usize)as*mut u8,();
298(DebugUnitItemMenu_SubMenu_SellingMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
299 }
300 }
301 #[doc = "`GetColumnName0()` overload"]
302 fn get_column_name0(self) -> ::unity::Il2CppString {
303 unsafe {
304 let __receiver = <DebugUnitItemMenu_SubMenu_SellingMenuItem as ::unity::FromIlInstance>::from_il_instance(
305 <Self as ::unity::SystemObject>::as_instance(self),
306 );
307 {
308 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
309 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
310 panic!(
311 "unity: virtual slot {}
312 out of range (vtable len {}
313) on the runtime class behind {}
314 (method `{}
315`)",
316 42usize,
317 __vt.len(),
318 <DebugUnitItemMenu_SubMenu_SellingMenuItem as ::unity::ClassIdentity>::NAME,
319 "GetColumnName0",
320 )
321 });
322 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_SellingMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
323 ::core::mem::transmute(__vi.method_ptr);
324 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
325 __inner(__receiver, __mi)
326 }
327 }
328 }
329 #[doc = "`GetColumnName1()` overload"]
330 fn get_column_name1(self) -> ::unity::Il2CppString {
331 unsafe {
332 let __receiver = <DebugUnitItemMenu_SubMenu_SellingMenuItem as ::unity::FromIlInstance>::from_il_instance(
333 <Self as ::unity::SystemObject>::as_instance(self),
334 );
335 {
336 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
337 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
338 panic!(
339 "unity: virtual slot {}
340 out of range (vtable len {}
341) on the runtime class behind {}
342 (method `{}
343`)",
344 43usize,
345 __vt.len(),
346 <DebugUnitItemMenu_SubMenu_SellingMenuItem as ::unity::ClassIdentity>::NAME,
347 "GetColumnName1",
348 )
349 });
350 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_SellingMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
351 ::core::mem::transmute(__vi.method_ptr);
352 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
353 __inner(__receiver, __mi)
354 }
355 }
356 }
357}
358
359#[cfg(feature = "app-debugunititemmenu")]
360impl<__T: IDebugUnitItemMenu_SubMenu_SellingMenuItem> IDebugUnitItemMenu_SubMenu_SellingMenuItemMethods for __T {}
361
362#[cfg(feature = "app-debugunititemmenu")]
363impl DebugUnitItemMenu_SubMenu_SellingMenuItem {
364 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
365 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
366 }
367
368 pub fn get_column_name0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
369 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
370 }
371
372 pub fn get_column_name1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
373 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
374 }
375}
376
377#[cfg(feature = "app-debugunititemmenu")]
378impl DebugUnitItemMenu_SubMenu_SellingMenuItem {
379 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_SellingMenuItem`'s own `GetColumnName0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
380 pub unsafe fn get_column_name0(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
381 let __mi = Self::get_column_name0_method_info();
382 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
383 __inner(this.into(), ::core::option::Option::None)
384 }
385
386 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_SellingMenuItem`'s own `GetColumnName1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
387 pub unsafe fn get_column_name1(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
388 let __mi = Self::get_column_name1_method_info();
389 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
390 __inner(this.into(), ::core::option::Option::None)
391 }
392}
393
394#[cfg(feature = "app-debugunititemmenu")]
395impl DebugUnitItemMenu_SubMenu_SellingMenuItem {
396 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
397 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
398 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
399 panic!(
400 "{}
401::{}
402 failed to instantiate",
403 ::core::stringify!(DebugUnitItemMenu_SubMenu_SellingMenuItem),
404 ::core::stringify!(new),
405 )
406 });
407 <Self as IDebugUnitItemMenu_SubMenu_SellingMenuItemMethods>::ctor(this, unit, unit_item_index);
408 this
409 }
410}
411
412#[cfg(feature = "app-debugunititemmenu")]
413pub trait IDebugUnitItemMenu_SubMenu_PriceMenuItemMethods: IDebugUnitItemMenu_SubMenu_PriceMenuItem {
414 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
415 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
416 unsafe {
417 let __receiver = <DebugUnitItemMenu_SubMenu_PriceMenuItem as ::unity::FromIlInstance>::from_il_instance(
418 <Self as ::unity::SystemObject>::as_instance(self),
419 );
420 ::unity::il2cpp_call!((::unity::module_base()+0x1b358c0usize)as*mut u8,();
421(DebugUnitItemMenu_SubMenu_PriceMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
422 }
423 }
424 #[doc = "`GetColumnName0()` overload"]
425 fn get_column_name0(self) -> ::unity::Il2CppString {
426 unsafe {
427 let __receiver = <DebugUnitItemMenu_SubMenu_PriceMenuItem as ::unity::FromIlInstance>::from_il_instance(
428 <Self as ::unity::SystemObject>::as_instance(self),
429 );
430 {
431 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
432 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
433 panic!(
434 "unity: virtual slot {}
435 out of range (vtable len {}
436) on the runtime class behind {}
437 (method `{}
438`)",
439 42usize,
440 __vt.len(),
441 <DebugUnitItemMenu_SubMenu_PriceMenuItem as ::unity::ClassIdentity>::NAME,
442 "GetColumnName0",
443 )
444 });
445 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_PriceMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
446 ::core::mem::transmute(__vi.method_ptr);
447 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
448 __inner(__receiver, __mi)
449 }
450 }
451 }
452 #[doc = "`GetColumnName1()` overload"]
453 fn get_column_name1(self) -> ::unity::Il2CppString {
454 unsafe {
455 let __receiver = <DebugUnitItemMenu_SubMenu_PriceMenuItem as ::unity::FromIlInstance>::from_il_instance(
456 <Self as ::unity::SystemObject>::as_instance(self),
457 );
458 {
459 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
460 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
461 panic!(
462 "unity: virtual slot {}
463 out of range (vtable len {}
464) on the runtime class behind {}
465 (method `{}
466`)",
467 43usize,
468 __vt.len(),
469 <DebugUnitItemMenu_SubMenu_PriceMenuItem as ::unity::ClassIdentity>::NAME,
470 "GetColumnName1",
471 )
472 });
473 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_PriceMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
474 ::core::mem::transmute(__vi.method_ptr);
475 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
476 __inner(__receiver, __mi)
477 }
478 }
479 }
480}
481
482#[cfg(feature = "app-debugunititemmenu")]
483impl<__T: IDebugUnitItemMenu_SubMenu_PriceMenuItem> IDebugUnitItemMenu_SubMenu_PriceMenuItemMethods for __T {}
484
485#[cfg(feature = "app-debugunititemmenu")]
486impl DebugUnitItemMenu_SubMenu_PriceMenuItem {
487 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
488 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
489 }
490
491 pub fn get_column_name0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
492 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
493 }
494
495 pub fn get_column_name1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
496 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
497 }
498}
499
500#[cfg(feature = "app-debugunititemmenu")]
501impl DebugUnitItemMenu_SubMenu_PriceMenuItem {
502 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_PriceMenuItem`'s own `GetColumnName0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
503 pub unsafe fn get_column_name0(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
504 let __mi = Self::get_column_name0_method_info();
505 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
506 __inner(this.into(), ::core::option::Option::None)
507 }
508
509 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_PriceMenuItem`'s own `GetColumnName1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
510 pub unsafe fn get_column_name1(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
511 let __mi = Self::get_column_name1_method_info();
512 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
513 __inner(this.into(), ::core::option::Option::None)
514 }
515}
516
517#[cfg(feature = "app-debugunititemmenu")]
518impl DebugUnitItemMenu_SubMenu_PriceMenuItem {
519 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
520 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
521 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
522 panic!(
523 "{}
524::{}
525 failed to instantiate",
526 ::core::stringify!(DebugUnitItemMenu_SubMenu_PriceMenuItem),
527 ::core::stringify!(new),
528 )
529 });
530 <Self as IDebugUnitItemMenu_SubMenu_PriceMenuItemMethods>::ctor(this, unit, unit_item_index);
531 this
532 }
533}
534
535#[cfg(feature = "app-debugunititemmenu")]
536pub trait IDebugUnitItemMenu_SubMenu_EnchantHashMenuItemMethods: IDebugUnitItemMenu_SubMenu_EnchantHashMenuItem {
537 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
538 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
539 unsafe {
540 let __receiver = <DebugUnitItemMenu_SubMenu_EnchantHashMenuItem as ::unity::FromIlInstance>::from_il_instance(
541 <Self as ::unity::SystemObject>::as_instance(self),
542 );
543 ::unity::il2cpp_call!((::unity::module_base()+0x1b350b0usize)as*mut u8,();
544(DebugUnitItemMenu_SubMenu_EnchantHashMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
545 }
546 }
547 #[doc = "`GetColumnName0()` overload"]
548 fn get_column_name0(self) -> ::unity::Il2CppString {
549 unsafe {
550 let __receiver = <DebugUnitItemMenu_SubMenu_EnchantHashMenuItem as ::unity::FromIlInstance>::from_il_instance(
551 <Self as ::unity::SystemObject>::as_instance(self),
552 );
553 {
554 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
555 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
556 panic!(
557 "unity: virtual slot {}
558 out of range (vtable len {}
559) on the runtime class behind {}
560 (method `{}
561`)",
562 42usize,
563 __vt.len(),
564 <DebugUnitItemMenu_SubMenu_EnchantHashMenuItem as ::unity::ClassIdentity>::NAME,
565 "GetColumnName0",
566 )
567 });
568 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EnchantHashMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
569 ::core::mem::transmute(__vi.method_ptr);
570 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
571 __inner(__receiver, __mi)
572 }
573 }
574 }
575 #[doc = "`GetColumnName1()` overload"]
576 fn get_column_name1(self) -> ::unity::Il2CppString {
577 unsafe {
578 let __receiver = <DebugUnitItemMenu_SubMenu_EnchantHashMenuItem as ::unity::FromIlInstance>::from_il_instance(
579 <Self as ::unity::SystemObject>::as_instance(self),
580 );
581 {
582 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
583 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
584 panic!(
585 "unity: virtual slot {}
586 out of range (vtable len {}
587) on the runtime class behind {}
588 (method `{}
589`)",
590 43usize,
591 __vt.len(),
592 <DebugUnitItemMenu_SubMenu_EnchantHashMenuItem as ::unity::ClassIdentity>::NAME,
593 "GetColumnName1",
594 )
595 });
596 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EnchantHashMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
597 ::core::mem::transmute(__vi.method_ptr);
598 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
599 __inner(__receiver, __mi)
600 }
601 }
602 }
603}
604
605#[cfg(feature = "app-debugunititemmenu")]
606impl<__T: IDebugUnitItemMenu_SubMenu_EnchantHashMenuItem> IDebugUnitItemMenu_SubMenu_EnchantHashMenuItemMethods for __T {}
607
608#[cfg(feature = "app-debugunititemmenu")]
609impl DebugUnitItemMenu_SubMenu_EnchantHashMenuItem {
610 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
611 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
612 }
613
614 pub fn get_column_name0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
615 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
616 }
617
618 pub fn get_column_name1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
619 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
620 }
621}
622
623#[cfg(feature = "app-debugunititemmenu")]
624impl DebugUnitItemMenu_SubMenu_EnchantHashMenuItem {
625 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EnchantHashMenuItem`'s own `GetColumnName0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
626 pub unsafe fn get_column_name0(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
627 let __mi = Self::get_column_name0_method_info();
628 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
629 __inner(this.into(), ::core::option::Option::None)
630 }
631
632 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EnchantHashMenuItem`'s own `GetColumnName1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
633 pub unsafe fn get_column_name1(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
634 let __mi = Self::get_column_name1_method_info();
635 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
636 __inner(this.into(), ::core::option::Option::None)
637 }
638}
639
640#[cfg(feature = "app-debugunititemmenu")]
641impl DebugUnitItemMenu_SubMenu_EnchantHashMenuItem {
642 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
643 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
644 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
645 panic!(
646 "{}
647::{}
648 failed to instantiate",
649 ::core::stringify!(DebugUnitItemMenu_SubMenu_EnchantHashMenuItem),
650 ::core::stringify!(new),
651 )
652 });
653 <Self as IDebugUnitItemMenu_SubMenu_EnchantHashMenuItemMethods>::ctor(this, unit, unit_item_index);
654 this
655 }
656}
657
658#[cfg(feature = "app-debugunititemmenu")]
659pub trait IDebugUnitItemMenu_SubMenu_ItemBaseMenuItemMethods: IDebugUnitItemMenu_SubMenu_ItemBaseMenuItem {
660 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
661 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
662 unsafe {
663 let __receiver = <DebugUnitItemMenu_SubMenu_ItemBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
664 <Self as ::unity::SystemObject>::as_instance(self),
665 );
666 ::unity::il2cpp_call!((::unity::module_base()+0x1b35120usize)as*mut u8,();
667(DebugUnitItemMenu_SubMenu_ItemBaseMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
668 }
669 }
670 #[doc = "`GetColumnCount()` overload"]
671 fn get_column_count(self) -> i32 {
672 unsafe {
673 let __receiver = <DebugUnitItemMenu_SubMenu_ItemBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
674 <Self as ::unity::SystemObject>::as_instance(self),
675 );
676 {
677 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
678 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
679 panic!(
680 "unity: virtual slot {}
681 out of range (vtable len {}
682) on the runtime class behind {}
683 (method `{}
684`)",
685 29usize,
686 __vt.len(),
687 <DebugUnitItemMenu_SubMenu_ItemBaseMenuItem as ::unity::ClassIdentity>::NAME,
688 "GetColumnCount",
689 )
690 });
691 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_ItemBaseMenuItem, ::unity::OptionalMethod) -> i32 =
692 ::core::mem::transmute(__vi.method_ptr);
693 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
694 __inner(__receiver, __mi)
695 }
696 }
697 }
698 #[doc = "`GetColumnWidth0()` overload"]
699 fn get_column_width0(self) -> f32 {
700 unsafe {
701 let __receiver = <DebugUnitItemMenu_SubMenu_ItemBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
702 <Self as ::unity::SystemObject>::as_instance(self),
703 );
704 {
705 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
706 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
707 panic!(
708 "unity: virtual slot {}
709 out of range (vtable len {}
710) on the runtime class behind {}
711 (method `{}
712`)",
713 31usize,
714 __vt.len(),
715 <DebugUnitItemMenu_SubMenu_ItemBaseMenuItem as ::unity::ClassIdentity>::NAME,
716 "GetColumnWidth0",
717 )
718 });
719 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_ItemBaseMenuItem, ::unity::OptionalMethod) -> f32 =
720 ::core::mem::transmute(__vi.method_ptr);
721 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
722 __inner(__receiver, __mi)
723 }
724 }
725 }
726 #[doc = "`GetColumnWidth1()` overload"]
727 fn get_column_width1(self) -> f32 {
728 unsafe {
729 let __receiver = <DebugUnitItemMenu_SubMenu_ItemBaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
730 <Self as ::unity::SystemObject>::as_instance(self),
731 );
732 {
733 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
734 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
735 panic!(
736 "unity: virtual slot {}
737 out of range (vtable len {}
738) on the runtime class behind {}
739 (method `{}
740`)",
741 32usize,
742 __vt.len(),
743 <DebugUnitItemMenu_SubMenu_ItemBaseMenuItem as ::unity::ClassIdentity>::NAME,
744 "GetColumnWidth1",
745 )
746 });
747 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_ItemBaseMenuItem, ::unity::OptionalMethod) -> f32 =
748 ::core::mem::transmute(__vi.method_ptr);
749 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
750 __inner(__receiver, __mi)
751 }
752 }
753 }
754}
755
756#[cfg(feature = "app-debugunititemmenu")]
757impl<__T: IDebugUnitItemMenu_SubMenu_ItemBaseMenuItem> IDebugUnitItemMenu_SubMenu_ItemBaseMenuItemMethods for __T {}
758
759#[cfg(feature = "app-debugunititemmenu")]
760impl DebugUnitItemMenu_SubMenu_ItemBaseMenuItem {
761 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
762 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
763 }
764
765 pub fn get_column_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
766 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
767 }
768
769 pub fn get_column_width0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
770 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
771 }
772
773 pub fn get_column_width1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
774 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
775 }
776}
777
778#[cfg(feature = "app-debugunititemmenu")]
779impl DebugUnitItemMenu_SubMenu_ItemBaseMenuItem {
780 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_ItemBaseMenuItem`'s own `GetColumnCount`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
781 pub unsafe fn get_column_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
782 let __mi = Self::get_column_count_method_info();
783 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
784 __inner(this.into(), ::core::option::Option::None)
785 }
786
787 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_ItemBaseMenuItem`'s own `GetColumnWidth0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
788 pub unsafe fn get_column_width0(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
789 let __mi = Self::get_column_width0_method_info();
790 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
791 __inner(this.into(), ::core::option::Option::None)
792 }
793
794 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_ItemBaseMenuItem`'s own `GetColumnWidth1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
795 pub unsafe fn get_column_width1(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
796 let __mi = Self::get_column_width1_method_info();
797 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
798 __inner(this.into(), ::core::option::Option::None)
799 }
800}
801
802#[cfg(feature = "app-debugunititemmenu")]
803impl DebugUnitItemMenu_SubMenu_ItemBaseMenuItem {
804 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
805 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
806 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
807 panic!(
808 "{}
809::{}
810 failed to instantiate",
811 ::core::stringify!(DebugUnitItemMenu_SubMenu_ItemBaseMenuItem),
812 ::core::stringify!(new),
813 )
814 });
815 <Self as IDebugUnitItemMenu_SubMenu_ItemBaseMenuItemMethods>::ctor(this, unit, unit_item_index);
816 this
817 }
818}
819
820#[cfg(feature = "app-debugunititemmenu")]
821pub trait IDebugUnitItemMenu_SubMenu_BaseMenuItemMethods: IDebugUnitItemMenu_SubMenu_BaseMenuItem {
822 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
823 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
824 unsafe {
825 let __receiver = <DebugUnitItemMenu_SubMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
826 <Self as ::unity::SystemObject>::as_instance(self),
827 );
828 ::unity::il2cpp_call!((::unity::module_base()+0x1b34ee0usize)as*mut u8,();
829(DebugUnitItemMenu_SubMenu_BaseMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
830 }
831 }
832 #[doc = "`GetWidth()` overload"]
833 fn get_width(self) -> f32 {
834 unsafe {
835 let __receiver = <DebugUnitItemMenu_SubMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
836 <Self as ::unity::SystemObject>::as_instance(self),
837 );
838 {
839 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
840 let __vi = *__vt.get(25usize).unwrap_or_else(|| {
841 panic!(
842 "unity: virtual slot {}
843 out of range (vtable len {}
844) on the runtime class behind {}
845 (method `{}
846`)",
847 25usize,
848 __vt.len(),
849 <DebugUnitItemMenu_SubMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
850 "GetWidth",
851 )
852 });
853 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_BaseMenuItem, ::unity::OptionalMethod) -> f32 =
854 ::core::mem::transmute(__vi.method_ptr);
855 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
856 __inner(__receiver, __mi)
857 }
858 }
859 }
860}
861
862#[cfg(feature = "app-debugunititemmenu")]
863impl<__T: IDebugUnitItemMenu_SubMenu_BaseMenuItem> IDebugUnitItemMenu_SubMenu_BaseMenuItemMethods for __T {}
864
865#[cfg(feature = "app-debugunititemmenu")]
866impl DebugUnitItemMenu_SubMenu_BaseMenuItem {
867 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
868 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
869 }
870
871 pub fn get_width_method_info() -> &'static ::unity::il2cpp::MethodInfo {
872 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
873 }
874}
875
876#[cfg(feature = "app-debugunititemmenu")]
877impl DebugUnitItemMenu_SubMenu_BaseMenuItem {
878 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_BaseMenuItem`'s own `GetWidth`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
879 pub unsafe fn get_width(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
880 let __mi = Self::get_width_method_info();
881 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
882 __inner(this.into(), ::core::option::Option::None)
883 }
884}
885
886#[cfg(feature = "app-debugunititemmenu")]
887impl DebugUnitItemMenu_SubMenu_BaseMenuItem {
888 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
889 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
890 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
891 panic!(
892 "{}
893::{}
894 failed to instantiate",
895 ::core::stringify!(DebugUnitItemMenu_SubMenu_BaseMenuItem),
896 ::core::stringify!(new),
897 )
898 });
899 <Self as IDebugUnitItemMenu_SubMenu_BaseMenuItemMethods>::ctor(this, unit, unit_item_index);
900 this
901 }
902}
903
904#[cfg(feature = "app-debugunititemmenu")]
905pub trait IDebugUnitItemMenu_SubMenu_EnchantMenuItemMethods: IDebugUnitItemMenu_SubMenu_EnchantMenuItem {
906 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
907 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
908 unsafe {
909 let __receiver = <DebugUnitItemMenu_SubMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(
910 <Self as ::unity::SystemObject>::as_instance(self),
911 );
912 ::unity::il2cpp_call!((::unity::module_base()+0x1b35250usize)as*mut u8,();
913(DebugUnitItemMenu_SubMenu_EnchantMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
914 }
915 }
916 #[doc = "`GetLabel()` overload"]
917 fn get_label(self) -> ::unity::Il2CppString {
918 unsafe {
919 let __receiver = <DebugUnitItemMenu_SubMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(
920 <Self as ::unity::SystemObject>::as_instance(self),
921 );
922 {
923 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
924 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
925 panic!(
926 "unity: virtual slot {}
927 out of range (vtable len {}
928) on the runtime class behind {}
929 (method `{}
930`)",
931 72usize,
932 __vt.len(),
933 <DebugUnitItemMenu_SubMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
934 "GetLabel",
935 )
936 });
937 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EnchantMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
938 ::core::mem::transmute(__vi.method_ptr);
939 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
940 __inner(__receiver, __mi)
941 }
942 }
943 }
944 #[doc = "`SetFlag(bool)` overload"]
945 fn set_flag(self, enable: impl ::core::convert::Into<bool>) -> () {
946 unsafe {
947 let __receiver = <DebugUnitItemMenu_SubMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(
948 <Self as ::unity::SystemObject>::as_instance(self),
949 );
950 {
951 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
952 let __vi = *__vt.get(73usize).unwrap_or_else(|| {
953 panic!(
954 "unity: virtual slot {}
955 out of range (vtable len {}
956) on the runtime class behind {}
957 (method `{}
958`)",
959 73usize,
960 __vt.len(),
961 <DebugUnitItemMenu_SubMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
962 "SetFlag",
963 )
964 });
965 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EnchantMenuItem, bool, ::unity::OptionalMethod) -> () =
966 ::core::mem::transmute(__vi.method_ptr);
967 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
968 __inner(__receiver, ::core::convert::Into::into(enable), __mi)
969 }
970 }
971 }
972 #[doc = "`IsFlag()` overload"]
973 fn is_flag(self) -> bool {
974 unsafe {
975 let __receiver = <DebugUnitItemMenu_SubMenu_EnchantMenuItem as ::unity::FromIlInstance>::from_il_instance(
976 <Self as ::unity::SystemObject>::as_instance(self),
977 );
978 {
979 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
980 let __vi = *__vt.get(74usize).unwrap_or_else(|| {
981 panic!(
982 "unity: virtual slot {}
983 out of range (vtable len {}
984) on the runtime class behind {}
985 (method `{}
986`)",
987 74usize,
988 __vt.len(),
989 <DebugUnitItemMenu_SubMenu_EnchantMenuItem as ::unity::ClassIdentity>::NAME,
990 "IsFlag",
991 )
992 });
993 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EnchantMenuItem, ::unity::OptionalMethod) -> bool =
994 ::core::mem::transmute(__vi.method_ptr);
995 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
996 __inner(__receiver, __mi)
997 }
998 }
999 }
1000}
1001
1002#[cfg(feature = "app-debugunititemmenu")]
1003impl<__T: IDebugUnitItemMenu_SubMenu_EnchantMenuItem> IDebugUnitItemMenu_SubMenu_EnchantMenuItemMethods for __T {}
1004
1005#[cfg(feature = "app-debugunititemmenu")]
1006impl DebugUnitItemMenu_SubMenu_EnchantMenuItem {
1007 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1008 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1009 }
1010
1011 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1012 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1013 }
1014
1015 pub fn set_flag_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1016 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1017 }
1018
1019 pub fn is_flag_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1020 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1021 }
1022}
1023
1024#[cfg(feature = "app-debugunititemmenu")]
1025impl DebugUnitItemMenu_SubMenu_EnchantMenuItem {
1026 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EnchantMenuItem`'s own `GetLabel`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1027 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1028 let __mi = Self::get_label_method_info();
1029 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1030 __inner(this.into(), ::core::option::Option::None)
1031 }
1032
1033 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EnchantMenuItem`'s own `SetFlag`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1034 pub unsafe fn set_flag(this: impl ::core::convert::Into<::unity::IlInstance>, enable: bool) -> () {
1035 let __mi = Self::set_flag_method_info();
1036 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1037 __inner(this.into(), enable, ::core::option::Option::None)
1038 }
1039
1040 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EnchantMenuItem`'s own `IsFlag`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1041 pub unsafe fn is_flag(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1042 let __mi = Self::is_flag_method_info();
1043 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1044 __inner(this.into(), ::core::option::Option::None)
1045 }
1046}
1047
1048#[cfg(feature = "app-debugunititemmenu")]
1049impl DebugUnitItemMenu_SubMenu_EnchantMenuItem {
1050 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
1051 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
1052 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1053 panic!(
1054 "{}
1055::{}
1056 failed to instantiate",
1057 ::core::stringify!(DebugUnitItemMenu_SubMenu_EnchantMenuItem),
1058 ::core::stringify!(new),
1059 )
1060 });
1061 <Self as IDebugUnitItemMenu_SubMenu_EnchantMenuItemMethods>::ctor(this, unit, unit_item_index);
1062 this
1063 }
1064}
1065
1066#[cfg(feature = "app-debugunititemmenu")]
1067pub trait IDebugUnitItemMenu_ItemListMenu_ItemMenuItemMethods: IDebugUnitItemMenu_ItemListMenu_ItemMenuItem {
1068 #[doc = "`.ctor(crate::app::unit::Unit, crate::app::unititem::UnitItem, i32)` overload"]
1069 fn ctor(
1070 self,
1071 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
1072 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1073 index: impl ::core::convert::Into<i32>,
1074 ) -> () {
1075 unsafe {
1076 let __receiver = <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
1077 <Self as ::unity::SystemObject>::as_instance(self),
1078 );
1079 ::unity::il2cpp_call!((::unity::module_base()+0x1b33440usize)as*mut u8,();
1080(DebugUnitItemMenu_ItemListMenu_ItemMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item),(i32)::core::convert::Into::into(index))
1081 }
1082 }
1083 #[doc = "`GetColumnCount()` overload"]
1084 fn get_column_count(self) -> i32 {
1085 unsafe {
1086 let __receiver = <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
1087 <Self as ::unity::SystemObject>::as_instance(self),
1088 );
1089 {
1090 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1091 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
1092 panic!(
1093 "unity: virtual slot {}
1094 out of range (vtable len {}
1095) on the runtime class behind {}
1096 (method `{}
1097`)",
1098 29usize,
1099 __vt.len(),
1100 <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1101 "GetColumnCount",
1102 )
1103 });
1104 let __inner: extern "C" fn(DebugUnitItemMenu_ItemListMenu_ItemMenuItem, ::unity::OptionalMethod) -> i32 =
1105 ::core::mem::transmute(__vi.method_ptr);
1106 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1107 __inner(__receiver, __mi)
1108 }
1109 }
1110 }
1111 #[doc = "`GetColumnWidth0()` overload"]
1112 fn get_column_width0(self) -> f32 {
1113 unsafe {
1114 let __receiver = <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
1115 <Self as ::unity::SystemObject>::as_instance(self),
1116 );
1117 {
1118 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1119 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
1120 panic!(
1121 "unity: virtual slot {}
1122 out of range (vtable len {}
1123) on the runtime class behind {}
1124 (method `{}
1125`)",
1126 31usize,
1127 __vt.len(),
1128 <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1129 "GetColumnWidth0",
1130 )
1131 });
1132 let __inner: extern "C" fn(DebugUnitItemMenu_ItemListMenu_ItemMenuItem, ::unity::OptionalMethod) -> f32 =
1133 ::core::mem::transmute(__vi.method_ptr);
1134 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1135 __inner(__receiver, __mi)
1136 }
1137 }
1138 }
1139 #[doc = "`GetColumnWidth1()` overload"]
1140 fn get_column_width1(self) -> f32 {
1141 unsafe {
1142 let __receiver = <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
1143 <Self as ::unity::SystemObject>::as_instance(self),
1144 );
1145 {
1146 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1147 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
1148 panic!(
1149 "unity: virtual slot {}
1150 out of range (vtable len {}
1151) on the runtime class behind {}
1152 (method `{}
1153`)",
1154 32usize,
1155 __vt.len(),
1156 <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1157 "GetColumnWidth1",
1158 )
1159 });
1160 let __inner: extern "C" fn(DebugUnitItemMenu_ItemListMenu_ItemMenuItem, ::unity::OptionalMethod) -> f32 =
1161 ::core::mem::transmute(__vi.method_ptr);
1162 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1163 __inner(__receiver, __mi)
1164 }
1165 }
1166 }
1167 #[doc = "`GetColumnName0()` overload"]
1168 fn get_column_name0(self) -> ::unity::Il2CppString {
1169 unsafe {
1170 let __receiver = <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
1171 <Self as ::unity::SystemObject>::as_instance(self),
1172 );
1173 {
1174 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1175 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
1176 panic!(
1177 "unity: virtual slot {}
1178 out of range (vtable len {}
1179) on the runtime class behind {}
1180 (method `{}
1181`)",
1182 42usize,
1183 __vt.len(),
1184 <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1185 "GetColumnName0",
1186 )
1187 });
1188 let __inner: extern "C" fn(DebugUnitItemMenu_ItemListMenu_ItemMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1189 ::core::mem::transmute(__vi.method_ptr);
1190 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1191 __inner(__receiver, __mi)
1192 }
1193 }
1194 }
1195 #[doc = "`GetColumnName1()` overload"]
1196 fn get_column_name1(self) -> ::unity::Il2CppString {
1197 unsafe {
1198 let __receiver = <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
1199 <Self as ::unity::SystemObject>::as_instance(self),
1200 );
1201 {
1202 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1203 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
1204 panic!(
1205 "unity: virtual slot {}
1206 out of range (vtable len {}
1207) on the runtime class behind {}
1208 (method `{}
1209`)",
1210 43usize,
1211 __vt.len(),
1212 <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1213 "GetColumnName1",
1214 )
1215 });
1216 let __inner: extern "C" fn(DebugUnitItemMenu_ItemListMenu_ItemMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1217 ::core::mem::transmute(__vi.method_ptr);
1218 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1219 __inner(__receiver, __mi)
1220 }
1221 }
1222 }
1223 #[doc = "`IsEnable()` overload"]
1224 fn is_enable(self) -> bool {
1225 unsafe {
1226 let __receiver = <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
1227 <Self as ::unity::SystemObject>::as_instance(self),
1228 );
1229 {
1230 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1231 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
1232 panic!(
1233 "unity: virtual slot {}
1234 out of range (vtable len {}
1235) on the runtime class behind {}
1236 (method `{}
1237`)",
1238 22usize,
1239 __vt.len(),
1240 <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1241 "IsEnable",
1242 )
1243 });
1244 let __inner: extern "C" fn(DebugUnitItemMenu_ItemListMenu_ItemMenuItem, ::unity::OptionalMethod) -> bool =
1245 ::core::mem::transmute(__vi.method_ptr);
1246 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1247 __inner(__receiver, __mi)
1248 }
1249 }
1250 }
1251 #[doc = "`ACall()` overload"]
1252 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
1253 unsafe {
1254 let __receiver = <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::FromIlInstance>::from_il_instance(
1255 <Self as ::unity::SystemObject>::as_instance(self),
1256 );
1257 {
1258 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1259 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
1260 panic!(
1261 "unity: virtual slot {}
1262 out of range (vtable len {}
1263) on the runtime class behind {}
1264 (method `{}
1265`)",
1266 12usize,
1267 __vt.len(),
1268 <DebugUnitItemMenu_ItemListMenu_ItemMenuItem as ::unity::ClassIdentity>::NAME,
1269 "ACall",
1270 )
1271 });
1272 let __inner: extern "C" fn(
1273 DebugUnitItemMenu_ItemListMenu_ItemMenuItem,
1274 ::unity::OptionalMethod,
1275 ) -> crate::app::menuitem::MenuItem_Result = ::core::mem::transmute(__vi.method_ptr);
1276 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1277 __inner(__receiver, __mi)
1278 }
1279 }
1280 }
1281}
1282
1283#[cfg(feature = "app-debugunititemmenu")]
1284impl<__T: IDebugUnitItemMenu_ItemListMenu_ItemMenuItem> IDebugUnitItemMenu_ItemListMenu_ItemMenuItemMethods for __T {}
1285
1286#[cfg(feature = "app-debugunititemmenu")]
1287impl DebugUnitItemMenu_ItemListMenu_ItemMenuItem {
1288 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1289 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1290 }
1291
1292 pub fn get_column_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1293 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1294 }
1295
1296 pub fn get_column_width0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1297 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1298 }
1299
1300 pub fn get_column_width1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1301 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1302 }
1303
1304 pub fn get_column_name0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1305 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1306 }
1307
1308 pub fn get_column_name1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1309 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1310 }
1311
1312 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1313 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1314 }
1315
1316 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1317 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1318 }
1319}
1320
1321#[cfg(feature = "app-debugunititemmenu")]
1322impl DebugUnitItemMenu_ItemListMenu_ItemMenuItem {
1323 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_ItemListMenu_ItemMenuItem`'s own `GetColumnCount`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1324 pub unsafe fn get_column_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
1325 let __mi = Self::get_column_count_method_info();
1326 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
1327 __inner(this.into(), ::core::option::Option::None)
1328 }
1329
1330 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_ItemListMenu_ItemMenuItem`'s own `GetColumnWidth0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1331 pub unsafe fn get_column_width0(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1332 let __mi = Self::get_column_width0_method_info();
1333 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1334 __inner(this.into(), ::core::option::Option::None)
1335 }
1336
1337 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_ItemListMenu_ItemMenuItem`'s own `GetColumnWidth1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1338 pub unsafe fn get_column_width1(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
1339 let __mi = Self::get_column_width1_method_info();
1340 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
1341 __inner(this.into(), ::core::option::Option::None)
1342 }
1343
1344 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_ItemListMenu_ItemMenuItem`'s own `GetColumnName0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1345 pub unsafe fn get_column_name0(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1346 let __mi = Self::get_column_name0_method_info();
1347 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1348 __inner(this.into(), ::core::option::Option::None)
1349 }
1350
1351 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_ItemListMenu_ItemMenuItem`'s own `GetColumnName1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1352 pub unsafe fn get_column_name1(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1353 let __mi = Self::get_column_name1_method_info();
1354 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1355 __inner(this.into(), ::core::option::Option::None)
1356 }
1357
1358 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_ItemListMenu_ItemMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1359 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1360 let __mi = Self::is_enable_method_info();
1361 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1362 __inner(this.into(), ::core::option::Option::None)
1363 }
1364
1365 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_ItemListMenu_ItemMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1366 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
1367 let __mi = Self::a_call_method_info();
1368 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
1369 ::core::mem::transmute(__mi.method_ptr);
1370 __inner(this.into(), ::core::option::Option::None)
1371 }
1372}
1373
1374#[cfg(feature = "app-debugunititemmenu")]
1375impl DebugUnitItemMenu_ItemListMenu_ItemMenuItem {
1376 #[doc = "`.ctor(crate::app::unit::Unit, crate::app::unititem::UnitItem, i32)` — overload selector"]
1377 pub fn new(unit: crate::app::unit::Unit, unit_item: crate::app::unititem::UnitItem, index: i32) -> Self {
1378 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1379 panic!(
1380 "{}
1381::{}
1382 failed to instantiate",
1383 ::core::stringify!(DebugUnitItemMenu_ItemListMenu_ItemMenuItem),
1384 ::core::stringify!(new),
1385 )
1386 });
1387 <Self as IDebugUnitItemMenu_ItemListMenu_ItemMenuItemMethods>::ctor(this, unit, unit_item, index);
1388 this
1389 }
1390}
1391
1392#[cfg(feature = "app-debugunititemmenu")]
1393pub trait IDebugUnitItemMenu_RefineMenu_EvolveMenuItemMethods: IDebugUnitItemMenu_RefineMenu_EvolveMenuItem {
1394 #[doc = "`.ctor(crate::app::unit::Unit, i32, i32, crate::app::itemevolvedata::ItemEvolveData)` overload"]
1395 fn ctor(
1396 self,
1397 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
1398 unit_item_index: impl ::core::convert::Into<i32>,
1399 data_index: impl ::core::convert::Into<i32>,
1400 evolve_data: impl ::core::convert::Into<crate::app::itemevolvedata::ItemEvolveData>,
1401 ) -> () {
1402 unsafe {
1403 let __receiver = <DebugUnitItemMenu_RefineMenu_EvolveMenuItem as ::unity::FromIlInstance>::from_il_instance(
1404 <Self as ::unity::SystemObject>::as_instance(self),
1405 );
1406 ::unity::il2cpp_call!((::unity::module_base()+0x1b343b0usize)as*mut u8,();
1407(DebugUnitItemMenu_RefineMenu_EvolveMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index),(i32)::core::convert::Into::into(data_index),(crate::app::itemevolvedata::ItemEvolveData)::core::convert::Into::into(evolve_data))
1408 }
1409 }
1410 #[doc = "`GetColumnName0()` overload"]
1411 fn get_column_name0(self) -> ::unity::Il2CppString {
1412 unsafe {
1413 let __receiver = <DebugUnitItemMenu_RefineMenu_EvolveMenuItem as ::unity::FromIlInstance>::from_il_instance(
1414 <Self as ::unity::SystemObject>::as_instance(self),
1415 );
1416 {
1417 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1418 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
1419 panic!(
1420 "unity: virtual slot {}
1421 out of range (vtable len {}
1422) on the runtime class behind {}
1423 (method `{}
1424`)",
1425 42usize,
1426 __vt.len(),
1427 <DebugUnitItemMenu_RefineMenu_EvolveMenuItem as ::unity::ClassIdentity>::NAME,
1428 "GetColumnName0",
1429 )
1430 });
1431 let __inner: extern "C" fn(DebugUnitItemMenu_RefineMenu_EvolveMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1432 ::core::mem::transmute(__vi.method_ptr);
1433 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1434 __inner(__receiver, __mi)
1435 }
1436 }
1437 }
1438 #[doc = "`GetColumnName1()` overload"]
1439 fn get_column_name1(self) -> ::unity::Il2CppString {
1440 unsafe {
1441 let __receiver = <DebugUnitItemMenu_RefineMenu_EvolveMenuItem as ::unity::FromIlInstance>::from_il_instance(
1442 <Self as ::unity::SystemObject>::as_instance(self),
1443 );
1444 {
1445 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1446 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
1447 panic!(
1448 "unity: virtual slot {}
1449 out of range (vtable len {}
1450) on the runtime class behind {}
1451 (method `{}
1452`)",
1453 43usize,
1454 __vt.len(),
1455 <DebugUnitItemMenu_RefineMenu_EvolveMenuItem as ::unity::ClassIdentity>::NAME,
1456 "GetColumnName1",
1457 )
1458 });
1459 let __inner: extern "C" fn(DebugUnitItemMenu_RefineMenu_EvolveMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1460 ::core::mem::transmute(__vi.method_ptr);
1461 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1462 __inner(__receiver, __mi)
1463 }
1464 }
1465 }
1466 #[doc = "`GetColumnName2()` overload"]
1467 fn get_column_name2(self) -> ::unity::Il2CppString {
1468 unsafe {
1469 let __receiver = <DebugUnitItemMenu_RefineMenu_EvolveMenuItem as ::unity::FromIlInstance>::from_il_instance(
1470 <Self as ::unity::SystemObject>::as_instance(self),
1471 );
1472 {
1473 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1474 let __vi = *__vt.get(44usize).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 44usize,
1482 __vt.len(),
1483 <DebugUnitItemMenu_RefineMenu_EvolveMenuItem as ::unity::ClassIdentity>::NAME,
1484 "GetColumnName2",
1485 )
1486 });
1487 let __inner: extern "C" fn(DebugUnitItemMenu_RefineMenu_EvolveMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
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 = "`ACall()` overload"]
1495 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
1496 unsafe {
1497 let __receiver = <DebugUnitItemMenu_RefineMenu_EvolveMenuItem as ::unity::FromIlInstance>::from_il_instance(
1498 <Self as ::unity::SystemObject>::as_instance(self),
1499 );
1500 {
1501 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1502 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
1503 panic!(
1504 "unity: virtual slot {}
1505 out of range (vtable len {}
1506) on the runtime class behind {}
1507 (method `{}
1508`)",
1509 12usize,
1510 __vt.len(),
1511 <DebugUnitItemMenu_RefineMenu_EvolveMenuItem as ::unity::ClassIdentity>::NAME,
1512 "ACall",
1513 )
1514 });
1515 let __inner: extern "C" fn(
1516 DebugUnitItemMenu_RefineMenu_EvolveMenuItem,
1517 ::unity::OptionalMethod,
1518 ) -> crate::app::menuitem::MenuItem_Result = ::core::mem::transmute(__vi.method_ptr);
1519 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1520 __inner(__receiver, __mi)
1521 }
1522 }
1523 }
1524}
1525
1526#[cfg(feature = "app-debugunititemmenu")]
1527impl<__T: IDebugUnitItemMenu_RefineMenu_EvolveMenuItem> IDebugUnitItemMenu_RefineMenu_EvolveMenuItemMethods for __T {}
1528
1529#[cfg(feature = "app-debugunititemmenu")]
1530impl DebugUnitItemMenu_RefineMenu_EvolveMenuItem {
1531 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1532 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1533 }
1534
1535 pub fn get_column_name0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1536 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1537 }
1538
1539 pub fn get_column_name1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1540 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1541 }
1542
1543 pub fn get_column_name2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1544 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1545 }
1546
1547 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1548 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1549 }
1550}
1551
1552#[cfg(feature = "app-debugunititemmenu")]
1553impl DebugUnitItemMenu_RefineMenu_EvolveMenuItem {
1554 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_EvolveMenuItem`'s own `GetColumnName0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1555 pub unsafe fn get_column_name0(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1556 let __mi = Self::get_column_name0_method_info();
1557 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1558 __inner(this.into(), ::core::option::Option::None)
1559 }
1560
1561 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_EvolveMenuItem`'s own `GetColumnName1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1562 pub unsafe fn get_column_name1(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1563 let __mi = Self::get_column_name1_method_info();
1564 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1565 __inner(this.into(), ::core::option::Option::None)
1566 }
1567
1568 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_EvolveMenuItem`'s own `GetColumnName2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1569 pub unsafe fn get_column_name2(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1570 let __mi = Self::get_column_name2_method_info();
1571 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1572 __inner(this.into(), ::core::option::Option::None)
1573 }
1574
1575 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_EvolveMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1576 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
1577 let __mi = Self::a_call_method_info();
1578 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
1579 ::core::mem::transmute(__mi.method_ptr);
1580 __inner(this.into(), ::core::option::Option::None)
1581 }
1582}
1583
1584#[cfg(feature = "app-debugunititemmenu")]
1585impl DebugUnitItemMenu_RefineMenu_EvolveMenuItem {
1586 #[doc = "`.ctor(crate::app::unit::Unit, i32, i32, crate::app::itemevolvedata::ItemEvolveData)` — overload selector"]
1587 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32, data_index: i32, evolve_data: crate::app::itemevolvedata::ItemEvolveData) -> Self {
1588 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1589 panic!(
1590 "{}
1591::{}
1592 failed to instantiate",
1593 ::core::stringify!(DebugUnitItemMenu_RefineMenu_EvolveMenuItem),
1594 ::core::stringify!(new),
1595 )
1596 });
1597 <Self as IDebugUnitItemMenu_RefineMenu_EvolveMenuItemMethods>::ctor(this, unit, unit_item_index, data_index, evolve_data);
1598 this
1599 }
1600}
1601
1602#[cfg(feature = "app-debugunititemmenu")]
1603pub trait IDebugUnitItemMenu_SubMenu_EquipMenuItemMethods: IDebugUnitItemMenu_SubMenu_EquipMenuItem {
1604 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
1605 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
1606 unsafe {
1607 let __receiver = <DebugUnitItemMenu_SubMenu_EquipMenuItem as ::unity::FromIlInstance>::from_il_instance(
1608 <Self as ::unity::SystemObject>::as_instance(self),
1609 );
1610 ::unity::il2cpp_call!((::unity::module_base()+0x1b355b0usize)as*mut u8,();
1611(DebugUnitItemMenu_SubMenu_EquipMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
1612 }
1613 }
1614 #[doc = "`GetLabel()` overload"]
1615 fn get_label(self) -> ::unity::Il2CppString {
1616 unsafe {
1617 let __receiver = <DebugUnitItemMenu_SubMenu_EquipMenuItem as ::unity::FromIlInstance>::from_il_instance(
1618 <Self as ::unity::SystemObject>::as_instance(self),
1619 );
1620 {
1621 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1622 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
1623 panic!(
1624 "unity: virtual slot {}
1625 out of range (vtable len {}
1626) on the runtime class behind {}
1627 (method `{}
1628`)",
1629 72usize,
1630 __vt.len(),
1631 <DebugUnitItemMenu_SubMenu_EquipMenuItem as ::unity::ClassIdentity>::NAME,
1632 "GetLabel",
1633 )
1634 });
1635 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EquipMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1636 ::core::mem::transmute(__vi.method_ptr);
1637 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1638 __inner(__receiver, __mi)
1639 }
1640 }
1641 }
1642 #[doc = "`SetFlag(bool)` overload"]
1643 fn set_flag(self, enable: impl ::core::convert::Into<bool>) -> () {
1644 unsafe {
1645 let __receiver = <DebugUnitItemMenu_SubMenu_EquipMenuItem as ::unity::FromIlInstance>::from_il_instance(
1646 <Self as ::unity::SystemObject>::as_instance(self),
1647 );
1648 {
1649 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1650 let __vi = *__vt.get(73usize).unwrap_or_else(|| {
1651 panic!(
1652 "unity: virtual slot {}
1653 out of range (vtable len {}
1654) on the runtime class behind {}
1655 (method `{}
1656`)",
1657 73usize,
1658 __vt.len(),
1659 <DebugUnitItemMenu_SubMenu_EquipMenuItem as ::unity::ClassIdentity>::NAME,
1660 "SetFlag",
1661 )
1662 });
1663 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EquipMenuItem, bool, ::unity::OptionalMethod) -> () =
1664 ::core::mem::transmute(__vi.method_ptr);
1665 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1666 __inner(__receiver, ::core::convert::Into::into(enable), __mi)
1667 }
1668 }
1669 }
1670 #[doc = "`IsFlag()` overload"]
1671 fn is_flag(self) -> bool {
1672 unsafe {
1673 let __receiver = <DebugUnitItemMenu_SubMenu_EquipMenuItem as ::unity::FromIlInstance>::from_il_instance(
1674 <Self as ::unity::SystemObject>::as_instance(self),
1675 );
1676 {
1677 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1678 let __vi = *__vt.get(74usize).unwrap_or_else(|| {
1679 panic!(
1680 "unity: virtual slot {}
1681 out of range (vtable len {}
1682) on the runtime class behind {}
1683 (method `{}
1684`)",
1685 74usize,
1686 __vt.len(),
1687 <DebugUnitItemMenu_SubMenu_EquipMenuItem as ::unity::ClassIdentity>::NAME,
1688 "IsFlag",
1689 )
1690 });
1691 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EquipMenuItem, ::unity::OptionalMethod) -> bool =
1692 ::core::mem::transmute(__vi.method_ptr);
1693 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1694 __inner(__receiver, __mi)
1695 }
1696 }
1697 }
1698 #[doc = "`IsEnable()` overload"]
1699 fn is_enable(self) -> bool {
1700 unsafe {
1701 let __receiver = <DebugUnitItemMenu_SubMenu_EquipMenuItem as ::unity::FromIlInstance>::from_il_instance(
1702 <Self as ::unity::SystemObject>::as_instance(self),
1703 );
1704 {
1705 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1706 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
1707 panic!(
1708 "unity: virtual slot {}
1709 out of range (vtable len {}
1710) on the runtime class behind {}
1711 (method `{}
1712`)",
1713 22usize,
1714 __vt.len(),
1715 <DebugUnitItemMenu_SubMenu_EquipMenuItem as ::unity::ClassIdentity>::NAME,
1716 "IsEnable",
1717 )
1718 });
1719 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EquipMenuItem, ::unity::OptionalMethod) -> bool =
1720 ::core::mem::transmute(__vi.method_ptr);
1721 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1722 __inner(__receiver, __mi)
1723 }
1724 }
1725 }
1726}
1727
1728#[cfg(feature = "app-debugunititemmenu")]
1729impl<__T: IDebugUnitItemMenu_SubMenu_EquipMenuItem> IDebugUnitItemMenu_SubMenu_EquipMenuItemMethods for __T {}
1730
1731#[cfg(feature = "app-debugunititemmenu")]
1732impl DebugUnitItemMenu_SubMenu_EquipMenuItem {
1733 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1734 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1735 }
1736
1737 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1738 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1739 }
1740
1741 pub fn set_flag_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1742 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1743 }
1744
1745 pub fn is_flag_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1746 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1747 }
1748
1749 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1750 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1751 }
1752}
1753
1754#[cfg(feature = "app-debugunititemmenu")]
1755impl DebugUnitItemMenu_SubMenu_EquipMenuItem {
1756 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EquipMenuItem`'s own `GetLabel`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1757 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1758 let __mi = Self::get_label_method_info();
1759 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1760 __inner(this.into(), ::core::option::Option::None)
1761 }
1762
1763 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EquipMenuItem`'s own `SetFlag`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1764 pub unsafe fn set_flag(this: impl ::core::convert::Into<::unity::IlInstance>, enable: bool) -> () {
1765 let __mi = Self::set_flag_method_info();
1766 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1767 __inner(this.into(), enable, ::core::option::Option::None)
1768 }
1769
1770 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EquipMenuItem`'s own `IsFlag`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1771 pub unsafe fn is_flag(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1772 let __mi = Self::is_flag_method_info();
1773 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1774 __inner(this.into(), ::core::option::Option::None)
1775 }
1776
1777 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EquipMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1778 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1779 let __mi = Self::is_enable_method_info();
1780 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1781 __inner(this.into(), ::core::option::Option::None)
1782 }
1783}
1784
1785#[cfg(feature = "app-debugunititemmenu")]
1786impl DebugUnitItemMenu_SubMenu_EquipMenuItem {
1787 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
1788 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
1789 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1790 panic!(
1791 "{}
1792::{}
1793 failed to instantiate",
1794 ::core::stringify!(DebugUnitItemMenu_SubMenu_EquipMenuItem),
1795 ::core::stringify!(new),
1796 )
1797 });
1798 <Self as IDebugUnitItemMenu_SubMenu_EquipMenuItemMethods>::ctor(this, unit, unit_item_index);
1799 this
1800 }
1801}
1802
1803#[cfg(feature = "app-debugunititemmenu")]
1804pub trait IDebugUnitItemMenu_EngraveMenu_BaseMenuItemMethods: IDebugUnitItemMenu_EngraveMenu_BaseMenuItem {
1805 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
1806 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
1807 unsafe {
1808 let __receiver = <DebugUnitItemMenu_EngraveMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
1809 <Self as ::unity::SystemObject>::as_instance(self),
1810 );
1811 ::unity::il2cpp_call!((::unity::module_base()+0x1b33140usize)as*mut u8,();
1812(DebugUnitItemMenu_EngraveMenu_BaseMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
1813 }
1814 }
1815}
1816
1817#[cfg(feature = "app-debugunititemmenu")]
1818impl<__T: IDebugUnitItemMenu_EngraveMenu_BaseMenuItem> IDebugUnitItemMenu_EngraveMenu_BaseMenuItemMethods for __T {}
1819
1820#[cfg(feature = "app-debugunititemmenu")]
1821impl DebugUnitItemMenu_EngraveMenu_BaseMenuItem {
1822 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1823 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1824 }
1825}
1826
1827#[cfg(feature = "app-debugunititemmenu")]
1828impl DebugUnitItemMenu_EngraveMenu_BaseMenuItem {
1829 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
1830 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
1831 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1832 panic!(
1833 "{}
1834::{}
1835 failed to instantiate",
1836 ::core::stringify!(DebugUnitItemMenu_EngraveMenu_BaseMenuItem),
1837 ::core::stringify!(new),
1838 )
1839 });
1840 <Self as IDebugUnitItemMenu_EngraveMenu_BaseMenuItemMethods>::ctor(this, unit, unit_item_index);
1841 this
1842 }
1843}
1844
1845#[cfg(feature = "app-debugunititemmenu")]
1846impl DebugUnitItemMenu {
1847 #[doc = "`UpdateEquip(crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
1848 pub fn update_equip(
1849 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
1850 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
1851 ) -> () {
1852 unsafe {
1853 ::unity::il2cpp_call!((::unity::module_base()+0x2a10f20usize)as*mut u8,();
1854(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1855 }
1856 }
1857
1858 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::unit::Unit)` overload"]
1859 pub fn create_bind(
1860 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
1861 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
1862 ) -> () {
1863 unsafe {
1864 ::unity::il2cpp_call!((::unity::module_base()+0x2a10ff0usize)as*mut u8,();
1865(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::unit::Unit)::core::convert::Into::into(unit))
1866 }
1867 }
1868
1869 #[doc = "`Postprocess(crate::app::unit::Unit)` overload"]
1870 pub fn postprocess(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> () {
1871 unsafe {
1872 ::unity::il2cpp_call!((::unity::module_base()+0x2a113b0usize)as*mut u8,();
1873(crate::app::unit::Unit)::core::convert::Into::into(unit))
1874 }
1875 }
1876
1877 #[doc = "`IsValid(crate::app::itemdata::ItemData)` overload"]
1878 pub fn is_valid(item: impl ::core::convert::Into<crate::app::itemdata::ItemData>) -> bool {
1879 unsafe {
1880 ::unity::il2cpp_call!((::unity::module_base()+0x2a113c0usize)as*mut u8,bool;
1881(crate::app::itemdata::ItemData)::core::convert::Into::into(item))
1882 }
1883 }
1884
1885 #[doc = "`IsValid(crate::app::unititem::UnitItem)` overload"]
1886 pub fn is_valid_2(unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>) -> bool {
1887 unsafe {
1888 ::unity::il2cpp_call!((::unity::module_base()+0x2a11440usize)as*mut u8,bool;
1889(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
1890 }
1891 }
1892}
1893
1894#[cfg(feature = "app-debugunititemmenu")]
1895pub trait IDebugUnitItemMenuMethods: IDebugUnitItemMenu {
1896 #[doc = "`.ctor()` overload"]
1897 fn ctor(self) -> () {
1898 unsafe {
1899 let __receiver = <DebugUnitItemMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1900 ::unity::il2cpp_call!((::unity::module_base()+0x2a114d0usize)as*mut u8,();
1901(DebugUnitItemMenu)__receiver)
1902 }
1903 }
1904}
1905
1906#[cfg(feature = "app-debugunititemmenu")]
1907impl<__T: IDebugUnitItemMenu> IDebugUnitItemMenuMethods for __T {}
1908
1909#[cfg(feature = "app-debugunititemmenu")]
1910impl DebugUnitItemMenu {
1911 pub fn update_equip_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1912 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1913 }
1914
1915 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1916 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1917 }
1918
1919 pub fn postprocess_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1920 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1921 }
1922
1923 pub fn is_valid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1924 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1925 }
1926
1927 pub fn is_valid_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1928 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1929 }
1930
1931 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1932 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1933 }
1934}
1935
1936#[cfg(feature = "app-debugunititemmenu")]
1937impl DebugUnitItemMenu {
1938 #[doc = "`.ctor()` — no args"]
1939 pub fn new() -> Self {
1940 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1941 panic!(
1942 "{}
1943::{}
1944 failed to instantiate",
1945 ::core::stringify!(DebugUnitItemMenu),
1946 ::core::stringify!(new),
1947 )
1948 });
1949 <Self as IDebugUnitItemMenuMethods>::ctor(this);
1950 this
1951 }
1952}
1953
1954#[cfg(feature = "app-debugunititemmenu")]
1955pub trait IDebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItemMethods: IDebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem {
1956 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
1957 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
1958 unsafe {
1959 let __receiver = <DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
1960 <Self as ::unity::SystemObject>::as_instance(self),
1961 );
1962 ::unity::il2cpp_call!((::unity::module_base()+0x1b331b0usize)as*mut u8,();
1963(DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
1964 }
1965 }
1966 #[doc = "`GetName()` overload"]
1967 fn get_name(self) -> ::unity::Il2CppString {
1968 unsafe {
1969 let __receiver = <DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
1970 <Self as ::unity::SystemObject>::as_instance(self),
1971 );
1972 {
1973 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1974 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
1975 panic!(
1976 "unity: virtual slot {}
1977 out of range (vtable len {}
1978) on the runtime class behind {}
1979 (method `{}
1980`)",
1981 5usize,
1982 __vt.len(),
1983 <DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem as ::unity::ClassIdentity>::NAME,
1984 "GetName",
1985 )
1986 });
1987 let __inner: extern "C" fn(DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1988 ::core::mem::transmute(__vi.method_ptr);
1989 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1990 __inner(__receiver, __mi)
1991 }
1992 }
1993 }
1994 #[doc = "`IsEnable()` overload"]
1995 fn is_enable(self) -> bool {
1996 unsafe {
1997 let __receiver = <DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
1998 <Self as ::unity::SystemObject>::as_instance(self),
1999 );
2000 {
2001 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2002 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
2003 panic!(
2004 "unity: virtual slot {}
2005 out of range (vtable len {}
2006) on the runtime class behind {}
2007 (method `{}
2008`)",
2009 22usize,
2010 __vt.len(),
2011 <DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem as ::unity::ClassIdentity>::NAME,
2012 "IsEnable",
2013 )
2014 });
2015 let __inner: extern "C" fn(DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem, ::unity::OptionalMethod) -> bool =
2016 ::core::mem::transmute(__vi.method_ptr);
2017 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2018 __inner(__receiver, __mi)
2019 }
2020 }
2021 }
2022 #[doc = "`ACall()` overload"]
2023 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
2024 unsafe {
2025 let __receiver = <DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
2026 <Self as ::unity::SystemObject>::as_instance(self),
2027 );
2028 {
2029 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2030 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
2031 panic!(
2032 "unity: virtual slot {}
2033 out of range (vtable len {}
2034) on the runtime class behind {}
2035 (method `{}
2036`)",
2037 12usize,
2038 __vt.len(),
2039 <DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem as ::unity::ClassIdentity>::NAME,
2040 "ACall",
2041 )
2042 });
2043 let __inner: extern "C" fn(
2044 DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem,
2045 ::unity::OptionalMethod,
2046 ) -> crate::app::menuitem::MenuItem_Result = ::core::mem::transmute(__vi.method_ptr);
2047 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2048 __inner(__receiver, __mi)
2049 }
2050 }
2051 }
2052}
2053
2054#[cfg(feature = "app-debugunititemmenu")]
2055impl<__T: IDebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem> IDebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItemMethods for __T {}
2056
2057#[cfg(feature = "app-debugunititemmenu")]
2058impl DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem {
2059 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2060 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2061 }
2062
2063 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2064 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2065 }
2066
2067 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2068 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2069 }
2070
2071 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2072 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2073 }
2074}
2075
2076#[cfg(feature = "app-debugunititemmenu")]
2077impl DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem {
2078 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2079 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2080 let __mi = Self::get_name_method_info();
2081 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2082 __inner(this.into(), ::core::option::Option::None)
2083 }
2084
2085 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2086 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2087 let __mi = Self::is_enable_method_info();
2088 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2089 __inner(this.into(), ::core::option::Option::None)
2090 }
2091
2092 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2093 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2094 let __mi = Self::a_call_method_info();
2095 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2096 ::core::mem::transmute(__mi.method_ptr);
2097 __inner(this.into(), ::core::option::Option::None)
2098 }
2099}
2100
2101#[cfg(feature = "app-debugunititemmenu")]
2102impl DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem {
2103 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
2104 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
2105 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2106 panic!(
2107 "{}
2108::{}
2109 failed to instantiate",
2110 ::core::stringify!(DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem),
2111 ::core::stringify!(new),
2112 )
2113 });
2114 <Self as IDebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItemMethods>::ctor(this, unit, unit_item_index);
2115 this
2116 }
2117}
2118
2119#[cfg(feature = "app-debugunititemmenu")]
2120pub trait IDebugUnitItemMenu_SubMenu_FlagMenuItemMethods: IDebugUnitItemMenu_SubMenu_FlagMenuItem {
2121 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
2122 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
2123 unsafe {
2124 let __receiver = <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::FromIlInstance>::from_il_instance(
2125 <Self as ::unity::SystemObject>::as_instance(self),
2126 );
2127 ::unity::il2cpp_call!((::unity::module_base()+0x1b34fd0usize)as*mut u8,();
2128(DebugUnitItemMenu_SubMenu_FlagMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
2129 }
2130 }
2131 #[doc = "`GetName()` overload"]
2132 fn get_name(self) -> ::unity::Il2CppString {
2133 unsafe {
2134 let __receiver = <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::FromIlInstance>::from_il_instance(
2135 <Self as ::unity::SystemObject>::as_instance(self),
2136 );
2137 {
2138 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2139 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
2140 panic!(
2141 "unity: virtual slot {}
2142 out of range (vtable len {}
2143) on the runtime class behind {}
2144 (method `{}
2145`)",
2146 5usize,
2147 __vt.len(),
2148 <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::ClassIdentity>::NAME,
2149 "GetName",
2150 )
2151 });
2152 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_FlagMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2153 ::core::mem::transmute(__vi.method_ptr);
2154 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2155 __inner(__receiver, __mi)
2156 }
2157 }
2158 }
2159 #[doc = "`GetLabel()` overload"]
2160 fn get_label(self) -> ::unity::Il2CppString {
2161 unsafe {
2162 let __receiver = <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::FromIlInstance>::from_il_instance(
2163 <Self as ::unity::SystemObject>::as_instance(self),
2164 );
2165 {
2166 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2167 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
2168 panic!(
2169 "unity: virtual slot {}
2170 out of range (vtable len {}
2171) on the runtime class behind {}
2172 (method `{}
2173`)",
2174 72usize,
2175 __vt.len(),
2176 <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::ClassIdentity>::NAME,
2177 "GetLabel",
2178 )
2179 });
2180 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_FlagMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2181 ::core::mem::transmute(__vi.method_ptr);
2182 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2183 __inner(__receiver, __mi)
2184 }
2185 }
2186 }
2187 #[doc = "`SetFlag(bool)` overload"]
2188 fn set_flag(self, enable: impl ::core::convert::Into<bool>) -> () {
2189 unsafe {
2190 let __receiver = <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::FromIlInstance>::from_il_instance(
2191 <Self as ::unity::SystemObject>::as_instance(self),
2192 );
2193 {
2194 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2195 let __vi = *__vt.get(73usize).unwrap_or_else(|| {
2196 panic!(
2197 "unity: virtual slot {}
2198 out of range (vtable len {}
2199) on the runtime class behind {}
2200 (method `{}
2201`)",
2202 73usize,
2203 __vt.len(),
2204 <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::ClassIdentity>::NAME,
2205 "SetFlag",
2206 )
2207 });
2208 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_FlagMenuItem, bool, ::unity::OptionalMethod) -> () =
2209 ::core::mem::transmute(__vi.method_ptr);
2210 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2211 __inner(__receiver, ::core::convert::Into::into(enable), __mi)
2212 }
2213 }
2214 }
2215 #[doc = "`IsFlag()` overload"]
2216 fn is_flag(self) -> bool {
2217 unsafe {
2218 let __receiver = <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::FromIlInstance>::from_il_instance(
2219 <Self as ::unity::SystemObject>::as_instance(self),
2220 );
2221 {
2222 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2223 let __vi = *__vt.get(74usize).unwrap_or_else(|| {
2224 panic!(
2225 "unity: virtual slot {}
2226 out of range (vtable len {}
2227) on the runtime class behind {}
2228 (method `{}
2229`)",
2230 74usize,
2231 __vt.len(),
2232 <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::ClassIdentity>::NAME,
2233 "IsFlag",
2234 )
2235 });
2236 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_FlagMenuItem, ::unity::OptionalMethod) -> bool =
2237 ::core::mem::transmute(__vi.method_ptr);
2238 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2239 __inner(__receiver, __mi)
2240 }
2241 }
2242 }
2243 #[doc = "`IsEnable()` overload"]
2244 fn is_enable(self) -> bool {
2245 unsafe {
2246 let __receiver = <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::FromIlInstance>::from_il_instance(
2247 <Self as ::unity::SystemObject>::as_instance(self),
2248 );
2249 {
2250 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2251 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
2252 panic!(
2253 "unity: virtual slot {}
2254 out of range (vtable len {}
2255) on the runtime class behind {}
2256 (method `{}
2257`)",
2258 22usize,
2259 __vt.len(),
2260 <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::ClassIdentity>::NAME,
2261 "IsEnable",
2262 )
2263 });
2264 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_FlagMenuItem, ::unity::OptionalMethod) -> bool =
2265 ::core::mem::transmute(__vi.method_ptr);
2266 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2267 __inner(__receiver, __mi)
2268 }
2269 }
2270 }
2271 #[doc = "`ACall()` overload"]
2272 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
2273 unsafe {
2274 let __receiver = <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::FromIlInstance>::from_il_instance(
2275 <Self as ::unity::SystemObject>::as_instance(self),
2276 );
2277 {
2278 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2279 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
2280 panic!(
2281 "unity: virtual slot {}
2282 out of range (vtable len {}
2283) on the runtime class behind {}
2284 (method `{}
2285`)",
2286 12usize,
2287 __vt.len(),
2288 <DebugUnitItemMenu_SubMenu_FlagMenuItem as ::unity::ClassIdentity>::NAME,
2289 "ACall",
2290 )
2291 });
2292 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_FlagMenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2293 ::core::mem::transmute(__vi.method_ptr);
2294 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2295 __inner(__receiver, __mi)
2296 }
2297 }
2298 }
2299}
2300
2301#[cfg(feature = "app-debugunititemmenu")]
2302impl<__T: IDebugUnitItemMenu_SubMenu_FlagMenuItem> IDebugUnitItemMenu_SubMenu_FlagMenuItemMethods for __T {}
2303
2304#[cfg(feature = "app-debugunititemmenu")]
2305impl DebugUnitItemMenu_SubMenu_FlagMenuItem {
2306 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2307 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2308 }
2309
2310 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2311 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2312 }
2313
2314 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2315 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2316 }
2317
2318 pub fn set_flag_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2319 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2320 }
2321
2322 pub fn is_flag_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2323 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2324 }
2325
2326 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2327 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2328 }
2329
2330 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2331 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2332 }
2333}
2334
2335#[cfg(feature = "app-debugunititemmenu")]
2336impl DebugUnitItemMenu_SubMenu_FlagMenuItem {
2337 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_FlagMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2338 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2339 let __mi = Self::get_name_method_info();
2340 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2341 __inner(this.into(), ::core::option::Option::None)
2342 }
2343
2344 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_FlagMenuItem`'s own `GetLabel`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2345 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2346 let __mi = Self::get_label_method_info();
2347 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2348 __inner(this.into(), ::core::option::Option::None)
2349 }
2350
2351 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_FlagMenuItem`'s own `SetFlag`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2352 pub unsafe fn set_flag(this: impl ::core::convert::Into<::unity::IlInstance>, enable: bool) -> () {
2353 let __mi = Self::set_flag_method_info();
2354 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2355 __inner(this.into(), enable, ::core::option::Option::None)
2356 }
2357
2358 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_FlagMenuItem`'s own `IsFlag`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2359 pub unsafe fn is_flag(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2360 let __mi = Self::is_flag_method_info();
2361 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2362 __inner(this.into(), ::core::option::Option::None)
2363 }
2364
2365 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_FlagMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2366 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2367 let __mi = Self::is_enable_method_info();
2368 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2369 __inner(this.into(), ::core::option::Option::None)
2370 }
2371
2372 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_FlagMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2373 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2374 let __mi = Self::a_call_method_info();
2375 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2376 ::core::mem::transmute(__mi.method_ptr);
2377 __inner(this.into(), ::core::option::Option::None)
2378 }
2379}
2380
2381#[cfg(feature = "app-debugunititemmenu")]
2382impl DebugUnitItemMenu_SubMenu_FlagMenuItem {
2383 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
2384 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
2385 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2386 panic!(
2387 "{}
2388::{}
2389 failed to instantiate",
2390 ::core::stringify!(DebugUnitItemMenu_SubMenu_FlagMenuItem),
2391 ::core::stringify!(new),
2392 )
2393 });
2394 <Self as IDebugUnitItemMenu_SubMenu_FlagMenuItemMethods>::ctor(this, unit, unit_item_index);
2395 this
2396 }
2397}
2398
2399#[cfg(feature = "app-debugunititemmenu")]
2400impl DebugUnitItemMenu_EngraveMenu {
2401 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::unit::Unit, i32)` overload"]
2402 pub fn create_bind(
2403 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
2404 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
2405 unit_item_index: impl ::core::convert::Into<i32>,
2406 ) -> () {
2407 unsafe {
2408 ::unity::il2cpp_call!((::unity::module_base()+0x1bbda60usize)as*mut u8,();
2409(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
2410 }
2411 }
2412}
2413
2414#[cfg(feature = "app-debugunititemmenu")]
2415pub trait IDebugUnitItemMenu_EngraveMenuMethods: IDebugUnitItemMenu_EngraveMenu {
2416 #[doc = "`.ctor()` overload"]
2417 fn ctor(self) -> () {
2418 unsafe {
2419 let __receiver =
2420 <DebugUnitItemMenu_EngraveMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2421 ::unity::il2cpp_call!((::unity::module_base()+0x1bbdd20usize)as*mut u8,();
2422(DebugUnitItemMenu_EngraveMenu)__receiver)
2423 }
2424 }
2425}
2426
2427#[cfg(feature = "app-debugunititemmenu")]
2428impl<__T: IDebugUnitItemMenu_EngraveMenu> IDebugUnitItemMenu_EngraveMenuMethods for __T {}
2429
2430#[cfg(feature = "app-debugunititemmenu")]
2431impl DebugUnitItemMenu_EngraveMenu {
2432 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2433 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2434 }
2435
2436 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2437 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2438 }
2439}
2440
2441#[cfg(feature = "app-debugunititemmenu")]
2442impl DebugUnitItemMenu_EngraveMenu {
2443 #[doc = "`.ctor()` — no args"]
2444 pub fn new() -> Self {
2445 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2446 panic!(
2447 "{}
2448::{}
2449 failed to instantiate",
2450 ::core::stringify!(DebugUnitItemMenu_EngraveMenu),
2451 ::core::stringify!(new),
2452 )
2453 });
2454 <Self as IDebugUnitItemMenu_EngraveMenuMethods>::ctor(this);
2455 this
2456 }
2457}
2458
2459#[cfg(feature = "app-debugunititemmenu")]
2460pub trait IDebugUnitItemMenu_SubMenu_RefineMenuItemMethods: IDebugUnitItemMenu_SubMenu_RefineMenuItem {
2461 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
2462 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
2463 unsafe {
2464 let __receiver = <DebugUnitItemMenu_SubMenu_RefineMenuItem as ::unity::FromIlInstance>::from_il_instance(
2465 <Self as ::unity::SystemObject>::as_instance(self),
2466 );
2467 ::unity::il2cpp_call!((::unity::module_base()+0x1b359c0usize)as*mut u8,();
2468(DebugUnitItemMenu_SubMenu_RefineMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
2469 }
2470 }
2471 #[doc = "`GetName()` overload"]
2472 fn get_name(self) -> ::unity::Il2CppString {
2473 unsafe {
2474 let __receiver = <DebugUnitItemMenu_SubMenu_RefineMenuItem as ::unity::FromIlInstance>::from_il_instance(
2475 <Self as ::unity::SystemObject>::as_instance(self),
2476 );
2477 {
2478 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2479 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
2480 panic!(
2481 "unity: virtual slot {}
2482 out of range (vtable len {}
2483) on the runtime class behind {}
2484 (method `{}
2485`)",
2486 5usize,
2487 __vt.len(),
2488 <DebugUnitItemMenu_SubMenu_RefineMenuItem as ::unity::ClassIdentity>::NAME,
2489 "GetName",
2490 )
2491 });
2492 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_RefineMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2493 ::core::mem::transmute(__vi.method_ptr);
2494 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2495 __inner(__receiver, __mi)
2496 }
2497 }
2498 }
2499 #[doc = "`IsEnable()` overload"]
2500 fn is_enable(self) -> bool {
2501 unsafe {
2502 let __receiver = <DebugUnitItemMenu_SubMenu_RefineMenuItem as ::unity::FromIlInstance>::from_il_instance(
2503 <Self as ::unity::SystemObject>::as_instance(self),
2504 );
2505 {
2506 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2507 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
2508 panic!(
2509 "unity: virtual slot {}
2510 out of range (vtable len {}
2511) on the runtime class behind {}
2512 (method `{}
2513`)",
2514 22usize,
2515 __vt.len(),
2516 <DebugUnitItemMenu_SubMenu_RefineMenuItem as ::unity::ClassIdentity>::NAME,
2517 "IsEnable",
2518 )
2519 });
2520 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_RefineMenuItem, ::unity::OptionalMethod) -> bool =
2521 ::core::mem::transmute(__vi.method_ptr);
2522 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2523 __inner(__receiver, __mi)
2524 }
2525 }
2526 }
2527 #[doc = "`ACall()` overload"]
2528 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
2529 unsafe {
2530 let __receiver = <DebugUnitItemMenu_SubMenu_RefineMenuItem as ::unity::FromIlInstance>::from_il_instance(
2531 <Self as ::unity::SystemObject>::as_instance(self),
2532 );
2533 {
2534 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2535 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
2536 panic!(
2537 "unity: virtual slot {}
2538 out of range (vtable len {}
2539) on the runtime class behind {}
2540 (method `{}
2541`)",
2542 12usize,
2543 __vt.len(),
2544 <DebugUnitItemMenu_SubMenu_RefineMenuItem as ::unity::ClassIdentity>::NAME,
2545 "ACall",
2546 )
2547 });
2548 let __inner: extern "C" fn(
2549 DebugUnitItemMenu_SubMenu_RefineMenuItem,
2550 ::unity::OptionalMethod,
2551 ) -> crate::app::menuitem::MenuItem_Result = ::core::mem::transmute(__vi.method_ptr);
2552 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2553 __inner(__receiver, __mi)
2554 }
2555 }
2556 }
2557}
2558
2559#[cfg(feature = "app-debugunititemmenu")]
2560impl<__T: IDebugUnitItemMenu_SubMenu_RefineMenuItem> IDebugUnitItemMenu_SubMenu_RefineMenuItemMethods for __T {}
2561
2562#[cfg(feature = "app-debugunititemmenu")]
2563impl DebugUnitItemMenu_SubMenu_RefineMenuItem {
2564 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2565 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2566 }
2567
2568 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2569 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2570 }
2571
2572 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2573 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2574 }
2575
2576 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2577 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2578 }
2579}
2580
2581#[cfg(feature = "app-debugunititemmenu")]
2582impl DebugUnitItemMenu_SubMenu_RefineMenuItem {
2583 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_RefineMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2584 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2585 let __mi = Self::get_name_method_info();
2586 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2587 __inner(this.into(), ::core::option::Option::None)
2588 }
2589
2590 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_RefineMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2591 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
2592 let __mi = Self::is_enable_method_info();
2593 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
2594 __inner(this.into(), ::core::option::Option::None)
2595 }
2596
2597 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_RefineMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2598 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2599 let __mi = Self::a_call_method_info();
2600 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2601 ::core::mem::transmute(__mi.method_ptr);
2602 __inner(this.into(), ::core::option::Option::None)
2603 }
2604}
2605
2606#[cfg(feature = "app-debugunititemmenu")]
2607impl DebugUnitItemMenu_SubMenu_RefineMenuItem {
2608 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
2609 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
2610 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2611 panic!(
2612 "{}
2613::{}
2614 failed to instantiate",
2615 ::core::stringify!(DebugUnitItemMenu_SubMenu_RefineMenuItem),
2616 ::core::stringify!(new),
2617 )
2618 });
2619 <Self as IDebugUnitItemMenu_SubMenu_RefineMenuItemMethods>::ctor(this, unit, unit_item_index);
2620 this
2621 }
2622}
2623
2624#[cfg(feature = "app-debugunititemmenu")]
2625pub trait IDebugUnitItemMenu_EngraveMenu_EngraveMenuItemMethods: IDebugUnitItemMenu_EngraveMenu_EngraveMenuItem {
2626 #[doc = "`.ctor(crate::app::unit::Unit, i32, crate::app::goddata::GodData)` overload"]
2627 fn ctor(
2628 self,
2629 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
2630 unit_item_index: impl ::core::convert::Into<i32>,
2631 god_data: impl ::core::convert::Into<crate::app::goddata::GodData>,
2632 ) -> () {
2633 unsafe {
2634 let __receiver = <DebugUnitItemMenu_EngraveMenu_EngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
2635 <Self as ::unity::SystemObject>::as_instance(self),
2636 );
2637 ::unity::il2cpp_call!((::unity::module_base()+0x1b332e0usize)as*mut u8,();
2638(DebugUnitItemMenu_EngraveMenu_EngraveMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index),(crate::app::goddata::GodData)::core::convert::Into::into(god_data))
2639 }
2640 }
2641 #[doc = "`GetName()` overload"]
2642 fn get_name(self) -> ::unity::Il2CppString {
2643 unsafe {
2644 let __receiver = <DebugUnitItemMenu_EngraveMenu_EngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
2645 <Self as ::unity::SystemObject>::as_instance(self),
2646 );
2647 {
2648 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2649 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
2650 panic!(
2651 "unity: virtual slot {}
2652 out of range (vtable len {}
2653) on the runtime class behind {}
2654 (method `{}
2655`)",
2656 5usize,
2657 __vt.len(),
2658 <DebugUnitItemMenu_EngraveMenu_EngraveMenuItem as ::unity::ClassIdentity>::NAME,
2659 "GetName",
2660 )
2661 });
2662 let __inner: extern "C" fn(DebugUnitItemMenu_EngraveMenu_EngraveMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2663 ::core::mem::transmute(__vi.method_ptr);
2664 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2665 __inner(__receiver, __mi)
2666 }
2667 }
2668 }
2669 #[doc = "`ACall()` overload"]
2670 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
2671 unsafe {
2672 let __receiver = <DebugUnitItemMenu_EngraveMenu_EngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
2673 <Self as ::unity::SystemObject>::as_instance(self),
2674 );
2675 {
2676 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2677 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
2678 panic!(
2679 "unity: virtual slot {}
2680 out of range (vtable len {}
2681) on the runtime class behind {}
2682 (method `{}
2683`)",
2684 12usize,
2685 __vt.len(),
2686 <DebugUnitItemMenu_EngraveMenu_EngraveMenuItem as ::unity::ClassIdentity>::NAME,
2687 "ACall",
2688 )
2689 });
2690 let __inner: extern "C" fn(
2691 DebugUnitItemMenu_EngraveMenu_EngraveMenuItem,
2692 ::unity::OptionalMethod,
2693 ) -> crate::app::menuitem::MenuItem_Result = ::core::mem::transmute(__vi.method_ptr);
2694 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2695 __inner(__receiver, __mi)
2696 }
2697 }
2698 }
2699}
2700
2701#[cfg(feature = "app-debugunititemmenu")]
2702impl<__T: IDebugUnitItemMenu_EngraveMenu_EngraveMenuItem> IDebugUnitItemMenu_EngraveMenu_EngraveMenuItemMethods for __T {}
2703
2704#[cfg(feature = "app-debugunititemmenu")]
2705impl DebugUnitItemMenu_EngraveMenu_EngraveMenuItem {
2706 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2707 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2708 }
2709
2710 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2711 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2712 }
2713
2714 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2715 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2716 }
2717}
2718
2719#[cfg(feature = "app-debugunititemmenu")]
2720impl DebugUnitItemMenu_EngraveMenu_EngraveMenuItem {
2721 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EngraveMenu_EngraveMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2722 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2723 let __mi = Self::get_name_method_info();
2724 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2725 __inner(this.into(), ::core::option::Option::None)
2726 }
2727
2728 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EngraveMenu_EngraveMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2729 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
2730 let __mi = Self::a_call_method_info();
2731 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2732 ::core::mem::transmute(__mi.method_ptr);
2733 __inner(this.into(), ::core::option::Option::None)
2734 }
2735}
2736
2737#[cfg(feature = "app-debugunititemmenu")]
2738impl DebugUnitItemMenu_EngraveMenu_EngraveMenuItem {
2739 #[doc = "`.ctor(crate::app::unit::Unit, i32, crate::app::goddata::GodData)` — overload selector"]
2740 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32, god_data: crate::app::goddata::GodData) -> Self {
2741 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2742 panic!(
2743 "{}
2744::{}
2745 failed to instantiate",
2746 ::core::stringify!(DebugUnitItemMenu_EngraveMenu_EngraveMenuItem),
2747 ::core::stringify!(new),
2748 )
2749 });
2750 <Self as IDebugUnitItemMenu_EngraveMenu_EngraveMenuItemMethods>::ctor(this, unit, unit_item_index, god_data);
2751 this
2752 }
2753}
2754
2755#[cfg(feature = "app-debugunititemmenu")]
2756pub trait IDebugUnitItemMenu_EditItemMenuItemMethods: IDebugUnitItemMenu_EditItemMenuItem {
2757 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
2758 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
2759 unsafe {
2760 let __receiver =
2761 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2762 ::unity::il2cpp_call!((::unity::module_base()+0x1bbbbd0usize)as*mut u8,();
2763(DebugUnitItemMenu_EditItemMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
2764 }
2765 }
2766 #[doc = "`GetColumnCount()` overload"]
2767 fn get_column_count(self) -> i32 {
2768 unsafe {
2769 let __receiver =
2770 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2771 {
2772 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2773 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
2774 panic!(
2775 "unity: virtual slot {}
2776 out of range (vtable len {}
2777) on the runtime class behind {}
2778 (method `{}
2779`)",
2780 29usize,
2781 __vt.len(),
2782 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
2783 "GetColumnCount",
2784 )
2785 });
2786 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> i32 =
2787 ::core::mem::transmute(__vi.method_ptr);
2788 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2789 __inner(__receiver, __mi)
2790 }
2791 }
2792 }
2793 #[doc = "`GetColumnWidth0()` overload"]
2794 fn get_column_width0(self) -> f32 {
2795 unsafe {
2796 let __receiver =
2797 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2798 {
2799 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2800 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
2801 panic!(
2802 "unity: virtual slot {}
2803 out of range (vtable len {}
2804) on the runtime class behind {}
2805 (method `{}
2806`)",
2807 31usize,
2808 __vt.len(),
2809 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
2810 "GetColumnWidth0",
2811 )
2812 });
2813 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> f32 =
2814 ::core::mem::transmute(__vi.method_ptr);
2815 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2816 __inner(__receiver, __mi)
2817 }
2818 }
2819 }
2820 #[doc = "`GetColumnWidth1()` overload"]
2821 fn get_column_width1(self) -> f32 {
2822 unsafe {
2823 let __receiver =
2824 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2825 {
2826 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2827 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
2828 panic!(
2829 "unity: virtual slot {}
2830 out of range (vtable len {}
2831) on the runtime class behind {}
2832 (method `{}
2833`)",
2834 32usize,
2835 __vt.len(),
2836 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
2837 "GetColumnWidth1",
2838 )
2839 });
2840 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> f32 =
2841 ::core::mem::transmute(__vi.method_ptr);
2842 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2843 __inner(__receiver, __mi)
2844 }
2845 }
2846 }
2847 #[doc = "`GetFontColor()` overload"]
2848 fn get_font_color(self) -> crate::unity_engine::color::Color {
2849 unsafe {
2850 let __receiver =
2851 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2852 {
2853 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2854 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
2855 panic!(
2856 "unity: virtual slot {}
2857 out of range (vtable len {}
2858) on the runtime class behind {}
2859 (method `{}
2860`)",
2861 27usize,
2862 __vt.len(),
2863 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
2864 "GetFontColor",
2865 )
2866 });
2867 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
2868 ::core::mem::transmute(__vi.method_ptr);
2869 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2870 __inner(__receiver, __mi)
2871 }
2872 }
2873 }
2874 #[doc = "`GetColumnName0()` overload"]
2875 fn get_column_name0(self) -> ::unity::Il2CppString {
2876 unsafe {
2877 let __receiver =
2878 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2879 {
2880 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2881 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
2882 panic!(
2883 "unity: virtual slot {}
2884 out of range (vtable len {}
2885) on the runtime class behind {}
2886 (method `{}
2887`)",
2888 42usize,
2889 __vt.len(),
2890 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
2891 "GetColumnName0",
2892 )
2893 });
2894 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2895 ::core::mem::transmute(__vi.method_ptr);
2896 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2897 __inner(__receiver, __mi)
2898 }
2899 }
2900 }
2901 #[doc = "`GetColumnName1()` overload"]
2902 fn get_column_name1(self) -> ::unity::Il2CppString {
2903 unsafe {
2904 let __receiver =
2905 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2906 {
2907 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2908 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
2909 panic!(
2910 "unity: virtual slot {}
2911 out of range (vtable len {}
2912) on the runtime class behind {}
2913 (method `{}
2914`)",
2915 43usize,
2916 __vt.len(),
2917 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
2918 "GetColumnName1",
2919 )
2920 });
2921 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2922 ::core::mem::transmute(__vi.method_ptr);
2923 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2924 __inner(__receiver, __mi)
2925 }
2926 }
2927 }
2928 #[doc = "`IsEnable()` overload"]
2929 fn is_enable(self) -> bool {
2930 unsafe {
2931 let __receiver =
2932 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2933 {
2934 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2935 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
2936 panic!(
2937 "unity: virtual slot {}
2938 out of range (vtable len {}
2939) on the runtime class behind {}
2940 (method `{}
2941`)",
2942 22usize,
2943 __vt.len(),
2944 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
2945 "IsEnable",
2946 )
2947 });
2948 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> bool =
2949 ::core::mem::transmute(__vi.method_ptr);
2950 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2951 __inner(__receiver, __mi)
2952 }
2953 }
2954 }
2955 #[doc = "`ACall()` overload"]
2956 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
2957 unsafe {
2958 let __receiver =
2959 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2960 {
2961 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2962 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
2963 panic!(
2964 "unity: virtual slot {}
2965 out of range (vtable len {}
2966) on the runtime class behind {}
2967 (method `{}
2968`)",
2969 12usize,
2970 __vt.len(),
2971 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
2972 "ACall",
2973 )
2974 });
2975 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
2976 ::core::mem::transmute(__vi.method_ptr);
2977 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2978 __inner(__receiver, __mi)
2979 }
2980 }
2981 }
2982 #[doc = "`XCall()` overload"]
2983 fn x_call(self) -> crate::app::menuitem::MenuItem_Result {
2984 unsafe {
2985 let __receiver =
2986 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2987 {
2988 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2989 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
2990 panic!(
2991 "unity: virtual slot {}
2992 out of range (vtable len {}
2993) on the runtime class behind {}
2994 (method `{}
2995`)",
2996 14usize,
2997 __vt.len(),
2998 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
2999 "XCall",
3000 )
3001 });
3002 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
3003 ::core::mem::transmute(__vi.method_ptr);
3004 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3005 __inner(__receiver, __mi)
3006 }
3007 }
3008 }
3009 #[doc = "`OnTick()` overload"]
3010 fn on_tick(self) -> () {
3011 unsafe {
3012 let __receiver =
3013 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3014 {
3015 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3016 let __vi = *__vt.get(68usize).unwrap_or_else(|| {
3017 panic!(
3018 "unity: virtual slot {}
3019 out of range (vtable len {}
3020) on the runtime class behind {}
3021 (method `{}
3022`)",
3023 68usize,
3024 __vt.len(),
3025 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
3026 "OnTick",
3027 )
3028 });
3029 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> () =
3030 ::core::mem::transmute(__vi.method_ptr);
3031 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3032 __inner(__receiver, __mi)
3033 }
3034 }
3035 }
3036 #[doc = "`GetHelp()` overload"]
3037 fn get_help(self) -> ::unity::Il2CppString {
3038 unsafe {
3039 let __receiver =
3040 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3041 {
3042 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3043 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
3044 panic!(
3045 "unity: virtual slot {}
3046 out of range (vtable len {}
3047) on the runtime class behind {}
3048 (method `{}
3049`)",
3050 7usize,
3051 __vt.len(),
3052 <DebugUnitItemMenu_EditItemMenuItem as ::unity::ClassIdentity>::NAME,
3053 "GetHelp",
3054 )
3055 });
3056 let __inner: extern "C" fn(DebugUnitItemMenu_EditItemMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3057 ::core::mem::transmute(__vi.method_ptr);
3058 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3059 __inner(__receiver, __mi)
3060 }
3061 }
3062 }
3063 #[doc = "`GetPrevIndex(i32, bool)` overload"]
3064 fn get_prev_index(self, index: impl ::core::convert::Into<i32>, is_trigger: impl ::core::convert::Into<bool>) -> i32 {
3065 unsafe {
3066 let __receiver =
3067 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3068 ::unity::il2cpp_call!((::unity::module_base()+0x1bbd7d0usize)as*mut u8,i32;
3069(DebugUnitItemMenu_EditItemMenuItem)__receiver,(i32)::core::convert::Into::into(index),(bool)::core::convert::Into::into(is_trigger))
3070 }
3071 }
3072 #[doc = "`GetNextIndex(i32, bool)` overload"]
3073 fn get_next_index(self, index: impl ::core::convert::Into<i32>, is_trigger: impl ::core::convert::Into<bool>) -> i32 {
3074 unsafe {
3075 let __receiver =
3076 <DebugUnitItemMenu_EditItemMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3077 ::unity::il2cpp_call!((::unity::module_base()+0x1bbd8e0usize)as*mut u8,i32;
3078(DebugUnitItemMenu_EditItemMenuItem)__receiver,(i32)::core::convert::Into::into(index),(bool)::core::convert::Into::into(is_trigger))
3079 }
3080 }
3081}
3082
3083#[cfg(feature = "app-debugunititemmenu")]
3084impl<__T: IDebugUnitItemMenu_EditItemMenuItem> IDebugUnitItemMenu_EditItemMenuItemMethods for __T {}
3085
3086#[cfg(feature = "app-debugunititemmenu")]
3087impl DebugUnitItemMenu_EditItemMenuItem {
3088 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3089 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3090 }
3091
3092 pub fn get_column_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3093 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3094 }
3095
3096 pub fn get_column_width0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3097 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3098 }
3099
3100 pub fn get_column_width1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3101 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3102 }
3103
3104 pub fn get_font_color_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3105 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3106 }
3107
3108 pub fn get_column_name0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3109 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3110 }
3111
3112 pub fn get_column_name1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3113 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
3114 }
3115
3116 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3117 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
3118 }
3119
3120 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3121 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
3122 }
3123
3124 pub fn x_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3125 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
3126 }
3127
3128 pub fn on_tick_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3129 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
3130 }
3131
3132 pub fn get_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3133 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
3134 }
3135
3136 pub fn get_prev_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3137 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
3138 }
3139
3140 pub fn get_next_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3141 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
3142 }
3143}
3144
3145#[cfg(feature = "app-debugunititemmenu")]
3146impl DebugUnitItemMenu_EditItemMenuItem {
3147 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `GetColumnCount`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3148 pub unsafe fn get_column_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
3149 let __mi = Self::get_column_count_method_info();
3150 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3151 __inner(this.into(), ::core::option::Option::None)
3152 }
3153
3154 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `GetColumnWidth0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3155 pub unsafe fn get_column_width0(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3156 let __mi = Self::get_column_width0_method_info();
3157 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3158 __inner(this.into(), ::core::option::Option::None)
3159 }
3160
3161 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `GetColumnWidth1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3162 pub unsafe fn get_column_width1(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3163 let __mi = Self::get_column_width1_method_info();
3164 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3165 __inner(this.into(), ::core::option::Option::None)
3166 }
3167
3168 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `GetFontColor`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3169 pub unsafe fn get_font_color(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::unity_engine::color::Color {
3170 let __mi = Self::get_font_color_method_info();
3171 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::unity_engine::color::Color =
3172 ::core::mem::transmute(__mi.method_ptr);
3173 __inner(this.into(), ::core::option::Option::None)
3174 }
3175
3176 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `GetColumnName0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3177 pub unsafe fn get_column_name0(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3178 let __mi = Self::get_column_name0_method_info();
3179 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3180 __inner(this.into(), ::core::option::Option::None)
3181 }
3182
3183 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `GetColumnName1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3184 pub unsafe fn get_column_name1(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3185 let __mi = Self::get_column_name1_method_info();
3186 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3187 __inner(this.into(), ::core::option::Option::None)
3188 }
3189
3190 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3191 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3192 let __mi = Self::is_enable_method_info();
3193 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3194 __inner(this.into(), ::core::option::Option::None)
3195 }
3196
3197 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3198 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
3199 let __mi = Self::a_call_method_info();
3200 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
3201 ::core::mem::transmute(__mi.method_ptr);
3202 __inner(this.into(), ::core::option::Option::None)
3203 }
3204
3205 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `XCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3206 pub unsafe fn x_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
3207 let __mi = Self::x_call_method_info();
3208 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
3209 ::core::mem::transmute(__mi.method_ptr);
3210 __inner(this.into(), ::core::option::Option::None)
3211 }
3212
3213 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `OnTick`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3214 pub unsafe fn on_tick(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3215 let __mi = Self::on_tick_method_info();
3216 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3217 __inner(this.into(), ::core::option::Option::None)
3218 }
3219
3220 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_EditItemMenuItem`'s own `GetHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3221 pub unsafe fn get_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3222 let __mi = Self::get_help_method_info();
3223 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3224 __inner(this.into(), ::core::option::Option::None)
3225 }
3226}
3227
3228#[cfg(feature = "app-debugunititemmenu")]
3229impl DebugUnitItemMenu_EditItemMenuItem {
3230 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
3231 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
3232 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3233 panic!(
3234 "{}
3235::{}
3236 failed to instantiate",
3237 ::core::stringify!(DebugUnitItemMenu_EditItemMenuItem),
3238 ::core::stringify!(new),
3239 )
3240 });
3241 <Self as IDebugUnitItemMenu_EditItemMenuItemMethods>::ctor(this, unit, unit_item_index);
3242 this
3243 }
3244}
3245
3246#[cfg(feature = "app-debugunititemmenu")]
3247pub trait IDebugUnitItemMenu_SubMenu_EngraveMenuItemMethods: IDebugUnitItemMenu_SubMenu_EngraveMenuItem {
3248 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
3249 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
3250 unsafe {
3251 let __receiver = <DebugUnitItemMenu_SubMenu_EngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
3252 <Self as ::unity::SystemObject>::as_instance(self),
3253 );
3254 ::unity::il2cpp_call!((::unity::module_base()+0x1b35490usize)as*mut u8,();
3255(DebugUnitItemMenu_SubMenu_EngraveMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
3256 }
3257 }
3258 #[doc = "`GetName()` overload"]
3259 fn get_name(self) -> ::unity::Il2CppString {
3260 unsafe {
3261 let __receiver = <DebugUnitItemMenu_SubMenu_EngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
3262 <Self as ::unity::SystemObject>::as_instance(self),
3263 );
3264 {
3265 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3266 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
3267 panic!(
3268 "unity: virtual slot {}
3269 out of range (vtable len {}
3270) on the runtime class behind {}
3271 (method `{}
3272`)",
3273 5usize,
3274 __vt.len(),
3275 <DebugUnitItemMenu_SubMenu_EngraveMenuItem as ::unity::ClassIdentity>::NAME,
3276 "GetName",
3277 )
3278 });
3279 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EngraveMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3280 ::core::mem::transmute(__vi.method_ptr);
3281 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3282 __inner(__receiver, __mi)
3283 }
3284 }
3285 }
3286 #[doc = "`IsEnable()` overload"]
3287 fn is_enable(self) -> bool {
3288 unsafe {
3289 let __receiver = <DebugUnitItemMenu_SubMenu_EngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
3290 <Self as ::unity::SystemObject>::as_instance(self),
3291 );
3292 {
3293 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3294 let __vi = *__vt.get(22usize).unwrap_or_else(|| {
3295 panic!(
3296 "unity: virtual slot {}
3297 out of range (vtable len {}
3298) on the runtime class behind {}
3299 (method `{}
3300`)",
3301 22usize,
3302 __vt.len(),
3303 <DebugUnitItemMenu_SubMenu_EngraveMenuItem as ::unity::ClassIdentity>::NAME,
3304 "IsEnable",
3305 )
3306 });
3307 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_EngraveMenuItem, ::unity::OptionalMethod) -> bool =
3308 ::core::mem::transmute(__vi.method_ptr);
3309 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3310 __inner(__receiver, __mi)
3311 }
3312 }
3313 }
3314 #[doc = "`ACall()` overload"]
3315 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
3316 unsafe {
3317 let __receiver = <DebugUnitItemMenu_SubMenu_EngraveMenuItem as ::unity::FromIlInstance>::from_il_instance(
3318 <Self as ::unity::SystemObject>::as_instance(self),
3319 );
3320 {
3321 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3322 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
3323 panic!(
3324 "unity: virtual slot {}
3325 out of range (vtable len {}
3326) on the runtime class behind {}
3327 (method `{}
3328`)",
3329 12usize,
3330 __vt.len(),
3331 <DebugUnitItemMenu_SubMenu_EngraveMenuItem as ::unity::ClassIdentity>::NAME,
3332 "ACall",
3333 )
3334 });
3335 let __inner: extern "C" fn(
3336 DebugUnitItemMenu_SubMenu_EngraveMenuItem,
3337 ::unity::OptionalMethod,
3338 ) -> crate::app::menuitem::MenuItem_Result = ::core::mem::transmute(__vi.method_ptr);
3339 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3340 __inner(__receiver, __mi)
3341 }
3342 }
3343 }
3344}
3345
3346#[cfg(feature = "app-debugunititemmenu")]
3347impl<__T: IDebugUnitItemMenu_SubMenu_EngraveMenuItem> IDebugUnitItemMenu_SubMenu_EngraveMenuItemMethods for __T {}
3348
3349#[cfg(feature = "app-debugunititemmenu")]
3350impl DebugUnitItemMenu_SubMenu_EngraveMenuItem {
3351 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3352 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3353 }
3354
3355 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3356 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3357 }
3358
3359 pub fn is_enable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3360 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3361 }
3362
3363 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3364 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3365 }
3366}
3367
3368#[cfg(feature = "app-debugunititemmenu")]
3369impl DebugUnitItemMenu_SubMenu_EngraveMenuItem {
3370 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EngraveMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3371 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3372 let __mi = Self::get_name_method_info();
3373 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3374 __inner(this.into(), ::core::option::Option::None)
3375 }
3376
3377 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EngraveMenuItem`'s own `IsEnable`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3378 pub unsafe fn is_enable(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
3379 let __mi = Self::is_enable_method_info();
3380 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
3381 __inner(this.into(), ::core::option::Option::None)
3382 }
3383
3384 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_EngraveMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3385 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
3386 let __mi = Self::a_call_method_info();
3387 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
3388 ::core::mem::transmute(__mi.method_ptr);
3389 __inner(this.into(), ::core::option::Option::None)
3390 }
3391}
3392
3393#[cfg(feature = "app-debugunititemmenu")]
3394impl DebugUnitItemMenu_SubMenu_EngraveMenuItem {
3395 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
3396 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
3397 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3398 panic!(
3399 "{}
3400::{}
3401 failed to instantiate",
3402 ::core::stringify!(DebugUnitItemMenu_SubMenu_EngraveMenuItem),
3403 ::core::stringify!(new),
3404 )
3405 });
3406 <Self as IDebugUnitItemMenu_SubMenu_EngraveMenuItemMethods>::ctor(this, unit, unit_item_index);
3407 this
3408 }
3409}
3410
3411#[cfg(feature = "app-debugunititemmenu")]
3412pub trait IDebugUnitItemMenu_UnitDebugMenuMethods: IDebugUnitItemMenu_UnitDebugMenu {
3413 #[doc = "`SetUnit(crate::app::unit::Unit)` overload"]
3414 fn set_unit(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> crate::app::debugunititemmenu::DebugUnitItemMenu_UnitDebugMenu {
3415 unsafe {
3416 let __receiver =
3417 <DebugUnitItemMenu_UnitDebugMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3418 ::unity::il2cpp_call!((::unity::module_base()+0x1bbdff0usize)as*mut u8,crate::app::debugunititemmenu::DebugUnitItemMenu_UnitDebugMenu;
3419(DebugUnitItemMenu_UnitDebugMenu)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit))
3420 }
3421 }
3422 #[doc = "`OnClose()` overload"]
3423 fn on_close(self) -> () {
3424 unsafe {
3425 let __receiver =
3426 <DebugUnitItemMenu_UnitDebugMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3427 {
3428 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3429 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
3430 panic!(
3431 "unity: virtual slot {}
3432 out of range (vtable len {}
3433) on the runtime class behind {}
3434 (method `{}
3435`)",
3436 19usize,
3437 __vt.len(),
3438 <DebugUnitItemMenu_UnitDebugMenu as ::unity::ClassIdentity>::NAME,
3439 "OnClose",
3440 )
3441 });
3442 let __inner: extern "C" fn(DebugUnitItemMenu_UnitDebugMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
3443 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3444 __inner(__receiver, __mi)
3445 }
3446 }
3447 }
3448 #[doc = "`.ctor()` overload"]
3449 fn ctor(self) -> () {
3450 unsafe {
3451 let __receiver =
3452 <DebugUnitItemMenu_UnitDebugMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3453 ::unity::il2cpp_call!((::unity::module_base()+0x1bbe030usize)as*mut u8,();
3454(DebugUnitItemMenu_UnitDebugMenu)__receiver)
3455 }
3456 }
3457}
3458
3459#[cfg(feature = "app-debugunititemmenu")]
3460impl<__T: IDebugUnitItemMenu_UnitDebugMenu> IDebugUnitItemMenu_UnitDebugMenuMethods for __T {}
3461
3462#[cfg(feature = "app-debugunititemmenu")]
3463impl DebugUnitItemMenu_UnitDebugMenu {
3464 pub fn set_unit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3465 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3466 }
3467
3468 pub fn on_close_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3469 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3470 }
3471
3472 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3473 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3474 }
3475}
3476
3477#[cfg(feature = "app-debugunititemmenu")]
3478impl DebugUnitItemMenu_UnitDebugMenu {
3479 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_UnitDebugMenu`'s own `OnClose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3480 pub unsafe fn on_close(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
3481 let __mi = Self::on_close_method_info();
3482 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
3483 __inner(this.into(), ::core::option::Option::None)
3484 }
3485}
3486
3487#[cfg(feature = "app-debugunititemmenu")]
3488impl DebugUnitItemMenu_UnitDebugMenu {
3489 #[doc = "`.ctor()` — no args"]
3490 pub fn new() -> Self {
3491 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3492 panic!(
3493 "{}
3494::{}
3495 failed to instantiate",
3496 ::core::stringify!(DebugUnitItemMenu_UnitDebugMenu),
3497 ::core::stringify!(new),
3498 )
3499 });
3500 <Self as IDebugUnitItemMenu_UnitDebugMenuMethods>::ctor(this);
3501 this
3502 }
3503}
3504
3505#[cfg(feature = "app-debugunititemmenu")]
3506impl DebugUnitItemMenu_ItemListMenu {
3507 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::unit::Unit, crate::app::unititem::UnitItem)` overload"]
3508 pub fn create_bind(
3509 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
3510 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
3511 unit_item: impl ::core::convert::Into<crate::app::unititem::UnitItem>,
3512 ) -> () {
3513 unsafe {
3514 ::unity::il2cpp_call!((::unity::module_base()+0x1bbbf10usize)as*mut u8,();
3515(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::unit::Unit)::core::convert::Into::into(unit),(crate::app::unititem::UnitItem)::core::convert::Into::into(unit_item))
3516 }
3517 }
3518}
3519
3520#[cfg(feature = "app-debugunititemmenu")]
3521pub trait IDebugUnitItemMenu_ItemListMenuMethods: IDebugUnitItemMenu_ItemListMenu {
3522 #[doc = "`.ctor()` overload"]
3523 fn ctor(self) -> () {
3524 unsafe {
3525 let __receiver =
3526 <DebugUnitItemMenu_ItemListMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3527 ::unity::il2cpp_call!((::unity::module_base()+0x1bbdd30usize)as*mut u8,();
3528(DebugUnitItemMenu_ItemListMenu)__receiver)
3529 }
3530 }
3531}
3532
3533#[cfg(feature = "app-debugunititemmenu")]
3534impl<__T: IDebugUnitItemMenu_ItemListMenu> IDebugUnitItemMenu_ItemListMenuMethods for __T {}
3535
3536#[cfg(feature = "app-debugunititemmenu")]
3537impl DebugUnitItemMenu_ItemListMenu {
3538 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3539 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3540 }
3541
3542 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3543 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3544 }
3545}
3546
3547#[cfg(feature = "app-debugunititemmenu")]
3548impl DebugUnitItemMenu_ItemListMenu {
3549 #[doc = "`.ctor()` — no args"]
3550 pub fn new() -> Self {
3551 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3552 panic!(
3553 "{}
3554::{}
3555 failed to instantiate",
3556 ::core::stringify!(DebugUnitItemMenu_ItemListMenu),
3557 ::core::stringify!(new),
3558 )
3559 });
3560 <Self as IDebugUnitItemMenu_ItemListMenuMethods>::ctor(this);
3561 this
3562 }
3563}
3564
3565#[cfg(feature = "app-debugunititemmenu")]
3566pub trait IDebugUnitItemMenu_RefineMenu_RefineMenuItemMethods: IDebugUnitItemMenu_RefineMenu_RefineMenuItem {
3567 #[doc = "`.ctor(crate::app::unit::Unit, i32, i32, crate::app::itemrefinedata::ItemRefineData)` overload"]
3568 fn ctor(
3569 self,
3570 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
3571 unit_item_index: impl ::core::convert::Into<i32>,
3572 refine_level: impl ::core::convert::Into<i32>,
3573 refine_data: impl ::core::convert::Into<crate::app::itemrefinedata::ItemRefineData>,
3574 ) -> () {
3575 unsafe {
3576 let __receiver = <DebugUnitItemMenu_RefineMenu_RefineMenuItem as ::unity::FromIlInstance>::from_il_instance(
3577 <Self as ::unity::SystemObject>::as_instance(self),
3578 );
3579 ::unity::il2cpp_call!((::unity::module_base()+0x1b34830usize)as*mut u8,();
3580(DebugUnitItemMenu_RefineMenu_RefineMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index),(i32)::core::convert::Into::into(refine_level),(crate::app::itemrefinedata::ItemRefineData)::core::convert::Into::into(refine_data))
3581 }
3582 }
3583 #[doc = "`GetColumnName0()` overload"]
3584 fn get_column_name0(self) -> ::unity::Il2CppString {
3585 unsafe {
3586 let __receiver = <DebugUnitItemMenu_RefineMenu_RefineMenuItem as ::unity::FromIlInstance>::from_il_instance(
3587 <Self as ::unity::SystemObject>::as_instance(self),
3588 );
3589 {
3590 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3591 let __vi = *__vt.get(42usize).unwrap_or_else(|| {
3592 panic!(
3593 "unity: virtual slot {}
3594 out of range (vtable len {}
3595) on the runtime class behind {}
3596 (method `{}
3597`)",
3598 42usize,
3599 __vt.len(),
3600 <DebugUnitItemMenu_RefineMenu_RefineMenuItem as ::unity::ClassIdentity>::NAME,
3601 "GetColumnName0",
3602 )
3603 });
3604 let __inner: extern "C" fn(DebugUnitItemMenu_RefineMenu_RefineMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3605 ::core::mem::transmute(__vi.method_ptr);
3606 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3607 __inner(__receiver, __mi)
3608 }
3609 }
3610 }
3611 #[doc = "`GetColumnName1()` overload"]
3612 fn get_column_name1(self) -> ::unity::Il2CppString {
3613 unsafe {
3614 let __receiver = <DebugUnitItemMenu_RefineMenu_RefineMenuItem as ::unity::FromIlInstance>::from_il_instance(
3615 <Self as ::unity::SystemObject>::as_instance(self),
3616 );
3617 {
3618 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3619 let __vi = *__vt.get(43usize).unwrap_or_else(|| {
3620 panic!(
3621 "unity: virtual slot {}
3622 out of range (vtable len {}
3623) on the runtime class behind {}
3624 (method `{}
3625`)",
3626 43usize,
3627 __vt.len(),
3628 <DebugUnitItemMenu_RefineMenu_RefineMenuItem as ::unity::ClassIdentity>::NAME,
3629 "GetColumnName1",
3630 )
3631 });
3632 let __inner: extern "C" fn(DebugUnitItemMenu_RefineMenu_RefineMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3633 ::core::mem::transmute(__vi.method_ptr);
3634 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3635 __inner(__receiver, __mi)
3636 }
3637 }
3638 }
3639 #[doc = "`GetColumnName2()` overload"]
3640 fn get_column_name2(self) -> ::unity::Il2CppString {
3641 unsafe {
3642 let __receiver = <DebugUnitItemMenu_RefineMenu_RefineMenuItem as ::unity::FromIlInstance>::from_il_instance(
3643 <Self as ::unity::SystemObject>::as_instance(self),
3644 );
3645 {
3646 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3647 let __vi = *__vt.get(44usize).unwrap_or_else(|| {
3648 panic!(
3649 "unity: virtual slot {}
3650 out of range (vtable len {}
3651) on the runtime class behind {}
3652 (method `{}
3653`)",
3654 44usize,
3655 __vt.len(),
3656 <DebugUnitItemMenu_RefineMenu_RefineMenuItem as ::unity::ClassIdentity>::NAME,
3657 "GetColumnName2",
3658 )
3659 });
3660 let __inner: extern "C" fn(DebugUnitItemMenu_RefineMenu_RefineMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3661 ::core::mem::transmute(__vi.method_ptr);
3662 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3663 __inner(__receiver, __mi)
3664 }
3665 }
3666 }
3667 #[doc = "`ACall()` overload"]
3668 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
3669 unsafe {
3670 let __receiver = <DebugUnitItemMenu_RefineMenu_RefineMenuItem as ::unity::FromIlInstance>::from_il_instance(
3671 <Self as ::unity::SystemObject>::as_instance(self),
3672 );
3673 {
3674 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3675 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
3676 panic!(
3677 "unity: virtual slot {}
3678 out of range (vtable len {}
3679) on the runtime class behind {}
3680 (method `{}
3681`)",
3682 12usize,
3683 __vt.len(),
3684 <DebugUnitItemMenu_RefineMenu_RefineMenuItem as ::unity::ClassIdentity>::NAME,
3685 "ACall",
3686 )
3687 });
3688 let __inner: extern "C" fn(
3689 DebugUnitItemMenu_RefineMenu_RefineMenuItem,
3690 ::unity::OptionalMethod,
3691 ) -> crate::app::menuitem::MenuItem_Result = ::core::mem::transmute(__vi.method_ptr);
3692 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3693 __inner(__receiver, __mi)
3694 }
3695 }
3696 }
3697 #[doc = "`GetParameterText(i32)` overload"]
3698 fn get_parameter_text(self, value: impl ::core::convert::Into<i32>) -> ::unity::Il2CppString {
3699 unsafe {
3700 let __receiver = <DebugUnitItemMenu_RefineMenu_RefineMenuItem as ::unity::FromIlInstance>::from_il_instance(
3701 <Self as ::unity::SystemObject>::as_instance(self),
3702 );
3703 ::unity::il2cpp_call!((::unity::module_base()+0x1b34bd0usize)as*mut u8, ::unity::Il2CppString;
3704(DebugUnitItemMenu_RefineMenu_RefineMenuItem)__receiver,(i32)::core::convert::Into::into(value))
3705 }
3706 }
3707}
3708
3709#[cfg(feature = "app-debugunititemmenu")]
3710impl<__T: IDebugUnitItemMenu_RefineMenu_RefineMenuItem> IDebugUnitItemMenu_RefineMenu_RefineMenuItemMethods for __T {}
3711
3712#[cfg(feature = "app-debugunititemmenu")]
3713impl DebugUnitItemMenu_RefineMenu_RefineMenuItem {
3714 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3715 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3716 }
3717
3718 pub fn get_column_name0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3719 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3720 }
3721
3722 pub fn get_column_name1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3723 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3724 }
3725
3726 pub fn get_column_name2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3727 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3728 }
3729
3730 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3731 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3732 }
3733
3734 pub fn get_parameter_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3735 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3736 }
3737}
3738
3739#[cfg(feature = "app-debugunititemmenu")]
3740impl DebugUnitItemMenu_RefineMenu_RefineMenuItem {
3741 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_RefineMenuItem`'s own `GetColumnName0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3742 pub unsafe fn get_column_name0(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3743 let __mi = Self::get_column_name0_method_info();
3744 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3745 __inner(this.into(), ::core::option::Option::None)
3746 }
3747
3748 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_RefineMenuItem`'s own `GetColumnName1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3749 pub unsafe fn get_column_name1(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3750 let __mi = Self::get_column_name1_method_info();
3751 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3752 __inner(this.into(), ::core::option::Option::None)
3753 }
3754
3755 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_RefineMenuItem`'s own `GetColumnName2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3756 pub unsafe fn get_column_name2(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3757 let __mi = Self::get_column_name2_method_info();
3758 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3759 __inner(this.into(), ::core::option::Option::None)
3760 }
3761
3762 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_RefineMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3763 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
3764 let __mi = Self::a_call_method_info();
3765 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
3766 ::core::mem::transmute(__mi.method_ptr);
3767 __inner(this.into(), ::core::option::Option::None)
3768 }
3769}
3770
3771#[cfg(feature = "app-debugunititemmenu")]
3772impl DebugUnitItemMenu_RefineMenu_RefineMenuItem {
3773 #[doc = "`.ctor(crate::app::unit::Unit, i32, i32, crate::app::itemrefinedata::ItemRefineData)` — overload selector"]
3774 pub fn new(
3775 unit: crate::app::unit::Unit,
3776 unit_item_index: i32,
3777 refine_level: i32,
3778 refine_data: crate::app::itemrefinedata::ItemRefineData,
3779 ) -> Self {
3780 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3781 panic!(
3782 "{}
3783::{}
3784 failed to instantiate",
3785 ::core::stringify!(DebugUnitItemMenu_RefineMenu_RefineMenuItem),
3786 ::core::stringify!(new),
3787 )
3788 });
3789 <Self as IDebugUnitItemMenu_RefineMenu_RefineMenuItemMethods>::ctor(this, unit, unit_item_index, refine_level, refine_data);
3790 this
3791 }
3792}
3793
3794#[cfg(feature = "app-debugunititemmenu")]
3795pub trait IDebugUnitItemMenu_RefineMenu_BaseMenuItemMethods: IDebugUnitItemMenu_RefineMenu_BaseMenuItem {
3796 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
3797 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
3798 unsafe {
3799 let __receiver = <DebugUnitItemMenu_RefineMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
3800 <Self as ::unity::SystemObject>::as_instance(self),
3801 );
3802 ::unity::il2cpp_call!((::unity::module_base()+0x1b34300usize)as*mut u8,();
3803(DebugUnitItemMenu_RefineMenu_BaseMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
3804 }
3805 }
3806 #[doc = "`GetColumnCount()` overload"]
3807 fn get_column_count(self) -> i32 {
3808 unsafe {
3809 let __receiver = <DebugUnitItemMenu_RefineMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
3810 <Self as ::unity::SystemObject>::as_instance(self),
3811 );
3812 {
3813 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3814 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
3815 panic!(
3816 "unity: virtual slot {}
3817 out of range (vtable len {}
3818) on the runtime class behind {}
3819 (method `{}
3820`)",
3821 29usize,
3822 __vt.len(),
3823 <DebugUnitItemMenu_RefineMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
3824 "GetColumnCount",
3825 )
3826 });
3827 let __inner: extern "C" fn(DebugUnitItemMenu_RefineMenu_BaseMenuItem, ::unity::OptionalMethod) -> i32 =
3828 ::core::mem::transmute(__vi.method_ptr);
3829 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3830 __inner(__receiver, __mi)
3831 }
3832 }
3833 }
3834 #[doc = "`GetColumnWidth0()` overload"]
3835 fn get_column_width0(self) -> f32 {
3836 unsafe {
3837 let __receiver = <DebugUnitItemMenu_RefineMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
3838 <Self as ::unity::SystemObject>::as_instance(self),
3839 );
3840 {
3841 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3842 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
3843 panic!(
3844 "unity: virtual slot {}
3845 out of range (vtable len {}
3846) on the runtime class behind {}
3847 (method `{}
3848`)",
3849 31usize,
3850 __vt.len(),
3851 <DebugUnitItemMenu_RefineMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
3852 "GetColumnWidth0",
3853 )
3854 });
3855 let __inner: extern "C" fn(DebugUnitItemMenu_RefineMenu_BaseMenuItem, ::unity::OptionalMethod) -> f32 =
3856 ::core::mem::transmute(__vi.method_ptr);
3857 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3858 __inner(__receiver, __mi)
3859 }
3860 }
3861 }
3862 #[doc = "`GetColumnWidth1()` overload"]
3863 fn get_column_width1(self) -> f32 {
3864 unsafe {
3865 let __receiver = <DebugUnitItemMenu_RefineMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
3866 <Self as ::unity::SystemObject>::as_instance(self),
3867 );
3868 {
3869 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3870 let __vi = *__vt.get(32usize).unwrap_or_else(|| {
3871 panic!(
3872 "unity: virtual slot {}
3873 out of range (vtable len {}
3874) on the runtime class behind {}
3875 (method `{}
3876`)",
3877 32usize,
3878 __vt.len(),
3879 <DebugUnitItemMenu_RefineMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
3880 "GetColumnWidth1",
3881 )
3882 });
3883 let __inner: extern "C" fn(DebugUnitItemMenu_RefineMenu_BaseMenuItem, ::unity::OptionalMethod) -> f32 =
3884 ::core::mem::transmute(__vi.method_ptr);
3885 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3886 __inner(__receiver, __mi)
3887 }
3888 }
3889 }
3890 #[doc = "`GetColumnWidth2()` overload"]
3891 fn get_column_width2(self) -> f32 {
3892 unsafe {
3893 let __receiver = <DebugUnitItemMenu_RefineMenu_BaseMenuItem as ::unity::FromIlInstance>::from_il_instance(
3894 <Self as ::unity::SystemObject>::as_instance(self),
3895 );
3896 {
3897 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3898 let __vi = *__vt.get(33usize).unwrap_or_else(|| {
3899 panic!(
3900 "unity: virtual slot {}
3901 out of range (vtable len {}
3902) on the runtime class behind {}
3903 (method `{}
3904`)",
3905 33usize,
3906 __vt.len(),
3907 <DebugUnitItemMenu_RefineMenu_BaseMenuItem as ::unity::ClassIdentity>::NAME,
3908 "GetColumnWidth2",
3909 )
3910 });
3911 let __inner: extern "C" fn(DebugUnitItemMenu_RefineMenu_BaseMenuItem, ::unity::OptionalMethod) -> f32 =
3912 ::core::mem::transmute(__vi.method_ptr);
3913 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3914 __inner(__receiver, __mi)
3915 }
3916 }
3917 }
3918}
3919
3920#[cfg(feature = "app-debugunititemmenu")]
3921impl<__T: IDebugUnitItemMenu_RefineMenu_BaseMenuItem> IDebugUnitItemMenu_RefineMenu_BaseMenuItemMethods for __T {}
3922
3923#[cfg(feature = "app-debugunititemmenu")]
3924impl DebugUnitItemMenu_RefineMenu_BaseMenuItem {
3925 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3926 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3927 }
3928
3929 pub fn get_column_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3930 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3931 }
3932
3933 pub fn get_column_width0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3934 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3935 }
3936
3937 pub fn get_column_width1_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3938 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3939 }
3940
3941 pub fn get_column_width2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3942 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3943 }
3944}
3945
3946#[cfg(feature = "app-debugunititemmenu")]
3947impl DebugUnitItemMenu_RefineMenu_BaseMenuItem {
3948 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_BaseMenuItem`'s own `GetColumnCount`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3949 pub unsafe fn get_column_count(this: impl ::core::convert::Into<::unity::IlInstance>) -> i32 {
3950 let __mi = Self::get_column_count_method_info();
3951 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> i32 = ::core::mem::transmute(__mi.method_ptr);
3952 __inner(this.into(), ::core::option::Option::None)
3953 }
3954
3955 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_BaseMenuItem`'s own `GetColumnWidth0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3956 pub unsafe fn get_column_width0(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3957 let __mi = Self::get_column_width0_method_info();
3958 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3959 __inner(this.into(), ::core::option::Option::None)
3960 }
3961
3962 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_BaseMenuItem`'s own `GetColumnWidth1`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3963 pub unsafe fn get_column_width1(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3964 let __mi = Self::get_column_width1_method_info();
3965 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3966 __inner(this.into(), ::core::option::Option::None)
3967 }
3968
3969 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_RefineMenu_BaseMenuItem`'s own `GetColumnWidth2`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3970 pub unsafe fn get_column_width2(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
3971 let __mi = Self::get_column_width2_method_info();
3972 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
3973 __inner(this.into(), ::core::option::Option::None)
3974 }
3975}
3976
3977#[cfg(feature = "app-debugunititemmenu")]
3978impl DebugUnitItemMenu_RefineMenu_BaseMenuItem {
3979 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
3980 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
3981 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3982 panic!(
3983 "{}
3984::{}
3985 failed to instantiate",
3986 ::core::stringify!(DebugUnitItemMenu_RefineMenu_BaseMenuItem),
3987 ::core::stringify!(new),
3988 )
3989 });
3990 <Self as IDebugUnitItemMenu_RefineMenu_BaseMenuItemMethods>::ctor(this, unit, unit_item_index);
3991 this
3992 }
3993}
3994
3995#[cfg(feature = "app-debugunititemmenu")]
3996pub trait IDebugUnitItemMenu_SubMenu_NameMenuItemMethods: IDebugUnitItemMenu_SubMenu_NameMenuItem {
3997 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
3998 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
3999 unsafe {
4000 let __receiver = <DebugUnitItemMenu_SubMenu_NameMenuItem as ::unity::FromIlInstance>::from_il_instance(
4001 <Self as ::unity::SystemObject>::as_instance(self),
4002 );
4003 ::unity::il2cpp_call!((::unity::module_base()+0x1b35830usize)as*mut u8,();
4004(DebugUnitItemMenu_SubMenu_NameMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
4005 }
4006 }
4007 #[doc = "`GetName()` overload"]
4008 fn get_name(self) -> ::unity::Il2CppString {
4009 unsafe {
4010 let __receiver = <DebugUnitItemMenu_SubMenu_NameMenuItem as ::unity::FromIlInstance>::from_il_instance(
4011 <Self as ::unity::SystemObject>::as_instance(self),
4012 );
4013 {
4014 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4015 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
4016 panic!(
4017 "unity: virtual slot {}
4018 out of range (vtable len {}
4019) on the runtime class behind {}
4020 (method `{}
4021`)",
4022 5usize,
4023 __vt.len(),
4024 <DebugUnitItemMenu_SubMenu_NameMenuItem as ::unity::ClassIdentity>::NAME,
4025 "GetName",
4026 )
4027 });
4028 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_NameMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4029 ::core::mem::transmute(__vi.method_ptr);
4030 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4031 __inner(__receiver, __mi)
4032 }
4033 }
4034 }
4035}
4036
4037#[cfg(feature = "app-debugunititemmenu")]
4038impl<__T: IDebugUnitItemMenu_SubMenu_NameMenuItem> IDebugUnitItemMenu_SubMenu_NameMenuItemMethods for __T {}
4039
4040#[cfg(feature = "app-debugunititemmenu")]
4041impl DebugUnitItemMenu_SubMenu_NameMenuItem {
4042 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4043 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4044 }
4045
4046 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4047 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4048 }
4049}
4050
4051#[cfg(feature = "app-debugunititemmenu")]
4052impl DebugUnitItemMenu_SubMenu_NameMenuItem {
4053 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_NameMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4054 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4055 let __mi = Self::get_name_method_info();
4056 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4057 __inner(this.into(), ::core::option::Option::None)
4058 }
4059}
4060
4061#[cfg(feature = "app-debugunititemmenu")]
4062impl DebugUnitItemMenu_SubMenu_NameMenuItem {
4063 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
4064 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
4065 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4066 panic!(
4067 "{}
4068::{}
4069 failed to instantiate",
4070 ::core::stringify!(DebugUnitItemMenu_SubMenu_NameMenuItem),
4071 ::core::stringify!(new),
4072 )
4073 });
4074 <Self as IDebugUnitItemMenu_SubMenu_NameMenuItemMethods>::ctor(this, unit, unit_item_index);
4075 this
4076 }
4077}
4078
4079#[cfg(feature = "app-debugunititemmenu")]
4080impl DebugUnitItemMenu_RefineMenu {
4081 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::unit::Unit, i32)` overload"]
4082 pub fn create_bind(
4083 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
4084 unit: impl ::core::convert::Into<crate::app::unit::Unit>,
4085 unit_item_index: impl ::core::convert::Into<i32>,
4086 ) -> () {
4087 unsafe {
4088 ::unity::il2cpp_call!((::unity::module_base()+0x1bbdd40usize)as*mut u8,();
4089(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
4090 }
4091 }
4092}
4093
4094#[cfg(feature = "app-debugunititemmenu")]
4095pub trait IDebugUnitItemMenu_RefineMenuMethods: IDebugUnitItemMenu_RefineMenu {
4096 #[doc = "`.ctor()` overload"]
4097 fn ctor(self) -> () {
4098 unsafe {
4099 let __receiver =
4100 <DebugUnitItemMenu_RefineMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4101 ::unity::il2cpp_call!((::unity::module_base()+0x1bbdfd0usize)as*mut u8,();
4102(DebugUnitItemMenu_RefineMenu)__receiver)
4103 }
4104 }
4105}
4106
4107#[cfg(feature = "app-debugunititemmenu")]
4108impl<__T: IDebugUnitItemMenu_RefineMenu> IDebugUnitItemMenu_RefineMenuMethods for __T {}
4109
4110#[cfg(feature = "app-debugunititemmenu")]
4111impl DebugUnitItemMenu_RefineMenu {
4112 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4113 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4114 }
4115
4116 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4117 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4118 }
4119}
4120
4121#[cfg(feature = "app-debugunititemmenu")]
4122impl DebugUnitItemMenu_RefineMenu {
4123 #[doc = "`.ctor()` — no args"]
4124 pub fn new() -> Self {
4125 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4126 panic!(
4127 "{}
4128::{}
4129 failed to instantiate",
4130 ::core::stringify!(DebugUnitItemMenu_RefineMenu),
4131 ::core::stringify!(new),
4132 )
4133 });
4134 <Self as IDebugUnitItemMenu_RefineMenuMethods>::ctor(this);
4135 this
4136 }
4137}
4138
4139#[cfg(feature = "app-debugunititemmenu")]
4140pub trait IDebugUnitItemMenu_SubMenu_DropMenuItemMethods: IDebugUnitItemMenu_SubMenu_DropMenuItem {
4141 #[doc = "`.ctor(crate::app::unit::Unit, i32)` overload"]
4142 fn ctor(self, unit: impl ::core::convert::Into<crate::app::unit::Unit>, unit_item_index: impl ::core::convert::Into<i32>) -> () {
4143 unsafe {
4144 let __receiver = <DebugUnitItemMenu_SubMenu_DropMenuItem as ::unity::FromIlInstance>::from_il_instance(
4145 <Self as ::unity::SystemObject>::as_instance(self),
4146 );
4147 ::unity::il2cpp_call!((::unity::module_base()+0x1b34f60usize)as*mut u8,();
4148(DebugUnitItemMenu_SubMenu_DropMenuItem)__receiver,(crate::app::unit::Unit)::core::convert::Into::into(unit),(i32)::core::convert::Into::into(unit_item_index))
4149 }
4150 }
4151 #[doc = "`GetLabel()` overload"]
4152 fn get_label(self) -> ::unity::Il2CppString {
4153 unsafe {
4154 let __receiver = <DebugUnitItemMenu_SubMenu_DropMenuItem as ::unity::FromIlInstance>::from_il_instance(
4155 <Self as ::unity::SystemObject>::as_instance(self),
4156 );
4157 {
4158 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4159 let __vi = *__vt.get(72usize).unwrap_or_else(|| {
4160 panic!(
4161 "unity: virtual slot {}
4162 out of range (vtable len {}
4163) on the runtime class behind {}
4164 (method `{}
4165`)",
4166 72usize,
4167 __vt.len(),
4168 <DebugUnitItemMenu_SubMenu_DropMenuItem as ::unity::ClassIdentity>::NAME,
4169 "GetLabel",
4170 )
4171 });
4172 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_DropMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4173 ::core::mem::transmute(__vi.method_ptr);
4174 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4175 __inner(__receiver, __mi)
4176 }
4177 }
4178 }
4179 #[doc = "`SetFlag(bool)` overload"]
4180 fn set_flag(self, enable: impl ::core::convert::Into<bool>) -> () {
4181 unsafe {
4182 let __receiver = <DebugUnitItemMenu_SubMenu_DropMenuItem as ::unity::FromIlInstance>::from_il_instance(
4183 <Self as ::unity::SystemObject>::as_instance(self),
4184 );
4185 {
4186 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4187 let __vi = *__vt.get(73usize).unwrap_or_else(|| {
4188 panic!(
4189 "unity: virtual slot {}
4190 out of range (vtable len {}
4191) on the runtime class behind {}
4192 (method `{}
4193`)",
4194 73usize,
4195 __vt.len(),
4196 <DebugUnitItemMenu_SubMenu_DropMenuItem as ::unity::ClassIdentity>::NAME,
4197 "SetFlag",
4198 )
4199 });
4200 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_DropMenuItem, bool, ::unity::OptionalMethod) -> () =
4201 ::core::mem::transmute(__vi.method_ptr);
4202 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4203 __inner(__receiver, ::core::convert::Into::into(enable), __mi)
4204 }
4205 }
4206 }
4207 #[doc = "`IsFlag()` overload"]
4208 fn is_flag(self) -> bool {
4209 unsafe {
4210 let __receiver = <DebugUnitItemMenu_SubMenu_DropMenuItem as ::unity::FromIlInstance>::from_il_instance(
4211 <Self as ::unity::SystemObject>::as_instance(self),
4212 );
4213 {
4214 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4215 let __vi = *__vt.get(74usize).unwrap_or_else(|| {
4216 panic!(
4217 "unity: virtual slot {}
4218 out of range (vtable len {}
4219) on the runtime class behind {}
4220 (method `{}
4221`)",
4222 74usize,
4223 __vt.len(),
4224 <DebugUnitItemMenu_SubMenu_DropMenuItem as ::unity::ClassIdentity>::NAME,
4225 "IsFlag",
4226 )
4227 });
4228 let __inner: extern "C" fn(DebugUnitItemMenu_SubMenu_DropMenuItem, ::unity::OptionalMethod) -> bool =
4229 ::core::mem::transmute(__vi.method_ptr);
4230 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4231 __inner(__receiver, __mi)
4232 }
4233 }
4234 }
4235}
4236
4237#[cfg(feature = "app-debugunititemmenu")]
4238impl<__T: IDebugUnitItemMenu_SubMenu_DropMenuItem> IDebugUnitItemMenu_SubMenu_DropMenuItemMethods for __T {}
4239
4240#[cfg(feature = "app-debugunititemmenu")]
4241impl DebugUnitItemMenu_SubMenu_DropMenuItem {
4242 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4243 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4244 }
4245
4246 pub fn get_label_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4247 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4248 }
4249
4250 pub fn set_flag_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4251 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4252 }
4253
4254 pub fn is_flag_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4255 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4256 }
4257}
4258
4259#[cfg(feature = "app-debugunititemmenu")]
4260impl DebugUnitItemMenu_SubMenu_DropMenuItem {
4261 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_DropMenuItem`'s own `GetLabel`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4262 pub unsafe fn get_label(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4263 let __mi = Self::get_label_method_info();
4264 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4265 __inner(this.into(), ::core::option::Option::None)
4266 }
4267
4268 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_DropMenuItem`'s own `SetFlag`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4269 pub unsafe fn set_flag(this: impl ::core::convert::Into<::unity::IlInstance>, enable: bool) -> () {
4270 let __mi = Self::set_flag_method_info();
4271 let __inner: extern "C" fn(::unity::IlInstance, bool, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
4272 __inner(this.into(), enable, ::core::option::Option::None)
4273 }
4274
4275 #[doc = "Direct (non-virtual) call to `DebugUnitItemMenu_SubMenu_DropMenuItem`'s own `IsFlag`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4276 pub unsafe fn is_flag(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
4277 let __mi = Self::is_flag_method_info();
4278 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
4279 __inner(this.into(), ::core::option::Option::None)
4280 }
4281}
4282
4283#[cfg(feature = "app-debugunititemmenu")]
4284impl DebugUnitItemMenu_SubMenu_DropMenuItem {
4285 #[doc = "`.ctor(crate::app::unit::Unit, i32)` — overload selector"]
4286 pub fn new(unit: crate::app::unit::Unit, unit_item_index: i32) -> Self {
4287 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4288 panic!(
4289 "{}
4290::{}
4291 failed to instantiate",
4292 ::core::stringify!(DebugUnitItemMenu_SubMenu_DropMenuItem),
4293 ::core::stringify!(new),
4294 )
4295 });
4296 <Self as IDebugUnitItemMenu_SubMenu_DropMenuItemMethods>::ctor(this, unit, unit_item_index);
4297 this
4298 }
4299}
4300
4301#[cfg(feature = "app-debugunititemmenu")]
4302#[doc(hidden)]
4303pub mod prelude {
4304 pub use super::{
4305 DebugUnitItemMenu, DebugUnitItemMenu_EditItemMenuItem, DebugUnitItemMenu_EngraveMenu, DebugUnitItemMenu_EngraveMenu_BaseMenuItem,
4306 DebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem, DebugUnitItemMenu_EngraveMenu_EngraveMenuItem, DebugUnitItemMenu_ItemListMenu,
4307 DebugUnitItemMenu_ItemListMenu_ItemMenuItem, DebugUnitItemMenu_RefineMenu, DebugUnitItemMenu_RefineMenu_BaseMenuItem,
4308 DebugUnitItemMenu_RefineMenu_EvolveMenuItem, DebugUnitItemMenu_RefineMenu_RefineMenuItem, DebugUnitItemMenu_SubMenu,
4309 DebugUnitItemMenu_SubMenu_BaseMenuItem, DebugUnitItemMenu_SubMenu_DropMenuItem, DebugUnitItemMenu_SubMenu_EnchantHashMenuItem,
4310 DebugUnitItemMenu_SubMenu_EnchantMenuItem, DebugUnitItemMenu_SubMenu_EngraveMenuItem, DebugUnitItemMenu_SubMenu_EquipMenuItem,
4311 DebugUnitItemMenu_SubMenu_FlagMenuItem, DebugUnitItemMenu_SubMenu_ItemBaseMenuItem, DebugUnitItemMenu_SubMenu_NameMenuItem,
4312 DebugUnitItemMenu_SubMenu_PriceMenuItem, DebugUnitItemMenu_SubMenu_RefineMenuItem, DebugUnitItemMenu_SubMenu_SellingMenuItem,
4313 DebugUnitItemMenu_UnitDebugMenu, IDebugUnitItemMenu, IDebugUnitItemMenuMethods, IDebugUnitItemMenu_EditItemMenuItem,
4314 IDebugUnitItemMenu_EditItemMenuItemMethods, IDebugUnitItemMenu_EngraveMenu, IDebugUnitItemMenu_EngraveMenuMethods,
4315 IDebugUnitItemMenu_EngraveMenu_BaseMenuItem, IDebugUnitItemMenu_EngraveMenu_BaseMenuItemMethods,
4316 IDebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItem, IDebugUnitItemMenu_EngraveMenu_ClearEngraveMenuItemMethods,
4317 IDebugUnitItemMenu_EngraveMenu_EngraveMenuItem, IDebugUnitItemMenu_EngraveMenu_EngraveMenuItemMethods, IDebugUnitItemMenu_ItemListMenu,
4318 IDebugUnitItemMenu_ItemListMenuMethods, IDebugUnitItemMenu_ItemListMenu_ItemMenuItem, IDebugUnitItemMenu_ItemListMenu_ItemMenuItemMethods,
4319 IDebugUnitItemMenu_RefineMenu, IDebugUnitItemMenu_RefineMenuMethods, IDebugUnitItemMenu_RefineMenu_BaseMenuItem,
4320 IDebugUnitItemMenu_RefineMenu_BaseMenuItemMethods, IDebugUnitItemMenu_RefineMenu_EvolveMenuItem,
4321 IDebugUnitItemMenu_RefineMenu_EvolveMenuItemMethods, IDebugUnitItemMenu_RefineMenu_RefineMenuItem,
4322 IDebugUnitItemMenu_RefineMenu_RefineMenuItemMethods, IDebugUnitItemMenu_SubMenu, IDebugUnitItemMenu_SubMenuMethods,
4323 IDebugUnitItemMenu_SubMenu_BaseMenuItem, IDebugUnitItemMenu_SubMenu_BaseMenuItemMethods, IDebugUnitItemMenu_SubMenu_DropMenuItem,
4324 IDebugUnitItemMenu_SubMenu_DropMenuItemMethods, IDebugUnitItemMenu_SubMenu_EnchantHashMenuItem,
4325 IDebugUnitItemMenu_SubMenu_EnchantHashMenuItemMethods, IDebugUnitItemMenu_SubMenu_EnchantMenuItem,
4326 IDebugUnitItemMenu_SubMenu_EnchantMenuItemMethods, IDebugUnitItemMenu_SubMenu_EngraveMenuItem,
4327 IDebugUnitItemMenu_SubMenu_EngraveMenuItemMethods, IDebugUnitItemMenu_SubMenu_EquipMenuItem, IDebugUnitItemMenu_SubMenu_EquipMenuItemMethods,
4328 IDebugUnitItemMenu_SubMenu_FlagMenuItem, IDebugUnitItemMenu_SubMenu_FlagMenuItemMethods, IDebugUnitItemMenu_SubMenu_ItemBaseMenuItem,
4329 IDebugUnitItemMenu_SubMenu_ItemBaseMenuItemMethods, IDebugUnitItemMenu_SubMenu_NameMenuItem, IDebugUnitItemMenu_SubMenu_NameMenuItemMethods,
4330 IDebugUnitItemMenu_SubMenu_PriceMenuItem, IDebugUnitItemMenu_SubMenu_PriceMenuItemMethods, IDebugUnitItemMenu_SubMenu_RefineMenuItem,
4331 IDebugUnitItemMenu_SubMenu_RefineMenuItemMethods, IDebugUnitItemMenu_SubMenu_SellingMenuItem,
4332 IDebugUnitItemMenu_SubMenu_SellingMenuItemMethods, IDebugUnitItemMenu_UnitDebugMenu, IDebugUnitItemMenu_UnitDebugMenuMethods,
4333 };
4334 #[cfg(feature = "app-debugmenu")]
4335 pub use crate::app::debugmenu::IDebugMenuMethods;
4336 #[cfg(feature = "app-menuitem")]
4337 pub use crate::app::menuitem::IMenuItemMethods;
4338 #[cfg(feature = "app-procinst")]
4339 pub use crate::app::procinst::IProcInstMethods;
4340 #[cfg(feature = "system-object")]
4341 pub use crate::system::object::IObjectMethods;
4342 pub use crate::{
4343 app::{debugmenu::IDebugMenu, menuitem::IMenuItem, procinst::IProcInst},
4344 system::object::IObject,
4345 };
4346}