1#[cfg(feature = "app-unitselectallunitmenu-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 basicdialog::{BasicDialog, IBasicDialog},
11 basicdialogitem::{BasicDialogItem, IBasicDialogItem},
12 basicdialogitemno::{BasicDialogItemNo, IBasicDialogItemNo},
13 basicdialogitemyes::{BasicDialogItemYes, IBasicDialogItemYes},
14 basicmenu::{BasicMenu, IBasicMenu},
15 basicmenuitem::{BasicMenuItem, IBasicMenuItem},
16 procinst::{IProcInst, ProcInst},
17 yesnodialog::{IYesNoDialog, YesNoDialog},
18 },
19 system::{
20 delegate::{Delegate, IDelegate},
21 multicastdelegate::{IMulticastDelegate, MulticastDelegate},
22 object::{IObject, Object},
23 r#enum::{Enum, IEnum},
24 valuetype::{IValueType, ValueType},
25 },
26 };
27
28 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_StoreAllMenuItem.md"))]
29 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.StoreAllMenuItem")]
30 #[parent(crate::app::basicmenuitem::BasicMenuItem)]
31 pub struct UnitSelectAllUnitMenu_StoreAllMenuItem {
32 #[offset(100)]
33 #[rename(name = "m_IsSuccess")]
34 pub m_is_success: bool,
35 }
36
37 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_EntrustMenuItem.md"))]
38 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.EntrustMenuItem")]
39 #[parent(crate::app::basicmenuitem::BasicMenuItem)]
40 pub struct UnitSelectAllUnitMenu_EntrustMenuItem {
41 #[offset(100)]
42 #[rename(name = "m_Result")]
43 pub m_result: crate::app::sortieentrustresult::SortieEntrustResult,
44 }
45
46 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler.md"))]
47 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.ConfirmSequence.FailureEventHandler")]
48 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
49 pub struct UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler {}
50
51 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler.md"))]
52 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.ConfirmSequence.EndEventHandler")]
53 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
54 pub struct UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler {}
55
56 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem.md"))]
57 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.ConfirmDialog.ConfirmNoDialogItem")]
58 #[parent(crate::app::basicdialogitemno::BasicDialogItemNo)]
59 pub struct UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem {}
60
61 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmSequence_Label.md"))]
62 #[repr(C)]
63 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
64 pub struct UnitSelectAllUnitMenu_ConfirmSequence_Label {
65 pub value: i32,
66 }
67 impl ::unity::ClassIdentity for UnitSelectAllUnitMenu_ConfirmSequence_Label {
68 const NAME: &'static str = "UnitSelectAllUnitMenu.ConfirmSequence.Label";
69 const NAMESPACE: &'static str = "App";
70
71 fn class() -> ::unity::Class {
72 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
73 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
74 }
75 }
76 impl ::unity::IlType for UnitSelectAllUnitMenu_ConfirmSequence_Label {
77 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
78 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
79 }
80 }
81 impl UnitSelectAllUnitMenu_ConfirmSequence_Label {
82 pub fn end() -> Self {
83 Self { value: 0 }
84 }
85 }
86
87 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem.md"))]
88 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.ConfirmDialog.ConfirmYesDialogItem")]
89 #[parent(crate::app::basicdialogitemyes::BasicDialogItemYes)]
90 pub struct UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem {
91 #[offset(112)]
92 #[rename(name = "m_DecideEventHander")]
93 pub m_decide_event_hander: crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler,
94 }
95
96 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler.md"))]
97 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.ConfirmDialog.DecideEventHandler")]
98 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
99 pub struct UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler {}
100
101 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmDialog.md"))]
102 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.ConfirmDialog")]
103 #[parent(crate::app::yesnodialog::YesNoDialog)]
104 pub struct UnitSelectAllUnitMenu_ConfirmDialog {}
105
106 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu.md"))]
107 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu")]
108 #[parent(crate::app::basicmenu::BasicMenu)]
109 pub struct UnitSelectAllUnitMenu {}
110
111 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler.md"))]
112 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.ConfirmSequence.DecideEventHandler")]
113 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
114 pub struct UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler {}
115
116 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmSequence.md"))]
117 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.ConfirmSequence")]
118 #[parent(crate::app::procinst::ProcInst)]
119 pub struct UnitSelectAllUnitMenu_ConfirmSequence {}
120
121 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler.md"))]
122 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.ConfirmSequence.CheckEventHandler")]
123 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
124 pub struct UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler {}
125
126 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/unitselectallunitmenu/UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler.md"))]
127 #[::unity::class(namespace = "App", name = "UnitSelectAllUnitMenu.ConfirmDialog.CloseEventHandler")]
128 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
129 pub struct UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler {}
130}
131
132#[cfg(feature = "app-unitselectallunitmenu-types")]
133pub use __types::*;
134
135#[cfg(feature = "app-unitselectallunitmenu")]
136impl UnitSelectAllUnitMenu_StoreAllMenuItem {
137 #[doc = "`IsTarget(crate::app::unit::Unit)` overload"]
138 pub fn is_target(unit: impl ::core::convert::Into<crate::app::unit::Unit>) -> bool {
139 unsafe {
140 ::unity::il2cpp_call!((::unity::module_base()+0x1b552f0usize)as*mut u8,bool;
141(crate::app::unit::Unit)::core::convert::Into::into(unit))
142 }
143 }
144}
145
146#[cfg(feature = "app-unitselectallunitmenu")]
147pub trait IUnitSelectAllUnitMenu_StoreAllMenuItemMethods: IUnitSelectAllUnitMenu_StoreAllMenuItem {
148 #[doc = "`GetName()` overload"]
149 fn get_name(self) -> ::unity::Il2CppString {
150 unsafe {
151 let __receiver = <UnitSelectAllUnitMenu_StoreAllMenuItem as ::unity::FromIlInstance>::from_il_instance(
152 <Self as ::unity::SystemObject>::as_instance(self),
153 );
154 {
155 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
156 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
157 panic!(
158 "unity: virtual slot {}
159 out of range (vtable len {}
160) on the runtime class behind {}
161 (method `{}
162`)",
163 4usize,
164 __vt.len(),
165 <UnitSelectAllUnitMenu_StoreAllMenuItem as ::unity::ClassIdentity>::NAME,
166 "GetName",
167 )
168 });
169 let __inner: extern "C" fn(UnitSelectAllUnitMenu_StoreAllMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
170 ::core::mem::transmute(__vi.method_ptr);
171 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
172 __inner(__receiver, __mi)
173 }
174 }
175 }
176 #[doc = "`BuildAttribute()` overload"]
177 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
178 unsafe {
179 let __receiver = <UnitSelectAllUnitMenu_StoreAllMenuItem as ::unity::FromIlInstance>::from_il_instance(
180 <Self as ::unity::SystemObject>::as_instance(self),
181 );
182 {
183 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
184 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
185 panic!(
186 "unity: virtual slot {}
187 out of range (vtable len {}
188) on the runtime class behind {}
189 (method `{}
190`)",
191 8usize,
192 __vt.len(),
193 <UnitSelectAllUnitMenu_StoreAllMenuItem as ::unity::ClassIdentity>::NAME,
194 "BuildAttribute",
195 )
196 });
197 let __inner: extern "C" fn(
198 UnitSelectAllUnitMenu_StoreAllMenuItem,
199 ::unity::OptionalMethod,
200 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
201 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
202 __inner(__receiver, __mi)
203 }
204 }
205 }
206 #[doc = "`ACall()` overload"]
207 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
208 unsafe {
209 let __receiver = <UnitSelectAllUnitMenu_StoreAllMenuItem as ::unity::FromIlInstance>::from_il_instance(
210 <Self as ::unity::SystemObject>::as_instance(self),
211 );
212 {
213 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
214 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
215 panic!(
216 "unity: virtual slot {}
217 out of range (vtable len {}
218) on the runtime class behind {}
219 (method `{}
220`)",
221 18usize,
222 __vt.len(),
223 <UnitSelectAllUnitMenu_StoreAllMenuItem as ::unity::ClassIdentity>::NAME,
224 "ACall",
225 )
226 });
227 let __inner: extern "C" fn(
228 UnitSelectAllUnitMenu_StoreAllMenuItem,
229 ::unity::OptionalMethod,
230 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
231 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
232 __inner(__receiver, __mi)
233 }
234 }
235 }
236 #[doc = "`BCall()` overload"]
237 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
238 unsafe {
239 let __receiver = <UnitSelectAllUnitMenu_StoreAllMenuItem as ::unity::FromIlInstance>::from_il_instance(
240 <Self as ::unity::SystemObject>::as_instance(self),
241 );
242 {
243 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
244 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
245 panic!(
246 "unity: virtual slot {}
247 out of range (vtable len {}
248) on the runtime class behind {}
249 (method `{}
250`)",
251 19usize,
252 __vt.len(),
253 <UnitSelectAllUnitMenu_StoreAllMenuItem as ::unity::ClassIdentity>::NAME,
254 "BCall",
255 )
256 });
257 let __inner: extern "C" fn(
258 UnitSelectAllUnitMenu_StoreAllMenuItem,
259 ::unity::OptionalMethod,
260 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
261 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
262 __inner(__receiver, __mi)
263 }
264 }
265 }
266 #[doc = "`Decide()` overload"]
267 fn decide(self) -> () {
268 unsafe {
269 let __receiver = <UnitSelectAllUnitMenu_StoreAllMenuItem as ::unity::FromIlInstance>::from_il_instance(
270 <Self as ::unity::SystemObject>::as_instance(self),
271 );
272 ::unity::il2cpp_call!((::unity::module_base()+0x1b55670usize)as*mut u8,();
273(UnitSelectAllUnitMenu_StoreAllMenuItem)__receiver)
274 }
275 }
276 #[doc = "`.ctor()` overload"]
277 fn ctor(self) -> () {
278 unsafe {
279 let __receiver = <UnitSelectAllUnitMenu_StoreAllMenuItem as ::unity::FromIlInstance>::from_il_instance(
280 <Self as ::unity::SystemObject>::as_instance(self),
281 );
282 ::unity::il2cpp_call!((::unity::module_base()+0x1b55810usize)as*mut u8,();
283(UnitSelectAllUnitMenu_StoreAllMenuItem)__receiver)
284 }
285 }
286}
287
288#[cfg(feature = "app-unitselectallunitmenu")]
289impl<__T: IUnitSelectAllUnitMenu_StoreAllMenuItem> IUnitSelectAllUnitMenu_StoreAllMenuItemMethods for __T {}
290
291#[cfg(feature = "app-unitselectallunitmenu")]
292impl UnitSelectAllUnitMenu_StoreAllMenuItem {
293 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
294 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
295 }
296
297 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
298 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
299 }
300
301 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
302 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
303 }
304
305 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
306 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
307 }
308
309 pub fn is_target_method_info() -> &'static ::unity::il2cpp::MethodInfo {
310 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
311 }
312
313 pub fn decide_method_info() -> &'static ::unity::il2cpp::MethodInfo {
314 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
315 }
316
317 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
318 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
319 }
320}
321
322#[cfg(feature = "app-unitselectallunitmenu")]
323impl UnitSelectAllUnitMenu_StoreAllMenuItem {
324 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_StoreAllMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
325 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
326 let __mi = Self::get_name_method_info();
327 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
328 __inner(this.into(), ::core::option::Option::None)
329 }
330
331 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_StoreAllMenuItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
332 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
333 let __mi = Self::build_attribute_method_info();
334 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
335 ::core::mem::transmute(__mi.method_ptr);
336 __inner(this.into(), ::core::option::Option::None)
337 }
338
339 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_StoreAllMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
340 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
341 let __mi = Self::a_call_method_info();
342 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
343 ::core::mem::transmute(__mi.method_ptr);
344 __inner(this.into(), ::core::option::Option::None)
345 }
346
347 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_StoreAllMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
348 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
349 let __mi = Self::b_call_method_info();
350 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
351 ::core::mem::transmute(__mi.method_ptr);
352 __inner(this.into(), ::core::option::Option::None)
353 }
354}
355
356#[cfg(feature = "app-unitselectallunitmenu")]
357impl UnitSelectAllUnitMenu_StoreAllMenuItem {
358 #[doc = "`.ctor()` — no args"]
359 pub fn new() -> Self {
360 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
361 panic!(
362 "{}
363::{}
364 failed to instantiate",
365 ::core::stringify!(UnitSelectAllUnitMenu_StoreAllMenuItem),
366 ::core::stringify!(new),
367 )
368 });
369 <Self as IUnitSelectAllUnitMenu_StoreAllMenuItemMethods>::ctor(this);
370 this
371 }
372}
373
374#[cfg(feature = "app-unitselectallunitmenu")]
375pub trait IUnitSelectAllUnitMenu_EntrustMenuItemMethods: IUnitSelectAllUnitMenu_EntrustMenuItem {
376 #[doc = "`GetName()` overload"]
377 fn get_name(self) -> ::unity::Il2CppString {
378 unsafe {
379 let __receiver = <UnitSelectAllUnitMenu_EntrustMenuItem as ::unity::FromIlInstance>::from_il_instance(
380 <Self as ::unity::SystemObject>::as_instance(self),
381 );
382 {
383 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
384 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
385 panic!(
386 "unity: virtual slot {}
387 out of range (vtable len {}
388) on the runtime class behind {}
389 (method `{}
390`)",
391 4usize,
392 __vt.len(),
393 <UnitSelectAllUnitMenu_EntrustMenuItem as ::unity::ClassIdentity>::NAME,
394 "GetName",
395 )
396 });
397 let __inner: extern "C" fn(UnitSelectAllUnitMenu_EntrustMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
398 ::core::mem::transmute(__vi.method_ptr);
399 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
400 __inner(__receiver, __mi)
401 }
402 }
403 }
404 #[doc = "`BuildAttribute()` overload"]
405 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
406 unsafe {
407 let __receiver = <UnitSelectAllUnitMenu_EntrustMenuItem as ::unity::FromIlInstance>::from_il_instance(
408 <Self as ::unity::SystemObject>::as_instance(self),
409 );
410 {
411 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
412 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
413 panic!(
414 "unity: virtual slot {}
415 out of range (vtable len {}
416) on the runtime class behind {}
417 (method `{}
418`)",
419 8usize,
420 __vt.len(),
421 <UnitSelectAllUnitMenu_EntrustMenuItem as ::unity::ClassIdentity>::NAME,
422 "BuildAttribute",
423 )
424 });
425 let __inner: extern "C" fn(
426 UnitSelectAllUnitMenu_EntrustMenuItem,
427 ::unity::OptionalMethod,
428 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
429 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
430 __inner(__receiver, __mi)
431 }
432 }
433 }
434 #[doc = "`ACall()` overload"]
435 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
436 unsafe {
437 let __receiver = <UnitSelectAllUnitMenu_EntrustMenuItem as ::unity::FromIlInstance>::from_il_instance(
438 <Self as ::unity::SystemObject>::as_instance(self),
439 );
440 {
441 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
442 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
443 panic!(
444 "unity: virtual slot {}
445 out of range (vtable len {}
446) on the runtime class behind {}
447 (method `{}
448`)",
449 18usize,
450 __vt.len(),
451 <UnitSelectAllUnitMenu_EntrustMenuItem as ::unity::ClassIdentity>::NAME,
452 "ACall",
453 )
454 });
455 let __inner: extern "C" fn(
456 UnitSelectAllUnitMenu_EntrustMenuItem,
457 ::unity::OptionalMethod,
458 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
459 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
460 __inner(__receiver, __mi)
461 }
462 }
463 }
464 #[doc = "`BCall()` overload"]
465 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
466 unsafe {
467 let __receiver = <UnitSelectAllUnitMenu_EntrustMenuItem as ::unity::FromIlInstance>::from_il_instance(
468 <Self as ::unity::SystemObject>::as_instance(self),
469 );
470 {
471 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
472 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
473 panic!(
474 "unity: virtual slot {}
475 out of range (vtable len {}
476) on the runtime class behind {}
477 (method `{}
478`)",
479 19usize,
480 __vt.len(),
481 <UnitSelectAllUnitMenu_EntrustMenuItem as ::unity::ClassIdentity>::NAME,
482 "BCall",
483 )
484 });
485 let __inner: extern "C" fn(
486 UnitSelectAllUnitMenu_EntrustMenuItem,
487 ::unity::OptionalMethod,
488 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
489 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
490 __inner(__receiver, __mi)
491 }
492 }
493 }
494 #[doc = "`Decide()` overload"]
495 fn decide(self) -> () {
496 unsafe {
497 let __receiver = <UnitSelectAllUnitMenu_EntrustMenuItem as ::unity::FromIlInstance>::from_il_instance(
498 <Self as ::unity::SystemObject>::as_instance(self),
499 );
500 ::unity::il2cpp_call!((::unity::module_base()+0x1b54dc0usize)as*mut u8,();
501(UnitSelectAllUnitMenu_EntrustMenuItem)__receiver)
502 }
503 }
504 #[doc = "`.ctor()` overload"]
505 fn ctor(self) -> () {
506 unsafe {
507 let __receiver = <UnitSelectAllUnitMenu_EntrustMenuItem as ::unity::FromIlInstance>::from_il_instance(
508 <Self as ::unity::SystemObject>::as_instance(self),
509 );
510 ::unity::il2cpp_call!((::unity::module_base()+0x1b54ea0usize)as*mut u8,();
511(UnitSelectAllUnitMenu_EntrustMenuItem)__receiver)
512 }
513 }
514}
515
516#[cfg(feature = "app-unitselectallunitmenu")]
517impl<__T: IUnitSelectAllUnitMenu_EntrustMenuItem> IUnitSelectAllUnitMenu_EntrustMenuItemMethods for __T {}
518
519#[cfg(feature = "app-unitselectallunitmenu")]
520impl UnitSelectAllUnitMenu_EntrustMenuItem {
521 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
522 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
523 }
524
525 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
526 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
527 }
528
529 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
530 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
531 }
532
533 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
534 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
535 }
536
537 pub fn decide_method_info() -> &'static ::unity::il2cpp::MethodInfo {
538 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
539 }
540
541 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
542 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
543 }
544}
545
546#[cfg(feature = "app-unitselectallunitmenu")]
547impl UnitSelectAllUnitMenu_EntrustMenuItem {
548 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_EntrustMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
549 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
550 let __mi = Self::get_name_method_info();
551 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
552 __inner(this.into(), ::core::option::Option::None)
553 }
554
555 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_EntrustMenuItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
556 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
557 let __mi = Self::build_attribute_method_info();
558 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
559 ::core::mem::transmute(__mi.method_ptr);
560 __inner(this.into(), ::core::option::Option::None)
561 }
562
563 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_EntrustMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
564 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
565 let __mi = Self::a_call_method_info();
566 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
567 ::core::mem::transmute(__mi.method_ptr);
568 __inner(this.into(), ::core::option::Option::None)
569 }
570
571 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_EntrustMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
572 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
573 let __mi = Self::b_call_method_info();
574 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
575 ::core::mem::transmute(__mi.method_ptr);
576 __inner(this.into(), ::core::option::Option::None)
577 }
578}
579
580#[cfg(feature = "app-unitselectallunitmenu")]
581impl UnitSelectAllUnitMenu_EntrustMenuItem {
582 #[doc = "`.ctor()` — no args"]
583 pub fn new() -> Self {
584 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
585 panic!(
586 "{}
587::{}
588 failed to instantiate",
589 ::core::stringify!(UnitSelectAllUnitMenu_EntrustMenuItem),
590 ::core::stringify!(new),
591 )
592 });
593 <Self as IUnitSelectAllUnitMenu_EntrustMenuItemMethods>::ctor(this);
594 this
595 }
596}
597
598#[cfg(feature = "app-unitselectallunitmenu")]
599pub trait IUnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandlerMethods: IUnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler {
600 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
601 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
602 unsafe {
603 let __receiver = <UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler as ::unity::FromIlInstance>::from_il_instance(
604 <Self as ::unity::SystemObject>::as_instance(self),
605 );
606 ::unity::il2cpp_call!((::unity::module_base()+0x22f58e0usize)as*mut u8,();
607(UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
608 }
609 }
610 #[doc = "`Invoke(crate::app::procinst::ProcInst)` overload"]
611 fn invoke(self, super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
612 unsafe {
613 let __receiver = <UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler as ::unity::FromIlInstance>::from_il_instance(
614 <Self as ::unity::SystemObject>::as_instance(self),
615 );
616 {
617 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
618 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
619 panic!(
620 "unity: virtual slot {}
621 out of range (vtable len {}
622) on the runtime class behind {}
623 (method `{}
624`)",
625 13usize,
626 __vt.len(),
627 <UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler as ::unity::ClassIdentity>::NAME,
628 "Invoke",
629 )
630 });
631 let __inner: extern "C" fn(
632 UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler,
633 crate::app::procinst::ProcInst,
634 ::unity::OptionalMethod,
635 ) -> () = ::core::mem::transmute(__vi.method_ptr);
636 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
637 __inner(__receiver, ::core::convert::Into::into(super_), __mi)
638 }
639 }
640 }
641}
642
643#[cfg(feature = "app-unitselectallunitmenu")]
644impl<__T: IUnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler> IUnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandlerMethods for __T {}
645
646#[cfg(feature = "app-unitselectallunitmenu")]
647impl UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler {
648 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
649 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
650 }
651
652 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
653 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
654 }
655}
656
657#[cfg(feature = "app-unitselectallunitmenu")]
658impl UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler {
659 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
660 pub unsafe fn invoke(this: impl ::core::convert::Into<::unity::IlInstance>, super_: crate::app::procinst::ProcInst) -> () {
661 let __mi = Self::invoke_method_info();
662 let __inner: extern "C" fn(::unity::IlInstance, crate::app::procinst::ProcInst, ::unity::OptionalMethod) -> () =
663 ::core::mem::transmute(__mi.method_ptr);
664 __inner(this.into(), super_, ::core::option::Option::None)
665 }
666}
667
668#[cfg(feature = "app-unitselectallunitmenu")]
669impl UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler {
670 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
671 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
672 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
673 panic!(
674 "{}
675::{}
676 failed to instantiate",
677 ::core::stringify!(UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler),
678 ::core::stringify!(new),
679 )
680 });
681 <Self as IUnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandlerMethods>::ctor(this, object, method);
682 this
683 }
684}
685
686#[cfg(feature = "app-unitselectallunitmenu")]
687pub trait IUnitSelectAllUnitMenu_ConfirmSequence_EndEventHandlerMethods: IUnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler {
688 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
689 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
690 unsafe {
691 let __receiver = <UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler as ::unity::FromIlInstance>::from_il_instance(
692 <Self as ::unity::SystemObject>::as_instance(self),
693 );
694 ::unity::il2cpp_call!((::unity::module_base()+0x22f5880usize)as*mut u8,();
695(UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
696 }
697 }
698 #[doc = "`Invoke()` overload"]
699 fn invoke(self) -> () {
700 unsafe {
701 let __receiver = <UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler 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(13usize).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 13usize,
714 __vt.len(),
715 <UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler as ::unity::ClassIdentity>::NAME,
716 "Invoke",
717 )
718 });
719 let __inner: extern "C" fn(UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler, ::unity::OptionalMethod) -> () =
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}
727
728#[cfg(feature = "app-unitselectallunitmenu")]
729impl<__T: IUnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler> IUnitSelectAllUnitMenu_ConfirmSequence_EndEventHandlerMethods for __T {}
730
731#[cfg(feature = "app-unitselectallunitmenu")]
732impl UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler {
733 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
734 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
735 }
736
737 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
738 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
739 }
740}
741
742#[cfg(feature = "app-unitselectallunitmenu")]
743impl UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler {
744 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
745 pub unsafe fn invoke(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
746 let __mi = Self::invoke_method_info();
747 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
748 __inner(this.into(), ::core::option::Option::None)
749 }
750}
751
752#[cfg(feature = "app-unitselectallunitmenu")]
753impl UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler {
754 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
755 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
756 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
757 panic!(
758 "{}
759::{}
760 failed to instantiate",
761 ::core::stringify!(UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler),
762 ::core::stringify!(new),
763 )
764 });
765 <Self as IUnitSelectAllUnitMenu_ConfirmSequence_EndEventHandlerMethods>::ctor(this, object, method);
766 this
767 }
768}
769
770#[cfg(feature = "app-unitselectallunitmenu")]
771pub trait IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItemMethods: IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem {
772 #[doc = "`.ctor(::unity::Il2CppString)` overload"]
773 fn ctor(self, text: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
774 unsafe {
775 let __receiver = <UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem as ::unity::FromIlInstance>::from_il_instance(
776 <Self as ::unity::SystemObject>::as_instance(self),
777 );
778 ::unity::il2cpp_call!((::unity::module_base()+0x22f4960usize)as*mut u8,();
779(UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem)__receiver,(::unity::Il2CppString)::core::convert::Into::into(text))
780 }
781 }
782 #[doc = "`BuildAttribute()` overload"]
783 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
784 unsafe {
785 let __receiver = <UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem as ::unity::FromIlInstance>::from_il_instance(
786 <Self as ::unity::SystemObject>::as_instance(self),
787 );
788 {
789 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
790 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
791 panic!(
792 "unity: virtual slot {}
793 out of range (vtable len {}
794) on the runtime class behind {}
795 (method `{}
796`)",
797 8usize,
798 __vt.len(),
799 <UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem as ::unity::ClassIdentity>::NAME,
800 "BuildAttribute",
801 )
802 });
803 let __inner: extern "C" fn(
804 UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem,
805 ::unity::OptionalMethod,
806 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
807 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
808 __inner(__receiver, __mi)
809 }
810 }
811 }
812}
813
814#[cfg(feature = "app-unitselectallunitmenu")]
815impl<__T: IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem> IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItemMethods for __T {}
816
817#[cfg(feature = "app-unitselectallunitmenu")]
818impl UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem {
819 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
820 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
821 }
822
823 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
824 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
825 }
826}
827
828#[cfg(feature = "app-unitselectallunitmenu")]
829impl UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem {
830 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
831 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
832 let __mi = Self::build_attribute_method_info();
833 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
834 ::core::mem::transmute(__mi.method_ptr);
835 __inner(this.into(), ::core::option::Option::None)
836 }
837}
838
839#[cfg(feature = "app-unitselectallunitmenu")]
840impl UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem {
841 #[doc = "`.ctor(::unity::Il2CppString)` — overload selector"]
842 pub fn new(text: ::unity::Il2CppString) -> Self {
843 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
844 panic!(
845 "{}
846::{}
847 failed to instantiate",
848 ::core::stringify!(UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem),
849 ::core::stringify!(new),
850 )
851 });
852 <Self as IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItemMethods>::ctor(this, text);
853 this
854 }
855}
856
857#[cfg(feature = "app-unitselectallunitmenu")]
858pub trait IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItemMethods: IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem {
859 #[doc = "`.ctor(::unity::Il2CppString, crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler)` overload"]
860 fn ctor(
861 self,
862 text: impl ::core::convert::Into<::unity::Il2CppString>,
863 decide: impl ::core::convert::Into<crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler>,
864 ) -> () {
865 unsafe {
866 let __receiver = <UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem as ::unity::FromIlInstance>::from_il_instance(
867 <Self as ::unity::SystemObject>::as_instance(self),
868 );
869 ::unity::il2cpp_call!((::unity::module_base()+0x22f4980usize)as*mut u8,();
870(UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem)__receiver,(::unity::Il2CppString)::core::convert::Into::into(text),(crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler)::core::convert::Into::into(decide))
871 }
872 }
873 #[doc = "`BuildAttribute()` overload"]
874 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
875 unsafe {
876 let __receiver = <UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem as ::unity::FromIlInstance>::from_il_instance(
877 <Self as ::unity::SystemObject>::as_instance(self),
878 );
879 {
880 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
881 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
882 panic!(
883 "unity: virtual slot {}
884 out of range (vtable len {}
885) on the runtime class behind {}
886 (method `{}
887`)",
888 8usize,
889 __vt.len(),
890 <UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem as ::unity::ClassIdentity>::NAME,
891 "BuildAttribute",
892 )
893 });
894 let __inner: extern "C" fn(
895 UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem,
896 ::unity::OptionalMethod,
897 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
898 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
899 __inner(__receiver, __mi)
900 }
901 }
902 }
903 #[doc = "`ACall()` overload"]
904 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
905 unsafe {
906 let __receiver = <UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem as ::unity::FromIlInstance>::from_il_instance(
907 <Self as ::unity::SystemObject>::as_instance(self),
908 );
909 {
910 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
911 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
912 panic!(
913 "unity: virtual slot {}
914 out of range (vtable len {}
915) on the runtime class behind {}
916 (method `{}
917`)",
918 18usize,
919 __vt.len(),
920 <UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem as ::unity::ClassIdentity>::NAME,
921 "ACall",
922 )
923 });
924 let __inner: extern "C" fn(
925 UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem,
926 ::unity::OptionalMethod,
927 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
928 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
929 __inner(__receiver, __mi)
930 }
931 }
932 }
933}
934
935#[cfg(feature = "app-unitselectallunitmenu")]
936impl<__T: IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem> IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItemMethods for __T {}
937
938#[cfg(feature = "app-unitselectallunitmenu")]
939impl UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem {
940 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
941 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
942 }
943
944 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
945 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
946 }
947
948 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
949 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
950 }
951}
952
953#[cfg(feature = "app-unitselectallunitmenu")]
954impl UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem {
955 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
956 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
957 let __mi = Self::build_attribute_method_info();
958 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
959 ::core::mem::transmute(__mi.method_ptr);
960 __inner(this.into(), ::core::option::Option::None)
961 }
962
963 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
964 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
965 let __mi = Self::a_call_method_info();
966 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
967 ::core::mem::transmute(__mi.method_ptr);
968 __inner(this.into(), ::core::option::Option::None)
969 }
970}
971
972#[cfg(feature = "app-unitselectallunitmenu")]
973impl UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem {
974 #[doc = "`.ctor(::unity::Il2CppString, crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler)` — overload selector"]
975 pub fn new(
976 text: ::unity::Il2CppString,
977 decide: crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler,
978 ) -> Self {
979 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
980 panic!(
981 "{}
982::{}
983 failed to instantiate",
984 ::core::stringify!(UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem),
985 ::core::stringify!(new),
986 )
987 });
988 <Self as IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItemMethods>::ctor(this, text, decide);
989 this
990 }
991}
992
993#[cfg(feature = "app-unitselectallunitmenu")]
994pub trait IUnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandlerMethods: IUnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler {
995 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
996 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
997 unsafe {
998 let __receiver = <UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler as ::unity::FromIlInstance>::from_il_instance(
999 <Self as ::unity::SystemObject>::as_instance(self),
1000 );
1001 ::unity::il2cpp_call!((::unity::module_base()+0x22f4c00usize)as*mut u8,();
1002(UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
1003 }
1004 }
1005 #[doc = "`Invoke()` overload"]
1006 fn invoke(self) -> () {
1007 unsafe {
1008 let __receiver = <UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler as ::unity::FromIlInstance>::from_il_instance(
1009 <Self as ::unity::SystemObject>::as_instance(self),
1010 );
1011 {
1012 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1013 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
1014 panic!(
1015 "unity: virtual slot {}
1016 out of range (vtable len {}
1017) on the runtime class behind {}
1018 (method `{}
1019`)",
1020 13usize,
1021 __vt.len(),
1022 <UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler as ::unity::ClassIdentity>::NAME,
1023 "Invoke",
1024 )
1025 });
1026 let __inner: extern "C" fn(UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler, ::unity::OptionalMethod) -> () =
1027 ::core::mem::transmute(__vi.method_ptr);
1028 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1029 __inner(__receiver, __mi)
1030 }
1031 }
1032 }
1033}
1034
1035#[cfg(feature = "app-unitselectallunitmenu")]
1036impl<__T: IUnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler> IUnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandlerMethods for __T {}
1037
1038#[cfg(feature = "app-unitselectallunitmenu")]
1039impl UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler {
1040 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1041 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1042 }
1043
1044 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1045 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1046 }
1047}
1048
1049#[cfg(feature = "app-unitselectallunitmenu")]
1050impl UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler {
1051 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1052 pub unsafe fn invoke(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1053 let __mi = Self::invoke_method_info();
1054 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1055 __inner(this.into(), ::core::option::Option::None)
1056 }
1057}
1058
1059#[cfg(feature = "app-unitselectallunitmenu")]
1060impl UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler {
1061 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
1062 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
1063 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1064 panic!(
1065 "{}
1066::{}
1067 failed to instantiate",
1068 ::core::stringify!(UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler),
1069 ::core::stringify!(new),
1070 )
1071 });
1072 <Self as IUnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandlerMethods>::ctor(this, object, method);
1073 this
1074 }
1075}
1076
1077#[cfg(feature = "app-unitselectallunitmenu")]
1078impl UnitSelectAllUnitMenu_ConfirmDialog {
1079 #[doc = "`CreateBind(crate::app::procinst::ProcInst, ::unity::Il2CppString, ::unity::Il2CppString, crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler)` overload"]
1080 pub fn create_bind(
1081 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
1082 msg: impl ::core::convert::Into<::unity::Il2CppString>,
1083 yes: impl ::core::convert::Into<::unity::Il2CppString>,
1084 decide: impl ::core::convert::Into<crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler>,
1085 ) -> () {
1086 unsafe {
1087 ::unity::il2cpp_call!((::unity::module_base()+0x1b54300usize)as*mut u8,();
1088(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(::unity::Il2CppString)::core::convert::Into::into(msg),(::unity::Il2CppString)::core::convert::Into::into(yes),(crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler)::core::convert::Into::into(decide))
1089 }
1090 }
1091}
1092
1093#[cfg(feature = "app-unitselectallunitmenu")]
1094pub trait IUnitSelectAllUnitMenu_ConfirmDialogMethods: IUnitSelectAllUnitMenu_ConfirmDialog {
1095 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)` overload"]
1096 fn ctor(
1097 self,
1098 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
1099 ) -> () {
1100 unsafe {
1101 let __receiver = <UnitSelectAllUnitMenu_ConfirmDialog as ::unity::FromIlInstance>::from_il_instance(
1102 <Self as ::unity::SystemObject>::as_instance(self),
1103 );
1104 ::unity::il2cpp_call!((::unity::module_base()+0x1b54560usize)as*mut u8,();
1105(UnitSelectAllUnitMenu_ConfirmDialog)__receiver,(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list))
1106 }
1107 }
1108}
1109
1110#[cfg(feature = "app-unitselectallunitmenu")]
1111impl<__T: IUnitSelectAllUnitMenu_ConfirmDialog> IUnitSelectAllUnitMenu_ConfirmDialogMethods for __T {}
1112
1113#[cfg(feature = "app-unitselectallunitmenu")]
1114impl UnitSelectAllUnitMenu_ConfirmDialog {
1115 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1116 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1117 }
1118
1119 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1120 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1121 }
1122}
1123
1124#[cfg(feature = "app-unitselectallunitmenu")]
1125impl UnitSelectAllUnitMenu_ConfirmDialog {
1126 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)` — overload selector"]
1127 pub fn new(menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>) -> Self {
1128 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1129 panic!(
1130 "{}
1131::{}
1132 failed to instantiate",
1133 ::core::stringify!(UnitSelectAllUnitMenu_ConfirmDialog),
1134 ::core::stringify!(new),
1135 )
1136 });
1137 <Self as IUnitSelectAllUnitMenu_ConfirmDialogMethods>::ctor(this, menu_item_list);
1138 this
1139 }
1140}
1141
1142#[cfg(feature = "app-unitselectallunitmenu")]
1143impl UnitSelectAllUnitMenu {
1144 #[doc = "`CreateBind(crate::app::procinst::ProcInst)` overload"]
1145 pub fn create_bind(super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
1146 unsafe {
1147 ::unity::il2cpp_call!((::unity::module_base()+0x1c5dc00usize)as*mut u8,();
1148(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
1149 }
1150 }
1151}
1152
1153#[cfg(feature = "app-unitselectallunitmenu")]
1154pub trait IUnitSelectAllUnitMenuMethods: IUnitSelectAllUnitMenu {
1155 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)` overload"]
1156 fn ctor(
1157 self,
1158 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
1159 ) -> () {
1160 unsafe {
1161 let __receiver = <UnitSelectAllUnitMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1162 ::unity::il2cpp_call!((::unity::module_base()+0x1c5dde0usize)as*mut u8,();
1163(UnitSelectAllUnitMenu)__receiver,(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list))
1164 }
1165 }
1166}
1167
1168#[cfg(feature = "app-unitselectallunitmenu")]
1169impl<__T: IUnitSelectAllUnitMenu> IUnitSelectAllUnitMenuMethods for __T {}
1170
1171#[cfg(feature = "app-unitselectallunitmenu")]
1172impl UnitSelectAllUnitMenu {
1173 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1174 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1175 }
1176
1177 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1178 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1179 }
1180}
1181
1182#[cfg(feature = "app-unitselectallunitmenu")]
1183impl UnitSelectAllUnitMenu {
1184 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)` — overload selector"]
1185 pub fn new(menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>) -> Self {
1186 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1187 panic!(
1188 "{}
1189::{}
1190 failed to instantiate",
1191 ::core::stringify!(UnitSelectAllUnitMenu),
1192 ::core::stringify!(new),
1193 )
1194 });
1195 <Self as IUnitSelectAllUnitMenuMethods>::ctor(this, menu_item_list);
1196 this
1197 }
1198}
1199
1200#[cfg(feature = "app-unitselectallunitmenu")]
1201pub trait IUnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandlerMethods: IUnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler {
1202 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
1203 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
1204 unsafe {
1205 let __receiver = <UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler as ::unity::FromIlInstance>::from_il_instance(
1206 <Self as ::unity::SystemObject>::as_instance(self),
1207 );
1208 ::unity::il2cpp_call!((::unity::module_base()+0x22f5820usize)as*mut u8,();
1209(UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
1210 }
1211 }
1212 #[doc = "`Invoke(crate::app::procinst::ProcInst)` overload"]
1213 fn invoke(self, super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
1214 unsafe {
1215 let __receiver = <UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler as ::unity::FromIlInstance>::from_il_instance(
1216 <Self as ::unity::SystemObject>::as_instance(self),
1217 );
1218 {
1219 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1220 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
1221 panic!(
1222 "unity: virtual slot {}
1223 out of range (vtable len {}
1224) on the runtime class behind {}
1225 (method `{}
1226`)",
1227 13usize,
1228 __vt.len(),
1229 <UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler as ::unity::ClassIdentity>::NAME,
1230 "Invoke",
1231 )
1232 });
1233 let __inner: extern "C" fn(
1234 UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler,
1235 crate::app::procinst::ProcInst,
1236 ::unity::OptionalMethod,
1237 ) -> () = ::core::mem::transmute(__vi.method_ptr);
1238 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1239 __inner(__receiver, ::core::convert::Into::into(super_), __mi)
1240 }
1241 }
1242 }
1243}
1244
1245#[cfg(feature = "app-unitselectallunitmenu")]
1246impl<__T: IUnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler> IUnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandlerMethods for __T {}
1247
1248#[cfg(feature = "app-unitselectallunitmenu")]
1249impl UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler {
1250 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1251 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1252 }
1253
1254 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1255 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1256 }
1257}
1258
1259#[cfg(feature = "app-unitselectallunitmenu")]
1260impl UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler {
1261 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1262 pub unsafe fn invoke(this: impl ::core::convert::Into<::unity::IlInstance>, super_: crate::app::procinst::ProcInst) -> () {
1263 let __mi = Self::invoke_method_info();
1264 let __inner: extern "C" fn(::unity::IlInstance, crate::app::procinst::ProcInst, ::unity::OptionalMethod) -> () =
1265 ::core::mem::transmute(__mi.method_ptr);
1266 __inner(this.into(), super_, ::core::option::Option::None)
1267 }
1268}
1269
1270#[cfg(feature = "app-unitselectallunitmenu")]
1271impl UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler {
1272 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
1273 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
1274 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1275 panic!(
1276 "{}
1277::{}
1278 failed to instantiate",
1279 ::core::stringify!(UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler),
1280 ::core::stringify!(new),
1281 )
1282 });
1283 <Self as IUnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandlerMethods>::ctor(this, object, method);
1284 this
1285 }
1286}
1287
1288#[cfg(feature = "app-unitselectallunitmenu")]
1289impl UnitSelectAllUnitMenu_ConfirmSequence {
1290 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler, crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler, crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler, crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler)` overload"]
1291 pub fn create_bind(
1292 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
1293 decide: impl ::core::convert::Into<crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler>,
1294 check: impl ::core::convert::Into<crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler>,
1295 failure: impl ::core::convert::Into<crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler>,
1296 end: impl ::core::convert::Into<crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler>,
1297 ) -> () {
1298 unsafe {
1299 ::unity::il2cpp_call!((::unity::module_base()+0x1b545e0usize)as*mut u8,();
1300(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler)::core::convert::Into::into(decide),(crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler)::core::convert::Into::into(check),(crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler)::core::convert::Into::into(failure),(crate::app::unitselectallunitmenu::UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler)::core::convert::Into::into(end))
1301 }
1302 }
1303}
1304
1305#[cfg(feature = "app-unitselectallunitmenu")]
1306pub trait IUnitSelectAllUnitMenu_ConfirmSequenceMethods: IUnitSelectAllUnitMenu_ConfirmSequence {
1307 #[doc = "`.ctor()` overload"]
1308 fn ctor(self) -> () {
1309 unsafe {
1310 let __receiver = <UnitSelectAllUnitMenu_ConfirmSequence as ::unity::FromIlInstance>::from_il_instance(
1311 <Self as ::unity::SystemObject>::as_instance(self),
1312 );
1313 ::unity::il2cpp_call!((::unity::module_base()+0x1b54a20usize)as*mut u8,();
1314(UnitSelectAllUnitMenu_ConfirmSequence)__receiver)
1315 }
1316 }
1317}
1318
1319#[cfg(feature = "app-unitselectallunitmenu")]
1320impl<__T: IUnitSelectAllUnitMenu_ConfirmSequence> IUnitSelectAllUnitMenu_ConfirmSequenceMethods for __T {}
1321
1322#[cfg(feature = "app-unitselectallunitmenu")]
1323impl UnitSelectAllUnitMenu_ConfirmSequence {
1324 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1325 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1326 }
1327
1328 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1329 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1330 }
1331}
1332
1333#[cfg(feature = "app-unitselectallunitmenu")]
1334impl UnitSelectAllUnitMenu_ConfirmSequence {
1335 #[doc = "`.ctor()` — no args"]
1336 pub fn new() -> Self {
1337 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1338 panic!(
1339 "{}
1340::{}
1341 failed to instantiate",
1342 ::core::stringify!(UnitSelectAllUnitMenu_ConfirmSequence),
1343 ::core::stringify!(new),
1344 )
1345 });
1346 <Self as IUnitSelectAllUnitMenu_ConfirmSequenceMethods>::ctor(this);
1347 this
1348 }
1349}
1350
1351#[cfg(feature = "app-unitselectallunitmenu")]
1352pub trait IUnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandlerMethods: IUnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler {
1353 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
1354 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
1355 unsafe {
1356 let __receiver = <UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler as ::unity::FromIlInstance>::from_il_instance(
1357 <Self as ::unity::SystemObject>::as_instance(self),
1358 );
1359 ::unity::il2cpp_call!((::unity::module_base()+0x22f57a0usize)as*mut u8,();
1360(UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
1361 }
1362 }
1363 #[doc = "`Invoke()` overload"]
1364 fn invoke(self) -> bool {
1365 unsafe {
1366 let __receiver = <UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler as ::unity::FromIlInstance>::from_il_instance(
1367 <Self as ::unity::SystemObject>::as_instance(self),
1368 );
1369 {
1370 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1371 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
1372 panic!(
1373 "unity: virtual slot {}
1374 out of range (vtable len {}
1375) on the runtime class behind {}
1376 (method `{}
1377`)",
1378 13usize,
1379 __vt.len(),
1380 <UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler as ::unity::ClassIdentity>::NAME,
1381 "Invoke",
1382 )
1383 });
1384 let __inner: extern "C" fn(UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler, ::unity::OptionalMethod) -> bool =
1385 ::core::mem::transmute(__vi.method_ptr);
1386 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1387 __inner(__receiver, __mi)
1388 }
1389 }
1390 }
1391}
1392
1393#[cfg(feature = "app-unitselectallunitmenu")]
1394impl<__T: IUnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler> IUnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandlerMethods for __T {}
1395
1396#[cfg(feature = "app-unitselectallunitmenu")]
1397impl UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler {
1398 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1399 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1400 }
1401
1402 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1403 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1404 }
1405}
1406
1407#[cfg(feature = "app-unitselectallunitmenu")]
1408impl UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler {
1409 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1410 pub unsafe fn invoke(this: impl ::core::convert::Into<::unity::IlInstance>) -> bool {
1411 let __mi = Self::invoke_method_info();
1412 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> bool = ::core::mem::transmute(__mi.method_ptr);
1413 __inner(this.into(), ::core::option::Option::None)
1414 }
1415}
1416
1417#[cfg(feature = "app-unitselectallunitmenu")]
1418impl UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler {
1419 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
1420 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
1421 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1422 panic!(
1423 "{}
1424::{}
1425 failed to instantiate",
1426 ::core::stringify!(UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler),
1427 ::core::stringify!(new),
1428 )
1429 });
1430 <Self as IUnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandlerMethods>::ctor(this, object, method);
1431 this
1432 }
1433}
1434
1435#[cfg(feature = "app-unitselectallunitmenu")]
1436pub trait IUnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandlerMethods: IUnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler {
1437 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
1438 fn ctor(self, object: impl ::core::convert::Into<crate::system::object::Object>, method: impl ::core::convert::Into<::unity::IntPtr>) -> () {
1439 unsafe {
1440 let __receiver = <UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler as ::unity::FromIlInstance>::from_il_instance(
1441 <Self as ::unity::SystemObject>::as_instance(self),
1442 );
1443 ::unity::il2cpp_call!((::unity::module_base()+0x22f46f0usize)as*mut u8,();
1444(UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler)__receiver,(crate::system::object::Object)::core::convert::Into::into(object),(::unity::IntPtr)::core::convert::Into::into(method))
1445 }
1446 }
1447 #[doc = "`Invoke()` overload"]
1448 fn invoke(self) -> () {
1449 unsafe {
1450 let __receiver = <UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler as ::unity::FromIlInstance>::from_il_instance(
1451 <Self as ::unity::SystemObject>::as_instance(self),
1452 );
1453 {
1454 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1455 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
1456 panic!(
1457 "unity: virtual slot {}
1458 out of range (vtable len {}
1459) on the runtime class behind {}
1460 (method `{}
1461`)",
1462 13usize,
1463 __vt.len(),
1464 <UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler as ::unity::ClassIdentity>::NAME,
1465 "Invoke",
1466 )
1467 });
1468 let __inner: extern "C" fn(UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler, ::unity::OptionalMethod) -> () =
1469 ::core::mem::transmute(__vi.method_ptr);
1470 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1471 __inner(__receiver, __mi)
1472 }
1473 }
1474 }
1475}
1476
1477#[cfg(feature = "app-unitselectallunitmenu")]
1478impl<__T: IUnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler> IUnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandlerMethods for __T {}
1479
1480#[cfg(feature = "app-unitselectallunitmenu")]
1481impl UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler {
1482 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1483 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1484 }
1485
1486 pub fn invoke_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1487 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1488 }
1489}
1490
1491#[cfg(feature = "app-unitselectallunitmenu")]
1492impl UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler {
1493 #[doc = "Direct (non-virtual) call to `UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler`'s own `Invoke`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1494 pub unsafe fn invoke(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1495 let __mi = Self::invoke_method_info();
1496 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
1497 __inner(this.into(), ::core::option::Option::None)
1498 }
1499}
1500
1501#[cfg(feature = "app-unitselectallunitmenu")]
1502impl UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler {
1503 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
1504 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
1505 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1506 panic!(
1507 "{}
1508::{}
1509 failed to instantiate",
1510 ::core::stringify!(UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler),
1511 ::core::stringify!(new),
1512 )
1513 });
1514 <Self as IUnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandlerMethods>::ctor(this, object, method);
1515 this
1516 }
1517}
1518
1519#[cfg(feature = "app-unitselectallunitmenu")]
1520#[doc(hidden)]
1521pub mod prelude {
1522 pub use super::{
1523 IUnitSelectAllUnitMenu, IUnitSelectAllUnitMenuMethods, IUnitSelectAllUnitMenu_ConfirmDialog, IUnitSelectAllUnitMenu_ConfirmDialogMethods,
1524 IUnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler, IUnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandlerMethods,
1525 IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem, IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItemMethods,
1526 IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem, IUnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItemMethods,
1527 IUnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler, IUnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandlerMethods,
1528 IUnitSelectAllUnitMenu_ConfirmSequence, IUnitSelectAllUnitMenu_ConfirmSequenceMethods,
1529 IUnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler, IUnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandlerMethods,
1530 IUnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler, IUnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandlerMethods,
1531 IUnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler, IUnitSelectAllUnitMenu_ConfirmSequence_EndEventHandlerMethods,
1532 IUnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler, IUnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandlerMethods,
1533 IUnitSelectAllUnitMenu_EntrustMenuItem, IUnitSelectAllUnitMenu_EntrustMenuItemMethods, IUnitSelectAllUnitMenu_StoreAllMenuItem,
1534 IUnitSelectAllUnitMenu_StoreAllMenuItemMethods, UnitSelectAllUnitMenu, UnitSelectAllUnitMenu_ConfirmDialog,
1535 UnitSelectAllUnitMenu_ConfirmDialog_CloseEventHandler, UnitSelectAllUnitMenu_ConfirmDialog_ConfirmNoDialogItem,
1536 UnitSelectAllUnitMenu_ConfirmDialog_ConfirmYesDialogItem, UnitSelectAllUnitMenu_ConfirmDialog_DecideEventHandler,
1537 UnitSelectAllUnitMenu_ConfirmSequence, UnitSelectAllUnitMenu_ConfirmSequence_CheckEventHandler,
1538 UnitSelectAllUnitMenu_ConfirmSequence_DecideEventHandler, UnitSelectAllUnitMenu_ConfirmSequence_EndEventHandler,
1539 UnitSelectAllUnitMenu_ConfirmSequence_FailureEventHandler, UnitSelectAllUnitMenu_ConfirmSequence_Label,
1540 UnitSelectAllUnitMenu_EntrustMenuItem, UnitSelectAllUnitMenu_StoreAllMenuItem,
1541 };
1542 #[cfg(feature = "app-basicdialog")]
1543 pub use crate::app::basicdialog::IBasicDialogMethods;
1544 #[cfg(feature = "app-basicdialogitem")]
1545 pub use crate::app::basicdialogitem::IBasicDialogItemMethods;
1546 #[cfg(feature = "app-basicdialogitemno")]
1547 pub use crate::app::basicdialogitemno::IBasicDialogItemNoMethods;
1548 #[cfg(feature = "app-basicdialogitemyes")]
1549 pub use crate::app::basicdialogitemyes::IBasicDialogItemYesMethods;
1550 #[cfg(feature = "app-basicmenu")]
1551 pub use crate::app::basicmenu::IBasicMenuMethods;
1552 #[cfg(feature = "app-basicmenuitem")]
1553 pub use crate::app::basicmenuitem::IBasicMenuItemMethods;
1554 #[cfg(feature = "app-procinst")]
1555 pub use crate::app::procinst::IProcInstMethods;
1556 #[cfg(feature = "app-yesnodialog")]
1557 pub use crate::app::yesnodialog::IYesNoDialogMethods;
1558 #[cfg(feature = "system-delegate")]
1559 pub use crate::system::delegate::IDelegateMethods;
1560 #[cfg(feature = "system-multicastdelegate")]
1561 pub use crate::system::multicastdelegate::IMulticastDelegateMethods;
1562 #[cfg(feature = "system-object")]
1563 pub use crate::system::object::IObjectMethods;
1564 #[cfg(feature = "system-enum")]
1565 pub use crate::system::r#enum::IEnumMethods;
1566 #[cfg(feature = "system-valuetype")]
1567 pub use crate::system::valuetype::IValueTypeMethods;
1568 pub use crate::{
1569 app::{
1570 basicdialog::IBasicDialog, basicdialogitem::IBasicDialogItem, basicdialogitemno::IBasicDialogItemNo,
1571 basicdialogitemyes::IBasicDialogItemYes, basicmenu::IBasicMenu, basicmenuitem::IBasicMenuItem, procinst::IProcInst,
1572 yesnodialog::IYesNoDialog,
1573 },
1574 system::{delegate::IDelegate, multicastdelegate::IMulticastDelegate, object::IObject, r#enum::IEnum, valuetype::IValueType},
1575 };
1576}