blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
b14392f0f0cc1daa17c3b7217fb39dea387599c1 | 4ac19e8642b3005d702a1112a722811c8b3cc7c6 | /samples/test/crypto.cpp | d389b03482c89823165e4ccb49b8f2282e768646 | [
"BSD-3-Clause"
] | permissive | amreisa/freeCGI | 5ab00029e86fad79a2580262c04afa3ae442e127 | 84c047c4790eaabbc9d2284242a44c204fe674ea | refs/heads/master | 2022-04-27T19:51:11.690512 | 2011-02-28T22:33:34 | 2011-02-28T22:33:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,092 | cpp | ////////////////////////////////////////////////
// Testing ACrypto classes
//
#include "freeCGI.h"
//a_Arbitrary key...
#define MAIN_KEY "Pinky & The Brain" //a_There's a fun key :)
#define MAIN_KEYLENGTH 18 //a_1 added for the NULL terminator
void testACrypto(const char *pccData, int iDataLength);
void test6Bit(const char *pccData, int iDataLength);
int main()
{
//a_The following functions are for testing and serve as examples of use
//a_I used strlen() + 1 to keep the NULL termination as part of data for easy debugging :)
cout << "---------------START: A----------------" << endl;
testACrypto("A", 2); //a_Encryption and ASCII encoding
test6Bit("A", 2); //a_Encryption and ASCII encoding
cout << "-----------------END: A----------------" << endl;
cout << "---------------START: XyZ----------------" << endl;
testACrypto("XyZ", 4); //a_Encryption and ASCII encoding
test6Bit("XyZ", 4); //a_Encryption and ASCII encoding
cout << "-----------------END: 0123456789----------------" << endl;
cout << "---------------START: 0123456789----------------" << endl;
testACrypto("0123456789", 11); //a_Encryption and ASCII encoding
test6Bit("0123456789", 11); //a_Encryption and ASCII encoding
cout << "-----------------END: 0123456789----------------" << endl;
cout << "---------------START: %This!is&a(sample)^string..----------------" << endl;
testACrypto("%This!is&a(sample)^string..", 28); //a_Encryption and ASCII encoding
test6Bit("%This!is&a(sample)^string..", 28); //a_Encryption and ASCII encoding
cout << "-----------------END: %This!is&a(sample)^string..----------------" << endl;
return 0x0;
}
void testACrypto(const char *pccData, int iDataLength)
{
ACrypto acTest;
char *pcBuffer = aStrDup(NULL, 256);
int iLength;
if (pcBuffer)
{
strcpy(pcBuffer, pccData);
acTest.cryptoSetKey((BYTE *)MAIN_KEY, MAIN_KEYLENGTH);
cout << pcBuffer << endl;
cout << "\nNone:None\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectNone, &pcBuffer, iDataLength);
cout << acTest.cryptoDecrypt(ACrypto::ectNone, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
strcpy(pcBuffer, pccData);
cout << "\nXOR_Blitter:None\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectXOR_Blitter, &pcBuffer, iDataLength);
cout << acTest.cryptoDecrypt(ACrypto::ectXOR_Blitter, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
strcpy(pcBuffer, pccData);
cout << "\nXOR_Convolve:None\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectXOR_Convolver, &pcBuffer, iDataLength);
cout << acTest.cryptoDecrypt(ACrypto::ectXOR_Convolver, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
strcpy(pcBuffer, pccData);
cout << "\nNone:4Bit\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectNone|ACrypto::eat4Bit, &pcBuffer, iDataLength);
cout << pcBuffer << endl;
cout << acTest.cryptoDecrypt(ACrypto::ectNone|ACrypto::eat4Bit, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
strcpy(pcBuffer, pccData);
cout << "\nXOR_Blitter:4Bit\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectXOR_Blitter|ACrypto::eat4Bit, &pcBuffer, iDataLength);
cout << pcBuffer << endl;
cout << acTest.cryptoDecrypt(ACrypto::ectXOR_Blitter|ACrypto::eat4Bit, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
strcpy(pcBuffer, pccData);
cout << "\nXOR_Convolve:4Bit\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectXOR_Convolver|ACrypto::eat4Bit, &pcBuffer, iDataLength);
cout << pcBuffer << endl;
cout << acTest.cryptoDecrypt(ACrypto::ectXOR_Convolver|ACrypto::eat4Bit, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
strcpy(pcBuffer, pccData);
cout << "\nNone:6Bit\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectNone|ACrypto::eat6Bit, &pcBuffer, iDataLength);
cout << pcBuffer << endl;
cout << acTest.cryptoDecrypt(ACrypto::ectNone|ACrypto::eat6Bit, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
strcpy(pcBuffer, pccData);
cout << "\nXOR_Blitter:6Bit\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectXOR_Blitter|ACrypto::eat6Bit, &pcBuffer, iDataLength);
cout << pcBuffer << endl;
cout << acTest.cryptoDecrypt(ACrypto::ectXOR_Blitter|ACrypto::eat6Bit, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
strcpy(pcBuffer, pccData);
cout << "\nXOR_Convolve:6Bit\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectXOR_Convolver|ACrypto::eat6Bit, &pcBuffer, iDataLength);
cout << pcBuffer << endl;
cout << acTest.cryptoDecrypt(ACrypto::ectXOR_Convolver|ACrypto::eat6Bit, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
strcpy(pcBuffer, pccData);
cout << "\nXOR_ShiftingConvolver:6Bit\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectXOR_ShiftingConvolver|ACrypto::eat6Bit, &pcBuffer, iDataLength);
cout << pcBuffer << endl;
cout << acTest.cryptoDecrypt(ACrypto::ectXOR_ShiftingConvolver|ACrypto::eat6Bit, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
}
delete []pcBuffer;
}
void test6Bit(const char *pccData, int iDataLength)
{
ACrypto acTest;
char *pcBuffer = aStrDup(NULL, 256);
int iLength;
if (pcBuffer)
{
strcpy(pcBuffer, pccData);
acTest.cryptoSetKey((BYTE *)MAIN_KEY, MAIN_KEYLENGTH);
cout << pcBuffer << endl;
strcpy(pcBuffer, pccData);
cout << "\nNone:6Bit\n";
iLength = acTest.cryptoEncrypt(ACrypto::ectNone|ACrypto::eat6Bit, &pcBuffer, iDataLength);
cout << pcBuffer << endl;
char *pcTemp = aStrDup(pcBuffer);
delete []pcBuffer;
pcBuffer = pcTemp;
cout << acTest.cryptoDecrypt(ACrypto::ectNone|ACrypto::eat6Bit, &pcBuffer, iLength) << endl;
cout << pcBuffer << endl;
}
else
assert(0x0);
delete []pcBuffer;
}
| [
"achacha@hotmail.com"
] | achacha@hotmail.com |
86e7d8114e89dd465b675e82f26ce76f850fd30b | 6c5c921bf0187bce8362684234f89a704e761656 | /курсовая работа/Menu.cpp | e0c5d3f215d20f7030b80fa04dfd727dc1139abc | [] | no_license | kirillqwerty/CrossWord | cfc3770623e4a73069f1c8f1e86f030f34ee87d4 | fe1a1da87fcf200d291bb8f27c74db652cd22bb0 | refs/heads/main | 2023-05-25T18:47:53.779943 | 2021-06-06T15:36:50 | 2021-06-06T15:36:50 | 374,396,864 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 888 | cpp | //---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Menu.h"
#include "Topic.h"
#include "Rules.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Form6->Show();
//Form1->Hide();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
| [
"noreply@github.com"
] | noreply@github.com |
9aa594621d8e3b7839bbb07f9f4d177077800633 | ecb4e5a553fad9455a93dca4cc8c1927179935d6 | /Projet de synthèse 2017/Synthese-project-LUDWIG-COUDERC/Synthese-project-LULU-DEDERC/ExpertFormeComposee.cpp | 5b42a5f4816bab134950895c74201a921a0994e3 | [] | no_license | ALudwig57/Projet-de-synthese-2017 | b65a4da9a9a637d57631d843e647a700c51db5e3 | c584c789bb91be59e068524412617f4ab52263f7 | refs/heads/master | 2021-08-31T14:32:08.517742 | 2017-12-21T17:49:43 | 2017-12-21T17:49:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,170 | cpp | #include "ExpertFormeComposee.h"
#include "ExpertCercle.h"
#include "ExpertSegment.h"
#include "ExpertPolygone.h"
#include <fstream>
ExpertChargement* ExpertFormeComposee::initExpert() const
{
ExpertChargement* expert;
ExpertCercle * expertCercle;
ExpertPolygone* expertPolygone;
ExpertFormeComposee* expertFormeComposee;
ExpertSegment * expertSegment;
expertSegment = new ExpertSegment(NULL);
expertFormeComposee = new ExpertFormeComposee(expertSegment);
expertPolygone = new ExpertPolygone(expertFormeComposee);
expertCercle = new ExpertCercle(expertPolygone);
expert = expertCercle;
return expert;
}
ExpertFormeComposee::ExpertFormeComposee(ExpertChargement * suivant) :ExpertChargement(suivant)
{
}
FormeComposee * ExpertFormeComposee::handle(const string & requete) const
{
cout << "Expert Composee" << endl;
vector<string> s = explode(requete, '|');
if (s[0] == "FormeComposee")
{
FormeComposee * fc = new FormeComposee(stoi(s[1]));
ExpertChargement * expert = initExpert();
for (int i = 2; i < s.size(); i++)
{
Forme * f = expert->charge(s[i]);
*fc += *f;
f = NULL;
}
return fc;
}
else return NULL;
}
| [
"alexandre.ludwig3@etu.univ-lorraine.fr"
] | alexandre.ludwig3@etu.univ-lorraine.fr |
022e508b580c70b3d6577c4b8723f845f5cd063f | 723df7eac9045b5c7a030425eaabefc040cac46d | /examples/brotli/main.cc | 32d8da414047a4c483ee0dda517d97c05138bfa7 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | sAlexander/wasm_bazel | f157dc1afb60c7b2a0269d7d86e65d8cd2af7b01 | 37a8edd64f5a36cbd74eb203b69e175de97e7a8e | refs/heads/main | 2023-03-27T19:55:50.479154 | 2021-03-26T17:15:45 | 2021-03-26T17:15:45 | 341,063,914 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,317 | cc | #include <iostream>
#include "brotli/encode.h"
#include "brotli/decode.h"
int main() {
std::string to_compress =
"hello world hello world hello world hello world hello world!";
// Welcome!
std::cout << "Brotli wasm_bazel example." << std::endl;
std::cout << "Compressing string \"" << to_compress << "\"" << std::endl;
// Encode.
std::cout << "** ENCODE **" << std::endl;
size_t encoded_size = 100;
uint8_t encoded[100];
bool encode_result = BrotliEncoderCompress(
BROTLI_DEFAULT_QUALITY, BROTLI_DEFAULT_WINDOW, BROTLI_DEFAULT_MODE,
to_compress.size(), (uint8_t *)to_compress.data(), &encoded_size, encoded);
std::cout << "BrotliEncoderCompress return value: " << encode_result << std::endl;
std::cout << "Compressed size: " << encoded_size
<< " (uncompressed size: " << to_compress.size() << ")"
<< std::endl;
// Decode.
std::cout << "** DECODE **" << std::endl;
size_t decoded_size = 100;
uint8_t decoded[100];
auto decode_result = BrotliDecoderDecompress(
encoded_size, encoded, &decoded_size, decoded);
std::string decoded_string((char*)decoded, decoded_size);
std::cout << "BrotliDecoderDecompress return value: " << decode_result << std::endl;
std::cout << "Decoded string: \"" << decoded_string << "\"" << std::endl;
}
| [
"spencer.r.alexander@gmail.com"
] | spencer.r.alexander@gmail.com |
2b4396eda9f5812071717715f3f1bc29f8b2c675 | 5838cf8f133a62df151ed12a5f928a43c11772ed | /NT/base/fs/sis/groveler/etimer.cpp | 95c666bf0bffdb498a8cd1a292a85c9c61f35d60 | [] | no_license | proaholic/Win2K3 | e5e17b2262f8a2e9590d3fd7a201da19771eb132 | 572f0250d5825e7b80920b6610c22c5b9baaa3aa | refs/heads/master | 2023-07-09T06:15:54.474432 | 2021-08-11T09:09:14 | 2021-08-11T09:09:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,883 | cpp | /*++
Copyright (c) 1998 Microsoft Corporation
Module Name:
etimer.cpp
Abstract:
SIS Groveler event timer
Authors:
John Douceur, 1998
Environment:
User Mode
Revision History:
--*/
#include "all.hxx"
#define NEW_HeapSegment(segment_size) \
((HeapSegment *)(new BYTE[sizeof(HeapSegment) + \
((segment_size) - 1) * sizeof(Event)]))
#define DELETE_HeapSegment(heap_segment) delete[] ((BYTE *)(heap_segment))
EventTimer::EventTimer()
{
ASSERT(this != 0);
first_segment = NEW_HeapSegment(1);
first_segment->previous = 0;
first_segment->next = 0;
last_segment = first_segment;
population = 0;
segment_size = 1;
heap_ok = false;
}
EventTimer::~EventTimer()
{
ASSERT(this != 0);
ASSERT(first_segment != 0);
ASSERT(last_segment != 0);
ASSERT(population >= 0);
ASSERT(segment_size > 0);
ASSERT((segment_size & (segment_size - 1)) == 0); // power of 2
ASSERT(population >= segment_size - 1);
ASSERT(!heap_ok || population >= segment_size);
ASSERT(population < 2 * segment_size);
ASSERT(first_segment != last_segment || segment_size == 1);
ASSERT(first_segment == last_segment || segment_size > 1);
while (first_segment != 0)
{
HeapSegment *next_segment = first_segment->next;
ASSERT(first_segment != 0);
DELETE_HeapSegment(first_segment);
first_segment = next_segment;
}
}
void
EventTimer::run()
{
ASSERT(this != 0);
running = true;
while (running && population > 0)
{
ASSERT(first_segment != 0);
ASSERT(last_segment != 0);
ASSERT(population >= 0);
ASSERT(segment_size > 0);
ASSERT((segment_size & (segment_size - 1)) == 0); // power of 2
ASSERT(population >= segment_size - 1);
ASSERT(!heap_ok || population >= segment_size);
ASSERT(population < 2 * segment_size);
ASSERT(first_segment != last_segment || segment_size == 1);
ASSERT(first_segment == last_segment || segment_size > 1);
if (!heap_ok)
{
int final_position = (population + 1) % segment_size;
unsigned int final_time =
last_segment->events[final_position].event_time;
HeapSegment *segment = first_segment;
HeapSegment *next_segment = segment->next;
int position = 0;
int next_position = 0;
while (segment != last_segment
&& (next_segment != last_segment
|| next_position < final_position))
{
if ((next_segment != last_segment ||
next_position + 1 < final_position) &&
signed(next_segment->events[next_position].event_time -
next_segment->events[next_position + 1].event_time) > 0)
{
next_position++;
}
if (signed(final_time -
next_segment->events[next_position].event_time) <= 0)
{
break;
}
segment->events[position] = next_segment->events[next_position];
segment = next_segment;
next_segment = segment->next;
position = next_position;
next_position = 2 * position;
}
segment->events[position] = last_segment->events[final_position];
if (population < segment_size)
{
segment_size /= 2;
last_segment = last_segment->previous;
}
heap_ok = true;
}
ASSERT(first_segment != 0);
ASSERT(last_segment != 0);
ASSERT(population >= 0);
ASSERT(segment_size > 0);
ASSERT((segment_size & (segment_size - 1)) == 0); // power of 2
ASSERT(population >= segment_size - 1);
ASSERT(!heap_ok || population >= segment_size);
ASSERT(population < 2 * segment_size);
ASSERT(first_segment != last_segment || segment_size == 1);
ASSERT(first_segment == last_segment || segment_size > 1);
unsigned int current_time = GET_TICK_COUNT();
int sleep_time = __max(
signed(first_segment->events[0].event_time - current_time), 0);
do
{
bool event_triggered = sync_event.wait(sleep_time);
if (event_triggered)
{
SERVICE_FOLLOW_COMMAND();
if (!running)
{
return;
}
}
current_time = GET_TICK_COUNT();
sleep_time = __max(
signed(first_segment->events[0].event_time - current_time), 0);
} while (sleep_time > 0);
heap_ok = false;
population--;
(*first_segment->events[0].callback)(first_segment->events[0].context);
bool ok = shared_data->send_values();
if (!ok)
{
PRINT_DEBUG_MSG((_T("GROVELER: SharedData::send_values() failed\n")));
}
}
}
void
EventTimer::halt()
{
ASSERT(this != 0);
ASSERT(first_segment != 0);
ASSERT(last_segment != 0);
ASSERT(population >= 0);
ASSERT(segment_size > 0);
ASSERT((segment_size & (segment_size - 1)) == 0); // power of 2
ASSERT(population >= segment_size - 1);
ASSERT(!heap_ok || population >= segment_size);
ASSERT(population < 2 * segment_size);
ASSERT(first_segment != last_segment || segment_size == 1);
ASSERT(first_segment == last_segment || segment_size > 1);
running = false;
}
void
EventTimer::schedule(
unsigned int event_time,
void *context,
EventCallback callback)
{
ASSERT(this != 0);
ASSERT(first_segment != 0);
ASSERT(last_segment != 0);
ASSERT(population >= 0);
ASSERT(segment_size > 0);
ASSERT((segment_size & (segment_size - 1)) == 0); // power of 2
ASSERT(population >= segment_size - 1);
ASSERT(!heap_ok || population >= segment_size);
ASSERT(population < 2 * segment_size);
ASSERT(first_segment != last_segment || segment_size == 1);
ASSERT(first_segment == last_segment || segment_size > 1);
population++;
HeapSegment *segment;
int position;
if (heap_ok)
{
if (population >= 2 * segment_size)
{
segment_size *= 2;
if (last_segment->next == 0)
{
last_segment->next = NEW_HeapSegment(segment_size);
last_segment->next->previous = last_segment;
last_segment->next->next = 0;
}
last_segment = last_segment->next;
}
segment = last_segment;
HeapSegment *previous_segment = segment->previous;
position = population % segment_size;
int next_position = position >> 1;
while (previous_segment != 0 && signed(event_time
- previous_segment->events[next_position].event_time) < 0)
{
segment->events[position] = previous_segment->events[next_position];
segment = previous_segment;
previous_segment = segment->previous;
position = next_position;
next_position >>= 1;
}
}
else
{
int final_position = population % segment_size + 1;
segment = first_segment;
HeapSegment *next_segment = segment->next;
position = 0;
int next_position = 0;
while (segment != last_segment
&& (next_segment != last_segment
|| next_position < final_position))
{
if ((next_segment != last_segment ||
next_position + 1 < final_position) &&
signed(next_segment->events[next_position].event_time -
next_segment->events[next_position + 1].event_time) > 0)
{
next_position++;
}
if (signed(event_time -
next_segment->events[next_position].event_time) <= 0)
{
break;
}
segment->events[position] = next_segment->events[next_position];
segment = next_segment;
next_segment = segment->next;
position = next_position;
next_position = 2 * position;
}
}
segment->events[position].event_time = event_time;
segment->events[position].context = context;
segment->events[position].callback = callback;
heap_ok = true;
ASSERT(first_segment != 0);
ASSERT(last_segment != 0);
ASSERT(population >= 0);
ASSERT(segment_size > 0);
ASSERT((segment_size & (segment_size - 1)) == 0); // power of 2
ASSERT(population >= segment_size);
ASSERT(population < 2 * segment_size);
ASSERT(first_segment != last_segment || segment_size == 1);
ASSERT(first_segment == last_segment || segment_size > 1);
return;
}
| [
"blindtiger@foxmail.com"
] | blindtiger@foxmail.com |
562165e33ee432706e2c7437dcf57a531314b2ae | 49fac4986eb2c78a7b2dc15eb5bf4471bd29d3ae | /tags/FRAMEWAVE_1.1_BETA-old/Framewave/domain/fwVideo/src/AANIDCT.cpp | 60c9dea8ba7c8f243ecf9945fb02e3a952f58463 | [
"Apache-2.0"
] | permissive | imazen/framewave | 1f2f427cc8a4ff3a4d02b619c2f32fe7693039d8 | e6390439955a103d5a97d1568a99d3e02a11376d | refs/heads/master | 2021-01-24T14:56:16.069570 | 2014-10-23T21:55:58 | 2014-10-23T21:55:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 25,915 | cpp | /*
Copyright (c) 2006-2008 Advanced Micro Devices, Inc. All Rights Reserved.
This software is subject to the Apache v2.0 License.
*/
/*******************************************************/
#include "fwdev.h"
#include "FwSharedCode.h"
#include "FwSharedCode_SSE2.h"
#include "fwVideo.h"
#include "system.h"
using namespace OPT_LEVEL;
extern SYS_FORCEALIGN_16 const Fw16s idct_weighting[];
extern const float idct_coefficients[8][8];
static void Idct(const float c[8][8], const Fw16s *pSrc, Fw16s *pDst)
{
int i, j, k;
float partialProduct;
float tmp[64];
for (i=0; i<8; i++)
for (j=0; j<8; j++)
{
partialProduct = 0.0;
for (k=0; k<8; k++)
partialProduct+= c[k][j]*pSrc[8*i+k];
tmp[8*i+j] = partialProduct;
}
// Transpose operation is integrated into address mapping by switching
// loop order of i and j
for (j=0; j<8; j++)
for (i=0; i<8; i++)
{
partialProduct = 0.0;
for (k=0; k<8; k++)
partialProduct+= c[k][i]*tmp[8*k+j];
//v = CBL_LIBRARY::Limits<int>::Sat(floor(partialProduct+0.5));
//pDst[8*i+j] = (Fw16s) CBL_LIBRARY::Limits<Fw16s>::Sat(v);
pDst[8*i+j] = (Fw16s) CBL_LIBRARY::Limits<Fw16s>::Sat(floor(partialProduct+0.5));
}
}
/**
* performs AAN IDCT using SSE2
*
* Assumes destination is aligned on a 16-byte boundary
*/
SYS_INLINE static FwStatus My_idct_SSE2(const Fw16s* pSrc, Fw16s* pDst, Fw32s count)
{
count = count;//in the future we will use count. For the time being make the compiler happy
__m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
__m128i xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15;
Fw16s *peax = (Fw16s*)pSrc;
Fw16s *pedx = pDst;
const Fw16s *pesi, *pecx;
pesi = idct_weighting;
pecx = idct_weighting+64;
const bool bSrcIsAligned = FW_REF::IsAligned(peax, 16);
if(bSrcIsAligned)
{
xmm0 = _mm_load_si128((__m128i *)(peax));
xmm4 = _mm_load_si128((__m128i *)(peax+16));
xmm8 = _mm_load_si128((__m128i *)(peax+32));
xmm12 = _mm_load_si128((__m128i *)(peax+48));
}
else
{
xmm0 = _mm_loadu_si128((__m128i *)(peax));
xmm4 = _mm_loadu_si128((__m128i *)(peax+16));
xmm8 = _mm_loadu_si128((__m128i *)(peax+32));
xmm12 = _mm_loadu_si128((__m128i *)(peax+48));
}
// DCT_8_INV_ROW //Row 1, tab_i_04 and Row 3, tab_i_26
xmm0 = _mm_shufflelo_epi16(xmm0, 0xD8);
// DCT_8_INV_ROW //Row 5, tab_i_04 and Row 7, tab_i_26
xmm8 = _mm_shufflelo_epi16(xmm8, 0xD8);
xmm0 = _mm_shufflehi_epi16 (xmm0, 0xD8);
xmm8 = _mm_shufflehi_epi16 (xmm8, 0xD8);
xmm3 = _mm_shuffle_epi32 (xmm0, 0x55) ;
xmm11 = _mm_shuffle_epi32 (xmm8, 0x55) ;
xmm1 = _mm_shuffle_epi32 (xmm0, 0) ;
xmm9 = _mm_shuffle_epi32 (xmm8, 0) ;
xmm2 = _mm_shuffle_epi32 (xmm0, 0xAA) ;
xmm10 = _mm_shuffle_epi32 (xmm8, 0xAA) ;
xmm0 = _mm_shuffle_epi32 (xmm0, 0xFF) ;
xmm8 = _mm_shuffle_epi32 (xmm8, 0xFF) ;
xmm1 = _mm_madd_epi16(xmm1, _mm_load_si128((__m128i *)(pesi)));
xmm9 = _mm_madd_epi16(xmm9, _mm_load_si128((__m128i *)(pesi)));
xmm2 = _mm_madd_epi16(xmm2, _mm_load_si128((__m128i *)(pesi+8)));
xmm10 = _mm_madd_epi16(xmm10, _mm_load_si128((__m128i *)(pesi+8)));
xmm3 = _mm_madd_epi16(xmm3, _mm_load_si128((__m128i *)(pesi+16)));
xmm11 = _mm_madd_epi16(xmm11, _mm_load_si128((__m128i *)(pesi+16)));
xmm0 = _mm_madd_epi16(xmm0, _mm_load_si128((__m128i *)(pesi+24)));
xmm8 = _mm_madd_epi16(xmm8, _mm_load_si128((__m128i *)(pesi+24)));
xmm0 = _mm_add_epi32(xmm0, xmm3);
xmm8 = _mm_add_epi32(xmm8, xmm11);
xmm4 = _mm_shufflelo_epi16(xmm4, 0xD8);
xmm12 = _mm_shufflelo_epi16(xmm12, 0xD8);
xmm4 = _mm_shufflehi_epi16 (xmm4, 0xD8);
xmm12 = _mm_shufflehi_epi16 (xmm12, 0xD8);
xmm7 = _mm_set1_epi32 (0x800); // rounding
xmm15 = _mm_set1_epi32 (0x800); // rounding
xmm1 = _mm_add_epi32(xmm1, xmm7);
xmm9 = _mm_add_epi32(xmm9, xmm15);
xmm6 = _mm_shuffle_epi32 (xmm4, 0xAA) ;
xmm14 = _mm_shuffle_epi32 (xmm12, 0xAA) ;
xmm5 = _mm_shuffle_epi32 (xmm4, 0) ;
xmm13 = _mm_shuffle_epi32 (xmm12, 0) ;
xmm5 = _mm_madd_epi16(xmm5, _mm_load_si128((__m128i *)(pecx)));
xmm13 = _mm_madd_epi16(xmm13, _mm_load_si128((__m128i *)(pecx)));
xmm5 = _mm_add_epi32(xmm5, xmm7);
xmm13 = _mm_add_epi32(xmm13, xmm15);
xmm6 = _mm_madd_epi16(xmm6, _mm_load_si128((__m128i *)(pecx+8)));
xmm14 = _mm_madd_epi16(xmm14, _mm_load_si128((__m128i *)(pecx+8)));
xmm7 = _mm_shuffle_epi32 (xmm4, 0x55) ;
xmm15 = _mm_shuffle_epi32 (xmm12, 0x55) ;
xmm7 = _mm_madd_epi16(xmm7, _mm_load_si128((__m128i *)(pecx+16)));
xmm15 = _mm_madd_epi16(xmm15, _mm_load_si128((__m128i *)(pecx+16)));
xmm4 = _mm_shuffle_epi32 (xmm4, 0xFF) ;
xmm12 = _mm_shuffle_epi32 (xmm12, 0xFF) ;
xmm4 = _mm_madd_epi16(xmm4, _mm_load_si128((__m128i *)(pecx+24)));
xmm12 = _mm_madd_epi16(xmm12, _mm_load_si128((__m128i *)(pecx+24)));
xmm1 = _mm_add_epi32(xmm1, xmm2);
xmm9 = _mm_add_epi32(xmm9, xmm10);
xmm2 = xmm1 ;
xmm10 = xmm9 ;
xmm2 = _mm_sub_epi32(xmm2, xmm0);
xmm10 = _mm_sub_epi32(xmm10, xmm8);
xmm2 = _mm_srai_epi32(xmm2, 12);
xmm10 = _mm_srai_epi32(xmm10, 12);
xmm2 = _mm_shuffle_epi32 (xmm2, 0x1B) ;
xmm10 = _mm_shuffle_epi32 (xmm10, 0x1B) ;
xmm0 = _mm_add_epi32(xmm0, xmm1);
xmm8 = _mm_add_epi32(xmm8, xmm9);
xmm0 = _mm_srai_epi32(xmm0, 12);
xmm8 = _mm_srai_epi32(xmm8, 12);
xmm5 = _mm_add_epi32(xmm5, xmm6);
xmm13 = _mm_add_epi32(xmm13, xmm14);
xmm0 = _mm_packs_epi32(xmm0, xmm2);
xmm8 = _mm_packs_epi32(xmm8, xmm10);
xmm4 = _mm_add_epi32(xmm4, xmm7);
xmm12 = _mm_add_epi32(xmm12, xmm15);
xmm6 = xmm5;
xmm14 = xmm13;
xmm6 = _mm_sub_epi32(xmm6, xmm4);
xmm14 = _mm_sub_epi32(xmm14, xmm12);
xmm6 = _mm_srai_epi32(xmm6, 12);
xmm14 = _mm_srai_epi32(xmm14, 12);
xmm4 = _mm_add_epi32(xmm4, xmm5);
xmm12 = _mm_add_epi32(xmm12, xmm13);
xmm4 = _mm_srai_epi32(xmm4, 12);
xmm12 = _mm_srai_epi32(xmm12, 12);
xmm6 = _mm_shuffle_epi32 (xmm6, 0x1B) ;
xmm14 = _mm_shuffle_epi32 (xmm14, 0x1B) ;
xmm4 = _mm_packs_epi32(xmm4, xmm6);
xmm12 = _mm_packs_epi32(xmm12, xmm14);
_mm_store_si128((__m128i *)pedx, xmm0);
_mm_store_si128((__m128i *)(pedx+16), xmm4);
_mm_store_si128((__m128i *)(pedx+32), xmm8);
_mm_store_si128((__m128i *)(pedx+48), xmm12);
if(bSrcIsAligned)
{
xmm8 = _mm_load_si128((__m128i *)(peax+24));
}
else
{
xmm8 = _mm_loadu_si128((__m128i *)(peax+24));
}
pesi = idct_weighting + 96;
if(bSrcIsAligned)
{
xmm12 = _mm_load_si128((__m128i *)(peax+8));
}
else
{
xmm12 = _mm_loadu_si128((__m128i *)(peax+8));
}
pecx = idct_weighting + 32;
// DCT_8_INV_ROW //Row 4, tab_i_35 and Row 2, tab_i_17
xmm8 = _mm_shufflelo_epi16(xmm8, 0xD8);
xmm8 = _mm_shufflehi_epi16 (xmm8, 0xD8);
xmm11 = _mm_shuffle_epi32 (xmm8, 0x55) ;
xmm9 = _mm_shuffle_epi32 (xmm8, 0) ;
xmm10 = _mm_shuffle_epi32 (xmm8, 0xAA) ;
xmm8 = _mm_shuffle_epi32 (xmm8, 0xFF) ;
xmm9 = _mm_madd_epi16(xmm9, _mm_load_si128((__m128i *)(pesi)));
xmm10 = _mm_madd_epi16(xmm10, _mm_load_si128((__m128i *)(pesi+8)));
xmm11 = _mm_madd_epi16(xmm11, _mm_load_si128((__m128i *)(pesi+16)));
xmm8 = _mm_madd_epi16(xmm8, _mm_load_si128((__m128i *)(pesi+24)));
xmm8 = _mm_add_epi32(xmm8, xmm11);
xmm12 = _mm_shufflelo_epi16(xmm12, 0xD8);
xmm12 = _mm_shufflehi_epi16 (xmm12, 0xD8);
xmm15 = _mm_set1_epi32 (0x800); // rounding
xmm9 = _mm_add_epi32(xmm9, xmm15);
xmm14 = _mm_shuffle_epi32 (xmm12, 0xAA) ;
xmm13 = _mm_shuffle_epi32 (xmm12, 0) ;
xmm13 = _mm_madd_epi16(xmm13, _mm_load_si128((__m128i *)(pecx)));
xmm13 = _mm_add_epi32(xmm13, xmm15);
xmm14 = _mm_madd_epi16(xmm14, _mm_load_si128((__m128i *)(pecx+8)));
xmm15 = _mm_shuffle_epi32 (xmm12, 0x55) ;
xmm15 = _mm_madd_epi16(xmm15, _mm_load_si128((__m128i *)(pecx+16)));
xmm12 = _mm_shuffle_epi32 (xmm12, 0xFF) ;
xmm12 = _mm_madd_epi16(xmm12, _mm_load_si128((__m128i *)(pecx+24)));
xmm9 = _mm_add_epi32(xmm9, xmm10);
xmm10 = xmm9 ;
xmm10 = _mm_sub_epi32(xmm10, xmm8);
xmm10 = _mm_srai_epi32(xmm10, 12);
xmm10 = _mm_shuffle_epi32 (xmm10, 0x1B) ;
xmm8 = _mm_add_epi32(xmm8, xmm9);
xmm8 = _mm_srai_epi32(xmm8, 12);
xmm13 = _mm_add_epi32(xmm13, xmm14);
xmm8 = _mm_packs_epi32(xmm8, xmm10);
xmm12 = _mm_add_epi32(xmm12, xmm15);
xmm14 = xmm13;
xmm14 = _mm_sub_epi32(xmm14, xmm12);
xmm14 = _mm_srai_epi32(xmm14, 12);
xmm12 = _mm_add_epi32(xmm12, xmm13);
xmm12 = _mm_srai_epi32(xmm12, 12);
xmm14 = _mm_shuffle_epi32 (xmm14, 0x1B) ;
xmm12 = _mm_packs_epi32(xmm12, xmm14);
_mm_store_si128((__m128i *)(pedx+24), xmm8);
if(bSrcIsAligned)
{
xmm0 = _mm_load_si128((__m128i *)(peax+40));
}
else
{
xmm0 = _mm_loadu_si128((__m128i *)(peax+40));
}
_mm_store_si128((__m128i *)(pedx+8), xmm12);
if(bSrcIsAligned)
{
xmm4 = _mm_load_si128((__m128i *)(peax+56));
}
else
{
xmm4 = _mm_loadu_si128((__m128i *)(peax+56));
}
// DCT_8_INV_ROW //Row 6, tab_i_35 and Row 8, tab_i_17
xmm0 = _mm_shufflelo_epi16(xmm0, 0xD8);
xmm0 = _mm_shufflehi_epi16 (xmm0, 0xD8);
xmm3 = _mm_shuffle_epi32 (xmm0, 0x55) ;
xmm1 = _mm_shuffle_epi32 (xmm0, 0) ;
xmm2 = _mm_shuffle_epi32 (xmm0, 0xAA) ;
xmm0 = _mm_shuffle_epi32 (xmm0, 0xFF) ;
xmm1 = _mm_madd_epi16(xmm1, _mm_load_si128((__m128i *)(pesi)));
xmm2 = _mm_madd_epi16(xmm2, _mm_load_si128((__m128i *)(pesi+8)));
xmm3 = _mm_madd_epi16(xmm3, _mm_load_si128((__m128i *)(pesi+16)));
xmm0 = _mm_madd_epi16(xmm0, _mm_load_si128((__m128i *)(pesi+24)));
xmm0 = _mm_add_epi32(xmm0, xmm3);
xmm4 = _mm_shufflelo_epi16(xmm4, 0xD8);
xmm4 = _mm_shufflehi_epi16 (xmm4, 0xD8);
xmm7 = _mm_set1_epi32 (0x800); // rounding
xmm1 = _mm_add_epi32(xmm1, xmm7);
xmm6 = _mm_shuffle_epi32 (xmm4, 0xAA) ;
xmm5 = _mm_shuffle_epi32 (xmm4, 0) ;
xmm5 = _mm_madd_epi16(xmm5, _mm_load_si128((__m128i *)(pecx)));
xmm5 = _mm_add_epi32(xmm5, xmm7);
xmm6 = _mm_madd_epi16(xmm6, _mm_load_si128((__m128i *)(pecx+8)));
xmm7 = _mm_shuffle_epi32 (xmm4, 0x55) ;
xmm7 = _mm_madd_epi16(xmm7, _mm_load_si128((__m128i *)(pecx+16)));
xmm4 = _mm_shuffle_epi32 (xmm4, 0xFF) ;
xmm4 = _mm_madd_epi16(xmm4, _mm_load_si128((__m128i *)(pecx+24)));
xmm1 = _mm_add_epi32(xmm1, xmm2);
xmm2 = xmm1 ;
xmm2 = _mm_sub_epi32(xmm2, xmm0);
xmm2 = _mm_srai_epi32(xmm2, 12);
xmm2 = _mm_shuffle_epi32 (xmm2, 0x1B) ;
xmm0 = _mm_add_epi32(xmm0, xmm1);
xmm0 = _mm_srai_epi32(xmm0, 12);
xmm5 = _mm_add_epi32(xmm5, xmm6);
xmm0 = _mm_packs_epi32(xmm0, xmm2);
xmm4 = _mm_add_epi32(xmm4, xmm7);
xmm6 = xmm5;
xmm6 = _mm_sub_epi32(xmm6, xmm4);
xmm6 = _mm_srai_epi32(xmm6, 12);
xmm4 = _mm_add_epi32(xmm4, xmm5);
xmm4 = _mm_srai_epi32(xmm4, 12);
xmm6 = _mm_shuffle_epi32 (xmm6, 0x1B) ;
xmm4 = _mm_packs_epi32(xmm4, xmm6);
// DCT_8_INV_COL_8
xmm6 = xmm4;
xmm2 = xmm0;
xmm3 = _mm_load_si128((__m128i *)(pedx+24));
xmm1 = _mm_load_si128((__m128i *)(idct_weighting+144));
xmm0 = _mm_mulhi_epi16(xmm0, xmm1);
xmm5 = _mm_load_si128((__m128i *)(idct_weighting+128));
xmm1 = _mm_mulhi_epi16(xmm1, xmm3);
xmm1 = _mm_adds_epi16(xmm1, xmm3);
xmm4 = _mm_mulhi_epi16(xmm4, xmm5);
xmm7 = _mm_load_si128((__m128i *)(pedx+48));
xmm5 = _mm_mulhi_epi16(xmm5, _mm_load_si128((__m128i *)(pedx+8)));
xmm5 = _mm_subs_epi16(xmm5, xmm6);
xmm6 = xmm5;
xmm4 = _mm_adds_epi16(xmm4, _mm_load_si128((__m128i *)(pedx+8)));
xmm0 = _mm_adds_epi16(xmm0, xmm2);
xmm0 = _mm_adds_epi16(xmm0, xmm3);
xmm2 = _mm_subs_epi16(xmm2, xmm1);
xmm1 = xmm0;
xmm3 = _mm_load_si128((__m128i *)(idct_weighting+136));
xmm7 = _mm_mulhi_epi16(xmm7, xmm3);
xmm3 = _mm_mulhi_epi16(xmm3, _mm_load_si128((__m128i *)(pedx+16)));
xmm0 = _mm_adds_epi16(xmm0, xmm4);
xmm4 = _mm_subs_epi16(xmm4, xmm1);
xmm0 = _mm_adds_epi16(xmm0, _mm_set1_epi16 (1));
_mm_store_si128((__m128i *)(pedx+56), xmm0);
xmm5 = _mm_subs_epi16(xmm5, xmm2);
xmm5 = _mm_adds_epi16(xmm5, _mm_set1_epi16 (1));
xmm6 = _mm_adds_epi16(xmm6, xmm2);
_mm_store_si128((__m128i *)(pedx+24), xmm6);
xmm1 = xmm4;
xmm0 = _mm_load_si128((__m128i *)(idct_weighting+152));
xmm2 = xmm0;
xmm4 = _mm_adds_epi16(xmm4, xmm5);
xmm1 = _mm_subs_epi16(xmm1, xmm5);
xmm7 = _mm_adds_epi16(xmm7, _mm_load_si128((__m128i *)(pedx+16)));
xmm3 = _mm_subs_epi16(xmm3, _mm_load_si128((__m128i *)(pedx+48)));
xmm6 = _mm_load_si128((__m128i *)(pedx));
xmm0 = _mm_mulhi_epi16(xmm0, xmm1);
xmm5 = _mm_load_si128((__m128i *)(pedx+32));
xmm5 = _mm_adds_epi16(xmm5, xmm6);
xmm6 = _mm_subs_epi16(xmm6, _mm_load_si128((__m128i *)(pedx+32)));
xmm2 = _mm_mulhi_epi16(xmm2, xmm4);
xmm4 = _mm_adds_epi16(xmm4, xmm2);
xmm2 = xmm5;
xmm2 = _mm_subs_epi16(xmm2, xmm7);
xmm4 = _mm_or_si128(xmm4, _mm_set1_epi16 (1));
xmm0 = _mm_adds_epi16(xmm0, xmm1);
xmm0 = _mm_or_si128(xmm0, _mm_set1_epi16 (1));
xmm5 = _mm_adds_epi16(xmm5, xmm7);
xmm5 = _mm_adds_epi16(xmm5, _mm_set1_epi16 (16));
xmm1 = xmm6;
xmm7 = _mm_load_si128((__m128i *)(pedx+56));
xmm7 = _mm_adds_epi16(xmm7, xmm5);
xmm7 = _mm_srai_epi16(xmm7, 5);
_mm_store_si128((__m128i *)(pedx), xmm7);
xmm6 = _mm_adds_epi16(xmm6, xmm3);
xmm6 = _mm_adds_epi16(xmm6, _mm_set1_epi16 (16));
xmm1 = _mm_subs_epi16(xmm1, xmm3);
xmm1 = _mm_adds_epi16(xmm1, _mm_set1_epi16 (15));
xmm7 = xmm1;
xmm3 = xmm6;
xmm6 = _mm_adds_epi16(xmm6, xmm4);
xmm2 = _mm_adds_epi16(xmm2, _mm_set1_epi16 (15));
xmm6 = _mm_srai_epi16(xmm6, 5);
_mm_store_si128((__m128i *)(pedx+8), xmm6);
xmm1 = _mm_adds_epi16(xmm1, xmm0);
xmm1 = _mm_srai_epi16(xmm1, 5);
_mm_store_si128((__m128i *)(pedx+16), xmm1);
xmm1 = _mm_load_si128((__m128i *)(pedx+24));
xmm6 = xmm1;
xmm7 = _mm_subs_epi16(xmm7, xmm0);
xmm7 = _mm_srai_epi16(xmm7, 5);
_mm_store_si128((__m128i *)(pedx+40), xmm7);
xmm5 = _mm_subs_epi16(xmm5, _mm_load_si128((__m128i *)(pedx+56)));
xmm5 = _mm_srai_epi16(xmm5, 5);
_mm_store_si128((__m128i *)(pedx+56), xmm5);
xmm3 = _mm_subs_epi16(xmm3, xmm4);
xmm6 = _mm_adds_epi16(xmm6, xmm2);
xmm2 = _mm_subs_epi16(xmm2, xmm1);
xmm6 = _mm_srai_epi16(xmm6, 5);
_mm_store_si128((__m128i *)(pedx+24), xmm6);
xmm2 = _mm_srai_epi16(xmm2, 5);
_mm_store_si128((__m128i *)(pedx+32), xmm2);
xmm3 = _mm_srai_epi16(xmm3, 5);
_mm_store_si128((__m128i *)(pedx+48), xmm3);
return(fwStsNoErr);
}
/**
* Performs inverse DCT on pre-transposed block.
*
* @param pSrc Pointer to the block of DCT coefficients.
* @param pDst Pointer to the destination array.
* @param dstStep Step of the destination array.
* @param count Number of the last non-zero coefficient in zig-zag order. If the block contains
* no non-zero coefficients, pass the value -1.
*
* This function is declared in the fwVideo.h header file. The function fwiDCT8x8Inv_AANTransposed_16s_C1R
* is used for non-intra macroblocks and performs inverse DCT on a transposed block. The block is transposed
* during the rearranging stage of VLC decoding, using the transposed scanning matrix as scanMatrix argument
* of the functions ReconstructDCTBlock_MPEG1 and ReconstructDCTBlock_MPEG2.
*
* @return fwStsNoErr Indicates no error. fwStsNullPtrErr Indicates an error when at least one input pointer is NULL.
*/
FwStatus STDCALL PREFIX_OPT(OPT_PREFIX, fwiDCT8x8Inv_AANTransposed_16s_C1R)(const Fw16s* pSrc, Fw16s* pDst, Fw32s dstStep, Fw32s count)
{
if(FW_REF::PtrNotOK(pSrc, pDst))return fwStsNullPtrErr;
SYS_FORCEALIGN_16 Fw16s eightxEightDst[64];
Fw16s* pEightxEightDst = eightxEightDst;
bool isAligned;
__m128i reg;
switch(Dispatch::Type<DT_SSE2>())
{
case DT_SSE3:
case DT_SSE2:
My_idct_SSE2(pSrc, eightxEightDst, count);
for(int i=0;i<8;i++)
{
reg = _mm_load_si128((__m128i*)pEightxEightDst);
isAligned = FW_REF::IsAligned(pDst,16);
if(isAligned)
_mm_store_si128((__m128i*)pDst, reg);
else
_mm_storeu_si128((__m128i*)pDst, reg);
pDst = pDst + dstStep/2;
pEightxEightDst = pEightxEightDst + 8;
}
break;
default:
Idct(idct_coefficients, pSrc, eightxEightDst);
for(int i=0;i<8;i++)
{
for(int j=0;j<8;j++)
pDst[j] = pEightxEightDst[j];
pDst = pDst + dstStep/2;
pEightxEightDst = pEightxEightDst + 8;
}
}
return fwStsNoErr;
}
/**
* Performs inverse DCT on pre-transposed block and converts output to unsigned char format.
* @param pSrc Pointer to the block of DCT coefficients.
* @param pDst Pointer to the destination array.
* @param dstStep Step of the destination array.
* @param count Number of the last non-zero coefficient in zig-zag order. If the block contains
* no non-zero coefficients, pass the value -1.
*
*
* This function is declared in the fwVideo.h header file. The function fwiDCT8x8Inv_AANTransposed_16s8u_C1R
* is used for intra macroblocks. The function performs inverse DCT on a transposed block and converts the
* output to unsigned char format. The block is transposed during the rearranging stage of VCL decoding,
* using the transposed scanning matrix as scanMatrix argument of the functions ReconstructDCTBlockIntra_MPEG1
* and ReconstructDCTBlockIntra_MPEG2.
*
* @return fwStsNoErr Indicates no error.fwStsNullPtrErr Indicates an error when at least one input pointer is NULL.
*/
FwStatus STDCALL PREFIX_OPT(OPT_PREFIX, fwiDCT8x8Inv_AANTransposed_16s8u_C1R)(const Fw16s* pSrc, Fw8u* pDst, Fw32s dstStep, Fw32s count)
{
if(FW_REF::PtrNotOK(pSrc, pDst))return fwStsNullPtrErr;
SYS_FORCEALIGN_16 Fw16s eightxEightDst[64];
Fw16s* pEightxEightDst = eightxEightDst;
XMM128 reg1, reg2;
switch(Dispatch::Type<DT_SSE2>())
{
case DT_SSE3:
case DT_SSE2:
My_idct_SSE2(pSrc, eightxEightDst, count);
for(int i=0;i<4;i++)
{
reg1.i = _mm_load_si128((__m128i*)pEightxEightDst);
pEightxEightDst = pEightxEightDst + 8;
reg2.i = _mm_load_si128((__m128i*)pEightxEightDst);
pEightxEightDst = pEightxEightDst + 8;
reg1.i = _mm_packus_epi16(reg1.i, reg2.i);
*((Fw64s*)pDst) = reg1.s64[0];
pDst = pDst + dstStep;
*((Fw64s*)pDst) = reg1.s64[1];
pDst = pDst + dstStep;
}
break;
default:
Idct(idct_coefficients, pSrc, eightxEightDst);
for(int i=0;i<8;i++)
{
for(int j=0;j<8;j++)
pDst[j] = CBL_LIBRARY::Limits<Fw8u>::Sat(pEightxEightDst[j]);
pDst = pDst + dstStep;
pEightxEightDst = pEightxEightDst + 8;
}
}
return fwStsNoErr;
}
/**
* Performs inverse DCT on pre-transposed data of two input chroma blocks and joins the output data into one
* array.
*
* @param pSrcU Pointer to the block of DCT coefficients for U component.
* @param pSrcV Pointer to the block of DCT coefficients for V component.
* @param pDstUV Pointer to the destination array.
* @param dstStep Step of the destination array.
* @param countU Number of the last non-zero U coefficient in zig-zag order. If the block contains no non-zero
* coefficients, pass the value -1.
* @param countV Number of the last non-zero V coefficient in zig-zag order. If the block contains no non-zero
* coefficients, pass the value -1.
*
* This function is declared in the fwVideo.h header file. The function fwiDCT8x8Inv_AANTransposed_16s_P2C2R is
* used for non-intra macroblocks.
* The function performs inverse DCT on a transposed U-block and a transposed V-block and joins the output data
* into one UV Block. The blocks are transposed during the rearranging stage of VCL decoding, using the
* transposed scanning matrix as scanMatrix argument of the functions ReconstructDCTBlock_MPEG1 and
* ReconstructDCTBlock_MPEG2.
* @return fwStsNoErr Indicates no error. fwStsNullPtrErr Indicates an error when at least one input pointer is NULL.
*/
FwStatus STDCALL PREFIX_OPT(OPT_PREFIX, fwiDCT8x8Inv_AANTransposed_16s_P2C2R)(const Fw16s* pSrcU, const Fw16s* pSrcV, Fw16s* pDstUV, Fw32s dstStep, Fw32s countU, Fw32s countV)
{
if(FW_REF::PtrNotOK(pSrcU, pSrcV, pDstUV))return fwStsNullPtrErr;
SYS_FORCEALIGN_16 Fw16s eightxEightDstU[64];
SYS_FORCEALIGN_16 Fw16s eightxEightDstV[64];
Fw16s* pEightxEightDstU = eightxEightDstU;
Fw16s* pEightxEightDstV = eightxEightDstV;
__m128i reg1, reg2, reg3;
bool isAligned;
switch(Dispatch::Type<DT_SSE2>())
{
case DT_SSE3:
case DT_SSE2:
//perform the AAN IDCT twice, once for the U and once for the V components
My_idct_SSE2(pSrcU, eightxEightDstU, countU);//U
My_idct_SSE2(pSrcV, eightxEightDstV, countV);//V
for(int i=0;i<8;i++)
{
reg1 = _mm_load_si128((__m128i*)pEightxEightDstU);
reg2 = _mm_load_si128((__m128i*)pEightxEightDstV);
reg3 = _mm_unpacklo_epi16(reg1, reg2);
reg1 = _mm_unpackhi_epi16(reg1, reg2);
isAligned = FW_REF::IsAligned(pDstUV,16);
if(isAligned)
{
_mm_store_si128((__m128i*)pDstUV, reg3);
_mm_store_si128((((__m128i*)pDstUV) + 1), reg1);
}
else
{
_mm_storeu_si128((__m128i*)pDstUV, reg3);
_mm_storeu_si128((((__m128i*)pDstUV) + 1), reg1);
}
pDstUV = pDstUV + dstStep/2;
pEightxEightDstU = pEightxEightDstU + 8;
pEightxEightDstV = pEightxEightDstV + 8;
}
break;
default:
Idct(idct_coefficients, pSrcU, eightxEightDstU);
Idct(idct_coefficients, pSrcV, eightxEightDstV);
for(int i=0;i<8;i++)
{
for(int j=0,k=0;j<8;j++,k+=2)
{
pDstUV[k] = pEightxEightDstU[j];
pDstUV[k+1] = pEightxEightDstV[j];
}
pDstUV = pDstUV + dstStep/2;
pEightxEightDstU = pEightxEightDstU + 8;
pEightxEightDstV = pEightxEightDstV + 8;
}
}
return fwStsNoErr;
}
/**
* Performs inverse DCT on pre-transposed data of two input chroma blocks and joins the output data into one
* unsigned char array.
*
* @param pSrcU Pointer to the block of DCT coefficients for U component.
* @param pSrcV Pointer to the block of DCT coefficients for V component.
* @param pDstUV Pointer to the destination array.
* @param dstStep Step of the destination array.
* @param countU Number of the last non-zero U coefficient in zig-zag order. If the block contains no non-zero
* coefficients, pass the value -1.
* @param countV Number of the last non-zero V coefficient in zig-zag order. If the block contains no non-zero
* coefficients, pass the value -1.
*
* This function is declared in the fwVideo.h header file. The function fwiDCT8x8Inv_AANTransposed_16s8u_P2C2R is
* used for intra macroblocks. The function performs inverse DCT on a transposed U-block and a transposed V-block
* and joins the output data into one unsigned char UV Block. The blocks are transposed during the rearranging
* stage of VCL decoding, using the transposed scanning matrix as scanMatrix argument of the functions
* ReconstructDCTBlockIntra_MPEG1 and ReconstructDCTBlockIntra_MPEG2.
* @return fwStsNoErr Indicates no error. fwStsNullPtrErr Indicates an error when at least one input pointer is NULL.
*/
FwStatus STDCALL PREFIX_OPT(OPT_PREFIX, fwiDCT8x8Inv_AANTransposed_16s8u_P2C2R)(const Fw16s* pSrcU, const Fw16s* pSrcV, Fw8u* pDstUV, Fw32s dstStep, Fw32s countU, Fw32s countV)
{
if(FW_REF::PtrNotOK(pSrcU, pSrcV, pDstUV))return fwStsNullPtrErr;
SYS_FORCEALIGN_16 Fw16s eightxEightDstU[64];
SYS_FORCEALIGN_16 Fw16s eightxEightDstV[64];
Fw16s* pEightxEightDstU = eightxEightDstU;
Fw16s* pEightxEightDstV = eightxEightDstV;
__m128i reg1, reg2, reg3;
bool isAligned;
switch(Dispatch::Type<DT_SSE2>())
{
case DT_SSE3:
case DT_SSE2:
//perform the AAN IDCT twice, once for the U and once for the V components
My_idct_SSE2(pSrcU, eightxEightDstU, countU);//U
My_idct_SSE2(pSrcV, eightxEightDstV, countV);//V
for(int i=0;i<8;i++)
{
reg1 = _mm_load_si128((__m128i*)pEightxEightDstU);
reg2 = _mm_load_si128((__m128i*)pEightxEightDstV);
reg3 = _mm_unpacklo_epi16(reg1, reg2);
reg1 = _mm_unpackhi_epi16(reg1, reg2);
reg3 = _mm_packus_epi16(reg3, reg1);
isAligned = FW_REF::IsAligned(pDstUV,16);
if(isAligned)
_mm_store_si128((__m128i*)pDstUV, reg3);
else
_mm_storeu_si128((__m128i*)pDstUV, reg3);
pDstUV = pDstUV + dstStep;
pEightxEightDstU = pEightxEightDstU + 8;
pEightxEightDstV = pEightxEightDstV + 8;
}
break;
default:
Idct(idct_coefficients, pSrcU, eightxEightDstU);
Idct(idct_coefficients, pSrcV, eightxEightDstV);
for(int i=0;i<8;i++)
{
for(int j=0,k=0;j<8;j++,k+=2)
{
pDstUV[k] = CBL_LIBRARY::Limits<Fw8u>::Sat(pEightxEightDstU[j]);
pDstUV[k+1] = CBL_LIBRARY::Limits<Fw8u>::Sat(pEightxEightDstV[j]);
}
pDstUV = pDstUV + dstStep;
pEightxEightDstU = pEightxEightDstU + 8;
pEightxEightDstV = pEightxEightDstV + 8;
}
}
return fwStsNoErr;
}
// Please do NOT remove the above line for CPP files that need to be multipass compiled
// OREFR OSSE2
| [
"jalby@f364fc6c-7e41-0410-b16c-eb8c68fe7df8"
] | jalby@f364fc6c-7e41-0410-b16c-eb8c68fe7df8 |
aae988038203cc67a04e011e3c749d5b75f234cd | 12c4f7d9308b0b7285554eb311fd82bb3093202b | /lc0004_MedianTwoSortedArrays/lc0004.cc | 612851882355e0a7f4dbad2f024fdbf70a6f1b75 | [] | no_license | cgi0911/LeetCodePractice | b7d6ec5eded6eecc9f5c9a45dcfccf8cce8956ff | cd3900a7d91d1d94d308bc7a65533b8262781ee9 | refs/heads/master | 2021-01-18T19:57:06.360094 | 2017-09-24T02:09:41 | 2017-09-24T02:09:41 | 100,540,701 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 263 | cc | // LeetCode #4: Median of two sorted arrays
#include <iostream>
#include <vector>
#include <algorithm>
#include <random>
using namespace std;
double findMedian (vector<int> &a, vector<int> &b) {
int m = a.size ();
int n = b.size ();
}
int main () {
}
| [
"cgi0911@gmail.com"
] | cgi0911@gmail.com |
8edba380464018b518d9b2414f2a0a379f2b8440 | ae35ab4d2ce60e0efc72d4d3a6eb76bfacd7eef0 | /adult/scripts/08_history.swap.inc | c342a34618003bd5a5989492457761990e6cb983 | [] | no_license | qq674684107/hdp_ims | a72594e9ffa1019541eb1adfd842f1f386017a5e | f060203b5eef99295d86682c35be599c6cc42d31 | refs/heads/master | 2020-05-15T18:20:00.969739 | 2017-01-09T05:38:02 | 2017-01-09T05:38:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 39 | inc | ../../video/scripts/08_history.swap.inc | [
"ypchen@users.noreply.github.com"
] | ypchen@users.noreply.github.com |
66d4d2d167366dd3915baba4ae87d81ea14f4aba | 9b854d21fea95f24f7bde41e7a172e8a8a6327f9 | /tensorflow/core/common_runtime/gpu/gpu_init.h | e3981ebb652533edead6b2f2888c149460b56bcd | [
"Apache-2.0"
] | permissive | devsangwoo/tensor | 84345bb05d969c732f70a8a64f2d070bf71d1f9b | 066592c9f9cdf4acdd1b9b104766271133e9088e | refs/heads/master | 2022-12-09T00:33:43.272931 | 2015-11-07T00:27:58 | 2020-01-10T07:33:06 | 232,987,148 | 1 | 0 | NOASSERTION | 2022-10-04T23:56:16 | 2020-01-10T07:06:05 | C++ | UTF-8 | C++ | false | false | 2,272 | h | <<<<<<< HEAD
/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_INIT_H_
#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_INIT_H_
#include <string>
#include "tensorflow/core/lib/core/status.h"
namespace stream_executor {
class Platform;
} // namespace stream_executor
namespace tensorflow {
// Initializes the GPU platform and returns OK if the GPU
// platform could be initialized.
Status ValidateGPUMachineManager();
// Returns the GPU machine manager singleton, creating it and
// initializing the GPUs on the machine if needed the first time it is
// called. Must only be called when there is a valid GPU environment
// in the process (e.g., ValidateGPUMachineManager() returns OK).
stream_executor::Platform* GPUMachineManager();
// Returns the string describing the name of the GPU platform in use.
// This value is "CUDA" by default, and
// "ROCM" when TF is built with `--config==rocm`
string GpuPlatformName();
} // namespace tensorflow
#endif // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_INIT_H_
=======
#ifndef TENSORFLOW_COMMON_RUNTIME_GPU_GPU_INIT_H_
#define TENSORFLOW_COMMON_RUNTIME_GPU_GPU_INIT_H_
namespace perftools {
namespace gputools {
class Platform;
} // namespace gputools
} // namespace perftools
namespace tensorflow {
// Returns the GPU machine manager singleton, creating it and
// initializing the GPUs on the machine if needed the first time it is
// called.
perftools::gputools::Platform* GPUMachineManager();
} // namespace tensorflow
#endif // TENSORFLOW_COMMON_RUNTIME_GPU_GPU_INIT_H_
>>>>>>> f41959ccb2... TensorFlow: Initial commit of TensorFlow library.
| [
"devsangwoo@gmail.com"
] | devsangwoo@gmail.com |
ca694e9bcfc55b3813de3984c8600c8a51222905 | 0122c8dd3e5071ecd4cc8056aa3afe6ebced6da4 | /menoh/mkldnn/model_core.cpp | b4af689a8159accf43ad383abd6f85cd8333e1d4 | [
"MIT",
"CC-BY-4.0"
] | permissive | eiichiroi/menoh | 265421a54b27b0782d2643f2fc1f99aaba6f96be | d3be9bd5695103d826bb08e083bae4f7a0fdf75d | refs/heads/master | 2020-03-22T05:26:37.288646 | 2018-07-03T06:49:48 | 2018-07-03T06:49:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,131 | cpp | #include <menoh/mkldnn/model_core.hpp>
#include <functional>
#include <iterator>
#include <tuple>
#include <menoh/exception.hpp>
#include <menoh/graph.hpp>
#include <menoh/json.hpp>
#include <menoh/model_core.hpp>
#include <menoh/model_data.hpp>
#include <menoh/utility.hpp>
#include <menoh/mkldnn/operator.hpp>
#include <menoh/mkldnn/primitive_factory_return_type.hpp>
#include <menoh/mkldnn/utility.hpp>
namespace menoh_impl {
namespace mkldnn_backend {
using inplace_primitive_factory =
std::function<primitive_factory_return_type(
node,
int, // node_index
std::vector<node> const&, // node_list
std::unordered_map<std::string,
array> const&, // parameter table
std::unordered_map<std::string,
mkldnn::memory> const&, // variable memory table
std::unordered_map<std::string,
array> const&, // required output table
mkldnn::engine const&)>;
using primitive_factory = std::function<primitive_factory_return_type(
node,
std::unordered_map<std::string,
array> const&, // parameter table
std::unordered_map<std::string,
mkldnn::memory> const&, // variable memory table
std::unordered_map<std::string,
array> const&, // required output table
mkldnn::engine const&)>;
auto make_nets_core(
menoh_impl::graph const& graph,
std::unordered_map<std::string, array> const& parameter_table,
std::unordered_map<std::string, array> const& input_table,
std::unordered_map<std::string, array> const& output_table,
std::unordered_map<std::string, inplace_primitive_factory>
inplace_primitive_factory_table,
std::unordered_map<std::string, primitive_factory>
primitive_factory_table,
mkldnn::engine const& engine) {
std::vector<mkldnn::primitive> nets;
std::unordered_map<std::string, mkldnn::memory>
variable_memory_table;
for(auto const& name_and_arr_pair : input_table) {
std::string name;
array arr;
std::tie(name, arr) = name_and_arr_pair;
mkldnn::memory::format format;
if(arr.dims().size() == 2) {
format = mkldnn::memory::format::nc;
} else if(arr.dims().size() == 4) {
format = mkldnn::memory::format::nchw;
} else {
assert("invalid input dims size");
}
auto mem = array_to_memory(arr, format, engine);
variable_memory_table.insert({name, mem});
}
std::vector<mkldnn::memory> temp_memory_list;
std::vector<array> owned_array_list;
std::set<std::string> variable_name_set;
std::vector<std::string> output_name_sorted_list;
{
std::transform(output_table.begin(), output_table.end(),
std::back_inserter(output_name_sorted_list),
[](auto const& e) { return e.first; });
std::sort(output_name_sorted_list.begin(),
output_name_sorted_list.end());
}
for(decltype(graph.node_list().size()) i = 0;
i < graph.node_list().size(); ++i) {
auto const& node = graph.node_list().at(i);
try {
auto inplace_primitive_factory_pair_iter =
inplace_primitive_factory_table.find(node.op_type);
auto primitive_factory_pair_iter =
primitive_factory_table.find(node.op_type);
if(inplace_primitive_factory_pair_iter ==
inplace_primitive_factory_table.end() &&
primitive_factory_pair_iter ==
primitive_factory_table.end()) {
throw unsupported_operator(node.op_type);
}
// Call a primitive factory
std::vector<mkldnn::primitive> net;
std::unordered_map<std::string, mkldnn::memory>
new_output_memory_table;
std::vector<mkldnn::memory> new_temp_memory_list;
std::vector<array> new_owned_array_list;
if(inplace_primitive_factory_pair_iter !=
inplace_primitive_factory_table.end()) {
std::tie(net, new_output_memory_table,
new_temp_memory_list, new_owned_array_list) =
inplace_primitive_factory_pair_iter->second.
operator()(node, i, graph.node_list(),
parameter_table, variable_memory_table,
output_table, engine);
} else {
assert(primitive_factory_pair_iter !=
primitive_factory_table.end());
std::tie(net, new_output_memory_table,
new_temp_memory_list, new_owned_array_list) =
primitive_factory_pair_iter->second.operator()(
node, parameter_table, variable_memory_table,
output_table, engine);
}
nets.insert(nets.end(), net.begin(), net.end());
variable_memory_table.insert(
new_output_memory_table.begin(),
new_output_memory_table.end());
temp_memory_list.insert(temp_memory_list.end(),
new_temp_memory_list.begin(),
new_temp_memory_list.end());
owned_array_list.insert(owned_array_list.end(),
new_owned_array_list.begin(),
new_owned_array_list.end());
// Check weather all required output is emitted
std::transform(
new_output_memory_table.begin(),
new_output_memory_table.end(),
std::inserter(variable_name_set, variable_name_set.end()),
[](auto const& e) { return e.first; });
std::vector<std::string> diffs;
std::set_difference(
output_name_sorted_list.begin(),
output_name_sorted_list.end(), variable_name_set.begin(),
variable_name_set.end(), std::back_inserter(diffs));
if(diffs.empty()) {
break;
}
} catch(mkldnn::error const& e) {
throw failed_to_configure_operator(
node.op_type, node.output_name_list.at(0), e.message);
}
}
return std::make_tuple(nets, variable_memory_table,
temp_memory_list, owned_array_list);
}
auto
make_nets(std::unordered_map<std::string, array> const& input_table,
std::unordered_map<std::string, array> const& output_table,
menoh_impl::model_data const& model_data,
mkldnn::engine const& engine) {
std::unordered_map<std::string, inplace_primitive_factory>
inplace_primitive_factory_table;
inplace_primitive_factory_table.insert({"Abs", make_abs_primitive});
inplace_primitive_factory_table.insert({"Elu", make_elu_primitive});
inplace_primitive_factory_table.insert(
{"LeakyRelu", make_leaky_relu_primitive});
inplace_primitive_factory_table.insert(
{"Relu", make_relu_primitive});
inplace_primitive_factory_table.insert(
{"Sqrt", make_sqrt_primitive});
inplace_primitive_factory_table.insert(
{"Tanh", make_sqrt_primitive});
std::unordered_map<std::string, primitive_factory>
primitive_factory_table;
primitive_factory_table.insert(
{"AveragePool", make_average_pool_primitive});
primitive_factory_table.insert({"Add", make_add_primitive});
primitive_factory_table.insert(
{"BatchNormalization", make_batch_norm_primitive});
primitive_factory_table.insert({"Concat", make_concat_primitive});
primitive_factory_table.insert({"Conv", make_conv_primitive});
primitive_factory_table.insert(
{"ConvTranspose", make_conv_transpose_primitive});
primitive_factory_table.insert({"FC", make_fc_primitive});
primitive_factory_table.insert({"Gemm", make_gemm_primitive});
primitive_factory_table.insert(
{"GlobalAveragePool", make_global_average_pool_primitive});
primitive_factory_table.insert(
{"GlobalMaxPool", make_global_max_pool_primitive});
primitive_factory_table.insert({"LRN", make_lrn_primitive});
primitive_factory_table.insert(
{"MaxPool", make_max_pool_primitive});
primitive_factory_table.insert({"Softmax", make_softmax_primitive});
primitive_factory_table.insert({"Sum", make_sum_primitive});
// TODO other primitives
auto graph = make_graph(model_data.node_list);
auto parameter_table = std::unordered_map<std::string, array>(
model_data.parameter_name_and_array_list.begin(),
model_data.parameter_name_and_array_list.end());
return make_nets_core(graph, parameter_table, input_table,
output_table, inplace_primitive_factory_table,
primitive_factory_table, engine);
}
model_core::model_core(
std::unordered_map<std::string, array> const& input_table,
std::unordered_map<std::string, array> const& output_table,
menoh_impl::model_data const& model_data,
mkldnn::engine const& engine)
: engine_(engine) {
std::tie(nets_, variable_memory_table_, temp_memory_list_,
owned_array_list_) =
make_nets(input_table, output_table, model_data, engine_);
}
void model_core::do_run() {
try {
mkldnn::stream(mkldnn::stream::kind::eager)
.submit(nets_)
.wait();
} catch(mkldnn::error const& e) {
throw backend_error("mkldnn", e.message);
}
}
model_core make_model_core(
std::unordered_map<std::string, array> const& input_table,
std::unordered_map<std::string, array> const& output_table,
menoh_impl::model_data const& model_data,
backend_config const& config) {
try {
int cpu_id = 0;
if(!config.empty()) {
auto c = nlohmann::json::parse(config);
if(c.find("cpu_id") != c.end()) {
cpu_id = c["cpu_id"].get<int>();
}
}
mkldnn::engine engine(mkldnn::engine::cpu, cpu_id);
return model_core(input_table, output_table, model_data,
engine);
} catch(nlohmann::json::parse_error const& e) {
throw json_parse_error(e.what());
} catch(mkldnn::error const& e) {
throw backend_error("mkldnn", e.message);
}
}
} // namespace mkldnn_backend
} // namespace menoh_impl
| [
"kokuzen@gmail.com"
] | kokuzen@gmail.com |
77218bdcba6b776ceab5ea0374c24bd359fee97a | 7e48d392300fbc123396c6a517dfe8ed1ea7179f | /RodentVR/Intermediate/Build/Win64/RodentVR/Inc/Engine/ParticleModuleRotationRate_Seeded.gen.cpp | 11fa5c462013ed61c1c962aafd1fbca157d9ad50 | [] | no_license | WestRyanK/Rodent-VR | f4920071b716df6a006b15c132bc72d3b0cba002 | 2033946f197a07b8c851b9a5075f0cb276033af6 | refs/heads/master | 2021-06-14T18:33:22.141793 | 2020-10-27T03:25:33 | 2020-10-27T03:25:33 | 154,956,842 | 1 | 1 | null | 2018-11-29T09:56:21 | 2018-10-27T11:23:11 | C++ | UTF-8 | C++ | false | false | 5,866 | cpp | // Copyright Epic Games, Inc. All Rights Reserved.
/*===========================================================================
Generated code exported from UnrealHeaderTool.
DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/
#include "UObject/GeneratedCppIncludes.h"
#include "Engine/Classes/Particles/RotationRate/ParticleModuleRotationRate_Seeded.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeParticleModuleRotationRate_Seeded() {}
// Cross Module References
ENGINE_API UClass* Z_Construct_UClass_UParticleModuleRotationRate_Seeded_NoRegister();
ENGINE_API UClass* Z_Construct_UClass_UParticleModuleRotationRate_Seeded();
ENGINE_API UClass* Z_Construct_UClass_UParticleModuleRotationRate();
UPackage* Z_Construct_UPackage__Script_Engine();
ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FParticleRandomSeedInfo();
// End Cross Module References
void UParticleModuleRotationRate_Seeded::StaticRegisterNativesUParticleModuleRotationRate_Seeded()
{
}
UClass* Z_Construct_UClass_UParticleModuleRotationRate_Seeded_NoRegister()
{
return UParticleModuleRotationRate_Seeded::StaticClass();
}
struct Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics
{
static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RandomSeedInfo_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_RandomSeedInfo;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
static const UE4CodeGen_Private::FClassParams ClassParams;
};
UObject* (*const Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::DependentSingletons[])() = {
(UObject* (*)())Z_Construct_UClass_UParticleModuleRotationRate,
(UObject* (*)())Z_Construct_UPackage__Script_Engine,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::Class_MetaDataParams[] = {
{ "DisplayName", "Init Rotation Rate (Seed)" },
{ "HideCategories", "Object Object Object Object" },
{ "IncludePath", "Particles/RotationRate/ParticleModuleRotationRate_Seeded.h" },
{ "ModuleRelativePath", "Classes/Particles/RotationRate/ParticleModuleRotationRate_Seeded.h" },
};
#endif
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::NewProp_RandomSeedInfo_MetaData[] = {
{ "Category", "RandomSeed" },
{ "Comment", "/** The random seed(s) to use for looking up values in StartLocation */" },
{ "ModuleRelativePath", "Classes/Particles/RotationRate/ParticleModuleRotationRate_Seeded.h" },
{ "ToolTip", "The random seed(s) to use for looking up values in StartLocation" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::NewProp_RandomSeedInfo = { "RandomSeedInfo", nullptr, (EPropertyFlags)0x0010000000000001, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UParticleModuleRotationRate_Seeded, RandomSeedInfo), Z_Construct_UScriptStruct_FParticleRandomSeedInfo, METADATA_PARAMS(Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::NewProp_RandomSeedInfo_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::NewProp_RandomSeedInfo_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::NewProp_RandomSeedInfo,
};
const FCppClassTypeInfoStatic Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::StaticCppClassTypeInfo = {
TCppClassTypeTraits<UParticleModuleRotationRate_Seeded>::IsAbstract,
};
const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::ClassParams = {
&UParticleModuleRotationRate_Seeded::StaticClass,
nullptr,
&StaticCppClassTypeInfo,
DependentSingletons,
nullptr,
Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::PropPointers,
nullptr,
UE_ARRAY_COUNT(DependentSingletons),
0,
UE_ARRAY_COUNT(Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::PropPointers),
0,
0x008010A0u,
METADATA_PARAMS(Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::Class_MetaDataParams))
};
UClass* Z_Construct_UClass_UParticleModuleRotationRate_Seeded()
{
static UClass* OuterClass = nullptr;
if (!OuterClass)
{
UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UParticleModuleRotationRate_Seeded_Statics::ClassParams);
}
return OuterClass;
}
IMPLEMENT_CLASS(UParticleModuleRotationRate_Seeded, 1913547269);
template<> ENGINE_API UClass* StaticClass<UParticleModuleRotationRate_Seeded>()
{
return UParticleModuleRotationRate_Seeded::StaticClass();
}
static FCompiledInDefer Z_CompiledInDefer_UClass_UParticleModuleRotationRate_Seeded(Z_Construct_UClass_UParticleModuleRotationRate_Seeded, &UParticleModuleRotationRate_Seeded::StaticClass, TEXT("/Script/Engine"), TEXT("UParticleModuleRotationRate_Seeded"), false, nullptr, nullptr, nullptr);
DEFINE_VTABLE_PTR_HELPER_CTOR(UParticleModuleRotationRate_Seeded);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif
| [
"west.ryan.k@gmail.com"
] | west.ryan.k@gmail.com |
c6d84e652a90b55783ec0afdaa3ebbf6a23b477e | 63b12d05383c6bd28fc5c9df4f594d646c132b72 | /http/curl_http_response.h | 3ad3b12c054798befe02460cb50f72e295c35c84 | [
"Apache-2.0"
] | permissive | enquery/enquery | 5f88a99cd006629dc14d60f8132d8cb107df2074 | 49401a140318efab367fe74bc16e66d488bdadb8 | refs/heads/master | 2020-04-23T22:54:48.237179 | 2015-10-27T10:26:54 | 2015-10-27T10:26:54 | 40,278,697 | 0 | 0 | null | 2015-10-27T10:26:54 | 2015-08-06T02:00:41 | C++ | UTF-8 | C++ | false | false | 1,259 | h | // Copyright 2015 The Enquery Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License. See the AUTHORS file for names of
// contributors.
#ifndef HTTP_CURL_HTTP_RESPONSE_H_
#define HTTP_CURL_HTTP_RESPONSE_H_
#include "enquery/http_response.h"
#include "enquery/shared.h"
namespace enquery {
class Buffer;
class CurlHttpResponse : public HttpResponse {
public:
explicit CurlHttpResponse(Shared<Buffer>::Ptr body);
virtual ~CurlHttpResponse();
virtual const char* Body() const;
virtual size_t BodySize() const;
private:
CurlHttpResponse(const CurlHttpResponse& no_copy);
CurlHttpResponse& operator=(const CurlHttpResponse& no_assign);
Shared<Buffer>::Ptr body_;
};
} // namespace enquery
#endif // HTTP_CURL_HTTP_RESPONSE_H_
| [
"dialtr@gmail.com"
] | dialtr@gmail.com |
dd18b225d0af71e697b86a2093f0e1c5340902a1 | 69b436861330ea76612c39bfdf7ac2a03d838411 | /array_and_string/151.cpp | 8cffa1227262d9e754ca2afd5079395bba0f17d9 | [] | no_license | MXBBY/leetcode_solution | 06aa026fa348ddacdc6744377541f4dc91db1931 | 2dd081dad02aefb017cade5b0caf6f8286aa4148 | refs/heads/master | 2023-01-19T05:32:15.446128 | 2020-10-28T07:52:01 | 2020-10-28T07:52:01 | 306,235,411 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 983 | cpp |
// 作者：mxbbylin
// 创建时间：2020-10-28 16:11
// 最后修改时间：2020-10-28 16:11
// 文件名：151.cpp
// 说明：
// 题目：
// 给定一个字符串，逐个翻转字符串中的每个单词。
class Solution {
public:
string reverseWords(string s) {
stack<string> stk;
int n=s.size();
int head=0;
string out="";
for(int i=0;i<n;i++){
if(s[i]==' '){
int num=i-head;
string temp=s.substr(head,num);
if(num>0) stk.push(temp);
while(s[i]==' ' && i<n) i++;
head=i;
i--;
}
else if(i==n-1){
string temp=s.substr(head,n-head);
stk.push(temp);
}
}
while(!stk.empty()){
string temp=stk.top();
stk.pop();
out+=temp;
if(!stk.empty()) out+=' ';
}
return out;
}
};
| [
"2621737712@qq.com"
] | 2621737712@qq.com |
fa41aa2a011eeeb50eff58604735bb267251637c | 08a1230b129c34e3d78164a7da75fdda79c9557c | /vehicles.cpp | b896fb0987ce0ba2ef79a4b3aac0075ca5103a27 | [] | no_license | stormvolt/29-10-2015 | adf7ecabcd622f0595a17baa8b0dd86ab7a7dc17 | 287b14469b92ff14771f70abb658298b135038ff | refs/heads/master | 2021-01-10T03:05:39.337670 | 2015-10-29T18:56:06 | 2015-10-29T18:56:06 | 45,187,866 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,441 | cpp | #include <iostream>
#include <sstream>
#include <string>
using namespace std;
string stringify(int number)
{
ostringstream ostr;
ostr << number;
string theNumberString = ostr.str();
return theNumberString;
}
class Vehicle
{
protected:
string license;
int year;
public:
Vehicle(const string &myLicense , const int myYear)
: license(myLicense) , year(myYear) {}
virtual const string getDesc() const
{return license + " from " + stringify( year );}
const string &getLicense() const {return license;}
const int getYear() const {return year;}
};
class Car : public Vehicle
{
string style;
public:
Car( const string & myLicense , const int myYear , const string & myStyle )
: Vehicle ( myLicense , myYear ), style ( myStyle ) {}
const string getDesc ()
{ return stringify ( year ) + style + ": " + license ;}
const string & getStyle () { return style ;}
};
class Truck : public Vehicle
{
string model;
public:
Truck( const string & myLicense , const int myYear , const string & myModel )
: Vehicle ( myLicense , myYear ), model ( myModel ) {}
const string getDesc ()
{ return stringify ( year ) + model + ": " + license ;}
const string & getModel () { return model ;}
};
int main()
{
Car c("TH3456", 2003, "VANITY");
Vehicle *vPtr = &c;
cout<<vPtr->getDesc()<<"\n";
Truck t("GH7890", 1987, "VALTRA");
Vehicle *vPt = &t;
cout<<vPt->getDesc()<<"\n";
}
| [
"luisnu97@hotmail.com"
] | luisnu97@hotmail.com |
3ed86b292483376674c314e80d6d76931015b600 | f2cdb7cefd12b90f05e8b5f2cbcb951ae265b181 | /chrome/browser/ui/views/extensions/extensions_toolbar_container.cc | 00d3905bbdccb2787c8a175ba0502fd8395e7bdd | [
"BSD-3-Clause"
] | permissive | rootFaheem/chromium | 06e557df14776c344d7fee68b5e3f177755cd9a9 | af88457951f3e660f1bfd43860168dbbbfccfbbb | refs/heads/master | 2022-11-29T20:28:09.085773 | 2020-03-10T15:56:55 | 2020-03-10T15:56:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 22,970 | cc | // Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/views/extensions/extensions_toolbar_container.h"
#include "base/numerics/ranges.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_window.h"
#include "chrome/browser/ui/extensions/settings_api_bubble_helpers.h"
#include "chrome/browser/ui/layout_constants.h"
#include "chrome/browser/ui/toolbar/toolbar_action_view_controller.h"
#include "chrome/browser/ui/view_ids.h"
#include "chrome/browser/ui/views/extensions/browser_action_drag_data.h"
#include "chrome/browser/ui/views/extensions/extensions_menu_view.h"
#include "chrome/browser/ui/views/extensions/extensions_toolbar_button.h"
#include "chrome/browser/ui/views/frame/browser_view.h"
#include "chrome/browser/ui/views/toolbar/toolbar_actions_bar_bubble_views.h"
#include "chrome/browser/ui/views/web_apps/web_app_frame_toolbar_view.h"
#include "ui/views/layout/animating_layout_manager.h"
#include "ui/views/layout/flex_layout.h"
#include "ui/views/layout/flex_layout_types.h"
#include "ui/views/view_class_properties.h"
#include "ui/views/widget/widget_observer.h"
struct ExtensionsToolbarContainer::DropInfo {
DropInfo(ToolbarActionsModel::ActionId action_id, size_t index);
// The id for the action being dragged.
ToolbarActionsModel::ActionId action_id;
// The (0-indexed) icon before the action will be dropped.
size_t index;
};
ExtensionsToolbarContainer::DropInfo::DropInfo(
ToolbarActionsModel::ActionId action_id,
size_t index)
: action_id(action_id), index(index) {}
ExtensionsToolbarContainer::ExtensionsToolbarContainer(Browser* browser,
DisplayMode display_mode)
: ToolbarIconContainerView(/*uses_highlight=*/true),
browser_(browser),
model_(ToolbarActionsModel::Get(browser_->profile())),
model_observer_(this),
extensions_button_(new ExtensionsToolbarButton(browser_, this)),
display_mode_(display_mode) {
// The container shouldn't show unless / until we have extensions available.
SetVisible(false);
model_observer_.Add(model_);
// Do not flip the Extensions icon in RTL.
extensions_button_->EnableCanvasFlippingForRTLUI(false);
const views::FlexSpecification hide_icon_flex_specification =
views::FlexSpecification(views::MinimumFlexSizeRule::kPreferredSnapToZero,
views::MaximumFlexSizeRule::kPreferred)
.WithWeight(0);
switch (display_mode) {
case DisplayMode::kNormal:
// In normal mode, the menu icon is always shown.
extensions_button_->SetProperty(views::kFlexBehaviorKey,
views::FlexSpecification());
break;
case DisplayMode::kCompact:
// In compact mode, the menu icon can be hidden but has the highest
// priority.
extensions_button_->SetProperty(
views::kFlexBehaviorKey, hide_icon_flex_specification.WithOrder(1));
break;
}
extensions_button_->SetID(VIEW_ID_EXTENSIONS_MENU_BUTTON);
AddMainButton(extensions_button_);
target_layout_manager()
->SetFlexAllocationOrder(views::FlexAllocationOrder::kReverse)
.SetDefault(views::kFlexBehaviorKey,
hide_icon_flex_specification.WithOrder(3));
CreateActions();
// TODO(pbos): Consider splitting out tab-strip observing into another class.
// Triggers for Extensions-related bubbles should preferably be separate from
// the container where they are shown.
browser_->tab_strip_model()->AddObserver(this);
}
ExtensionsToolbarContainer::~ExtensionsToolbarContainer() {
// Create a copy of the anchored widgets, since |anchored_widgets_| will
// be modified by closing them.
std::vector<views::Widget*> widgets;
widgets.reserve(anchored_widgets_.size());
for (auto& anchored_widget : anchored_widgets_)
widgets.push_back(anchored_widget.widget);
for (views::Widget* widget : widgets)
widget->Close();
// The widgets should close synchronously (resulting in OnWidgetClosing()),
// so |anchored_widgets_| should now be empty.
CHECK(anchored_widgets_.empty());
}
void ExtensionsToolbarContainer::UpdateAllIcons() {
extensions_button_->UpdateIcon();
for (const auto& action : actions_)
action->UpdateState();
}
ToolbarActionView* ExtensionsToolbarContainer::GetViewForId(
const std::string& id) {
auto it = icons_.find(id);
if (it == icons_.end())
return nullptr;
return it->second.get();
}
void ExtensionsToolbarContainer::ShowWidgetForExtension(
views::Widget* widget,
const std::string& extension_id) {
anchored_widgets_.push_back({widget, extension_id});
widget->AddObserver(this);
UpdateIconVisibility(extension_id);
animating_layout_manager()->PostOrQueueAction(base::BindOnce(
&ExtensionsToolbarContainer::AnchorAndShowWidgetImmediately,
weak_ptr_factory_.GetWeakPtr(), widget));
}
views::Widget*
ExtensionsToolbarContainer::GetAnchoredWidgetForExtensionForTesting(
const std::string& extension_id) {
auto iter = std::find_if(anchored_widgets_.begin(), anchored_widgets_.end(),
[extension_id](const auto& info) {
return info.extension_id == extension_id;
});
return iter->widget;
}
bool ExtensionsToolbarContainer::ShouldForceVisibility(
const std::string& extension_id) const {
if (popped_out_action_ && popped_out_action_->GetId() == extension_id)
return true;
if (extension_with_open_context_menu_id_.has_value() &&
extension_with_open_context_menu_id_.value() == extension_id) {
return true;
}
for (const auto& anchored_widget : anchored_widgets_) {
if (anchored_widget.extension_id == extension_id)
return true;
}
return false;
}
void ExtensionsToolbarContainer::UpdateIconVisibility(
const std::string& extension_id) {
ToolbarActionView* const action_view = GetViewForId(extension_id);
if (!action_view)
return;
// Popped out action uses a flex rule that causes it to always be visible
// regardless of space; default for actions is to drop out when there is
// insufficient space. So if an action is being forced visible, it should have
// a rule that gives it higher priority, and if it does not, it should use the
// default.
const bool must_show = ShouldForceVisibility(extension_id);
if (must_show) {
switch (display_mode_) {
case DisplayMode::kNormal:
// In normal mode, the icon's visibility is forced.
action_view->SetProperty(views::kFlexBehaviorKey,
views::FlexSpecification());
break;
case DisplayMode::kCompact:
// In compact mode, the icon can still drop out, but receives precedence
// over other actions.
action_view->SetProperty(
views::kFlexBehaviorKey,
views::FlexSpecification(
views::MinimumFlexSizeRule::kPreferredSnapToZero,
views::MaximumFlexSizeRule::kPreferred)
.WithWeight(0)
.WithOrder(2));
break;
}
} else {
action_view->ClearProperty(views::kFlexBehaviorKey);
}
if (must_show || model_->IsActionPinned(extension_id))
animating_layout_manager()->FadeIn(action_view);
else
animating_layout_manager()->FadeOut(action_view);
}
void ExtensionsToolbarContainer::AnchorAndShowWidgetImmediately(
views::Widget* widget) {
auto iter = std::find_if(
anchored_widgets_.begin(), anchored_widgets_.end(),
[widget](const auto& info) { return info.widget == widget; });
if (iter == anchored_widgets_.end()) {
// This should mean that the Widget destructed before we got to showing it.
// |widget| is invalid here and should not be shown.
return;
}
// TODO(pbos): Make extension removal close associated widgets. Right now, it
// seems possible that:
// * ShowWidgetForExtension starts
// * Extension gets removed
// * AnchorAndShowWidgetImmediately runs.
// Revisit how to handle that, likely the Widget should Close on removal which
// would remove the AnchoredWidget entry.
views::View* const anchor_view = GetViewForId(iter->extension_id);
widget->widget_delegate()->AsBubbleDialogDelegate()->SetAnchorView(
anchor_view && anchor_view->GetVisible() ? anchor_view
: extensions_button_);
widget->Show();
}
ToolbarActionViewController* ExtensionsToolbarContainer::GetActionForId(
const std::string& action_id) {
for (const auto& action : actions_) {
if (action->GetId() == action_id)
return action.get();
}
return nullptr;
}
ToolbarActionViewController* ExtensionsToolbarContainer::GetPoppedOutAction()
const {
return popped_out_action_;
}
void ExtensionsToolbarContainer::OnContextMenuShown(
ToolbarActionViewController* extension) {
extension_with_open_context_menu_id_ = extension->GetId();
UpdateIconVisibility(extension_with_open_context_menu_id_.value());
}
void ExtensionsToolbarContainer::OnContextMenuClosed(
ToolbarActionViewController* extension) {
DCHECK(extension_with_open_context_menu_id_.has_value());
base::Optional<extensions::ExtensionId> const
extension_with_open_context_menu = extension_with_open_context_menu_id_;
extension_with_open_context_menu_id_.reset();
UpdateIconVisibility(extension_with_open_context_menu.value());
}
bool ExtensionsToolbarContainer::IsActionVisibleOnToolbar(
const ToolbarActionViewController* action) const {
const std::string& extension_id = action->GetId();
return ShouldForceVisibility(extension_id) ||
model_->IsActionPinned(extension_id);
}
void ExtensionsToolbarContainer::UndoPopOut() {
DCHECK(popped_out_action_);
ToolbarActionViewController* const popped_out_action = popped_out_action_;
popped_out_action_ = nullptr;
UpdateIconVisibility(popped_out_action->GetId());
}
void ExtensionsToolbarContainer::SetPopupOwner(
ToolbarActionViewController* popup_owner) {
// We should never be setting a popup owner when one already exists, and
// never unsetting one when one wasn't set.
DCHECK((popup_owner_ != nullptr) ^ (popup_owner != nullptr));
popup_owner_ = popup_owner;
}
void ExtensionsToolbarContainer::HideActivePopup() {
if (popup_owner_)
popup_owner_->HidePopup();
DCHECK(!popup_owner_);
}
bool ExtensionsToolbarContainer::CloseOverflowMenuIfOpen() {
if (ExtensionsMenuView::IsShowing()) {
ExtensionsMenuView::Hide();
return true;
}
return false;
}
void ExtensionsToolbarContainer::PopOutAction(
ToolbarActionViewController* action,
bool is_sticky,
const base::Closure& closure) {
// TODO(pbos): Highlight popout differently.
DCHECK(!popped_out_action_);
popped_out_action_ = action;
UpdateIconVisibility(action->GetId());
animating_layout_manager()->PostOrQueueAction(closure);
}
bool ExtensionsToolbarContainer::ShowToolbarActionPopup(
const std::string& action_id,
bool grant_active_tab) {
// Don't override another popup, and only show in the active window.
if (popped_out_action_ || !browser_->window()->IsActive())
return false;
ToolbarActionViewController* action = GetActionForId(action_id);
return action && action->ExecuteAction(grant_active_tab);
}
void ExtensionsToolbarContainer::ShowToolbarActionBubble(
std::unique_ptr<ToolbarActionsBarBubbleDelegate> controller) {
const std::string extension_id = controller->GetAnchorActionId();
views::View* const anchor_view = GetViewForId(extension_id);
views::Widget* const widget = views::BubbleDialogDelegateView::CreateBubble(
new ToolbarActionsBarBubbleViews(
anchor_view ? anchor_view : extensions_button_,
anchor_view != nullptr, std::move(controller)));
ShowWidgetForExtension(widget, extension_id);
}
void ExtensionsToolbarContainer::ShowToolbarActionBubbleAsync(
std::unique_ptr<ToolbarActionsBarBubbleDelegate> bubble) {
ShowToolbarActionBubble(std::move(bubble));
}
void ExtensionsToolbarContainer::OnTabStripModelChanged(
TabStripModel* tab_strip_model,
const TabStripModelChange& change,
const TabStripSelectionChange& selection) {
if (tab_strip_model->empty() || !selection.active_tab_changed())
return;
extensions::MaybeShowExtensionControlledNewTabPage(browser_,
selection.new_contents);
}
void ExtensionsToolbarContainer::OnToolbarActionAdded(
const ToolbarActionsModel::ActionId& action_id,
int index) {
CreateActionForId(action_id);
ReorderViews();
UpdateContainerVisibility();
}
void ExtensionsToolbarContainer::OnToolbarActionRemoved(
const ToolbarActionsModel::ActionId& action_id) {
// TODO(pbos): Handle extension upgrades, see ToolbarActionsBar. Arguably this
// could be handled inside the model and be invisible to the container when
// permissions are unchanged.
auto iter = std::find_if(
actions_.begin(), actions_.end(),
[action_id](const auto& item) { return item->GetId() == action_id; });
DCHECK(iter != actions_.end());
// Ensure the action outlives the UI element to perform any cleanup.
std::unique_ptr<ToolbarActionViewController> controller = std::move(*iter);
actions_.erase(iter);
// Undo the popout, if necessary. Actions expect to not be popped out while
// destroying.
if (popped_out_action_ == controller.get())
UndoPopOut();
icons_.erase(action_id);
UpdateContainerVisibility();
}
void ExtensionsToolbarContainer::OnToolbarActionMoved(
const ToolbarActionsModel::ActionId& action_id,
int index) {}
void ExtensionsToolbarContainer::OnToolbarActionLoadFailed() {}
void ExtensionsToolbarContainer::OnToolbarActionUpdated(
const ToolbarActionsModel::ActionId& action_id) {
ToolbarActionViewController* action = GetActionForId(action_id);
if (action)
action->UpdateState();
}
void ExtensionsToolbarContainer::OnToolbarVisibleCountChanged() {}
void ExtensionsToolbarContainer::OnToolbarHighlightModeChanged(
bool is_highlighting) {}
void ExtensionsToolbarContainer::OnToolbarModelInitialized() {
CreateActions();
}
void ExtensionsToolbarContainer::OnToolbarPinnedActionsChanged() {
for (auto& it : icons_)
UpdateIconVisibility(it.first);
ReorderViews();
}
void ExtensionsToolbarContainer::ReorderViews() {
const auto& pinned_action_ids = model_->pinned_action_ids();
for (size_t i = 0; i < pinned_action_ids.size(); ++i)
ReorderChildView(icons_[pinned_action_ids[i]].get(), i);
if (drop_info_.get())
ReorderChildView(icons_[drop_info_->action_id].get(), drop_info_->index);
// The extension button is always last.
ReorderChildView(extensions_button_, -1);
}
void ExtensionsToolbarContainer::CreateActions() {
DCHECK(icons_.empty());
DCHECK(actions_.empty());
// If the model isn't initialized, wait for it.
if (!model_->actions_initialized())
return;
for (auto& action_id : model_->action_ids())
CreateActionForId(action_id);
ReorderViews();
UpdateContainerVisibility();
}
void ExtensionsToolbarContainer::CreateActionForId(
const ToolbarActionsModel::ActionId& action_id) {
actions_.push_back(
model_->CreateActionForId(browser_, this, false, action_id));
auto icon = std::make_unique<ToolbarActionView>(actions_.back().get(), this);
// Set visibility before adding to prevent extraneous animation.
icon->SetVisible(model_->IsActionPinned(action_id));
icon->set_owned_by_client();
icon->AddButtonObserver(this);
icon->AddObserver(this);
AddChildView(icon.get());
icons_[action_id] = std::move(icon);
}
content::WebContents* ExtensionsToolbarContainer::GetCurrentWebContents() {
return browser_->tab_strip_model()->GetActiveWebContents();
}
bool ExtensionsToolbarContainer::ShownInsideMenu() const {
return false;
}
void ExtensionsToolbarContainer::OnToolbarActionViewDragDone() {}
views::LabelButton* ExtensionsToolbarContainer::GetOverflowReferenceView()
const {
return extensions_button_;
}
gfx::Size ExtensionsToolbarContainer::GetToolbarActionSize() {
constexpr gfx::Size kDefaultSize(28, 28);
BrowserView* const browser_view =
BrowserView::GetBrowserViewForBrowser(browser_);
return browser_view
? browser_view->toolbar_button_provider()->GetToolbarButtonSize()
: kDefaultSize;
}
void ExtensionsToolbarContainer::WriteDragDataForView(
View* sender,
const gfx::Point& press_pt,
ui::OSExchangeData* data) {
DCHECK(data);
auto it = std::find_if(model_->pinned_action_ids().cbegin(),
model_->pinned_action_ids().cend(),
[this, sender](const std::string& action_id) {
return GetViewForId(action_id) == sender;
});
DCHECK(it != model_->pinned_action_ids().cend());
size_t index = it - model_->pinned_action_ids().cbegin();
ToolbarActionView* extension_view = GetViewForId(*it);
data->provider().SetDragImage(GetExtensionIcon(extension_view),
press_pt.OffsetFromOrigin());
// Fill in the remaining info.
BrowserActionDragData drag_data(extension_view->view_controller()->GetId(),
index);
drag_data.Write(browser_->profile(), data);
}
int ExtensionsToolbarContainer::GetDragOperationsForView(View* sender,
const gfx::Point& p) {
return ui::DragDropTypes::DRAG_MOVE;
}
bool ExtensionsToolbarContainer::CanStartDragForView(View* sender,
const gfx::Point& press_pt,
const gfx::Point& p) {
// Only pinned extensions should be draggable.
auto it = std::find_if(model_->pinned_action_ids().cbegin(),
model_->pinned_action_ids().cend(),
[this, sender](const std::string& action_id) {
return GetViewForId(action_id) == sender;
});
return it != model_->pinned_action_ids().cend();
}
bool ExtensionsToolbarContainer::GetDropFormats(
int* formats,
std::set<ui::ClipboardFormatType>* format_types) {
return BrowserActionDragData::GetDropFormats(format_types);
}
bool ExtensionsToolbarContainer::AreDropTypesRequired() {
return BrowserActionDragData::AreDropTypesRequired();
}
bool ExtensionsToolbarContainer::CanDrop(const OSExchangeData& data) {
return BrowserActionDragData::CanDrop(data, browser_->profile());
}
int ExtensionsToolbarContainer::OnDragUpdated(
const ui::DropTargetEvent& event) {
BrowserActionDragData data;
if (!data.Read(event.data()))
return ui::DragDropTypes::DRAG_NONE;
size_t before_icon = 0;
// Figure out where to display the icon during dragging transition.
// First, since we want to update the dragged extension's position from before
// an icon to after it when the event passes the midpoint between two icons.
// This will convert the event coordinate into the index of the icon we want
// to display the dragged extension before. We also mirror the event.x() so
// that our calculations are consistent with left-to-right.
const int offset_into_icon_area = GetMirroredXInView(event.x());
const int before_icon_unclamped = WidthToIconCount(offset_into_icon_area);
int visible_icons = model_->pinned_action_ids().size();
// Because the user can drag outside the container bounds, we need to clamp
// to the valid range. Note that the maximum allowable value is
// |visible_icons|, not (|visible_icons| - 1), because we represent the
// dragged extension being past the last icon as being "before the (last + 1)
// icon".
before_icon = base::ClampToRange(before_icon_unclamped, 0, visible_icons);
if (!drop_info_.get() || drop_info_->index != before_icon) {
drop_info_ = std::make_unique<DropInfo>(data.id(), before_icon);
SetExtensionIconVisibility(drop_info_->action_id, false);
ReorderViews();
}
return ui::DragDropTypes::DRAG_MOVE;
}
void ExtensionsToolbarContainer::OnDragExited() {
const ToolbarActionsModel::ActionId dragged_extension_id =
drop_info_->action_id;
drop_info_.reset();
ReorderViews();
animating_layout_manager()->PostOrQueueAction(base::BindOnce(
&ExtensionsToolbarContainer::SetExtensionIconVisibility,
weak_ptr_factory_.GetWeakPtr(), dragged_extension_id, true));
}
int ExtensionsToolbarContainer::OnPerformDrop(
const ui::DropTargetEvent& event) {
BrowserActionDragData data;
if (!data.Read(event.data()))
return ui::DragDropTypes::DRAG_NONE;
model_->MovePinnedAction(drop_info_->action_id, drop_info_->index);
OnDragExited(); // Perform clean up after dragging.
return ui::DragDropTypes::DRAG_MOVE;
}
void ExtensionsToolbarContainer::OnWidgetClosing(views::Widget* widget) {
auto iter = std::find_if(
anchored_widgets_.begin(), anchored_widgets_.end(),
[widget](const auto& info) { return info.widget == widget; });
DCHECK(iter != anchored_widgets_.end());
iter->widget->RemoveObserver(this);
const std::string extension_id = std::move(iter->extension_id);
anchored_widgets_.erase(iter);
UpdateIconVisibility(extension_id);
}
void ExtensionsToolbarContainer::OnWidgetDestroying(views::Widget* widget) {
OnWidgetClosing(widget);
}
size_t ExtensionsToolbarContainer::WidthToIconCount(int x_offset) {
const int element_padding = GetLayoutConstant(TOOLBAR_ELEMENT_PADDING);
size_t unclamped_count =
std::max((x_offset + element_padding) /
(GetToolbarActionSize().width() + element_padding),
0);
return std::min(unclamped_count, actions_.size());
}
gfx::ImageSkia ExtensionsToolbarContainer::GetExtensionIcon(
ToolbarActionView* extension_view) {
return extension_view->view_controller()
->GetIcon(GetCurrentWebContents(), GetToolbarActionSize())
.AsImageSkia();
}
void ExtensionsToolbarContainer::SetExtensionIconVisibility(
ToolbarActionsModel::ActionId id,
bool visible) {
auto it = std::find_if(model_->pinned_action_ids().cbegin(),
model_->pinned_action_ids().cend(),
[this, id](const std::string& action_id) {
return GetViewForId(action_id) == GetViewForId(id);
});
ToolbarActionView* extension_view = GetViewForId(*it);
extension_view->SetImage(
views::Button::STATE_NORMAL,
visible ? GetExtensionIcon(extension_view) : gfx::ImageSkia());
}
void ExtensionsToolbarContainer::UpdateContainerVisibility() {
// The container (and extensions-menu button) should be visible if we have at
// least one extension.
SetVisible(!actions_.empty());
}
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
3960bdfeb97c399ee82db09dc307f9ca26105879 | bf93758b90f349cc0b4d034a06c60595b299841c | /Level2/Make the most minimum value/Make the most minimum value/Source.cpp | 4ec19d121957c7e38114fda941c6ef4f0c99561e | [] | no_license | ZeroFive0505/Programmers | f2a9244385e90e1ccc9eb67da9fa8127b8a2219e | 672898325cc71a59e6c098d9cd760b301616900d | refs/heads/master | 2023-07-18T13:23:22.383262 | 2021-09-06T01:35:12 | 2021-09-06T01:35:12 | 366,214,131 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 557 | cpp | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int solution(vector<int> A, vector<int> B)
{
int answer = 0;
sort(A.begin(), A.end(), [](const int& a, const int& b) {
return a < b;
});
sort(B.begin(), B.end(), [](const int& a, const int& b) {
return a > b;
});
for (int i = 0; i < A.size(); i++)
answer += A[i] * B[i];
return answer;
}
int main()
{
vector<int> a = { 1, 2 };
vector<int> b = { 3, 4 };
cout << solution(a, b) << "\n";
return 0;
} | [
"kimyoung1218@gmail.com"
] | kimyoung1218@gmail.com |
30ea1db1e831749a354a5eb0be1301dfde27d54b | de6881a6c1710057eaa4eeca90a1a15967a58275 | /MathsLibary/Vector3.cpp | cdf67a25530a550c0dab247d0a5f51e3488d7547 | [] | no_license | springmouse/AI | d28572f6eb4ac6ad07e2f4d09ec66fb86a140866 | 98ce976c7f60b9ac03955eef8bf47dd70e41a943 | refs/heads/master | 2021-01-01T06:53:23.142943 | 2018-12-15T09:26:01 | 2018-12-15T09:26:01 | 97,533,067 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,310 | cpp | #include "Vector3.h"
#include "Vector4.h"
#include <math.h>
//sets all the possitions in the vector to 0
Vector3::Vector3()
{
x = 0;
y = 0;
z = 0;
}
//assigns all positions in the vector to the values requested by the user
Vector3::Vector3(realNum _x, realNum _y, realNum _z)
{
x = _x;
y = _y;
z = _z;
}
Vector3::~Vector3()
{
}
//gets the magnitude of the vector
realNum Vector3::magnitude()
{
return (realNum)sqrt((pow(x, 2) + pow(y, 2)) + pow(z, 2));
}
//this normalises the vector seting it to a unit leangth of 1 or less
void Vector3::normalise()
{
realNum m = this->magnitude();
if (m != 0)
{
this->x /= m;
this->y /= m ;
this->z /= m;
}
else
{
this->x = 0;
this->y = 0;
this->z = 0;
}
}
//this normalises the vector seting it to a unit leangth of 1 or less
Vector3 Vector3::normalised()
{
realNum m = this->magnitude();
Vector3 vec;
if (m != 0)
{
vec = Vector3(this->x / m, this->y / m, this->z / m);
}
else
{
vec = Vector3();
}
return vec;
}
//finds the dot product of the vector
realNum Vector3::dot(Vector3 & refA)
{
return ((this->x * refA.x) + (this->y * refA.y) + (this->z * refA.z));
}
//this gets the cross product of two vectors
Vector3 Vector3::cross(Vector3 & refA)
{
Vector3 v;
v.x = ((this->y * refA.z) - (this->z * refA.y));
v.y = ((this->z * refA.x) - (this->x * refA.z));
v.z = ((this->x * refA.y) - (this->y * refA.x));
return v;
}
//returns a vector with only a positive x
Vector3 Vector3::Right()
{
return Vector3(1, 0, 0);
}
//returns a vector with only a Negative x
Vector3 Vector3::Leaft()
{
return Vector3(-1, 0, 0);
}
//returns a vector with only a positive y
Vector3 Vector3::Up()
{
return Vector3(0, 1, 0);
}
//returns a vector with only a Negative y
Vector3 Vector3::Down()
{
return Vector3(0, -1, 0);
}
//returns a vector with only a positive z
Vector3 Vector3::Forward()
{
return Vector3(0, 0, 1);
}
//returns a vector with only a Negative z
Vector3 Vector3::Backward()
{
return Vector3(0, 0, -1);
}
//allows us to type cast from a vector 3 to a vector 4
Vector3::operator Vector4()
{
return Vector4(x, y, z, (realNum)0.0f);
}
//allows us to type cast to a vector2
Vector3::operator Vector2()
{
return Vector2(x, y);
}
//creates a new vector by adding to other vectors and returns that new vecotr
Vector3 Vector3::operator + (const Vector3 & refA) const
{
Vector3 v;
v.x = this->x + refA.x;
v.y = this->y + refA.y;
v.z = this->z + refA.z;
return v;
}
//adds one vector to another
void Vector3::operator += (const Vector3 & refA)
{
this->x += refA.x;
this->y += refA.y;
this->z += refA.z;
}
//creates a new vector by subtracting two other vectors then returns that
Vector3 Vector3::operator - (const Vector3 & refA) const
{
Vector3 v;
v.x = this->x - refA.x;
v.y = this->y - refA.y;
v.z = this->z - refA.z;
return v;
}
//subtracts one vector from another
void Vector3::operator -= (const Vector3 & refA)
{
this->x -= refA.x;
this->y -= refA.y;
this->z -= refA.z;
}
//makes the vector equal to another vector
void Vector3::operator = (const Vector3 & refA)
{
this->x = refA.x;
this->y = refA.y;
this->z = refA.z;
}
//checks if two vectors have the same values
bool Vector3::operator == (const Vector3 & refA) const
{
if (this->x == refA.x && this->y == refA.y && this->z == refA.z)
{
return true;
}
else
{
return false;
}
}
//checks if the two vectors are diffrent
bool Vector3::operator != (const Vector3 & refA) const
{
if (this->x != refA.x || this->y != refA.y || this->z != refA.z)
{
return true;
}
else
{
return false;
}
}
//multiplies the vector by a scaler/realNum and assigns that to a new vector that is passed back out
Vector3 Vector3::operator * (const realNum scaler) const
{
return Vector3(this->x * scaler, this->y * scaler, this->z * scaler);
}
//multiplies the vector by a scaler/realNum
void Vector3::operator *= (const realNum scaler)
{
this->x *= scaler;
this->y *= scaler;
this->z *= scaler;
}
//allows you to easily and quickly acces the vectors positions of x and y
realNum & Vector3::operator [] (int index)
{
switch (index)
{
case 0:
return x;
case 1:
return y;
case 2:
return z;
default: throw;
}
}
//exactly the same but dose not allow you to change any of the variables(needed for some matrix stuff)
const realNum & Vector3::operator [] (int index) const
{
switch (index)
{
case 0:
return x;
case 1:
return y;
case 2:
return z;
default: throw;
}
}
#pragma region MySwizzleThings
//swizzling the Vector3 to creat a new Vector2
Vector2 Vector3::GetXX()
{
return Vector2{ x,x };
}
//swizzling the Vector3 to creat a new Vector2
Vector2 Vector3::GetXY()
{
return Vector2{ x,y };
}
//swizzling the Vector3 to creat a new Vector2
Vector2 Vector3::GetXZ()
{
return Vector2{ x,z };
}
//swizzling the Vector3 to creat a new Vector2
Vector2 Vector3::GetYX()
{
return Vector2{ y,x };
}
//swizzling the Vector3 to creat a new Vector2
Vector2 Vector3::GetYY()
{
return Vector2{ y,y };
}
//swizzling the Vector3 to creat a new Vector2
Vector2 Vector3::GetYZ()
{
return Vector2{ y,z };
}
//swizzling the Vector3 to creat a new Vector2
Vector2 Vector3::GetZX()
{
return Vector2{ z,x };
}
//swizzling the Vector3 to creat a new Vector2
Vector2 Vector3::GetZY()
{
return Vector2{ z,y };
}
//swizzling the Vector3 to creat a new Vector2
Vector2 Vector3::GetZZ()
{
return Vector2{ z,z };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetXXX()
{
return Vector3{ x,x,x };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetXXY()
{
return Vector3{ x,x,y };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetXXZ()
{
return Vector3{ x,x,z };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetXYX()
{
return Vector3{ x,y,x };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetXYY()
{
return Vector3{ x,y,y };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetXZX()
{
return Vector3{ x,z,x };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetXZY()
{
return Vector3{ x,z,y };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetXZZ()
{
return Vector3{ x,z,z };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetYXX()
{
return Vector3{ y,x,x };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetYXY()
{
return Vector3{ y,x,y };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetYXZ()
{
return Vector3{ y,x,z };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetYYX()
{
return Vector3{ y,y,x };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetYYY()
{
return Vector3{ y,y,y };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetYYZ()
{
return Vector3{ y,y,z };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetYZX()
{
return Vector3{ y,z,x };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetYZY()
{
return Vector3{ y,z,y };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetYZZ()
{
return Vector3{ y,z,z };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetZXX()
{
return Vector3{ z,x,x };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetZXY()
{
return Vector3{ z,x,y };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetZXZ()
{
return Vector3{ z,x,z };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetZYX()
{
return Vector3{ z,y,x };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetZYY()
{
return Vector3{ z,y,y };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetZYZ()
{
return Vector3{ z,y,z };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetZZX()
{
return Vector3{ z,z,x };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetZZY()
{
return Vector3{ z,z,y };
}
//swizzling the Vector3 to creat a new Vector3
Vector3 Vector3::GetZZZ()
{
return Vector3{ z,z,z };
}
#pragma endregion
| [
"callum.dunstone@gmail.com"
] | callum.dunstone@gmail.com |
123c4ed7dac800369f5a496267748f9730cadae8 | 7fb8c421a2efa33969b0cf298a3f1fe4688dbbda | /GaleEngine/Rendering/GameObjects/Cameras/Camera.h | c38b113867936e01fb85abb1e073f2bc8b6608ec | [] | no_license | hakgagik/GaleEngine | 9c2e7d007ddb15a7a497b0aeac4a2df4e2107e06 | 3a3cb5a4330c67348d99bef56223f3ea4c14f09b | refs/heads/master | 2022-09-04T18:56:12.330889 | 2020-03-30T15:38:37 | 2020-03-30T15:38:37 | 47,303,019 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 978 | h | #pragma once
#include "../GameObject.h"
#include <glm/glm.hpp>
namespace Rendering {
namespace GameObjects {
namespace Cameras {
class Camera : public GameObject {
protected:
glm::vec3 target;
glm::vec3 up;
glm::vec3 right;
glm::vec3 negGaze;
glm::vec3 globalPos;
public:
float nearClip;
float farClip;
float aspect;
Camera(std::string name) : GameObject(name) { };
virtual glm::mat4 GetProjMatrix() = 0;
virtual glm::mat4 GetViewMatrix() = 0;
virtual void Destroy() override = 0;
virtual void LookAt(glm::vec3 pos, glm::vec3 target, glm::vec3 up) = 0;
virtual void Orbit(float dTheta, float dPhi, float boundSize = 0.001f) = 0;
virtual void Dolly(float dRho) = 0;
virtual void Zoom(float zoomFactor) = 0;
virtual void Strafe(float dx, float dy) = 0;
virtual nlohmann::json GetSourceJSON() const override = 0;
protected:
virtual void updateLocalMatrices() override = 0;
};
}
}
} | [
"xddarkgalegh@aim.com"
] | xddarkgalegh@aim.com |
614d320d4cc704fc244bd8740910bea3b1b87940 | ce7876095646b3da23811753cd1850f7dde2d673 | /highland2/baseAnalysis/v2r19/src/baseToyMaker.hxx | ff94c551c8cde792476722e59a6b9864cd1d7d14 | [] | no_license | Balthazar6969/T2K | 63d7bd6dc2ef9eb1d8e33311d220bf8eb8b61828 | 14709b0dbe1f9b22992efecf30c50d9b8f8bba5c | refs/heads/master | 2020-09-09T18:19:24.346765 | 2019-11-19T07:01:44 | 2019-11-19T07:01:44 | 221,523,255 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,011 | hxx | #ifndef baseToyMaker_h
#define baseToyMaker_h
#include "ToyMaker.hxx"
#include "BinnedPDF.hxx"
#include "TRandom3.h"
/// Creates ToyExperiments
class baseToyMaker: public ToyMaker{
public:
/// Create the Toy experiment
baseToyMaker(UInt_t seed);
/// Everyone should have a destructor.
virtual ~baseToyMaker() {}
/// Fills the Toy Experiment with a given index
void FillToyExperiment(ToyExperiment& toy);
/// returns the random seed
UInt_t GetSeed() const {return _seed;}
// Use a random generator for each systematic
void SetIndividualRandomGenerator(bool ok){ _individualRandomGenerator=ok;}
protected:
// A binned PDF
BinnedPDF* _binnedPDF;
/// A random generator that can be used to generate throws.
TRandom3 _RandomGenerator;
TRandom3 _RandomGenerators[NMAXSYSTEMATICS];
/// The random seed used
UInt_t _seed;
UInt_t _seeds[NMAXSYSTEMATICS];
// Use a random generator for each systematic
bool _individualRandomGenerator;
};
#endif
| [
"conor.francois@gmail.com"
] | conor.francois@gmail.com |
3a32f7b372dfa82651846c602ff92c4a23c8eced | 33d2bad6707384a8a281c766f48fc0c07a79bd5e | /src/leetcode/leetcode-0022/0022-210418.cpp | a9c03158aa42bb3ff7dbaa36f44d74efd7e9cd65 | [] | no_license | SolarAA-11/practice | fec9684791951485b0da6ef699e6ef231c86ae25 | a88d79e1219146c97f66b032748a039503ec2962 | refs/heads/main | 2023-04-13T03:12:37.567151 | 2021-04-25T04:30:21 | 2021-04-25T04:30:21 | 358,092,331 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 750 | cpp |
#include "common.h"
class Solution {
public:
vector<string> generateParenthesis(int n) {
string tmp(n * 2, ' ');
dfs(0,0,0,tmp);
return ans;
}
private:
vector<string> ans;
void dfs(int pos, int all_left, int unused_left, string& temp) {
if (pos == temp.size() && unused_left == 0) ans.emplace_back(temp);
else if (pos < temp.size()) {
if (unused_left > 0) {
temp[pos] = ')';
dfs(pos + 1, all_left, unused_left - 1, temp);
}
if (all_left < temp.size() / 2) {
temp[pos] = '(';
dfs(pos + 1, all_left + 1, unused_left + 1,temp);
}
}
}
};
int main() {
Solution s;
}
| [
"948872263@qq.com"
] | 948872263@qq.com |
78c9cc7d4b2b298825254c697e192f955d41a51f | bd5545efd1f257e73a185d0745a9d1f5f3183a6a | /StEtaPhiGrid.h | f82c612e691fc54dbc88fcf97835b18187fa24a5 | [] | no_license | TaiSakuma/StJetFinder | cfefdb8a203ee4007425dd33ed34e29a8f117836 | 6fca7dba6bdff1f14a086747750d811dc7e6eb8f | refs/heads/master | 2021-01-23T00:06:48.236491 | 2014-08-31T16:41:02 | 2014-08-31T16:41:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,267 | h | // -*- mode: c++;-*-
// $Id: StEtaPhiGrid.h,v 1.6 2008/05/08 04:07:23 tai Exp $
// Copyright (C) 2008 Tai Sakuma <sakuma@mit.edu>
#ifndef STETAPHIGRID_H
#define STETAPHIGRID_H
#include "StEtGridKey.h"
#include "StEtaPhiCell.h"
#include <map>
#include <list>
class StJetEtCellFactory;
class StConePars;
namespace StSpinJet {
class StEtaPhiGrid {
public:
typedef std::list<StProtoJet> JetList;
typedef std::map<StEtGridKey, StEtaPhiCell*> CellMap;
typedef CellMap::value_type CellMapValType;
typedef StEtaPhiCell::CellList CellList;
StEtaPhiGrid(StConePars& pars) : _pars(pars) { }
void buildGrid(StJetEtCellFactory* cellFactory);
void fillGridWith(JetList& protoJetList);
CellList EtSortedCellList();
CellList WithinTheConeRadiusCellList(const StEtaPhiCell& theCell) const;
StEtaPhiCell* findMidpointCell(const StEtaPhiCell& cell1, const StEtaPhiCell& cell2);
StEtaPhiCell* Cell(double eta, double phi);
private:
StEtaPhiCell* CellI(int iEta, int iPhi) const;
StEtGridKey findKey(double eta, double phi) const;
int findEtaKey(double eta) const;
int findPhiKey(double phi) const;
double midpoint(double v1, double v2);
StConePars& _pars;
CellMap _EtCellMap;
CellList _EtCellList;
};
}
#endif // STETAPHIGRID_H
| [
"tai.sakuma@gmail.com"
] | tai.sakuma@gmail.com |
eb3a43c385f304f6a469301fcf1c31ba1710856d | 9804ad6d82b7ca856a2e8058531e229874198884 | /elenasrc2/engine/bytecode.h | bd9b6bf93ffd55dfaa28d0b219458912f363d25e | [
"MIT"
] | permissive | adavidoaiei/elena-lang | 2f8fc6ce38c1be5fb73d1e5d870e79615f115c4b | 68f6dd01522768913a0c52152c8c77f6e6c73ae2 | refs/heads/master | 2022-12-05T18:49:17.112216 | 2020-08-20T15:04:33 | 2020-08-20T15:04:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,654 | h | // E L E N A P r o j e c t: ELENA Engine
//
// This file contains common ELENA byte code classes and constants
//
// (C)2009-2020, by Alexei Rakov
//------------------------------------------------------------------------------
#ifndef bytecodeH
#define bytecodeH 1
namespace _ELENA_
{
// --- Byte code command set ---
enum ByteCode
{
// commands:
bcNop = 0x00,
bcBreakpoint = 0x01,
bcCoalesce = 0x02,
bcPeek = 0x03,
bcSNop = 0x04,
bcPushVerb = 0x05,
bcLoadVerb = 0x06,
bcThrow = 0x07,
bcMCount = 0x08,
bcPush = 0x09,
bcPushA = 0x0A,
bcPopA = 0x0B,
// bcACopyB = 0x0C,
bcStoreV = 0x0D,
bcBSRedirect = 0x0E,
bcSetV = 0x0F,
bcNot = 0x10,
// bcLen = 0x11,
// bcBCopyA = 0x12,
bcSub = 0x13,
bcSwapD = 0x14,
bcClose = 0x15,
bcRExp = 0x16,
bcQuit = 0x17,
bcGet = 0x18,
bcSet = 0x19,
bcSwap = 0x1A,
bcMQuit = 0x1B,
bcCount = 0x1C,
bcUnhook = 0x1D,
bcRSin = 0x1E,
// bcCreate = 0x1F,
bcRCos = 0x20,
bcRArcTan = 0x21,
bcPushD = 0x22,
bcPopD = 0x23,
// bcXCopy = 0x24,
bcInclude = 0x25, // should immediately follow exclude (after callextr)
bcExclude = 0x26,
bcTryLock = 0x27,
bcFreeLock = 0x28,
// bcRethrow = 0x29,
bcLoadEnv = 0x2A,
// bcSelect = 0x2B,
bcRLn = 0x2C,
bcRead = 0x2D,
bcClone = 0x2E,
bcXSet = 0x2F,
bcRAbs = 0x30,
bcLen = 0x31,
bcRLoad = 0x32,
bcFlag = 0x33,
// bcNLen = 0x34,
bcParent = 0x35,
bcClass = 0x36,
bcMIndex = 0x37,
// bcCheck = 0x38,
// bcACallVD = 0x39,
// bcValidate = 0x3A,
// bcDMoveVerb = 0x3C,
bcRRound = 0x3D,
bcEqual = 0x3E,
bcNEqual = 0x40,
bcNLess = 0x41,
// bcNCopy = 0x42,
bcLEqual = 0x43,
bcLLess = 0x44,
bcRSet = 0x45,
bcRSave = 0x46,
bcSave = 0x47,
bcLoad = 0x48,
bcRSaveN = 0x49,
bcRSaveL = 0x4A,
bcLSave = 0x4B,
// bcNXor = 0x4C,
// bcNShiftL = 0x4D,
// bcNNot = 0x4E,
bcRInt = 0x4F,
bcAddF = 0x50,
bcSubF = 0x51,
bcNXorF = 0x52,
bcNOrF = 0x53,
bcNAndF = 0x54,
// bcWRead = 0x59,
bcXSave = 0x5A,
bcDiv = 0x5B,
bcXWrite = 0x5C,
bcCopyTo = 0x5D,
bcNShlF = 0x5E,
bcNShrF = 0x5F,
bcMul = 0x60,
bcCheckSI = 0x61,
bcXRedirect = 0x62,
bcXVRedirect = 0x63,
// bcBReadB = 0x65,
// bcBWrite = 0x69,
// bcBWriteB = 0x6C,
// bcBWriteW = 0x6D,
// bcBCreate = 0x6F,
//
// bcLCopy = 0x70,
// bcLSave = 0x71,
// bcLEqual = 0x72,
// bcLLess = 0x73,
bcLAddF = 0x74,
bcLSubF = 0x75,
bcLMulF = 0x76,
bcLDivF = 0x77,
bcLAndF = 0x78,
bcLOrF = 0x79,
bcLXorF = 0x7A,
bcLShlF = 0x7B,
// bcLNot = 0x7C,
bcLShrF = 0x7D,
bcRAddNF = 0x80,
bcRSubNF = 0x81,
bcRMulNF = 0x82,
bcREqual = 0x83,
bcRLess = 0x84,
bcRAddF = 0x85,
bcRSubF = 0x86,
bcRMulF = 0x87,
bcRDivF = 0x88,
bcRDivNF = 0x89,
bcRIntF = 0x8E,
bcDec = 0x90,
bcGetI = 0x91,
bcRestore = 0x92,
bcPeekR = 0x93,
bcPeekFI = 0x94,
bcPeekSI = 0x95,
bcIfHeap = 0x96,
bcXSetI = 0x97,
bcOpen = 0x98,
bcQuitN = 0x99,
bcCreate = 0x9A,
bcFillR = 0x9B,
bcMovF = 0x9C,
bcMovS = 0x9D,
bcMovR = 0x9E,
bcMovM = 0x9F,
bcJump = 0xA0,
bcJumpVI = 0xA1,
bcCallVI = 0xA2,
bcCallR = 0xA3,
bcJumpI = 0xA4,
bcCallExtR = 0xA5,
bcHook = 0xA6,
bcAddress = 0xA7,
bcCallI = 0xA8,
// bcLess = 0xA9,
bcNotLess = 0xAA,
bcNotGreater = 0xAB,
bcElseD = 0xAC,
bcIf = 0xAD,
bcElse = 0xAE,
bcIfCount = 0xAF,
bcPushN = 0xB0,
bcMovN = 0xB1,
bcPushR = 0xB2,
bcEqualFI = 0xB3,
bcPushAI = 0xB4,
bcLoadF = 0xB5,
bcPushFI = 0xB6,
bcLoadFI = 0xB7,
bcLoadSI = 0xB8,
bcSaveF = 0xB9,
bcPushSI = 0xBA,
bcSaveSI = 0xBB,
bcSaveFI = 0xBC,
bcPushF = 0xBD,
bcPushS = 0xBE,
bcReserve = 0xBF, // should be used only for unmanaged stack (stack may contains old references, which may break GC)
bcSetI = 0xC0,
// bcNWriteI = 0xC1,
// bcASwapSI = 0xC2,
bcStoreSI = 0xC3,
bcStoreFI = 0xC4,
bcNAddF = 0xC5,
bcNMulF = 0xC6,
// bcDSwapSI = 0xC7,
bcNSubF = 0xC8,
bcNDivF = 0xC9,
bcLoadI = 0xCA,
bcSaveI = 0xCB,
bcStoreR = 0xCC,
bcLCallExtR = 0xCD,
bcCloneF = 0xCE,
bcXLoad = 0xCF,
bcFreeI = 0xD0,
bcAllocI = 0xD1,
bcXCreate = 0xD2,
bcMovV = 0xD3,
bcShl = 0xD4,
bcAnd = 0xD5,
bcInc = 0xD6,
bcOr = 0xD7,
bcCoalesceR = 0xD8,
bcShr = 0xD9,
bcXOr = 0xDA,
bcXSaveAI = 0xDC,
bcCopyAI = 0xDD,
bcMove = 0xDE,
bcMoveTo = 0xDF,
bcReadToF = 0xE0,
bcCreateN = 0xE1,
bcXSetFI = 0xE2,
bcCopyToAI = 0xE3,
bcCopyToFI = 0xE4,
bcCopyToF = 0xE5,
bcCopyFI = 0xE6,
bcCopyF = 0xE7,
bcMTRedirect = 0xE8,
bcXMTRedirect = 0xE9,
bcGreaterN = 0xEA, // note that for code simplicity reverse order is used for jump parameters (jump label, arg)
bcNotGreaterN = 0xEB, // note that for code simplicity reverse order is used for jump parameters (jump label, arg)
bcNotLessN = 0xEC, // note that for code simplicity reverse order is used for jump parameters (jump label, arg)
bcXRSaveF = 0xED,
bcXAddF = 0xEE,
bcXSaveF = 0xEF,
bcNew = 0xF0,
bcNewN = 0xF1,
bcFillRI = 0xF2,
bcXSelectR = 0xF3,
bcVCallRM = 0xF4,
bcJumpRM = 0xF5,
bcSelect = 0xF6,
bcLessN = 0xF7, // note that for code simplicity reverse order is used for jump parameters (jump label, arg)
// bcIfM = 0xF8, // note that for code simplicity reverse order is used for jump parameters (jump label, arg)
// bcElseM = 0xF9, // though in bytecode section they saved in the correct order (jump arg, label)
bcIfR = 0xFA,
bcElseR = 0xFB,
bcIfN = 0xFC,
bcElseN = 0xFD,
bcCallRM = 0xFE,
bcReserved = 0xFF,
// labels
blLabelMask = 0xC000, // tape label mask
blBegin = 0xC001, // meta command, declaring the structure
blEnd = 0xC002, // meta command, closing the structure
blLabel = 0xC003, // meta command, declaring the label
blBreakLabel = 0xC004, // meta command, breaking the optimization rules
// meta commands:
//bcAllocStack = 0x8101, // meta command, used to indicate that the previous command allocate number of items in the stack; used only for exec
//bcFreeStack = 0x8102, // meta command, used to indicate that the previous command release number of items from stack; used only for exec
//bcResetStack = 0x8103, // meta command, used to indicate that the previous command release number of items from stack; used only for exec
bcMatch = 0x8FFE, // used in optimization engine
bcNone = 0x8FFF, // used in optimization engine
//blDeclare = 0x8120, // meta command, closing the structure
blStatement = 0x8121, // meta command, declaring statement
blBlock = 0x8122, // meta command, declaring sub code
// debug info
//bdDebugInfo = 0x8400,
bdBreakpoint = 0x8401,
bdBreakcoord = 0x8402,
bdLocal = 0x8403,
bdSelf = 0x8404,
bdMessage = 0x8405,
bdLocalInfo = 0x8406,
bdSourcePath = 0x8407,
bdIntLocal = 0x8413,
bdLongLocal = 0x8423,
bdRealLocal = 0x8433,
bdParamsLocal = 0x8443,
bdByteArrayLocal = 0x8453,
bdShortArrayLocal= 0x8463,
bdIntArrayLocal = 0x8473,
bdStruct = 0x8486,
bdStructSelf = 0x8484,
};
#define MAX_SINGLE_ECODE 0x4F
#define MAX_DOUBLE_ECODE 0xDB
enum PseudoArg
{
baNone = 0,
baFirstLabel = 1,
baCurrentLabel = 2,
baPreviousLabel = 3,
baPrev2Label = 4, // before previous
};
enum Predicate
{
bpNone = 0,
bpFrame = 1,
// bpBlock = 2
};
enum TapeStructure
{
bsNone = 0x0,
bsSymbol = 0x1,
bsClass = 0x2,
bsMethod = 0x3,
//bsBranch = 0x5,
bsImport = 0x6,
bsInitializer = 0x7,
};
struct ByteCommand
{
ByteCode code;
int argument;
int additional;
Predicate predicate;
int Argument() const { return argument; }
operator ByteCode() const { return code; }
ByteCommand()
{
code = bcNop;
argument = 0;
additional = 0;
predicate = bpNone;
}
ByteCommand(ByteCode code)
{
this->code = code;
this->argument = 0;
this->additional = 0;
this->predicate = bpNone;
}
ByteCommand(ByteCode code, int argument)
{
this->code = code;
this->argument = argument;
this->additional = 0;
this->predicate = bpNone;
}
ByteCommand(ByteCode code, int argument, int additional)
{
this->code = code;
this->argument = argument;
this->additional = additional;
this->predicate = bpNone;
}
ByteCommand(ByteCode code, int argument, int additional, Predicate predicate)
{
this->code = code;
this->argument = argument;
this->additional = additional;
this->predicate = predicate;
}
void save(MemoryWriter* writer, bool commandOnly = false)
{
writer->writeByte((unsigned char)code);
if (!commandOnly && (code > MAX_SINGLE_ECODE)) {
writer->writeDWord(argument);
}
if (!commandOnly && (code > MAX_DOUBLE_ECODE)) {
writer->writeDWord(additional);
}
}
// save additional argument if required
void saveAditional(MemoryWriter* writer)
{
if (code > MAX_DOUBLE_ECODE) {
writer->writeDWord(additional);
}
}
};
// --- ByteCodeCompiler ---
class ByteCodeCompiler
{
public:
//static void loadVerbs(MessageMap& verbs);
static void loadOperators(MessageMap& operators);
static ByteCode code(ident_t s);
static ident_t decode(ByteCode code, char* s);
static bool IsJump(ByteCode code)
{
switch(code) {
case bcJump:
case bcIfR:
case bcElseR:
//case bcIfB:
case bcElseD:
case bcIf:
case bcIfCount:
case bcElse:
//case bcLess:
case bcNotLess:
case bcNotGreater:
case bcIfN:
case bcElseN:
case bcLessN:
case bcNotLessN:
case bcGreaterN:
case bcNotGreaterN:
//case bcIfM:
//case bcElseM:
//case bcNext:
case bcIfHeap:
case bcHook:
case bcAddress:
return true;
default:
return false;
}
}
static bool IsRCode(ByteCode code)
{
switch(code) {
case bcPushR:
////case bcEvalR:
case bcCallR:
case bcPeekR:
case bcStoreR:
case bcMovR:
case bcNew:
case bcFillRI:
case bcFillR:
case bcNewN:
//case bcBCopyR:
case bcCallRM:
case bcCallExtR:
case bcLCallExtR:
case bcSelect:
case bcJumpRM:
case bcVCallRM:
//case bcBLoadR:
case bcCreate:
case bcXCreate:
case bcCreateN:
case bcCoalesceR:
case bcXSelectR:
return true;
default:
return false;
}
}
static bool IsR2Code(ByteCode code)
{
switch(code) {
case bcIfR:
case bcElseR:
case bcSelect:
case bcXSelectR:
return true;
default:
return false;
}
}
static bool IsM2Code(ByteCode code)
{
switch (code) {
case bcVCallRM:
case bcCallRM:
//case bcIfM:
//case bcElseM:
return true;
default:
return false;
}
}
static bool IsMCode(ByteCode code)
{
switch (code) {
case bcMovM:
return true;
default:
return false;
}
}
static bool IsMNCode(ByteCode code)
{
switch (code) {
case bcMovV:
return true;
default:
return false;
}
}
static bool IsPush(ByteCode code)
{
switch(code) {
case bcPushA:
//case bcPushB:
case bcPushFI:
case bcPushN:
case bcPushR:
case bcAllocI:
case bcPushSI:
case bcPushS:
case bcPushAI:
case bcPushF:
//case bcPushE:
case bcPushD:
return true;
default:
return false;
}
}
static bool IsPop(ByteCode code)
{
switch(code) {
//case bcPop:
case bcPopA:
case bcFreeI:
//case bcPopB:
//case bcPopE:
case bcPopD:
return true;
default:
return false;
}
}
static bool resolveMessageName(IdentifierString& messageName, _Module* module, size_t messageRef);
};
// --- CommandTape ---
typedef BList<ByteCommand>::Iterator ByteCodeIterator;
struct CommandTape
{
BList<ByteCommand> tape; // !! should we better use an array?
int labelSeed;
Stack<int> labels;
ByteCodeIterator start() { return tape.start(); }
ByteCodeIterator end() { return tape.end(); }
int newLabel()
{
labelSeed++;
labels.push(labelSeed);
return labelSeed;
}
void setLabel(bool persist = false)
{
if (persist) {
write(blLabel, labels.peek());
}
else write(blLabel, labels.pop());
}
void setPreviousLabel()
{
int lastLabel = labels.pop();
write(blLabel, labels.pop());
labels.push(lastLabel);
}
// to resolve possible conflicts the predefined labels should be negative
void setPredefinedLabel(int label)
{
write(blLabel, label);
}
void releaseLabel()
{
labels.pop();
}
int exchangeFirstsLabel(int newLabel)
{
auto it = labels.end();
int oldLabel = *it;
*it = newLabel;
return oldLabel;
}
ByteCodeIterator find(ByteCode code);
ByteCodeIterator find(ByteCode code, int argument);
int resolvePseudoArg(PseudoArg argument);
void write(ByteCode code);
void write(ByteCode code, int argument);
void write(ByteCode code, PseudoArg argument);
void write(ByteCode code, int argument, int additional);
void write(ByteCode code, PseudoArg argument, int additional);
void write(ByteCode code, TapeStructure argument, int additional);
void write(ByteCode code, int argument, int additional, Predicate predicate);
void write(ByteCode code, int argument, Predicate predicate);
void write(ByteCommand command);
void insert(ByteCodeIterator& it, ByteCommand command);
// ByteCommand extract()
// {
// ByteCommand command = *tape.end();
// tape.cut(tape.end());
//
// return command;
// }
void import(_Memory* section, bool withHeader = false, bool withBreakpoints = false);
static bool optimizeIdleBreakpoints(CommandTape& tape);
static bool optimizeJumps(CommandTape& tape);
static bool importReference(ByteCommand& command, _Module* sour, _Module* dest);
CommandTape()
{
labelSeed = 0;
}
void clear()
{
tape.clear();
labelSeed = 0;
labels.clear();
}
};
// --- ByteRule ---
enum PatternArgument
{
braNone = 0,
braValue,
braAditionalValue,
braAdd,
braCopy,
braMatch,
braSame, // TransformTape should perform xor operation with the argument (1 if same, 0 if different)
braAdditionalSame // TransformTape should perform xor operation with the argument (1 if same, 0 if different)
};
struct ByteCodePattern
{
ByteCode code;
PatternArgument argumentType;
int argument;
bool operator ==(ByteCode code) const
{
return (this->code == code);
}
bool operator !=(ByteCode code) const
{
return (this->code != code);
}
bool operator ==(ByteCommand command) const
{
if (this->code == command.code) {
if (argumentType == braSame || argumentType == braAdditionalSame) {
return argument == 0;
}
else return argumentType != braMatch || argument == command.argument;
}
else return false;
}
bool operator !=(ByteCommand command) const
{
return !(*this == command);
}
bool operator ==(ByteCodePattern pattern)
{
return (code == pattern.code && argumentType == pattern.argumentType && argument == pattern.argument);
}
bool operator !=(ByteCodePattern pattern)
{
return !(*this == pattern);
}
ByteCodePattern()
{
code = bcNone;
argumentType = braNone;
argument = 0;
}
ByteCodePattern(ByteCode code)
{
this->code = code;
this->argumentType = braNone;
this->argument = 0;
}
};
// --- TransformTape ---
struct TransformTape
{
typedef MemoryTrie<ByteCodePattern> MemoryByteTrie;
typedef MemoryTrieNode<ByteCodePattern> Node;
MemoryByteTrie trie;
bool loaded;
bool apply(CommandTape& tape);
void transform(ByteCodeIterator& trans_it, Node replacement);
bool makeStep(Node& step, ByteCommand& command, int previousArg);
void load(StreamReader* optimization)
{
loaded = true;
trie.load(optimization);
}
TransformTape()
: trie(ByteCodePattern(bcNone))
{
loaded = false;
}
};
} // _ELENA_
#endif // bytecodeH
| [
"arakov@yandex.ru"
] | arakov@yandex.ru |
c7cbde4fefda9f4f04d126666c49b772a8496737 | a7d268b5604acc600ab19f3c6c078e5ad3b70d39 | /cpp_learning/cpp_learning/PostMasterMessage.h | 67702614aa5adc9a262876e6f8f90c79b7bbdc84 | [] | no_license | 08zhangyi/cpp_learning | 2a0165303fae04fe6f53e6f56e7a25e353406ba1 | e0e4847d285841c7bba5ba78d8ba68a5bbc9f3f8 | refs/heads/master | 2020-04-09T16:24:56.373818 | 2019-01-13T01:21:14 | 2019-01-13T01:21:14 | 160,452,775 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 464 | h | #pragma once
class MailMessage
{};
class PostMasterMessage : public MailMessage
{
public:
PostMasterMessage();
PostMasterMessage(pAddress sender, pAddress recipient, pString subject, pDate, creationDate);
~PostMasterMessage();
pAddress& getSender() const;
void setSender(pAddress&);
private:
pAddress sender;
pAddress recipient;
pString subject;
pDate creationDate;
pDate lastModDate;
pDate receiptDate;
pDate firstReadDate;
pDate lastReadDate;
}; | [
"395871987@qq.com"
] | 395871987@qq.com |
02d17a71c03a9f4174230272b2a172f3a86c8896 | 3bb7933b38936e251e0b5e7041f5f93c6ce5efbb | /Main_EX603/Main/Interface.cpp | 662e16397b98d7d9e8bf9825418a21a48db57df1 | [] | no_license | sonniit92/MuEmu-source | c998050daee818080117770aa9758c67245c14df | a3380506929d304b3af5c67a95b0edf408e6658d | refs/heads/master | 2023-03-18T08:13:14.486171 | 2017-04-21T03:14:40 | 2017-04-21T03:14:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 42,004 | cpp | #include "stdafx.h"
#include "Interface.h"
#include "TMemory.h"
#include "Protocol.h"
#include "Offset.h"
#include "User.h"
#include "Import.h"
#include "Defines.h"
#include "Camera.h"
#include "Fog.h"
#include "Other.h"
#include "Graphics.h"
#include "Glow.h"
#include "ChatExpanded.h"
#include "Reconnect.h"
#include "Config.h"
Interface gInterface;
DWORD CharacterInfoExtern_Buff;
char CharacterInfoExtern_LevelBuff[80];
DWORD AddSomeShine_Buff;
DWORD AddSomeShine_Pointer;
bool Checkbox = true;
Interface::Interface()
{
ZeroMemory(this->Data, sizeof(this->Data));
}
Naked(AddSomeShine)
{
_asm
{
mov eax, dword ptr ds:[ecx + 0x30]
mov AddSomeShine_Buff, eax
}
if( AddSomeShine_Buff == 349 || AddSomeShine_Buff == 406 || AddSomeShine_Buff == 407 || AddSomeShine_Buff == 408 )
{
_asm
{
mov AddSomeShine_Buff, 0x005E4979
jmp AddSomeShine_Buff
}
}
else
{
_asm
{
mov AddSomeShine_Buff, 0x005E4A3C
jmp AddSomeShine_Buff
}
}
}
void Interface::Load()
{
this->BindObject(eSAMPLEBUTTON, 0x7AA4, 16, 15, 175, 1);
this->BindObject(eCheck, 0x9991, 15, 15, -1, -1);
this->BindObject(eUnCheck, 0x9992, 15, 15, -1, -1);
this->BindObject(eTIME, 0x787E, 73, 20, 174, 0);
this->BindObject(eCAMERA_MAIN, 0x787A, 54, 18, 174, 0);
this->BindObject(eCAMERA_BUTTON1, 0x787B, 16, 12, 175.5, 1);
this->BindObject(eCAMERA_BUTTON2, 0x787C, 16, 12, 192.5, 1);
this->BindObject(eLOGO, 0x9989, 63.3, 50, 192.5, 1);
this->BindObject(eSHOP_WC, 0x7E54, 52, 25, -1, -1);
this->BindObject(eSHOP_WP, 0x7E54, 52, 25, -1, -1);
this->BindObject(eSHOP_GP, 0x7E54, 52, 25, -1, -1);
this->BindObject(eSHOP_B, 0x7E54, 52, 25, -1, -1);
this->BindObject(eSHOP_S, 0x7E54, 52, 25, -1, -1);
this->BindObject(eSHOP_C, 0x7E54, 52, 25, -1, -1);
this->BindObject(eSHOP_OFF, 0x7C04, 36, 27, -1, -1);
this->BindObject(eOFFPANEL_MAIN, 0x7A5A, 222, 120, -1, -1);
this->BindObject(eOFFPANEL_TITLE, 0x7A63, 230, 67, -1, -1);
this->BindObject(eOFFPANEL_FRAME, 0x7A58, 230, 15, -1, -1);
this->BindObject(eOFFPANEL_FOOTER, 0x7A59, 230, 50, -1, -1);
this->BindObject(eOFFPANEL_YES, 0x7B12, 54, 30, -1, -1);
this->BindObject(eOFFPANEL_CANE, 0x7B0C, 54, 30, -1, -1);
this->BindObject(eUSERSPANEL_MAIN, 0x7A5A, 222, 303, -1, -1);
this->BindObject(eUSERSPANEL_TITLE, 0x7A63, 230, 67, -1, -1);
this->BindObject(eUSERSPANEL_FRAME, 0x7A58, 230, 15, -1, -1);
this->BindObject(eUSERSPANEL_FOOTER, 0x7A59, 230, 50, -1, -1);
this->BindObject(eUSERSPANEL_DIV, 0x7A62, 223, 21, -1, -1);
this->BindObject(eUSERSPANEL_OPTION, 0x7B68, 10, 10, -1, -1);
this->BindObject(eUSERSPANEL_LINE, 0x7B67, 154, 2, -1, -1);
this->BindObject(eUSERSPANEL_BUTTON, 0x9994, 40, 19, -1, -1);
this->BindObject(eUSERSPANEL_BUTTON1, 0x9994, 40, 19, -1, -1);
this->BindObject(eUSERSPANEL_BUTTON2, 0x9994, 40, 19, -1, -1);
this->BindObject(eUSERSPANEL_FOG, 0x9991, 15, 15, -1, -1);
this->BindObject(eUSERSPANEL_CLOSE, 0x7A5E, 128, 29, -1, -1);
this->BindObject(eUSERSPANEL_HPBAR, 0x9991, 15, 15, -1, -1);
this->BindObject(eUSERSPANEL_RANKHIDE, 0x9991, 15, 15, -1, -1);
this->BindObject(eUSERSPANEL_TRONGLOW, 0x9991, 15, 15, -1, -1);
this->BindObject(eUSERSPANEL_CHAT, 0x9991, 15, 15, -1, -1);
this->BindObject(eUSERSPANEL_MINIMAP, 0x9991, 15, 15, -1, -1);
this->BindObject(eUSERSPANEL_CAMERA, 0x9991, 15, 15, -1, -1);
//Minimap
this->BindObject(ePLAYER_POINT, 0x7883, 3, 3, -1, -1);
this->BindObject(eNULL_MAP, 0x7884, 128, 128, -1, -1);
this->BindObject(eLORENCIA_MAP, 0x7885, 128, 128, -1, -1);
this->BindObject(eDUNGEON_MAP, 0x7886, 128, 128, -1, -1);
this->BindObject(eDEVIAS_MAP, 0x7887, 128, 128, -1, -1);
this->BindObject(eNORIA_MAP, 0x7888, 128, 128, -1, -1);
this->BindObject(eLOSTTOWER_MAP, 0x7889, 128, 128, -1, -1);
this->BindObject(eATLANS_MAP, 0x788C, 128, 128, -1, -1);
this->BindObject(eTarkan_MAP, 0x7890, 128, 128, -1, -1);
this->BindObject(eElbeland_MAP, 0x7891, 128, 128, -1, -1);
this->BindObject(eICARUS_MAP, 0x7892, 128, 128, -1, -1);
this->BindObject(eLANDOFTRIALS_MAP, 0x7893, 128, 128, -1, -1);
this->BindObject(eAIDA_MAP, 0x7894, 128, 128, -1, -1);
this->BindObject(eCRYWOLF_MAP, 0x7895, 128, 128, -1, -1);
this->BindObject(eKANTRU_MAP, 0x7896, 128, 128, -1, -1);
this->BindObject(eKANTRU3_MAP, 0x7897, 128, 128, -1, -1);
this->BindObject(eBARRACKS_MAP, 0x7898, 128, 128, -1, -1);
this->BindObject(eCALMNESS_MAP, 0x7899, 128, 128, -1, -1);
this->BindObject(eRAKLION_MAP, 0x7900, 128, 128, -1, -1);
this->BindObject(eVULCANUS_MAP, 0x7901, 128, 128, -1, -1);
this->BindObject(eKALRUTAN_MAP, 0x7902, 128, 128, -1, -1);
this->BindObject(eKALRUTAN2_MAP, 0x7903, 128, 128, -1, -1);
//
this->Data[eTIME].OnShow = true;
//this->showMiniMap = false;
//SetOp((LPVOID)oAllowGUI_Call1, this->AllowGUI, ASM::CALL);
//SetOp((LPVOID)oAllowGUI_Call2, this->AllowGUI, ASM::CALL);
SetOp((LPVOID)oDrawInterface_Call, this->Work, ASM::CALL);
SetOp((LPVOID)oLoadSomeForm_Call, this->LoadImages, ASM::CALL);
SetOp((LPVOID)0x00633FFB, this->LoadModels, ASM::CALL);
}
void Interface::Work()
{
gInterface.DrawTimeUI();
gObjUser.Refresh();
gCamera.Rotate();
gCamera.Position();
gInterface.DrawMiniMap();
ReconnectMainProc();
gInterface.DrawPSHOP();
gInterface.DrawPSHOP_OFFMODE();
gInterface.DrawUsersPanelWindow();
gInterface.DrawCameraUI();
pDrawInterface();
}
void Interface::LoadImages()
{
pLoadImage("Custom\\Interface\\TimeBar.tga", 0x787E, 0x2601, 0x2901, 1, 0);
pLoadImage("Custom\\Interface\\CameraUI_BG.tga", 0x787A, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Interface\\CameraUI_Switch.tga", 0x787B, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Interface\\CameraUI_Reset.tga", 0x787C, 0x2601, 0x2900, 1, 0);
// logo
pLoadImage("Custom\\logo\\mwebgame.tga", 0x9989, 0x2601, 0x2900, 1, 0);
// MiniMap
pLoadImage("Custom\\Interface\\check.jpg", 0x9991, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Interface\\uncheck.jpg", 0x9992, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Interface\\button.tga", 0x9994, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\PlayerPoint.jpg", 0x7883, 0x2600, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\null.tga", 0x7884, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Lorencia.tga", 0x7885, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Dungeon.tga", 0x7886, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Devias.tga", 0x7887, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Noria.tga", 0x7888, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Losttower.tga", 0x7889, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Atlans.tga", 0x788C, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Tarkan.tga", 0x7890, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Elbeland.tga", 0x7891, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Icarus.tga", 0x7892, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\LandOfTrials.tga", 0x7893, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Aida.tga", 0x7894, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Crywolf.tga", 0x7895, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Kantru.tga", 0x7896, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Kantru3.tga", 0x7897, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Barracks.tga", 0x7898, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Calmness.tga", 0x7899, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Raklion.tga", 0x7900, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Vulcanus.tga", 0x7901, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Kalrutan.tga", 0x7902, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Maps\\Kalrutan2.tga", 0x7903, 0x2601, 0x2900, 1, 0);
// Danh Hieu
pLoadImage("Custom\\Rank\\anhdungthienchien.tga", 0x9960, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\bantayvang.tga", 0x9961, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\binhmadainguyensoai.tga", 0x9962, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\chiengiapthanthanh.tga", 0x9963, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\chuyengiadaomo.tga", 0x9964, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\doccocaubai.tga", 0x9965, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\doitruongkybinh.tga", 0x9966, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\gianghohaohiep.tga", 0x9967, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\gianghoneso.tga", 0x9968, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\hoangthanhbachu.tga", 0x9969, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\toiactaytroi.tga", 0x9970, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\tiendechetnguoi.tga", 0x9971, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\nghiengnuocnghiengthanh.tga", 0x9972, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\phungvucuuthien.tga", 0x9973, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\Rank\\suonglonghiepcot.tga", 0x9980, 0x2601, 0x2900, 1, 0);
//Rank thuoc tinh
pLoadImage("Custom\\element\\element_dark.tga", 0x9985, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\element\\element_fire.tga", 0x9984, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\element\\element_land.tga", 0x9986, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\element\\element_water.tga", 0x9987, 0x2601, 0x2900, 1, 0);
pLoadImage("Custom\\element\\element_wind.tga", 0x9988, 0x2601, 0x2900, 1, 0);
// ----
pLoadSomeForm();
}
void Interface::LoadModels()
{
pInitModelData2();
}
void Interface::BindObject(short MonsterID, DWORD ModelID, float Width, float Height, float X, float Y)
{
this->Data[MonsterID].EventTick = 0;
this->Data[MonsterID].OnClick = false;
this->Data[MonsterID].OnShow = false;
this->Data[MonsterID].ModelID = ModelID;
this->Data[MonsterID].Width = Width;
this->Data[MonsterID].Height = Height;
this->Data[MonsterID].X = X;
this->Data[MonsterID].Y = Y;
this->Data[MonsterID].MaxX = X + Width;
this->Data[MonsterID].MaxY = Y + Height;
this->Data[MonsterID].Attribute = 0;
}
void Interface::DrawSampleButton()
{
float PosX = this->GetResizeX(eSAMPLEBUTTON);
if( this->CheckWindow(ObjWindow::CashShop)
|| this->CheckWindow(ObjWindow::FullMap)
|| this->CheckWindow(ObjWindow::SkillTree)
|| this->CheckWindow(MoveList) )
{
return;
}
this->DrawGUI(eSAMPLEBUTTON, PosX, 1);
if( !IsWorkZone(eSAMPLEBUTTON) )
{
return;
}
this->DrawToolTip(PosX - 5, 31, "Button tooltip");
if( this->Data[eSAMPLEBUTTON].OnClick )
{
this->DrawColoredGUI(eSAMPLEBUTTON, PosX, 1, pMakeColor(40, 20, 3, 130));
return;
}
this->DrawColoredGUI(eSAMPLEBUTTON, PosX, 1, pMakeColor(255, 204, 20, 130));
}
void Interface::EventSampleButton(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eSAMPLEBUTTON].EventTick);
if( this->CheckWindow(CashShop) || this->CheckWindow(FullMap)
|| this->CheckWindow(SkillTree) || this->CheckWindow(MoveList)
|| !IsWorkZone(eSAMPLEBUTTON) )
{
return;
}
if( Event == WM_LBUTTONDOWN )
{
this->Data[eSAMPLEBUTTON].OnClick = true;
return;
}
this->Data[eSAMPLEBUTTON].OnClick = false;
if( Delay < 500 )
{
return;
}
this->Data[eSAMPLEBUTTON].EventTick = GetTickCount();
if( !this->Data[eRANK_MAIN].OnShow )
{
this->Data[eRANK_MAIN].OnShow = true;
}
else
{
this->Data[eRANK_MAIN].OnShow = false;
}
}
void Interface::DrawCameraUI()
{
float PosX = this->GetResizeX(eCAMERA_MAIN);
// ----
if (this->CheckWindow(CashShop)
|| this->CheckWindow(SkillTree)
|| this->CheckWindow(FullMap)
|| this->CheckWindow(MoveList)
|| (this->CheckWindow(Inventory)
&& this->CheckWindow(ExpandInventory)
&& this->CheckWindow(Store))
|| (this->CheckWindow(Inventory)
&& this->CheckWindow(Warehouse)
&& this->CheckWindow(ExpandWarehouse)))
{
return;
}
// ----
this->DrawGUI(eCAMERA_MAIN, PosX, 0);
this->DrawGUI(eCAMERA_BUTTON1, PosX + 0.5, 1);
this->DrawGUI(eCAMERA_BUTTON2, PosX + 18.5, 1);
this->DrawGUI(eLOGO, PosX + 370, 20);
// ----
if (gCamera.IsActive)
{
this->DrawColoredGUI(eCAMERA_BUTTON1, PosX + 0.5, 1, eShinyGreen);
}
// ----
if (IsWorkZone(eCAMERA_BUTTON1))
{
if (gCamera.IsActive)
{
this->DrawToolTip(PosX + 0.5 - 5, 25, "Zoom: %02.f%%", gCamera.ZoomPercent);
}
else
{
this->DrawToolTip(PosX + 0.5 - 5, 25, "3D Camera [On|Off]");
}
// ----
if (this->Data[eCAMERA_BUTTON1].OnClick)
{
this->DrawColoredGUI(eCAMERA_BUTTON1, PosX + 0.5, 1, pMakeColor(40, 20, 3, 130));
return;
}
// ----
this->DrawColoredGUI(eCAMERA_BUTTON1, PosX + 0.5, 1, pMakeColor(255, 204, 20, 200));
}
else if (IsWorkZone(eCAMERA_BUTTON2))
{
this->DrawToolTip(PosX + 18.5 - 5, 25, "3D Camera [Reset]");
// ----
if (this->Data[eCAMERA_BUTTON2].OnClick)
{
this->DrawColoredGUI(eCAMERA_BUTTON2, PosX + 18.5, 1, pMakeColor(40, 20, 3, 130));
return;
}
// ----
this->DrawColoredGUI(eCAMERA_BUTTON2, PosX + 18.5, 1, pMakeColor(255, 204, 20, 200));
}
}
// ----------------------------------------------------------------------------------------------
void Interface::EventCameraUI(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
// ----
if (this->CheckWindow(CashShop)
|| this->CheckWindow(SkillTree)
|| this->CheckWindow(FullMap)
|| this->CheckWindow(MoveList)
|| (this->CheckWindow(Inventory)
&& this->CheckWindow(ExpandInventory)
&& this->CheckWindow(Store))
|| (this->CheckWindow(Inventory)
&& this->CheckWindow(Warehouse)
&& this->CheckWindow(ExpandWarehouse)))
{
return;
}
// ----
if (IsWorkZone(eCAMERA_BUTTON1))
{
DWORD Delay = (CurrentTick - this->Data[eCAMERA_BUTTON1].EventTick);
// ----
if (Event == WM_LBUTTONDOWN)
{
this->Data[eCAMERA_BUTTON1].OnClick = true;
return;
}
// ----
this->Data[eCAMERA_BUTTON1].OnClick = false;
// ----
if (Delay < 500)
{
return;
}
// ----
this->Data[eCAMERA_BUTTON1].EventTick = GetTickCount();
// ----
gCamera.Switch();
}
else if (IsWorkZone(eCAMERA_BUTTON2))
{
DWORD Delay = (CurrentTick - this->Data[eCAMERA_BUTTON2].EventTick);
// ----
if (Event == WM_LBUTTONDOWN)
{
this->Data[eCAMERA_BUTTON2].OnClick = true;
return;
}
// ----
this->Data[eCAMERA_BUTTON2].OnClick = false;
// ----
if (Delay < 500)
{
return;
}
// ----
this->Data[eCAMERA_BUTTON2].EventTick = GetTickCount();
// ----
gCamera.Init();
}
}
// ----------------------------------------------------------------------------------------------
bool Interface::CheckWindow(int WindowID)
{
return pCheckWindow(pWindowThis(), WindowID);
}
int Interface::CloseWindow(int WindowID)
{
return pCloseWindow(pWindowThis(), WindowID);
}
int Interface::OpenWindow(int WindowID)
{
return pOpenWindow(pWindowThis(), WindowID);
}
void Interface::DrawTimeUI()
{
if (!this->Data[eTIME].OnShow)
{
return;
}
// ----
if (this->CheckWindow(ObjWindow::CashShop) || this->CheckWindow(ObjWindow::SkillTree)
|| this->CheckWindow(ObjWindow::MoveList) || this->CheckWindow(ObjWindow::ChatWindow))
{
return;
}
// ----
this->DrawGUI(eTIME, 0.0f, 412.0f);
// -----
time_t TimeLocal;
struct tm * LocalT;
time(&TimeLocal);
LocalT = localtime(&TimeLocal);
char LocalTime[30];
sprintf(LocalTime, "%2d:%02d:%02d", LocalT->tm_hour, LocalT->tm_min, LocalT->tm_sec);
this->DrawFormat(eWhite, 25.0f, 418.0f, 100.0f, 1.0f, LocalTime);
}
/*
bool Interface::AllowGUI()
{
if( gInterface.CheckResetWindow())
{
return false;
}
return pAllowGUI();
}
*/
void Interface::SetTextColor(BYTE Red, BYTE Green, BYTE Blue, BYTE Opacity)
{
pSetTextColor(pTextThis(), Red, Green, Blue, Opacity);
}
void Interface::DrawText(int X, int Y, LPCTSTR Text)
{
pDrawText(pTextThis(), X, Y, Text, 0, 0, (LPINT)1, 0);
}
int Interface::DrawFormat(DWORD Color, int PosX, int PosY, int Width, int Align, LPCSTR Text, ...)
{
char Buff[2048];
int BuffLen = sizeof(Buff)-1;
ZeroMemory(Buff, BuffLen);
va_list args;
va_start(args, Text);
int Len = vsprintf_s(Buff, BuffLen, Text, args);
va_end(args);
int LineCount = 0;
char * Line = strtok(Buff, "\n");
while( Line != NULL )
{
pDrawColorText(Line, PosX, PosY, Width, 0, Color, 0, Align);
PosY += 10;
Line = strtok(NULL, "\n");
}
return PosY;
}
void Interface::DrawFormatEx(DWORD Color, int PosX, int PosY, int Width, int Align, LPCSTR Text, ...)
{
char Buff[2048];
int BuffLen = sizeof(Buff)-1;
ZeroMemory(Buff, BuffLen);
va_list args;
va_start(args, Text);
int Len = vsprintf_s(Buff, BuffLen, Text, args);
va_end(args);
pDrawColorText(Buff, PosX, PosY, Width, 0, Color, 0, Align);
}
float Interface::DrawRepeatGUI(short MonsterID, float X, float Y, int Count)
{
float StartY = Y;
for( int i = 0; i < Count; i++ )
{
pDrawGUI(this->Data[MonsterID].ModelID, X, StartY,this->Data[MonsterID].Width, this->Data[MonsterID].Height);
StartY += this->Data[MonsterID].Height;
}
return StartY;
}
void Interface::DrawGUI(short ObjectID, float PosX, float PosY)
{
if( this->Data[ObjectID].X == -1 || this->Data[ObjectID].Y == -1 )
{
this->Data[ObjectID].X = PosX;
this->Data[ObjectID].Y = PosY;
this->Data[ObjectID].MaxX = PosX + this->Data[ObjectID].Width;
this->Data[ObjectID].MaxY = PosY + this->Data[ObjectID].Height;
}
pDrawGUI(this->Data[ObjectID].ModelID, PosX, PosY,this->Data[ObjectID].Width, this->Data[ObjectID].Height);
}
void Interface::DrawColoredGUI(short ObjectID, float X, float Y, DWORD Color)
{
if( this->Data[ObjectID].X == -1 || this->Data[ObjectID].Y == -1 )
{
this->Data[ObjectID].X = X;
this->Data[ObjectID].Y = Y;
this->Data[ObjectID].MaxX = X + this->Data[ObjectID].Width;
this->Data[ObjectID].MaxY = Y + this->Data[ObjectID].Height;
}
pDrawColorButton(this->Data[ObjectID].ModelID, X, Y,this->Data[ObjectID].Width, this->Data[ObjectID].Height, 0, 0, Color);
}
int Interface::DrawToolTip(int X, int Y, LPCSTR Text, ...)
{
char Buff[2048];
int BuffLen = sizeof(Buff);
ZeroMemory(Buff, BuffLen);
va_list args;
va_start(args, Text);
int Len = vsprintf_s(Buff, BuffLen, Text, args);
va_end(args);
return pDrawToolTip(X, Y, Buff);
}
int Interface::DrawToolTipEx(int X, int Y, LPCSTR Text, ...)
{
char Buff[2048];
int BuffLen = sizeof(Buff);
ZeroMemory(Buff, BuffLen);
va_list args;
va_start(args, Text);
int Len = vsprintf_s(Buff, BuffLen, Text, args);
va_end(args);
int LineCount = 0;
char * Line = strtok(Buff, "\n");
while( Line != NULL )
{
pDrawToolTip(X, Y, Line);
Y += 10;
Line = strtok(NULL, "\n");
}
return Y;
}
int Interface::DrawMessage(int Mode, LPCSTR Text, ...)
{
char Buff[2048];
int BuffLen = sizeof(Buff);
ZeroMemory(Buff, BuffLen);
va_list args;
va_start(args, Text);
int Len = vsprintf_s(Buff, BuffLen, Text, args);
va_end(args);
return pDrawMessage(Buff, Mode);
}
bool Interface::IsWorkZone(short ObjectID)
{
float PosX = this->Data[ObjectID].X;
float MaxX = PosX + this->Data[ObjectID].Width;
if( ObjectID == eSAMPLEBUTTON )
{
PosX = this->GetResizeX(ObjectID);
MaxX = PosX + this->Data[ObjectID].Width;
}
if( (gObjUser.m_CursorX < PosX || gObjUser.m_CursorX > MaxX) || (gObjUser.m_CursorY < this->Data[ObjectID].Y || gObjUser.m_CursorY > this->Data[ObjectID].MaxY) )
return false;
return true;
}
bool Interface::IsWorkZone(float X, float Y, float MaxX, float MaxY)
{
if( (gObjUser.m_CursorX < X || gObjUser.m_CursorX > MaxX) || (gObjUser.m_CursorY < Y || gObjUser.m_CursorY > MaxY) )
return false;
return true;
}
float Interface::GetResizeX(short ObjectID)
{
if( pWinWidth == 800 )
{
return this->Data[ObjectID].X + 16.0;
}
else if( pWinWidth != 1024 )
{
return this->Data[ObjectID].X - 16.0;
}
return this->Data[ObjectID].X;
}
float Interface::GetResizeY(short ObjectID)
{
return this->Data[ObjectID].Y;
}
// ----------------------------------------------------------------------------------------------
bool Interface::MiniMapCheck()
{
if (this->CheckWindow(Inventory) ||
this->CheckWindow(CashShop) ||
this->CheckWindow(ChaosBox) ||
this->CheckWindow(Character) ||
this->CheckWindow(CommandWindow) ||
this->CheckWindow(ExpandInventory) ||
this->CheckWindow(ExpandWarehouse) ||
this->CheckWindow(FullMap) ||
this->CheckWindow(GensInfo) ||
this->CheckWindow(Guild) ||
this->CheckWindow(NPC_Dialog) ||
this->CheckWindow(NPC_Julia) ||
this->CheckWindow(NPC_Titus) ||
this->CheckWindow(OtherStore) ||
this->CheckWindow(Party) ||
this->CheckWindow(PetInfo) ||
this->CheckWindow(Shop) ||
this->CheckWindow(SkillTree) ||
this->CheckWindow(Store) ||
this->CheckWindow(Trade) ||
this->CheckWindow(FriendList) ||
this->CheckWindow(FastMenu) ||
this->CheckWindow(MuHelper) ||
this->CheckWindow(Quest) ||
this->CheckWindow(Warehouse))
return true;
return false;
}
bool Interface::CombinedChecks()
{
if ((this->CheckWindow(Inventory)
&& this->CheckWindow(ExpandInventory)
&& this->CheckWindow(Store)) ||
(this->CheckWindow(Inventory)
&& this->CheckWindow(Warehouse)
&& this->CheckWindow(ExpandWarehouse)) ||
(this->CheckWindow(Inventory)
&& this->CheckWindow(Character)
&& this->CheckWindow(Store)))
return true;
return false;
}
void Interface::DrawMiniMap()
{
if (gInterface.showMiniMap)
{
float MainWidth = 138.0;
float MainHeight = 265.0;
float StartY = 264.0;
float StartX = 512.0;
// ----
if (this->MiniMapCheck() || this->CombinedChecks())
{
return;
}
// ----
switch (gObjUser.m_MapNumber)
{
case 0: //Lorencia
{
this->DrawGUI(eLORENCIA_MAP, StartX, StartY + 30);
}
break;
// --
case 1: //Dungeon
{
this->DrawGUI(eDUNGEON_MAP, StartX, StartY + 30);
}
break;
// --
case 2: //Devias
{
this->DrawGUI(eDEVIAS_MAP, StartX, StartY + 30);
}
break;
// --
case 3: //Noria
{
this->DrawGUI(eNORIA_MAP, StartX, StartY + 30);
}
break;
// --
case 4: //LostTower
{
this->DrawGUI(eLOSTTOWER_MAP, StartX, StartY + 30);
}
break;
// --
case 5: //Exile (disabled)
{
return;
}
break;
// --
// --
case 7: //Atlans
{
this->DrawGUI(eATLANS_MAP, StartX, StartY + 30);
}
break;
// --
case 8: //Tarkan
{
this->DrawGUI(eTarkan_MAP, StartX, StartY + 30);
}
break;
// --
case 10: //Icarus
{
this->DrawGUI(eICARUS_MAP, StartX, StartY + 30);
}
break;
// --
case 31: //Land of Trials
{
this->DrawGUI(eLANDOFTRIALS_MAP, StartX, StartY + 30);
}
break;
// --
case 33: //Aida
{
this->DrawGUI(eAIDA_MAP, StartX, StartY + 30);
}
break;
// --
case 34: //Crywolf Fortress
{
this->DrawGUI(eCRYWOLF_MAP, StartX, StartY + 30);
}
break;
// --
case 37: //Kantru
{
this->DrawGUI(eKANTRU_MAP, StartX, StartY + 30);
}
break;
// --
case 38: //Kantru 3
{
this->DrawGUI(eKANTRU3_MAP, StartX, StartY + 30);
}
break;
// --
case 41: //Barracks
{
this->DrawGUI(eBARRACKS_MAP, StartX, StartY + 30);
}
break;
// --
case 51: //Elbeland
{
this->DrawGUI(eElbeland_MAP, StartX, StartY + 30);
}
break;
// --
case 56: //Swamp of Calmness
{
this->DrawGUI(eCALMNESS_MAP, StartX, StartY + 30);
}
break;
// --
case 57: //Raklion
{
this->DrawGUI(eRAKLION_MAP, StartX, StartY + 30);
}
break;
// --
case 63: //Vulcanus
{
this->DrawGUI(eVULCANUS_MAP, StartX, StartY + 30);
}
break;
// --
case 80: //Kalrutan
{
this->DrawGUI(eKALRUTAN_MAP, StartX, StartY + 30);
}
break;
// --
case 81: //Kalrutan 2
{
this->DrawGUI(eKALRUTAN2_MAP, StartX, StartY + 30);
}
break;
// --
default: //Default
{
this->DrawGUI(eNULL_MAP, StartX, StartY + 30);
}
break;
}
// ----
this->DrawGUI(ePLAYER_POINT, (float)(StartX - 1 + gObjUser.lpViewPlayer->MapPosX / 2), (float)(294 - 1 + (255 - gObjUser.lpViewPlayer->MapPosY) / 2));
}
}
// ----------------------------------------------------------------------------------------------
void Interface::DrawUsersPanelWindow()
{
if( !this->Data[eUSERSPANEL_MAIN].OnShow )
{
return;
}
// ----
DWORD ItemNameColor = eWhite;
float MainWidth = 230.0;
float MainHeight = 313.0;
float StartY = 100.0;
float StartX = (MAX_WIN_WIDTH / 2) - (MainWidth / 2);
float MainCenter = StartX + (MainWidth / 3);
float ButtonX = MainCenter - (29.0 / 2);
this->DrawGUI(eUSERSPANEL_MAIN, StartX, StartY + 2);
this->DrawGUI(eUSERSPANEL_TITLE, StartX, StartY);
StartY = this->DrawRepeatGUI(eUSERSPANEL_FRAME, StartX, StartY + 67.0, 13);
this->DrawGUI(eUSERSPANEL_FOOTER, StartX, StartY);
// ----
if( IsWorkZone(eUSERSPANEL_CLOSE) )
{
DWORD Color = eGray100;
if( this->Data[eUSERSPANEL_CLOSE].OnClick )
{
Color = eGray150;
}
this->DrawColoredGUI(eUSERSPANEL_CLOSE, this->Data[eUSERSPANEL_CLOSE].X, this->Data[eUSERSPANEL_CLOSE].Y, Color);
}
// ----
this->DrawGUI(eUSERSPANEL_CLOSE, ButtonX, this->Data[eUSERSPANEL_FOOTER].Y + 10);
this->DrawFormat(eWhite, StartX + 8, this->Data[eUSERSPANEL_FOOTER].Y + 20, 210, 3, "Close");
this->DrawGUI(eUSERSPANEL_DIV, StartX, this->Data[eUSERSPANEL_FOOTER].Y - 10);
// ----
this->DrawGUI(eUnCheck, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 37);
this->DrawGUI(eUSERSPANEL_OPTION, StartX + 35, this->Data[eUSERSPANEL_MAIN].Y + 38);
this->DrawGUI(eUSERSPANEL_LINE, StartX + 30, this->Data[eUSERSPANEL_MAIN].Y + 55);
this->DrawFormat(eWhite, StartX + 20, this->Data[eUSERSPANEL_MAIN].Y + 40, +125, 3, Config.msg);
{
if(lifebar)
{
}
else
{
this->DrawGUI(eUSERSPANEL_HPBAR, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 37);
}
// ----
}
// ----
this->DrawGUI(eUSERSPANEL_RANKHIDE, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 62);
this->DrawGUI(eUSERSPANEL_OPTION, StartX + 35, this->Data[eUSERSPANEL_MAIN].Y + 63);
this->DrawGUI(eUSERSPANEL_LINE, StartX + 30, this->Data[eUSERSPANEL_MAIN].Y + 80);
this->DrawFormat(eWhite, StartX + 20, this->Data[eUSERSPANEL_MAIN].Y + 65, +125, 3, Config.msg2);
{
if(rankbar)
{
}
else
{
this->DrawGUI(eUnCheck, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 62);
}
// ----
}
// ----
this->DrawGUI(eUSERSPANEL_TRONGLOW, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 87);
this->DrawGUI(eUSERSPANEL_OPTION, StartX + 35, this->Data[eUSERSPANEL_MAIN].Y + 88);
this->DrawGUI(eUSERSPANEL_LINE, StartX + 30, this->Data[eUSERSPANEL_MAIN].Y + 105);
this->DrawFormat(eWhite, StartX + 20, this->Data[eUSERSPANEL_MAIN].Y + 90, +135, 3, Config.msg3);
{
if(g_bEnabled)
{
}
else
{
this->DrawGUI(eUnCheck, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 87);
}
// ----
}
// ----
this->DrawGUI(eUSERSPANEL_FOG, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 112);
this->DrawGUI(eUSERSPANEL_OPTION, StartX + 35, this->Data[eUSERSPANEL_MAIN].Y + 113);
this->DrawGUI(eUSERSPANEL_LINE, StartX + 30, this->Data[eUSERSPANEL_MAIN].Y + 130);
this->DrawFormat(eWhite, StartX + 20, this->Data[eUSERSPANEL_MAIN].Y + 115, +125, 3, Config.msg4);
{
if(gFog.EnableFog)
{
}
else
{
this->DrawGUI(eUnCheck, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 112);
}
// ----
}
// ----
this->DrawGUI(eUnCheck, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 137);
this->DrawGUI(eUSERSPANEL_OPTION, StartX + 35, this->Data[eUSERSPANEL_MAIN].Y + 138);
this->DrawGUI(eUSERSPANEL_LINE, StartX + 30, this->Data[eUSERSPANEL_MAIN].Y + 155);
this->DrawFormat(eWhite, StartX + 20, this->Data[eUSERSPANEL_MAIN].Y + 140, +125, 3, Config.msg5);
{
if (!gChatExpanded.IsActive)
{
}
else
{
this->DrawGUI(eUSERSPANEL_CHAT, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 137);
}
// ----
}
// ----
this->DrawGUI(eUSERSPANEL_MINIMAP, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 164);
this->DrawGUI(eUSERSPANEL_OPTION, StartX + 35, this->Data[eUSERSPANEL_MAIN].Y + 165);
this->DrawGUI(eUSERSPANEL_LINE, StartX + 30, this->Data[eUSERSPANEL_MAIN].Y + 182);
this->DrawFormat(eWhite, StartX + 20, this->Data[eUSERSPANEL_MAIN].Y + 167, +120, 3, Config.msg6);
{
if (showMiniMap)
{
}
else
{
this->DrawGUI(eUnCheck, ButtonX + 100, this->Data[eUSERSPANEL_MAIN].Y + 164);
}
// ----
}
// ----
}
bool Interface::EventUsersPanelWindow_Main(DWORD Event)
{
this->EventUsersPanelWindow_Close(Event);
this->EventUsersPanelWindow_HPBAR(Event);
this->EventUsersPanelWindow_RANKHIDE(Event);
this->EventUsersPanelWindow_TRONGLOW(Event);
this->EventUsersPanelWindow_FOG(Event);
this->EventUsersPanelWindow_CHAT(Event);
this->EventUsersPanelWindow_MINIMAP(Event);
return true;
}
bool Interface::EventUsersPanelWindow_Close(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eUSERSPANEL_CLOSE].EventTick);
// ----
if( !this->Data[eUSERSPANEL_MAIN].OnShow || !IsWorkZone(eUSERSPANEL_CLOSE) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eUSERSPANEL_CLOSE].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eUSERSPANEL_CLOSE].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
this->Data[eUSERSPANEL_CLOSE].EventTick = GetTickCount();
this->CloseUsersPanelWindow();
// ----
return false;
}
bool Interface::EventUsersPanelWindow_HPBAR(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eUSERSPANEL_HPBAR].EventTick);
// ----
if( !this->Data[eUSERSPANEL_MAIN].OnShow || !IsWorkZone(eUSERSPANEL_HPBAR) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eUSERSPANEL_HPBAR].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eUSERSPANEL_HPBAR].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eUSERSPANEL_HPBAR].EventTick = GetTickCount();
if(lifebar)
{
lifebar = false;
}
else
{
lifebar = true;
}
}
bool Interface::EventUsersPanelWindow_RANKHIDE(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eUSERSPANEL_RANKHIDE].EventTick);
// ----
if( !this->Data[eUSERSPANEL_MAIN].OnShow || !IsWorkZone(eUSERSPANEL_RANKHIDE) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eUSERSPANEL_RANKHIDE].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eUSERSPANEL_RANKHIDE].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eUSERSPANEL_RANKHIDE].EventTick = GetTickCount();
if(rankbar)
{
rankbar = false;
}
else
{
rankbar = true;
}
}
bool Interface::EventUsersPanelWindow_TRONGLOW(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eUSERSPANEL_TRONGLOW].EventTick);
// ----
if( !this->Data[eUSERSPANEL_MAIN].OnShow || !IsWorkZone(eUSERSPANEL_TRONGLOW) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eUSERSPANEL_TRONGLOW].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eUSERSPANEL_TRONGLOW].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
this->Data[eUSERSPANEL_TRONGLOW].EventTick = GetTickCount();
if(g_bEnabled) //Effects
{
g_bEnabled = false;
}
else
{
g_bEnabled = true;
}
}
bool Interface::EventUsersPanelWindow_FOG(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eUSERSPANEL_FOG].EventTick);
// ----
if( !this->Data[eUSERSPANEL_MAIN].OnShow || !IsWorkZone(eUSERSPANEL_FOG) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eUSERSPANEL_FOG].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eUSERSPANEL_FOG].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eUSERSPANEL_FOG].EventTick = GetTickCount();
if(gFog.EnableFog) //Fog
{
gFog.EnableFog = false;
}
else
{
gFog.EnableFog = true;
}
}
bool Interface::EventUsersPanelWindow_CHAT(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eUSERSPANEL_CHAT].EventTick);
// ----
if( !this->Data[eUSERSPANEL_MAIN].OnShow || !IsWorkZone(eUSERSPANEL_CHAT) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eUSERSPANEL_CHAT].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eUSERSPANEL_CHAT].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eUSERSPANEL_CHAT].EventTick = GetTickCount();
gChatExpanded.Switch();
}
bool Interface::EventUsersPanelWindow_MINIMAP(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eUSERSPANEL_MINIMAP].EventTick);
// ----
if( !this->Data[eUSERSPANEL_MAIN].OnShow || !IsWorkZone(eUSERSPANEL_MINIMAP) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eUSERSPANEL_MINIMAP].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eUSERSPANEL_MINIMAP].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eUSERSPANEL_MINIMAP].EventTick = GetTickCount();
if(showMiniMap) //Fog
{
gInterface.showMiniMap = false;
}
else
{
gInterface.showMiniMap = true;
}
}
void Interface::DrawPSHOP()
{
float MainWidth = 230.0;
float MainHeight = 313.0;
float StartY = 100.0;
float StartX = (MAX_WIN_WIDTH / 2) - (MainWidth / 2);
if (this->CheckWindow(ObjWindow::Store))
{
this->DrawFormat(eRed, StartX + 35, StartY + 76, +125, 3, "Custom Store:");
this->DrawGUI(eSHOP_WC, StartX + 70, StartY + 90);
this->DrawFormat(eWhite, StartX + 80, StartY + 97, 100.0f, 1.0f, "WCoinC");
this->DrawGUI(eSHOP_B, StartX + 70, StartY + 120);
this->DrawFormat(eYellow, StartX + 85, StartY + 127, 100.0f, 1.0f, "Bless");
this->DrawGUI(eSHOP_WP, StartX + 125, StartY + 90);
this->DrawFormat(eWhite, StartX + 135, StartY + 97, 100.0f, 1.0f, "WCoinP");
this->DrawGUI(eSHOP_S, StartX + 125, StartY + 120);
this->DrawFormat(eYellow, StartX + 140, StartY + 127, 100.0f, 1.0f, "Soul");
this->DrawGUI(eSHOP_GP, StartX + 180, StartY + 90);
this->DrawFormat(eWhite, StartX + 187, StartY + 97, 100.0f, 1.0f, "GoblinPoint");
this->DrawGUI(eSHOP_C, StartX + 180, StartY + 120);
this->DrawFormat(eYellow, StartX + 195, StartY + 127, 100.0f, 1.0f, "Chaos");
this->DrawGUI(eSHOP_OFF, StartX + 190, StartY + 291);
if( IsWorkZone(eSHOP_OFF) )
{
this->DrawToolTip(StartX + 190, StartY + 275, "OFFSTORE System, click to active!");
}
}
// ----
}
bool Interface::DrawPSHOP_Main(DWORD Event)
{
this->DrawPSHOP_BLESS(Event);
this->DrawPSHOP_SOUL(Event);
this->DrawPSHOP_CHAOS(Event);
this->DrawPSHOP_WCOINC(Event);
this->DrawPSHOP_WCOINP(Event);
this->DrawPSHOP_COINTP(Event);
this->DrawPSHOP_OFFBUTTON(Event);
return true;
}
bool Interface::DrawPSHOP_BLESS(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eSHOP_B].EventTick);
// ----
if( !this->CheckWindow(ObjWindow::Store) || !IsWorkZone(eSHOP_B) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eSHOP_B].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eSHOP_B].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eSHOP_B].EventTick = GetTickCount();
PMSG_TICKET_SEND pMsg;
pMsg.header.set(0xFF,0x01,sizeof(pMsg));
DataSend((BYTE*)&pMsg,pMsg.header.size);
}
bool Interface::DrawPSHOP_SOUL(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eSHOP_S].EventTick);
// ----
if( !this->CheckWindow(ObjWindow::Store) || !IsWorkZone(eSHOP_S) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eSHOP_S].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eSHOP_S].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eSHOP_S].EventTick = GetTickCount();
PMSG_TICKET_SEND pMsg;
pMsg.header.set(0xFF,0x02,sizeof(pMsg));
DataSend((BYTE*)&pMsg,pMsg.header.size);
}
bool Interface::DrawPSHOP_CHAOS(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eSHOP_C].EventTick);
// ----
if( !this->CheckWindow(ObjWindow::Store) || !IsWorkZone(eSHOP_C) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eSHOP_C].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eSHOP_C].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eSHOP_C].EventTick = GetTickCount();
PMSG_TICKET_SEND pMsg;
pMsg.header.set(0xFF,0x03,sizeof(pMsg));
DataSend((BYTE*)&pMsg,pMsg.header.size);
}
bool Interface::DrawPSHOP_WCOINC(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eSHOP_WC].EventTick);
// ----
if( !this->CheckWindow(ObjWindow::Store) || !IsWorkZone(eSHOP_WC) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eSHOP_WC].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eSHOP_WC].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eSHOP_WC].EventTick = GetTickCount();
PMSG_TICKET_SEND pMsg;
pMsg.header.set(0xFF,0x04,sizeof(pMsg));
DataSend((BYTE*)&pMsg,pMsg.header.size);
}
bool Interface::DrawPSHOP_WCOINP(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eSHOP_WP].EventTick);
// ----
if( !this->CheckWindow(ObjWindow::Store) || !IsWorkZone(eSHOP_WP) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eSHOP_WP].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eSHOP_WP].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eSHOP_WP].EventTick = GetTickCount();
PMSG_TICKET_SEND pMsg;
pMsg.header.set(0xFF,0x05,sizeof(pMsg));
DataSend((BYTE*)&pMsg,pMsg.header.size);
}
bool Interface::DrawPSHOP_COINTP(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eSHOP_GP].EventTick);
// ----
if( !this->CheckWindow(ObjWindow::Store) || !IsWorkZone(eSHOP_GP) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eSHOP_GP].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eSHOP_GP].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eSHOP_GP].EventTick = GetTickCount();
PMSG_TICKET_SEND pMsg;
pMsg.header.set(0xFF,0x06,sizeof(pMsg));
DataSend((BYTE*)&pMsg,pMsg.header.size);
}
bool Interface::DrawPSHOP_OFFBUTTON(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eSHOP_OFF].EventTick);
// ----
if( !this->CheckWindow(ObjWindow::Store) || !IsWorkZone(eSHOP_OFF) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eSHOP_OFF].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eSHOP_OFF].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
this->Data[eSHOP_OFF].EventTick = GetTickCount();
gInterface.OpenOffWindow();
}
void Interface::DrawPSHOP_OFFMODE()
{
if( !this->Data[eOFFPANEL_MAIN].OnShow )
{
return;
}
float MainWidth = 230.0;
float MainHeight = 313.0;
float StartY = 80.0;
float StartX = (MAX_WIN_WIDTH / 2) - (MainWidth / 2);
float MainCenter = StartX + (MainWidth / 3);
float ButtonX = MainCenter - (29.0 / 2);
this->DrawGUI(eOFFPANEL_MAIN, StartX, StartY + 2);
this->DrawGUI(eOFFPANEL_TITLE, StartX, StartY);
//StartY = this->DrawRepeatGUI(eOFFPANEL_FRAME, StartX, StartY + 67.0, 13);
this->DrawGUI(eOFFPANEL_FOOTER, StartX, StartY + 75);
this->DrawFormat(eGold, StartX + 10, 90, 210, 3, "Offline Shop System");
this->DrawFormat(eWhite, StartX + 10, 130, 210, 3, "Leave your Character in OFFSTORE mode?");
this->DrawGUI(eOFFPANEL_YES, StartX + 30, StartY + 75);
this->DrawGUI(eOFFPANEL_CANE, StartX + 140, StartY + 75);
}
bool Interface::DrawPSHOP_OFFMAIN(DWORD Event)
{
this->DrawPSHOP_OFFYES(Event);
this->DrawPSHOP_OFFCANE(Event);
return true;
}
bool Interface::DrawPSHOP_OFFYES(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eOFFPANEL_YES].EventTick);
// ----
if( !this->Data[eOFFPANEL_MAIN].OnShow || !IsWorkZone(eOFFPANEL_YES) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eOFFPANEL_YES].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eOFFPANEL_YES].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eOFFPANEL_YES].EventTick = GetTickCount();
PMSG_TICKET_SEND pMsg;
pMsg.header.set(0xFF,0x07,sizeof(pMsg));
DataSend((BYTE*)&pMsg,pMsg.header.size);
this->CloseOffWindow();
}
bool Interface::DrawPSHOP_OFFCANE(DWORD Event)
{
DWORD CurrentTick = GetTickCount();
DWORD Delay = (CurrentTick - this->Data[eOFFPANEL_CANE].EventTick);
// ----
if( !this->Data[eOFFPANEL_MAIN].OnShow || !IsWorkZone(eOFFPANEL_CANE) )
{
return false;
}
// ----
if( Event == WM_LBUTTONDOWN )
{
this->Data[eOFFPANEL_CANE].OnClick = true;
pSetCursorFocus = true;
return true;
}
// ----
this->Data[eOFFPANEL_CANE].OnClick = false;
pSetCursorFocus = false;
// ----
if( Delay < 500 )
{
return false;
}
// ----
// ----
this->Data[eOFFPANEL_CANE].EventTick = GetTickCount();
this->CloseOffWindow();
} | [
"natzugen@gmail.com"
] | natzugen@gmail.com |
9545e8e88d386e9fbe558125a8781457b5db9e9d | e641bd95bff4a447e25235c265a58df8e7e57c84 | /content/browser/accessibility/accessibility_tree_formatter_blink.cc | 8e3a8959cff06634c1e0321953d9adfd56270fd0 | [
"BSD-3-Clause"
] | permissive | zaourzag/chromium | e50cb6553b4f30e42f452e666885d511f53604da | 2370de33e232b282bd45faa084e5a8660cb396ed | refs/heads/master | 2023-01-02T08:48:14.707555 | 2020-11-13T13:47:30 | 2020-11-13T13:47:30 | 312,600,463 | 0 | 0 | BSD-3-Clause | 2022-12-23T17:01:30 | 2020-11-13T14:39:10 | null | UTF-8 | C++ | false | false | 23,344 | cc | // Copyright (c) 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/browser/accessibility/accessibility_tree_formatter_blink.h"
#include <cmath>
#include <cstddef>
#include <utility>
#include "base/optional.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "content/browser/accessibility/browser_accessibility_manager.h"
#include "ui/accessibility/ax_enums.mojom.h"
#include "ui/accessibility/ax_node_data.h"
#include "ui/accessibility/platform/ax_platform_node_delegate.h"
#include "ui/accessibility/platform/compute_attributes.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/transform.h"
namespace content {
namespace {
base::Optional<std::string> GetStringAttribute(
const BrowserAccessibility& node,
ax::mojom::StringAttribute attr) {
// Language is different from other string attributes as it inherits and has
// a method to compute it.
if (attr == ax::mojom::StringAttribute::kLanguage) {
std::string value = node.node()->GetLanguage();
if (value.empty()) {
return base::nullopt;
}
return value;
}
// Font Family is different from other string attributes as it inherits.
if (attr == ax::mojom::StringAttribute::kFontFamily) {
std::string value = node.GetInheritedStringAttribute(attr);
if (value.empty()) {
return base::nullopt;
}
return value;
}
// Always return the attribute if the node has it, even if the value is an
// empty string.
std::string value;
if (node.GetStringAttribute(attr, &value)) {
return value;
}
return base::nullopt;
}
std::string IntAttrToString(const BrowserAccessibility& node,
ax::mojom::IntAttribute attr,
int32_t value) {
if (ui::IsNodeIdIntAttribute(attr)) {
// Relation
BrowserAccessibility* target = node.manager()->GetFromID(value);
return target ? ui::ToString(target->GetData().role) : std::string("null");
}
switch (attr) {
case ax::mojom::IntAttribute::kAriaCurrentState:
return ui::ToString(static_cast<ax::mojom::AriaCurrentState>(value));
case ax::mojom::IntAttribute::kCheckedState:
return ui::ToString(static_cast<ax::mojom::CheckedState>(value));
case ax::mojom::IntAttribute::kDefaultActionVerb:
return ui::ToString(static_cast<ax::mojom::DefaultActionVerb>(value));
case ax::mojom::IntAttribute::kDescriptionFrom:
return ui::ToString(static_cast<ax::mojom::DescriptionFrom>(value));
case ax::mojom::IntAttribute::kDropeffect:
return node.GetData().DropeffectBitfieldToString();
case ax::mojom::IntAttribute::kHasPopup:
return ui::ToString(static_cast<ax::mojom::HasPopup>(value));
case ax::mojom::IntAttribute::kInvalidState:
return ui::ToString(static_cast<ax::mojom::InvalidState>(value));
case ax::mojom::IntAttribute::kListStyle:
return ui::ToString(static_cast<ax::mojom::ListStyle>(value));
case ax::mojom::IntAttribute::kNameFrom:
return ui::ToString(static_cast<ax::mojom::NameFrom>(value));
case ax::mojom::IntAttribute::kRestriction:
return ui::ToString(static_cast<ax::mojom::Restriction>(value));
case ax::mojom::IntAttribute::kSortDirection:
return ui::ToString(static_cast<ax::mojom::SortDirection>(value));
case ax::mojom::IntAttribute::kTextAlign:
return ui::ToString(static_cast<ax::mojom::TextAlign>(value));
case ax::mojom::IntAttribute::kTextOverlineStyle:
case ax::mojom::IntAttribute::kTextStrikethroughStyle:
case ax::mojom::IntAttribute::kTextUnderlineStyle:
return ui::ToString(static_cast<ax::mojom::TextDecorationStyle>(value));
case ax::mojom::IntAttribute::kTextDirection:
return ui::ToString(static_cast<ax::mojom::WritingDirection>(value));
case ax::mojom::IntAttribute::kTextPosition:
return ui::ToString(static_cast<ax::mojom::TextPosition>(value));
case ax::mojom::IntAttribute::kImageAnnotationStatus:
return ui::ToString(static_cast<ax::mojom::ImageAnnotationStatus>(value));
// No pretty printing necessary for these:
case ax::mojom::IntAttribute::kActivedescendantId:
case ax::mojom::IntAttribute::kAriaCellColumnIndex:
case ax::mojom::IntAttribute::kAriaCellRowIndex:
case ax::mojom::IntAttribute::kAriaColumnCount:
case ax::mojom::IntAttribute::kAriaCellColumnSpan:
case ax::mojom::IntAttribute::kAriaCellRowSpan:
case ax::mojom::IntAttribute::kAriaRowCount:
case ax::mojom::IntAttribute::kBackgroundColor:
case ax::mojom::IntAttribute::kColor:
case ax::mojom::IntAttribute::kColorValue:
case ax::mojom::IntAttribute::kDOMNodeId:
case ax::mojom::IntAttribute::kErrormessageId:
case ax::mojom::IntAttribute::kHierarchicalLevel:
case ax::mojom::IntAttribute::kInPageLinkTargetId:
case ax::mojom::IntAttribute::kMemberOfId:
case ax::mojom::IntAttribute::kNextFocusId:
case ax::mojom::IntAttribute::kNextOnLineId:
case ax::mojom::IntAttribute::kPosInSet:
case ax::mojom::IntAttribute::kPopupForId:
case ax::mojom::IntAttribute::kPreviousFocusId:
case ax::mojom::IntAttribute::kPreviousOnLineId:
case ax::mojom::IntAttribute::kScrollX:
case ax::mojom::IntAttribute::kScrollXMax:
case ax::mojom::IntAttribute::kScrollXMin:
case ax::mojom::IntAttribute::kScrollY:
case ax::mojom::IntAttribute::kScrollYMax:
case ax::mojom::IntAttribute::kScrollYMin:
case ax::mojom::IntAttribute::kSetSize:
case ax::mojom::IntAttribute::kTableCellColumnIndex:
case ax::mojom::IntAttribute::kTableCellColumnSpan:
case ax::mojom::IntAttribute::kTableCellRowIndex:
case ax::mojom::IntAttribute::kTableCellRowSpan:
case ax::mojom::IntAttribute::kTableColumnCount:
case ax::mojom::IntAttribute::kTableColumnHeaderId:
case ax::mojom::IntAttribute::kTableColumnIndex:
case ax::mojom::IntAttribute::kTableHeaderId:
case ax::mojom::IntAttribute::kTableRowCount:
case ax::mojom::IntAttribute::kTableRowHeaderId:
case ax::mojom::IntAttribute::kTableRowIndex:
case ax::mojom::IntAttribute::kTextSelEnd:
case ax::mojom::IntAttribute::kTextSelStart:
case ax::mojom::IntAttribute::kTextStyle:
case ax::mojom::IntAttribute::kNone:
break;
}
// Just return the number
return std::to_string(value);
}
} // namespace
AccessibilityTreeFormatterBlink::AccessibilityTreeFormatterBlink()
: AccessibilityTreeFormatterBase() {}
AccessibilityTreeFormatterBlink::~AccessibilityTreeFormatterBlink() {}
void AccessibilityTreeFormatterBlink::AddDefaultFilters(
std::vector<AXPropertyFilter>* property_filters) {
// Noisy, perhaps add later:
// editable, focus*, horizontal, linked, richlyEditable, vertical
// Too flaky: hovered, offscreen
// States
AddPropertyFilter(property_filters, "collapsed");
AddPropertyFilter(property_filters, "invisible");
AddPropertyFilter(property_filters, "multiline");
AddPropertyFilter(property_filters, "protected");
AddPropertyFilter(property_filters, "required");
AddPropertyFilter(property_filters, "select*");
AddPropertyFilter(property_filters, "selectedFromFocus=*",
AXPropertyFilter::DENY);
AddPropertyFilter(property_filters, "visited");
// Other attributes
AddPropertyFilter(property_filters, "busy=true");
AddPropertyFilter(property_filters, "valueForRange*");
AddPropertyFilter(property_filters, "minValueForRange*");
AddPropertyFilter(property_filters, "maxValueForRange*");
AddPropertyFilter(property_filters, "autoComplete*");
AddPropertyFilter(property_filters, "restriction*");
AddPropertyFilter(property_filters, "keyShortcuts*");
AddPropertyFilter(property_filters, "activedescendantId*");
AddPropertyFilter(property_filters, "controlsIds*");
AddPropertyFilter(property_filters, "flowtoIds*");
AddPropertyFilter(property_filters, "detailsIds*");
AddPropertyFilter(property_filters, "invalidState=*");
AddPropertyFilter(property_filters, "ignored*");
AddPropertyFilter(property_filters, "invalidState=false",
AXPropertyFilter::DENY); // Don't show false value
AddPropertyFilter(property_filters, "roleDescription=*");
AddPropertyFilter(property_filters, "errormessageId=*");
}
// static
std::unique_ptr<ui::AXTreeFormatter>
AccessibilityTreeFormatterBlink::CreateBlink() {
return std::make_unique<AccessibilityTreeFormatterBlink>();
}
const char* const TREE_DATA_ATTRIBUTES[] = {"TreeData.textSelStartOffset",
"TreeData.textSelEndOffset"};
const char* STATE_FOCUSED = "focused";
const char* STATE_OFFSCREEN = "offscreen";
std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterBlink::BuildAccessibilityTree(
BrowserAccessibility* root) {
CHECK(root);
std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
RecursiveBuildAccessibilityTree(*root, dict.get());
return dict;
}
base::Value AccessibilityTreeFormatterBlink::BuildTreeForWindow(
gfx::AcceleratedWidget widget) const {
NOTREACHED();
return base::Value(base::Value::Type::DICTIONARY);
}
base::Value AccessibilityTreeFormatterBlink::BuildTreeForSelector(
const AXTreeSelector& selector) const {
NOTREACHED();
return base::Value(base::Value::Type::DICTIONARY);
}
void AccessibilityTreeFormatterBlink::RecursiveBuildAccessibilityTree(
const BrowserAccessibility& node,
base::DictionaryValue* dict) const {
AddProperties(node, dict);
auto children = std::make_unique<base::ListValue>();
for (size_t i = 0; i < ChildCount(node); ++i) {
BrowserAccessibility* child_node = GetChild(node, i);
std::unique_ptr<base::DictionaryValue> child_dict(
new base::DictionaryValue);
RecursiveBuildAccessibilityTree(*child_node, child_dict.get());
children->Append(std::move(child_dict));
}
dict->Set(kChildrenDictAttr, std::move(children));
}
uint32_t AccessibilityTreeFormatterBlink::ChildCount(
const BrowserAccessibility& node) const {
if (node.HasStringAttribute(ax::mojom::StringAttribute::kChildTreeId))
return node.PlatformChildCount();
// We don't want to use InternalGetChild as we want to include
// ignored nodes in the tree for tests.
return node.node()->children().size();
}
BrowserAccessibility* AccessibilityTreeFormatterBlink::GetChild(
const BrowserAccessibility& node,
uint32_t i) const {
if (node.HasStringAttribute(ax::mojom::StringAttribute::kChildTreeId))
return node.PlatformGetChild(i);
// We don't want to use InternalGetChild as we want to include
// ignored nodes in the tree for tests.
if (i < 0 && i >= node.node()->children().size())
return nullptr;
ui::AXNode* child_node = node.node()->children()[i];
DCHECK(child_node);
return node.manager()->GetFromAXNode(child_node);
}
void AccessibilityTreeFormatterBlink::AddProperties(
const BrowserAccessibility& node,
base::DictionaryValue* dict) const {
int id = node.GetId();
dict->SetInteger("id", id);
dict->SetString("internalRole", ui::ToString(node.GetData().role));
gfx::Rect bounds =
gfx::ToEnclosingRect(node.GetData().relative_bounds.bounds);
dict->SetInteger("boundsX", bounds.x());
dict->SetInteger("boundsY", bounds.y());
dict->SetInteger("boundsWidth", bounds.width());
dict->SetInteger("boundsHeight", bounds.height());
ui::AXOffscreenResult offscreen_result = ui::AXOffscreenResult::kOnscreen;
gfx::Rect page_bounds = node.GetClippedRootFrameBoundsRect(&offscreen_result);
dict->SetInteger("pageBoundsX", page_bounds.x());
dict->SetInteger("pageBoundsY", page_bounds.y());
dict->SetInteger("pageBoundsWidth", page_bounds.width());
dict->SetInteger("pageBoundsHeight", page_bounds.height());
dict->SetBoolean("transform",
node.GetData().relative_bounds.transform &&
!node.GetData().relative_bounds.transform->IsIdentity());
gfx::Rect unclipped_bounds =
node.GetUnclippedRootFrameBoundsRect(&offscreen_result);
dict->SetInteger("unclippedBoundsX", unclipped_bounds.x());
dict->SetInteger("unclippedBoundsY", unclipped_bounds.y());
dict->SetInteger("unclippedBoundsWidth", unclipped_bounds.width());
dict->SetInteger("unclippedBoundsHeight", unclipped_bounds.height());
for (int32_t state_index = static_cast<int32_t>(ax::mojom::State::kNone);
state_index <= static_cast<int32_t>(ax::mojom::State::kMaxValue);
++state_index) {
auto state = static_cast<ax::mojom::State>(state_index);
if (node.HasState(state))
dict->SetBoolean(ui::ToString(state), true);
}
if (offscreen_result == ui::AXOffscreenResult::kOffscreen)
dict->SetBoolean(STATE_OFFSCREEN, true);
for (int32_t attr_index =
static_cast<int32_t>(ax::mojom::StringAttribute::kNone);
attr_index <=
static_cast<int32_t>(ax::mojom::StringAttribute::kMaxValue);
++attr_index) {
auto attr = static_cast<ax::mojom::StringAttribute>(attr_index);
auto maybe_value = GetStringAttribute(node, attr);
if (maybe_value.has_value())
dict->SetString(ui::ToString(attr), maybe_value.value());
}
for (int32_t attr_index =
static_cast<int32_t>(ax::mojom::IntAttribute::kNone);
attr_index <= static_cast<int32_t>(ax::mojom::IntAttribute::kMaxValue);
++attr_index) {
auto attr = static_cast<ax::mojom::IntAttribute>(attr_index);
auto maybe_value = ui::ComputeAttribute(&node, attr);
if (maybe_value.has_value()) {
dict->SetString(ui::ToString(attr),
IntAttrToString(node, attr, maybe_value.value()));
}
}
for (int32_t attr_index =
static_cast<int32_t>(ax::mojom::FloatAttribute::kNone);
attr_index <= static_cast<int32_t>(ax::mojom::FloatAttribute::kMaxValue);
++attr_index) {
auto attr = static_cast<ax::mojom::FloatAttribute>(attr_index);
if (node.HasFloatAttribute(attr) &&
std::isfinite(node.GetFloatAttribute(attr)))
dict->SetDouble(ui::ToString(attr), node.GetFloatAttribute(attr));
}
for (int32_t attr_index =
static_cast<int32_t>(ax::mojom::BoolAttribute::kNone);
attr_index <= static_cast<int32_t>(ax::mojom::BoolAttribute::kMaxValue);
++attr_index) {
auto attr = static_cast<ax::mojom::BoolAttribute>(attr_index);
if (node.HasBoolAttribute(attr))
dict->SetBoolean(ui::ToString(attr), node.GetBoolAttribute(attr));
}
for (int32_t attr_index =
static_cast<int32_t>(ax::mojom::IntListAttribute::kNone);
attr_index <=
static_cast<int32_t>(ax::mojom::IntListAttribute::kMaxValue);
++attr_index) {
auto attr = static_cast<ax::mojom::IntListAttribute>(attr_index);
if (node.HasIntListAttribute(attr)) {
std::vector<int32_t> values;
node.GetIntListAttribute(attr, &values);
auto value_list = std::make_unique<base::ListValue>();
for (size_t i = 0; i < values.size(); ++i) {
if (ui::IsNodeIdIntListAttribute(attr)) {
BrowserAccessibility* target = node.manager()->GetFromID(values[i]);
if (target)
value_list->AppendString(ui::ToString(target->GetData().role));
else
value_list->AppendString("null");
} else {
value_list->AppendInteger(values[i]);
}
}
dict->Set(ui::ToString(attr), std::move(value_list));
}
}
// Check for relevant rich text selection info in AXTreeData
ui::AXTree::Selection unignored_selection =
node.manager()->ax_tree()->GetUnignoredSelection();
int anchor_id = unignored_selection.anchor_object_id;
if (id == anchor_id) {
int anchor_offset = unignored_selection.anchor_offset;
dict->SetInteger("TreeData.textSelStartOffset", anchor_offset);
}
int focus_id = unignored_selection.focus_object_id;
if (id == focus_id) {
int focus_offset = unignored_selection.focus_offset;
dict->SetInteger("TreeData.textSelEndOffset", focus_offset);
}
std::vector<std::string> actions_strings;
for (int32_t action_index =
static_cast<int32_t>(ax::mojom::Action::kNone) + 1;
action_index <= static_cast<int32_t>(ax::mojom::Action::kMaxValue);
++action_index) {
auto action = static_cast<ax::mojom::Action>(action_index);
if (node.HasAction(action))
actions_strings.push_back(ui::ToString(action));
}
if (!actions_strings.empty())
dict->SetString("actions", base::JoinString(actions_strings, ","));
}
std::string AccessibilityTreeFormatterBlink::ProcessTreeForOutput(
const base::DictionaryValue& dict,
base::DictionaryValue* filtered_dict_result) {
std::string error_value;
if (dict.GetString("error", &error_value))
return error_value;
std::string line;
if (show_ids()) {
int id_value;
dict.GetInteger("id", &id_value);
WriteAttribute(true, base::NumberToString(id_value), &line);
}
std::string role_value;
dict.GetString("internalRole", &role_value);
WriteAttribute(true, role_value, &line);
for (int state_index = static_cast<int32_t>(ax::mojom::State::kNone);
state_index <= static_cast<int32_t>(ax::mojom::State::kMaxValue);
++state_index) {
auto state = static_cast<ax::mojom::State>(state_index);
const base::Value* value;
if (!dict.Get(ui::ToString(state), &value))
continue;
WriteAttribute(false, ui::ToString(state), &line);
}
// Offscreen and Focused states are not in the state list.
bool offscreen = false;
dict.GetBoolean(STATE_OFFSCREEN, &offscreen);
if (offscreen)
WriteAttribute(false, STATE_OFFSCREEN, &line);
bool focused = false;
dict.GetBoolean(STATE_FOCUSED, &focused);
if (focused)
WriteAttribute(false, STATE_FOCUSED, &line);
WriteAttribute(
false, FormatCoordinates(dict, "location", "boundsX", "boundsY"), &line);
WriteAttribute(false,
FormatCoordinates(dict, "size", "boundsWidth", "boundsHeight"),
&line);
bool ignored = false;
dict.GetBoolean("ignored", &ignored);
if (!ignored) {
WriteAttribute(
false,
FormatCoordinates(dict, "pageLocation", "pageBoundsX", "pageBoundsY"),
&line);
WriteAttribute(false,
FormatCoordinates(dict, "pageSize", "pageBoundsWidth",
"pageBoundsHeight"),
&line);
WriteAttribute(false,
FormatCoordinates(dict, "unclippedLocation",
"unclippedBoundsX", "unclippedBoundsY"),
&line);
WriteAttribute(
false,
FormatCoordinates(dict, "unclippedSize", "unclippedBoundsWidth",
"unclippedBoundsHeight"),
&line);
}
bool transform;
if (dict.GetBoolean("transform", &transform) && transform)
WriteAttribute(false, "transform", &line);
for (int attr_index = static_cast<int32_t>(ax::mojom::StringAttribute::kNone);
attr_index <=
static_cast<int32_t>(ax::mojom::StringAttribute::kMaxValue);
++attr_index) {
auto attr = static_cast<ax::mojom::StringAttribute>(attr_index);
std::string string_value;
if (!dict.GetString(ui::ToString(attr), &string_value))
continue;
WriteAttribute(
false,
base::StringPrintf("%s='%s'", ui::ToString(attr), string_value.c_str()),
&line);
}
for (int attr_index = static_cast<int32_t>(ax::mojom::IntAttribute::kNone);
attr_index <= static_cast<int32_t>(ax::mojom::IntAttribute::kMaxValue);
++attr_index) {
auto attr = static_cast<ax::mojom::IntAttribute>(attr_index);
std::string string_value;
if (!dict.GetString(ui::ToString(attr), &string_value))
continue;
WriteAttribute(
false,
base::StringPrintf("%s=%s", ui::ToString(attr), string_value.c_str()),
&line);
}
for (int attr_index = static_cast<int32_t>(ax::mojom::BoolAttribute::kNone);
attr_index <= static_cast<int32_t>(ax::mojom::BoolAttribute::kMaxValue);
++attr_index) {
auto attr = static_cast<ax::mojom::BoolAttribute>(attr_index);
bool bool_value;
if (!dict.GetBoolean(ui::ToString(attr), &bool_value))
continue;
WriteAttribute(false,
base::StringPrintf("%s=%s", ui::ToString(attr),
bool_value ? "true" : "false"),
&line);
}
for (int attr_index = static_cast<int32_t>(ax::mojom::FloatAttribute::kNone);
attr_index <= static_cast<int32_t>(ax::mojom::FloatAttribute::kMaxValue);
++attr_index) {
auto attr = static_cast<ax::mojom::FloatAttribute>(attr_index);
double float_value;
if (!dict.GetDouble(ui::ToString(attr), &float_value))
continue;
WriteAttribute(
false, base::StringPrintf("%s=%.2f", ui::ToString(attr), float_value),
&line);
}
for (int attr_index =
static_cast<int32_t>(ax::mojom::IntListAttribute::kNone);
attr_index <=
static_cast<int32_t>(ax::mojom::IntListAttribute::kMaxValue);
++attr_index) {
auto attr = static_cast<ax::mojom::IntListAttribute>(attr_index);
const base::ListValue* value;
if (!dict.GetList(ui::ToString(attr), &value))
continue;
std::string attr_string(ui::ToString(attr));
attr_string.push_back('=');
for (size_t i = 0; i < value->GetSize(); ++i) {
if (i > 0)
attr_string += ",";
if (ui::IsNodeIdIntListAttribute(attr)) {
std::string string_value;
value->GetString(i, &string_value);
attr_string += string_value;
} else {
int int_value;
value->GetInteger(i, &int_value);
attr_string += base::NumberToString(int_value);
}
}
WriteAttribute(false, attr_string, &line);
}
std::string actions_value;
if (dict.GetString("actions", &actions_value)) {
WriteAttribute(
false, base::StringPrintf("%s=%s", "actions", actions_value.c_str()),
&line);
}
for (const char* attribute_name : TREE_DATA_ATTRIBUTES) {
const base::Value* value;
if (!dict.Get(attribute_name, &value))
continue;
switch (value->type()) {
case base::Value::Type::STRING: {
std::string string_value;
value->GetAsString(&string_value);
WriteAttribute(
false,
base::StringPrintf("%s=%s", attribute_name, string_value.c_str()),
&line);
break;
}
case base::Value::Type::INTEGER: {
int int_value = 0;
value->GetAsInteger(&int_value);
WriteAttribute(false,
base::StringPrintf("%s=%d", attribute_name, int_value),
&line);
break;
}
case base::Value::Type::DOUBLE: {
double double_value = 0.0;
value->GetAsDouble(&double_value);
WriteAttribute(
false, base::StringPrintf("%s=%.2f", attribute_name, double_value),
&line);
break;
}
default:
NOTREACHED();
break;
}
}
return line;
}
} // namespace content
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
46c2bba4f57e825713b1319be8ade6427dc878df | 81ff248f99a607b242a80d2ad942ccfc9f706d14 | /jni/McuReader.cpp | decec42d4226955266500b2738895bb9601906e1 | [
"Apache-2.0"
] | permissive | liujiangang/BinderServer | cb2f205f0031e1697cb6d2c4eec22c560749dc15 | 3d68ee3cdcae7bf2639c2fc0a247f72fcfe288a7 | refs/heads/master | 2021-01-21T13:48:02.858739 | 2016-05-27T00:38:16 | 2016-05-27T00:38:16 | 54,006,601 | 0 | 1 | null | null | null | null | GB18030 | C++ | false | false | 23,491 | cpp |
#define LOG_TAG "mcu_reader"
//#define LOG_NDEBUG 0
#include <utils/Log.h>
#include "IncludeAll.h"
#include "McuService.h"
#include "McuReader.h"
//using namespace android;
#define PARSE_DEBUG 0
#define MCU_READ_MAX 64
McuReader::McuReader(CMCUUart* mcu_uart)
:UartProxy(mcu_uart)
{
}
McuReader::McuReader(CMCUUart* mcu_uart, McuService* ms)
:UartProxy(mcu_uart),mMcuService(ms)
{
}
McuReader::~McuReader()
{
ALOGI("mcu reader destory...");
}
void McuReader::start_read_mcu_data_loop()
{
this->run("mcu_reader");
}
bool McuReader::threadLoop()
{
static u_c read_buff[MCU_READ_MAX];
static u_t read_len;
if(getUart() != NULL && getUart()->isUartOpened())
{
getUart()->readUart(read_buff,read_len);
if(read_len > 0)
{
if(PARSE_DEBUG)
{
ALOGI("read mcu data 0x%02x 0x%02x 0x%02x 0x%02x", read_buff[3], read_buff[4], read_buff[5], read_buff[6]);
}
start_parse_data(read_buff, read_len);
}
}
return true;
}
void McuReader::start_parse_data(const u_c ptr[], int len)
{
static u_c cache_buff[512];
static int consumed_size = 0;
static int size = 0;
if(len <= 512-consumed_size)
{
memcpy(&cache_buff[size], ptr, len);
size += len;
parse_state state;
state.ptr = cache_buff;
state.ptr_length = size;
state.consumed_index = consumed_size;
if((size-consumed_size) < 6)
{
if(PARSE_DEBUG)
ALOGI("cache buff is less than 6(unconsumed size[%d])", size-consumed_size);
return;
}
while(1)
{
state.consumed_index = consumed_size;
int consumed = parse_data_inner(state);
consumed_size += consumed;
if(PARSE_DEBUG)
{
ALOGI("consumed[%d]", consumed);
ALOGI("consumed_size[%d]", consumed_size);
ALOGI("size[%d]", size);
}
if(consumed == 0)
{
break;
}
}
if((size-consumed_size) <= 0 && consumed_size >= 256)
{
ALOGI("already consume cache buff over, so clean cache buff(size[%d])", size);
memset(cache_buff, 0, sizeof(cache_buff));
consumed_size = 0;
size = 0;
}
}
else
{
ALOGE("consumed_size[%d]", consumed_size);
ALOGE("error:receive buf is bigger than cache buff, you must create bigger catche buff");
}
}
//return consumed size
int McuReader::parse_data_inner(parse_state& state)
{
int consumed_index = 0;
u_c* ptr = &state.ptr[state.consumed_index];
//seek the head of frame,recursive
//find first 0xFF 0xAA
while((state.ptr_length-consumed_index-state.consumed_index) >= 6 && ptr[0] != 0xFF && ptr[1] != 0xAA)
{
consumed_index ++;
ptr++;
}
//match the frame
if((state.ptr_length-consumed_index-state.consumed_index) < 6)
{
if(PARSE_DEBUG)
ALOGE("error: the frame is too short(less than 6)");
return consumed_index;
}
if(ptr[0] == 0xFF
&&ptr[1] == 0xAA)
{
int cmd_len = ptr[2];
if(cmd_len <= (state.ptr_length-consumed_index-state.consumed_index))
{
if(ptr[cmd_len-1] == 0x0A)
{
u_c* cmd = ptr;
int len = cmd_len;
parse_single_cmd(cmd, len);
if(cmd_len == (state.ptr_length-consumed_index-state.consumed_index))
{
if(PARSE_DEBUG)
ALOGI("find the last cmd");
consumed_index += cmd_len;
return consumed_index;
}
else
{
//ALOGI("tip: find the next cmd...\r\n");
consumed_index += cmd_len;
return consumed_index;
}
}
else
{
if(PARSE_DEBUG)
ALOGE("error: can not find the end of frame(0x0A)!!");
return consumed_index;
}
}
else
{
if(PARSE_DEBUG)
ALOGE("error:the frame is not complete!!");
return consumed_index;
}
}
else
{
ALOGE("error: can not find the head of frame(0xFF, 0xAA), almost do not happen");
return consumed_index;
}
}
//0xFF 0xAA len 0x82 data... 0x0A
void McuReader::parse_sysinfo(const BYTE *pBuff,int num)
{
BYTE cmd = pBuff[3];
switch(pBuff[4])
{
case ARM_DATA_YEAR :
getMcuDataPtr()->sSettins.year = pBuff[5];
ALOGI("year = %d", getMcuDataPtr()->sSettins.year);
break;
case ARM_DATA_MONTH :
getMcuDataPtr()->sSettins.month = pBuff[5];
ALOGI("month = %d", getMcuDataPtr()->sSettins.month);
break;
case ARM_DATA_DAY :
getMcuDataPtr()->sSettins.day = pBuff[5];
ALOGI("day = %d", getMcuDataPtr()->sSettins.day);
break;
case ARM_DATA_HOUR :
getMcuDataPtr()->sSettins.hour = pBuff[5];
ALOGI("hour = %d", getMcuDataPtr()->sSettins.hour);
break;
case ARM_DATA_MINUTE :
getMcuDataPtr()->sSettins.minute = pBuff[5];
ALOGI("minute = %d", getMcuDataPtr()->sSettins.minute);
break;
case ARM_DATA_SECOND :
getMcuDataPtr()->sSettins.second = pBuff[5];
ALOGI("second = %d", getMcuDataPtr()->sSettins.second);
break;
case ARM_DATA_TIME12H :
getMcuDataPtr()->sSettins.b12H = pBuff[5];
ALOGI("b12H = %d", getMcuDataPtr()->sSettins.b12H);
break;
case ARM_DATA_VOL: {
int vol = pBuff[5];
set_settings_volume(vol);
ALOGI("vol = %d", vol);
} break;
case ARM_DATA_BASS: {
int bass = pBuff[5];
set_settings_bass(bass);
ALOGI("bass = %d", bass);
} break;
case ARM_DATA_TREB: {
int treb = pBuff[5];
set_settings_treb(treb);
ALOGI("treb = %d", treb);
} break;
case ARM_DATA_MID: {
int mid = pBuff[5];
set_settings_mid(mid);
ALOGI("mid = %d", mid);
} break;
case ARM_DATA_FADE: {
int fade = pBuff[5];
set_settings_fade(fade);
ALOGI("fade = %d", fade);
} break;
case ARM_DATA_BAL: {
int bal = pBuff[5];
set_settings_bal(bal);
ALOGI("bal = %d", bal);
} break;
case ARM_DATA_AUDIOMODE: {
int mode = pBuff[5];
set_settings_audio_mode(mode);
ALOGI("audioMode = %d", mode);
} break;
case ARM_DATA_MUTE: {
bool bMute = (bool)pBuff[5];
set_settings_mute(bMute);
ALOGI("bMute = %d", bMute);
} break;
case ARM_DATA_BRIGHT: {
bool bright = pBuff[5];
set_settings_brightness(bright);
ALOGI("bright = %d", bright);
} break;
case ARM_DATA_CONTRAST:
getMcuDataPtr()->sSettins.contrast = pBuff[5];
ALOGI("contrast = %d", getMcuDataPtr()->sSettins.contrast);
break;
case ARM_DATA_COLOR :
getMcuDataPtr()->sSettins.color = pBuff[5];
ALOGI("color = %d", getMcuDataPtr()->sSettins.color);
break;
case ARM_DATA_VIDEOMODE :
getMcuDataPtr()->sSettins.videoMode = pBuff[5];
ALOGI("videoMode = %d", getMcuDataPtr()->sSettins.videoMode);
break;
case ARM_DATA_TUNERSYS :
getMcuDataPtr()->sSettins.tunerSys = pBuff[5];
break;
case ARM_DATA_TVSYS :
getMcuDataPtr()->sSettins.tvSys = pBuff[5];
break;
case ARM_DATA_BEEP: {
bool beep = (bool)pBuff[5];
set_settings_key_sound(beep);
ALOGI("beep = %d", beep);
} break;
case ARM_DATA_SYSFLAG :
getMcuDataPtr()->sSettins.sysFlag = pBuff[5];
ALOGI("sysFlag = [%d]", getMcuDataPtr()->sSettins.sysFlag);
break;
case ARM_DATA_BTVOL: {
int vol = pBuff[5];
set_settings_btvol(vol);
ALOGI("btvol = %d", vol);
} break;
case ARM_DATA_FREQ30 :
getMcuDataPtr()->sSettins.freq30 = pBuff[5];
ALOGI("freq30 = %d", getMcuDataPtr()->sSettins.freq30);
break;
case ARM_DATA_FREQ60 :
getMcuDataPtr()->sSettins.freq60 = pBuff[5];
ALOGI("freq60 = %d", getMcuDataPtr()->sSettins.freq60);
break;
case ARM_DATA_FREQ125 :
getMcuDataPtr()->sSettins.freq125 = pBuff[5];
ALOGI("freq125 = %d", getMcuDataPtr()->sSettins.freq125);
break;
case ARM_DATA_FREQ250 :
getMcuDataPtr()->sSettins.freq250 = pBuff[5];
ALOGI("freq250 = %d", getMcuDataPtr()->sSettins.freq250);
break;
case ARM_DATA_FREQ500 :
getMcuDataPtr()->sSettins.freq500 = pBuff[5];
ALOGI("freq500 = %d", getMcuDataPtr()->sSettins.freq500);
break;
case ARM_DATA_FREQ1K :
getMcuDataPtr()->sSettins.freq1K = pBuff[5];
ALOGI("freq1K = %d", getMcuDataPtr()->sSettins.freq1K);
break;
case ARM_DATA_FREQ2K :
getMcuDataPtr()->sSettins.freq2K = pBuff[5];
ALOGI("freq2K = %d", getMcuDataPtr()->sSettins.freq2K);
break;
case ARM_DATA_FREQ4K :
getMcuDataPtr()->sSettins.freq4K = pBuff[5];
ALOGI("freq4K = %d", getMcuDataPtr()->sSettins.freq4K);
break;
case ARM_DATA_FREQ8K :
getMcuDataPtr()->sSettins.freq8K = pBuff[5];
ALOGI("freq8K = %d", getMcuDataPtr()->sSettins.freq8K);
break;
case ARM_DATA_FREQ16K :
getMcuDataPtr()->sSettins.freq16K = pBuff[5];
ALOGI("freq16K = %d", getMcuDataPtr()->sSettins.freq16K);
break;
case ARM_DATA_DSP1 :
getMcuDataPtr()->sSettins.bDsp1 = pBuff[5];
ALOGI("bDsp1 = %d", getMcuDataPtr()->sSettins.bDsp1);
break;
case ARM_DATA_DSP2 :
getMcuDataPtr()->sSettins.bDsp2 = pBuff[5];
ALOGI("bDsp2 = %d", getMcuDataPtr()->sSettins.bDsp2);
break;
case ARM_DATA_DSP3 :
getMcuDataPtr()->sSettins.bDsp3 = pBuff[5];
ALOGI("bDsp3 = %d", getMcuDataPtr()->sSettins.bDsp3);
break;
case ARM_DATA_GPSVOL: {
int vol = pBuff[5];
set_settings_gpsvol(vol);
ALOGI("gpsvol = %d", vol);
} break;
case ARM_DATA_SYSFLAG2 :
getMcuDataPtr()->sSettins.sysFlag2 = pBuff[5];
ALOGI("sysFlag2 = %d", getMcuDataPtr()->sSettins.sysFlag2);
break;
case ARM_DATA_DEFVOL: {
int defvol = pBuff[5];
set_settings_defvol(defvol);
ALOGI("defvol = %d", defvol);
} break;
case ARM_DATA_ARMSAVE1 :
getMcuDataPtr()->sSettins.save1 = pBuff[5];
ALOGI("save1 = %d", getMcuDataPtr()->sSettins.save1);
break;
case ARM_DATA_ARMSAVE2 :
getMcuDataPtr()->sSettins.save2 = pBuff[5];
break;
case ARM_DATA_ARMSAVE3 :
getMcuDataPtr()->sSettins.save3 = pBuff[5];
break;
case ARM_DATA_TV_SIGNAL:
getMcuDataPtr()->sTVInfo.tvSigCheck=1;
ALOGI("ARM_DATA_TVSINGCHECK tvSigCheck = %d",getMcuDataPtr()->sTVInfo.tvSigCheck);
break;
case ARM_DATA_SUBWOOF:
getMcuDataPtr()->sSettins.subwoof = pBuff[5];
ALOGI("subwoof = %d", getMcuDataPtr()->sSettins.subwoof);
break;
case ARM_DATA_SRS_SW:
getMcuDataPtr()->sSettins.bSrsOn = pBuff[5];
ALOGI("bSrsOn = %d", getMcuDataPtr()->sSettins.bSrsOn);
break;
case ARM_DATA_LOW_FO :
getMcuDataPtr()->sSettins.lowFo = pBuff[5];
ALOGI("lowFo = %d", getMcuDataPtr()->sSettins.lowFo);
break;
case ARM_DATA_MID_FO :
getMcuDataPtr()->sSettins.midFo = pBuff[5];
ALOGI("midFo = %d", getMcuDataPtr()->sSettins.midFo);
break;
case ARM_DATA_HIGH_FO :
getMcuDataPtr()->sSettins.highFo = pBuff[5];
ALOGI("highFo = %d", getMcuDataPtr()->sSettins.highFo);
break;
case ARM_DATA_ADJ_BACKVOL:
getMcuDataPtr()->sSettins.parkvol = pBuff[5];
ALOGI("parkvol = %d", getMcuDataPtr()->sSettins.parkvol);
break;
case ARM_DATA_CAMARAMIX:
getMcuDataPtr()->sSettins.parkccd = pBuff[5];
ALOGI("parkccd = %d", getMcuDataPtr()->sSettins.parkccd);
break;
case ARM_DATA_USER_BASS:
getMcuDataPtr()->sSettins.userBass = pBuff[5];
ALOGI("userBass = %d", getMcuDataPtr()->sSettins.userBass);
break;
case ARM_DATA_USER_MID:
getMcuDataPtr()->sSettins.userMid = pBuff[5];
ALOGI("userMid = %d", getMcuDataPtr()->sSettins.userMid);
break;
case ARM_DATA_USER_TREB:
getMcuDataPtr()->sSettins.userTreb = pBuff[5];
ALOGI("userTreb = %d", getMcuDataPtr()->sSettins.userTreb);
break;
default :
ALOGI("the frame do not used");
ALOGI("0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x Len:[%d]",pBuff[0],pBuff[1],pBuff[2],pBuff[3],pBuff[4],pBuff[5],pBuff[6],pBuff[7],pBuff[8],num);
break;
}
}
//0xFF 0xAA len 0x89 data... 0x0A
void McuReader::parse_setupinfo(const BYTE *pBuff,int num)
{
switch(pBuff[4])
{
case ARM_DATA_RADIO_AREA: {
int area = pBuff[5];
set_radio_area(area);
ALOGI("radioArea = %d", area);
} break;
case ARM_DATA_LANG_SEL:
getMcuDataPtr()->nLanguage = pBuff[5];
ALOGI("nLanguage = %d", getMcuDataPtr()->nLanguage);
break;
case ARM_DATA_FM_STOP_VAL :
getMcuDataPtr()->sExtInfo.fmStopVal = pBuff[5];
ALOGI("fmStopVal = %d", getMcuDataPtr()->sExtInfo.fmStopVal);
break;
case ARM_DATA_AM_STOP_VAL :
getMcuDataPtr()->sExtInfo.amStopVal = pBuff[5];
ALOGI("amStopVal = %d", getMcuDataPtr()->sExtInfo.amStopVal);
break;
case ARM_DATA_DSP_SEL:
getMcuDataPtr()->iSrsType = pBuff[5];
ALOGI("iSrsType = %d", getMcuDataPtr()->iSrsType);
break;
case ARM_DATA_LED_TYPE:
getMcuDataPtr()->ledtype = pBuff[5];
ALOGI("ledtype = %d", getMcuDataPtr()->ledtype);
break;
case ARM_DATA_LED_TIME:
getMcuDataPtr()->ledtime = pBuff[5];
ALOGI("ledtime = %d", getMcuDataPtr()->ledtime);
break;
case ARM_DATA_RDS_ONOFF:
getMcuDataPtr()->sDeveice.RdsSel = (bool)pBuff[5];
ALOGI("RdsSel = %d", getMcuDataPtr()->sDeveice.RdsSel);
break;
case ARM_DATA_TIME_AREA:
break;
case ARM_DATA_BT_MODULE:
getMcuDataPtr()->sExtInfo.btModule = pBuff[5];
ALOGI("receive bt Modele:%d",getMcuDataPtr()->sExtInfo.btModule);
break;
case ARM_DATA_CAN_COMPANY:
getMcuDataPtr()->sCanInfo.canType = pBuff[5];
break;
case ARM_DATA_CAN_LOGO:
getMcuDataPtr()->sCanInfo.carType &= 0x00ff;
getMcuDataPtr()->sCanInfo.carType |= (pBuff[5]<<8);
break;
case ARM_DATA_CAN_TYPE:
getMcuDataPtr()->sCanInfo.carType &= 0xff00;
getMcuDataPtr()->sCanInfo.carType |= (pBuff[5]);
ALOGI("Receive Car Type:%x,CanBus Compan:%d",getMcuDataPtr()->sCanInfo.carType,getMcuDataPtr()->sCanInfo.canType);
break;
case ARM_DATA_REBOOTMODE:
//PostMessage(g_hWnd,MSG_SYSTEM_REBOOT_MODE,pBuff[5],0);
break;
case ARM_DATA_DARAR_SW:
getMcuDataPtr()->sSettins.radarSwitch = pBuff[5];
ALOGI("radar switch = %d", pBuff[5]);
break;
default:
ALOGE("the frame do not used");
ALOGE("0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x Len:[%d]",pBuff[0],pBuff[1],pBuff[2],pBuff[3],pBuff[4],pBuff[5],pBuff[6],pBuff[7],pBuff[8],num);
break;
}
}
//0xFF,0xAA,len,data0,data1,...,0x0A
void McuReader::parse_single_cmd(const u_c* pBuff, int num)
{
static bool timeUpdateReq = 0;
int temp;
if(pBuff[0] != 0xFF || pBuff[1] != 0xAA || pBuff[num-1] != 0x0A || num < 6)
{
ALOGE("!!mcu com check sum err!!\r\n");
return;
}
if(pBuff[0] == 0xFF && pBuff[1] == 0xAA && pBuff[3] == 0x95 && num == 6 )
{
return ;
}
ALOGI("arminfo is 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x Len:[%d]",pBuff[0],pBuff[1],pBuff[2],pBuff[3],pBuff[4],pBuff[5],pBuff[6],pBuff[7],pBuff[8],num);
BYTE cmd = pBuff[3];
if(cmd >= 0xD0 && cmd < 0xDF)
{
switch(cmd)
{
case 0xD0:
getMcuDataPtr()->sCtrl.bRefresh = true;
if (getMcuDataPtr()->sCtrl.bRefresh) {
getMcuDataPtr()->sCtrl.bRefresh = 0;
}
break;
case ARM_CMD_SYS_BACKSIGHT :
getMcuDataPtr()->sDeveice.bParking = pBuff[4];
break;
case ARM_CMD_SYS_VALIDWND :
getMcuDataPtr()->sDeveice.sourceValidFlag = (WORD)(pBuff[4])*256 + pBuff[5];
getMcuDataPtr()->sDeveice.sourceValidFlag |= BIT3; //car usb
getMcuDataPtr()->sDeveice.sourceValidFlag |= BIT4; // car ipod
break;
case ARM_CMD_SYS_DEVCHANGE :
getMcuDataPtr()->sDeveice.lastDeveiceChange = pBuff[4];
break;
case ARM_CMD_SYS_KEY : {
int keycode = pBuff[4];
if(keycode == C_KEY_VOL_INC //vol+
|| keycode == C_KEY_VOL_DEC //vol-
|| keycode == C_KEY_MUTE //mute
|| keycode == C_KEY_FREQ_INC //freq+
|| keycode == C_KEY_FREQ_DEC //freq-
|| keycode == C_KEY_PLAY //play or pause
|| keycode == C_KEY_SEL //setup
|| keycode == C_KEY_ESC //menu
|| keycode == 0xCA //long click menu
|| keycode == C_KEY_MODE //mode or media
|| keycode == C_KEY_RADIO //radio
|| keycode == C_KEY_BAND //band
|| keycode == C_KEY_GPS //gps
|| keycode == C_KEY_DIAL //bt or dial
|| keycode == 0xCB //prev
|| keycode == 0xCC //next
|| keycode == C_KEY_REW //long click prev, pew
|| keycode == C_KEY_FF //long click next, ff
|| keycode == 0x2A //long click up
)
{
ALOGI("keycode[%d]", keycode);
if(mMcuService != NULL)
{
mMcuService->notifyHardKey(keycode);
}
}
else
{
ALOGI("else keycode[%d]", keycode);
}
} break;
case ARM_CMD_SYS_REQ_EXIT: {
set_system_acc_state(false);
} break;
case ARM_CMD_SYS_REQ_ON: {
set_system_acc_state(true);
} break;
case ARM_CMD_SYS_INIT_OK :
//PostMessage(g_hWnd,UART_MCU_INIT_OK,pBuff[4],0);
break;
/*case ARM_CMD_SOURCE_SETBIT:
getMcuDataPtr()->sDeveice.SourceSetBit = (WORD)(pBuff[4])*256 + pBuff[5];//源设置开关参数
break;
case ARM_CMD_ICON_SETBIT:
getMcuDataPtr()->sDeveice.IconSetBit = (WORD)(pBuff[4])*256 + pBuff[5];
break;*/
default :
break;
}
}
//mp3 dvd info
else if(cmd >= 0xe0 && cmd <= 0xeF)
{
}
//Radio Info
else if(cmd >= 0x20 && cmd <= 0x2F)
{
switch(cmd)
{
case 0x20:
break;
case 0x21: {
int freq = (WORD)(pBuff[4])*256 + (WORD)pBuff[5];
set_radio_has_legal_freq(false);
set_radio_freq(freq);
ALOGI("0x21 :: freq = %d", freq);
} break;
case 0x22: {
} break;
case 0x23: {
int loc = pBuff[4];
set_radio_loc(loc);
ALOGI("0x23 :: bLoc = %d", loc);
} break;
case 0x24: {
int st = pBuff[4];
set_radio_st(st);
ALOGI("0x24 :: bSt = %d", st);
} break;
case 0x25: {
int stind = pBuff[4];
set_radio_stind(stind);
ALOGI("0x25 :: bStInd = %d", stind);
} break;
case ARM_CMD_RADIO_PS :
memset(getMcuDataPtr()->sRadio.PsName,0, sizeof(getMcuDataPtr()->sRadio.PsName));
for(int i = 0;i < 8; i++)
{
if(pBuff[4+i] == 0)
{
break;
}
getMcuDataPtr()->sRadio.PsName[i] = pBuff[4+i];
}
ALOGI("[RDS]:Receive PS Info:%s\n",&pBuff[4]);
break;
case ARM_CMD_RADIO_AFMODE:
getMcuDataPtr()->sRadio.bAF = (bool)pBuff[4];
ALOGI("0x27 :: bAF = %d", getMcuDataPtr()->sRadio.bAF);
break;
case ARM_CMD_RADIO_TPINFO :
memset(getMcuDataPtr()->sRadio.tpInfo, 0, sizeof(getMcuDataPtr()->sRadio.tpInfo));
for(int i = 0;i < 8; i++)
{
if(pBuff[4+i] == 0)
{
break;
}
getMcuDataPtr()->sRadio.tpInfo[i] = pBuff[4+i];
ALOGI("[RDS]:Receive TP Info:%s\n",&pBuff[4]);
}
break;
case ARM_CMD_RADIO_TAMODE :
getMcuDataPtr()->sRadio.bTA = pBuff[4];
ALOGI("[RDS]:Receive TA Flag:%d\n",pBuff[4]);
break;
case ARM_CMD_RADIO_EON :
getMcuDataPtr()->sRadio.bEON= pBuff[4];
ALOGI("[RDS]:Receive EON Flag:%d\n",pBuff[4]);
break;
case ARM_CMD_RADIO_TP :
getMcuDataPtr()->sRadio.bPTY= pBuff[4];
ALOGI("[RDS]:Receive TP Flag:%d\n",pBuff[4]);
break;
case ARM_CMD_RADIO_PTY :
getMcuDataPtr()->sRadio.ptyType = pBuff[4]&0x3F;
ALOGI("[RDS]:Receive PTY Type:%d\n",pBuff[4]&0x3F);
break;
case ARM_CMD_NEW_RADIO_INFO:
if(pBuff[4] == ARM_DATA_RADIO_HAVE_SIG)
{
set_radio_has_legal_freq(true);
int freq = pBuff[5]*256+pBuff[6];
set_radio_legal_freq(freq);
ALOGI("0x2D :: haslegalFreq = %d ",get_radio_has_legal_freq());
ALOGI("0x2D :: legalFreq = %d ",freq);
}
else
{
set_radio_has_legal_freq(false);
}
break;
case 0x2E: {
int search = pBuff[4];
set_radio_search(search);
if(!search)
{
set_radio_has_legal_freq(false);
}
ALOGI("0x2E :: bSearch = %d", search);
} break;
case 0x2F : {
int scan = pBuff[4];
set_radio_scan(scan);
ALOGI("0x2F :: bManu = %d", scan);
} break;
}
}
else if(cmd >= 0x30 && cmd <= 0x3F)
{
switch(cmd)
{
case 0x34 :
getMcuDataPtr()->sDeveice.bCarRun = pBuff[4];
break;
case 0x35 :
getMcuDataPtr()->sDeveice.bIllOn = pBuff[4];
break;
}
}
else if(cmd >= 0x40 && cmd <= 0x4F)
{
}
//can info
else if(cmd >= 0x50 && cmd <= 0x5F)
{
if(mMcuService != NULL)
{
mMcuService->notifyCanInfo(&pBuff[4], num-5);
}
}
else if (cmd == ARM_CMD_TV_BAR_INFO)
{
}
//0x82
else if(cmd == ARM_CMD_UPDATE_SYSINFO)
{
parse_sysinfo(pBuff,num);
}
else if(cmd == 0x83)
{
getMcuDataPtr()->sDeveice.bPowerBeforMcuInit = pBuff[4];
ALOGI("bPowerBeforMcuInit = %d", pBuff[4]);
}
else if(cmd == 0x84)
{
//PostMessage(g_hWnd,UART_MCU_EXTKEY0_CHANGE,pBuff[4]*2560 + pBuff[5]*10,0);
}
else if(cmd == 0x85)
{
//PostMessage(g_hWnd,UART_MCU_EXTKEY1_CHANGE,pBuff[4]*2560 + pBuff[5]*10,0);
}
else if(cmd == 0x86)
{
//PostMessage(g_hWnd,UART_MCU_EXTKEY0_MAXRES,pBuff[4]*2560 + pBuff[5]*10,0);
}
else if(cmd == 0x87)
{
//PostMessage(g_hWnd,UART_MCU_EXTKEY1_MAXRES,pBuff[4]*2560 + pBuff[5]*10,0);
}
else if(cmd == 0x88)
{
memset(getMcuDataPtr()->sSettins.mcuVer, 0, sizeof(getMcuDataPtr()->sSettins.rtkVer));
memcpy(getMcuDataPtr()->sSettins.mcuVer,&pBuff[4],9);
ALOGI("mcuVer = %s", getMcuDataPtr()->sSettins.mcuVer);
}
else if(ARM_CMD_SYSSETUP == cmd)
{
parse_setupinfo(pBuff,num);
}
else if(cmd == 0x8A)
{
getMcuDataPtr()->sSettins.freq30 = pBuff[4];
getMcuDataPtr()->sSettins.freq60 = pBuff[5];
getMcuDataPtr()->sSettins.freq125 = pBuff[6];
getMcuDataPtr()->sSettins.freq250 = pBuff[7];
getMcuDataPtr()->sSettins.freq500 = pBuff[8];
getMcuDataPtr()->sSettins.freq1K= pBuff[9];
getMcuDataPtr()->sSettins.freq2K= pBuff[10];
getMcuDataPtr()->sSettins.freq4K= pBuff[11];
getMcuDataPtr()->sSettins.freq8K= pBuff[12];
getMcuDataPtr()->sSettins.freq16K= pBuff[13];
ALOGI("0x8A = [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d]", getMcuDataPtr()->sSettins.freq30,
getMcuDataPtr()->sSettins.freq60,getMcuDataPtr()->sSettins.freq125,getMcuDataPtr()->sSettins.freq250,getMcuDataPtr()->sSettins.freq500,
getMcuDataPtr()->sSettins.freq1K,getMcuDataPtr()->sSettins.freq2K,getMcuDataPtr()->sSettins.freq4K,getMcuDataPtr()->sSettins.freq8K,
getMcuDataPtr()->sSettins.freq16K);
}
else if(cmd == 0x8b)
{
getMcuDataPtr()->sSettins.trubass = pBuff[4];
getMcuDataPtr()->sSettins.focus = pBuff[5];
getMcuDataPtr()->sSettins.defintion = pBuff[6];
getMcuDataPtr()->sSettins.limiter = pBuff[7];
getMcuDataPtr()->sSettins.trubassfreq = pBuff[8];
getMcuDataPtr()->sSettins.space = pBuff[10];
getMcuDataPtr()->sSettins.center = pBuff[11];
ALOGI("0x8A = [%d] [%d] [%d] [%d] [%d] [%d] [%d] ", getMcuDataPtr()->sSettins.trubass,
getMcuDataPtr()->sSettins.focus,getMcuDataPtr()->sSettins.defintion,getMcuDataPtr()->sSettins.limiter,getMcuDataPtr()->sSettins.trubassfreq,
getMcuDataPtr()->sSettins.space,getMcuDataPtr()->sSettins.center);
}
else if(cmd == 0x8c)
{
memset(getMcuDataPtr()->sSettins.rtkVer, 0, sizeof(getMcuDataPtr()->sSettins.rtkVer));
memcpy(getMcuDataPtr()->sSettins.rtkVer,&pBuff[4],12);
ALOGI("rtkVer = %s", getMcuDataPtr()->sSettins.rtkVer);
}
else if(cmd == 0xB5)
{
}
else if (ARM_CMD_VMDVD_INFO == cmd)
{
}
else if(ARM_CMD_USER_SAVE_DATA == cmd)
{
memcpy(&getMcuDataPtr()->sArmSaveData,&pBuff[4],8);
ALOGI("[RDS ] enter RDS Tarffic Mode[%d]", (bool)pBuff[4]);
}
else if(ARM_CMD_SYS_RADIO_MODE == cmd)
{
getMcuDataPtr()->sRadio.bTraffic = (bool)pBuff[4];
ALOGI("[RDS ] enter RDS Tarffic Mode[%d]", (bool)pBuff[4]);
}
}
| [
"liujianganggood@gmail.com"
] | liujianganggood@gmail.com |
5b0709a970edea61646a6b5849eb84a60c9834e1 | 157a0106fe36a1f5c6fef269e77d04fe4040fe95 | /VulkanDemo/Memory/Resources.h | 98f3bbfe492715c30c3698d748b48c7a3f4fdba6 | [] | no_license | parnny/VulkanDemo | 9c77b173be431bca8a05fc4ead8d795a89ef16c1 | 36562370d366c8f1d6130bec0441794a15767f22 | refs/heads/master | 2020-06-05T16:47:29.386926 | 2019-07-03T03:03:53 | 2019-07-03T03:03:53 | 192,487,375 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 431 | h |
#include "GlobalInclude.h"
class VDResources
{
public:
VDResources(VkPhysicalDevice* physical, VkDevice* logic)
: mPhysicalDevice(physical)
, mLogicDevice(logic)
{
mFormatProperties = new VkFormatProperties();
}
void Init();
void BufferOperation();
void ImageOperation();
void FormatAndSupportInfo();
private:
VkDevice* mLogicDevice;
VkPhysicalDevice* mPhysicalDevice;
VkFormatProperties* mFormatProperties;
};
| [
"436071683@qq.com"
] | 436071683@qq.com |
ca12df9d0900ca791b79ba63975849c8d4dba051 | 6b8bcd288111e4ffefcd0f42ae3d14f8404ccc65 | /Part1Basic/CPP/06-Union-Find/05-Quick-Union-Optimized-By-Layers/UnionFind.h | ea978eb3b76acb9898f90883bc364c978c7dc91f | [
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-mulanpsl-1.0-en",
"MulanPSL-1.0"
] | permissive | luqian2017/algorithms | 943c1365022e307ca2770d121cf8662ba6959e22 | e83a17ecf1a7cfea77c5b4ecddc92eb9f1fc329c | refs/heads/master | 2020-12-29T22:56:49.445532 | 2020-02-05T14:57:16 | 2020-02-05T14:57:16 | 238,765,020 | 1 | 0 | NOASSERTION | 2020-02-06T19:15:35 | 2020-02-06T19:15:35 | null | UTF-8 | C++ | false | false | 3,852 | h | /***********************************************************
* @Description : 优化1：利用parent数组把上一节Union操作的效率由N降到logN
* 优化2：通过比较两个并查集的大小来决定pRoot连接qRoot, 还是qRoot连接pRoot
* (即谁是谁的父节点，元素少的并查集根节点连接元素多的并查集的根节点)
* 优化3：按照两个并查集的层数来判断谁和谁连接，这样更准确，因为遍历的时候就是逐层遍历
* @author : 梁山广(Laing Shan Guang)
* @date : 2018/4/29 20:08
* @email : liangshanguang2@gmail.com
***********************************************************/
#ifndef UNIONFIND_H
#define UNIONFIND_H
#include <iostream>
#include <cassert>
using namespace std;
namespace UF {
class UnionFind {
private:
// 数据之间连接的情况，这里是数组指针.parent[i]标是下标为i的元素的父元素下标
int *parent;
// rank[i]表示以i为根的集合的层数
int *rank;
// 并查集有多少元素
int count;
public:
// 构造函数
UnionFind(int n) {
count = n;
// 初始化id数组
parent = new int[n];
rank = new int[n];
for (int i = 0; i < n; ++i) {
// 初始化的时候每个元素的父元素指向自己.这个特征也是每个并查集的根节点的特征
parent[i] = i;
// 初始时所有元素都是互不相连地，所以每个元素都是一个并查集，每个并查集只有一个元素,也就是一层
rank[i] = 1;
}
}
~UnionFind() {
delete[] parent;
delete[] rank;
}
// 返回p所在的根节点的下标(找到并查集的根节点)
int find(int p) {
assert(p >= 0 && p < count);
// 只要节点不指向自身，说明还没到根节点
while (p != parent[p]) {
// 不断刷新p直接遇到并查集的根节点
p = parent[p];
}
return p;
}
// 判断下标为p和q的点是否有同样的根，就可以判断p和q是否是连接在一起地了
bool isConnected(int p, int q) {
return find(p) == find(q);
}
// 连接两个元素p和q
void unionElements(int p, int q) {
// 找到p元素对应的根
int pRoot = find(p);
int qRoot = find(q);
// 根元素相等说明两个元素已经在同一个并查集内了，是相互连接地了。直接返回
if (pRoot == qRoot) {
return;
}
// 不在一个并查集内的话，只需要把两个根节点连接起来即可
// 下面按照两个并并查集的层数(rank[i])的大小决定谁连接谁(层数少地连接层数多地)
if (rank[pRoot] < rank[qRoot]) { // p所在的并查集层数小于q所在的并查集层数，p指向q
// p所在的并查集连接q所在的并查集，rank取两者中较大地，并不需要维护
parent[pRoot] = qRoot;
} else if (rank[pRoot] > rank[qRoot]) { // p所在的并查集层数大于q所在的并查集层数,q指向p
// q所在的并查集连接p所在的并查集
parent[qRoot] = pRoot;
} else { // p所在的并查集层数等于q所在的并查集层数,谁指向谁都行，这里选p指向q
//当 rank[pRoot] = rank[qRoot];
parent[pRoot] = qRoot;
// 把新的并查集层数+1
rank[qRoot] += 1;
}
}
};
}
#endif //UNIONFIND_H
| [
"1648266192@qq.com"
] | 1648266192@qq.com |
d3a7a543b3f812aa2f63c438e83b708993ca4aab | fec430ae3164f1a218c0a6b1a4313ecdc9443ff6 | /11.2.cpp | e09a71b6124ceb965133eb6264cedefbaf2de90f | [] | no_license | Sofia0408/Projects | 06b7976d1c593c059b5ed1901a59d346c033f668 | 2106b3a55cb663f7b4ee886cb77d71a871735cfc | refs/heads/master | 2023-02-16T02:03:19.348529 | 2021-01-18T13:37:00 | 2021-01-18T13:37:00 | 299,041,987 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 796 | cpp | #include <iostream>
#include <locale.h>
using namespace std;
int main()
{
setlocale(LC_ALL, "Russian");
int A, B, C, sum;
cout << "введите число А" << endl;
cin >> A;
cout << "введите число B" << endl;
cin >> B;
cout << "введите число C" << endl;
cin >> C;
if (A > B && B > C || B > A && A > C) {
sum = A + B;
cout << "Сумма наибольших = " << sum << endl;
}
if (C > A && A > B || A > C && C > B) {
sum = A + C;
cout << "Сумма наибольших = " << sum << endl;
}
if (C > B && B > A || B > C && C > A) {
sum = B + C;
cout << "Сумма наибольших = " << sum << endl;
}
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
7300dde86a3ec697f9774e0f614542bf6b444004 | 59e92e5c7e4ec1b89d8b8fd68e2fc54583b17de9 | /memtable/terark_zip_memtable_test.cc | f24b8266daa3f076971f5f961e39916662310be1 | [
"BSD-3-Clause",
"Apache-2.0"
] | permissive | weilewei/terarkdb | 688f594b22d39e6c046906678e722476cab29ca9 | 6e0eeaae853f6746b80e93e8ae4c9d8e95b8467a | refs/heads/dev.1.4 | 2023-08-02T16:26:23.557198 | 2021-09-18T11:32:02 | 2021-09-18T13:01:12 | 408,506,261 | 0 | 0 | NOASSERTION | 2021-09-21T01:32:39 | 2021-09-20T15:51:56 | null | UTF-8 | C++ | false | false | 6,961 | cc | // Copyright (c) 2020-present, Bytedance Inc. All rights reserved.
// This source code is licensed under Apache 2.0 License.
#include "terark_zip_memtable.h"
#include <inttypes.h>
#include <atomic>
#include <chrono>
#include <memory>
#include <string>
#include "db/dbformat.h"
#include "gtest/gtest.h"
#include "rocksdb/terark_namespace.h"
namespace TERARKDB_NAMESPACE {
class TerarkZipMemtableTest : public testing::Test {};
TEST_F(TerarkZipMemtableTest, SimpleTest) {
std::shared_ptr<MemTable> mem_;
Options options;
options.memtable_factory =
std::shared_ptr<MemTableRepFactory>(NewPatriciaTrieRepFactory());
InternalKeyComparator cmp(BytewiseComparator());
ImmutableCFOptions ioptions(options);
WriteBufferManager wb(options.db_write_buffer_size);
mem_ = std::shared_ptr<MemTable>(
new MemTable(cmp, ioptions, MutableCFOptions(options),
/* needs_dup_key_check */ true, &wb, kMaxSequenceNumber,
0 /* column_family_id */));
// Run some basic tests
SequenceNumber seq = 123;
bool res;
res = mem_->Add(seq, kTypeValue, "key", "value2");
ASSERT_TRUE(res);
res = mem_->Add(seq, kTypeValue, "key", "value2");
ASSERT_FALSE(res);
// Changing the type should still cause the duplicatae key
res = mem_->Add(seq, kTypeMerge, "key", "value2");
ASSERT_FALSE(res);
// Changing the seq number will make the key fresh
res = mem_->Add(seq + 1, kTypeMerge, "key", "value2");
ASSERT_TRUE(res);
// Test with different types for duplicate keys
res = mem_->Add(seq, kTypeDeletion, "key", "");
ASSERT_FALSE(res);
res = mem_->Add(seq, kTypeSingleDeletion, "key", "");
ASSERT_FALSE(res);
}
// Test multi-threading insertion
// we ignore multithread question for row-ttl
TEST_F(TerarkZipMemtableTest, MultiThreadingTest) {
MemTable* mem_;
Options options;
options.memtable_factory =
std::shared_ptr<MemTableRepFactory>(NewPatriciaTrieRepFactory());
InternalKeyComparator cmp(BytewiseComparator());
ImmutableCFOptions ioptions(options);
WriteBufferManager wb(options.db_write_buffer_size);
mem_ = new MemTable(cmp, ioptions, MutableCFOptions(options), true, &wb,
kMaxSequenceNumber, 0);
size_t records = 1 << 20;
int thread_cnt = 10;
SequenceNumber seq = 0;
// Single Thread CSPPTrie
auto start = std::chrono::system_clock::now();
for (size_t i = 0; i < records; ++i) {
std::string key("key " + std::to_string(i));
std::string value("value " + std::to_string(i));
auto ret = mem_->Add(seq, kTypeValue, key, value);
ASSERT_TRUE(ret);
seq++;
}
auto end = std::chrono::system_clock::now();
auto dur = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
.count();
printf("[CSPPTrie] Single-Thread Time Cost: %" PRId64
", mem_->size = %" PRId64 "\n",
dur, mem_->num_entries());
delete mem_;
// Single thread SkipList
options.memtable_factory =
std::shared_ptr<MemTableRepFactory>(new SkipListFactory());
ImmutableCFOptions ioptions2(options);
WriteBufferManager wb2(options.db_write_buffer_size);
mem_ = new MemTable(cmp, ioptions2, MutableCFOptions(options), true, &wb2,
kMaxSequenceNumber, 0);
start = std::chrono::system_clock::now();
seq = 0;
for (size_t i = 0; i < records; ++i) {
std::string key("key " + std::to_string(i));
std::string value("value " + std::to_string(i));
auto ret = mem_->Add(seq, kTypeValue, key, value);
ASSERT_TRUE(ret);
seq++;
}
end = std::chrono::system_clock::now();
dur = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
.count();
printf("[SkipList] Single-Thread Time Cost: %" PRId64
", mem_->size = %" PRId64 "\n",
dur, mem_->num_entries());
delete mem_;
// Multi Thread CSPPTrie
options.allow_concurrent_memtable_write = true;
options.memtable_factory =
std::shared_ptr<MemTableRepFactory>(NewPatriciaTrieRepFactory());
ImmutableCFOptions ioptions3(options);
WriteBufferManager wb3(options.db_write_buffer_size);
mem_ = new MemTable(cmp, ioptions3, MutableCFOptions(options), true, &wb3,
kMaxSequenceNumber, 0);
std::vector<std::thread> threads;
// Each thread should has its own post_process_info
std::vector<MemTablePostProcessInfo> infos(thread_cnt);
std::atomic<SequenceNumber> atomic_seq{0};
start = std::chrono::system_clock::now();
for (int t = 0; t < thread_cnt; ++t) {
threads.emplace_back(std::thread([&, t]() {
int start = (records / thread_cnt) * t;
int end = (records / thread_cnt) * (t + 1);
for (size_t i = start; i < end; ++i) {
std::string key("key " + std::to_string(i));
std::string value("value " + std::to_string(i));
auto ret =
mem_->Add(atomic_seq++, kTypeValue, key, value, true, &infos[t]);
ASSERT_TRUE(ret);
}
}));
}
for (auto& thread : threads) {
thread.join();
}
end = std::chrono::system_clock::now();
dur = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
.count();
uint64_t total_size = 0;
for (auto info : infos) {
total_size += info.num_entries;
}
printf("[CSPPTrie] Multi-Thread Time Cost: %" PRId64 ", mem_->size = %" PRId64
"\n",
dur, total_size);
delete mem_;
// Multi Thread SkipList
options.allow_concurrent_memtable_write = true;
options.memtable_factory =
std::shared_ptr<MemTableRepFactory>(new SkipListFactory());
ImmutableCFOptions ioptions4(options);
WriteBufferManager wb4(options.db_write_buffer_size);
mem_ = new MemTable(cmp, ioptions4, MutableCFOptions(options), true, &wb4,
kMaxSequenceNumber, 0);
threads.clear();
infos.clear();
infos.resize(thread_cnt);
atomic_seq = {0};
start = std::chrono::system_clock::now();
for (int t = 0; t < thread_cnt; ++t) {
threads.emplace_back(std::thread([&, t]() {
int start = (records / thread_cnt) * t;
int end = (records / thread_cnt) * (t + 1);
for (size_t i = start; i < end; ++i) {
std::string key("key " + std::to_string(i));
std::string value("value " + std::to_string(i));
auto ret =
mem_->Add(atomic_seq++, kTypeValue, key, value, true, &infos[t]);
ASSERT_TRUE(ret);
}
}));
}
for (auto& thread : threads) {
thread.join();
}
end = std::chrono::system_clock::now();
dur = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
.count();
total_size = 0;
for (auto info : infos) {
total_size += info.num_entries;
}
printf("[SkipList] Multi-Thread Time Cost: %" PRId64 ", mem_->size = %" PRId64
"\n",
dur, total_size);
delete mem_;
}
} // namespace TERARKDB_NAMESPACE
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| [
"mm304321141@gmail.com"
] | mm304321141@gmail.com |
6a7e71041743cb0c4229adfe55c55667864c01ad | c8cb134531c883d7c389fecee63a99f67f19bc8a | /dstream/middeval/middlebury/cvkit_src/gvr/globject.h | cf5b1255df12b998f59d55a9d9f263e8fa8d8f73 | [
"BSD-3-Clause",
"MIT"
] | permissive | renzbagaporo/depthstream | ddced4bb41f9144b7dfcccc1dc92efae7b65b9df | 9ad0febf3e7c0af5ccfbdca2746ce24b353c76a1 | refs/heads/master | 2021-01-10T23:05:42.019805 | 2017-12-22T10:48:45 | 2017-12-22T10:48:45 | 115,082,722 | 12 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,256 | h | /*
* This file is part of the Computer Vision Toolkit (cvkit).
*
* Author: Heiko Hirschmueller
*
* Copyright (c) 2014, Institute of Robotics and Mechatronics, German Aerospace Center
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef GVR_GLOBJECT_H
#define GVR_GLOBJECT_H
namespace gvr
{
class GLCamera;
class GLObject
{
private:
int id;
GLObject(const GLObject &);
GLObject& operator=(const GLObject &);
public:
GLObject(int _id)
{
id=_id;
}
virtual ~GLObject() {};
int getID() { return id; }
void setID(int _id) { id=_id; }
virtual int getVertexCount() { return 0; }
virtual int getTriangleCount() { return 0; }
virtual void draw(const GLCamera &cam) {}
};
}
#endif
| [
"renz.bagaporo@gmail.com"
] | renz.bagaporo@gmail.com |
0b7eb647b0961c9ea0a6a1cee04cea4dc3365c85 | dea3eecf94f4a0a5aff2625c437ae820bc4150c9 | /include/openmc/container_util.h | a40532343cb525145dc06b796feb05062ad89a4a | [
"MIT"
] | permissive | makeclean/openmc | 1d9df0f2c80d0081beba791f210e7f93907b5608 | 634ae61a190d5506d7a8964b19553a92f75a05ae | refs/heads/develop | 2021-12-18T20:35:20.501396 | 2021-12-08T13:09:12 | 2021-12-08T13:09:12 | 105,571,714 | 1 | 2 | MIT | 2021-11-25T10:05:59 | 2017-10-02T18:49:41 | Python | UTF-8 | C++ | false | false | 358 | h | #ifndef OPENMC_CONTAINER_UTIL_H
#define OPENMC_CONTAINER_UTIL_H
#include <algorithm> // for find
#include <iterator> // for begin, end
namespace openmc {
template<class C, class T>
inline bool contains(const C& v, const T& x)
{
return std::end(v) != std::find(std::begin(v), std::end(v), x);
}
} // namespace openmc
#endif // OPENMC_CONTAINER_UTIL_H
| [
"paul.k.romano@gmail.com"
] | paul.k.romano@gmail.com |
e086de01b306914def32b6206b8078ae9aeaa5e4 | 97e93de8e32e2d5d9760ccf3dbdfa1e05f97ea2c | /library.h | 5019929180640d5d705005048a96b646ca19af2d | [] | no_license | viniaikinp/lab30 | 38981a20044ab6a08c7d343fdf25b4c5e4f7b695 | 67024f3fa53b89582140adebdc461ff25a81bb6b | refs/heads/master | 2022-04-25T04:35:01.150954 | 2020-04-30T16:13:26 | 2020-04-30T16:13:26 | 260,257,016 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,627 | h | #ifndef LIBRARY_H
#define LIBRARY_H
#include <string>
#include <fstream>
struct Book;
class Shelf;
class Rack;
class Library
{
public:
Library();
virtual ~Library();
void save();
void load();
void giveOut(); // выдача
void addShelf();//добавить полку
void addShelf(int r);
void removeShelf();//убрать полку
void addRack(); //добавить стеллаж
void removeRack();//удалить стеллаж
void addNewBook();//добавить новый книгу
void addBook(int r, int s, Book& book);
void removeBook();//убрать книгу
void changeBook();//поменять книгу
void changeBookInSomePlace();//поменять книги местами
void outputAll();
void outputByShelfAndRack(int r, int s, int b);//вывод книги по полке и стеллажу
void findByShelfAndRack();//найти по полке (какая полка) и по стеллажу
void findByName();//найти по имени
void findByAvtor(); //найти по автору
void findByJanr();//найти по жанру
std::string filePath() const;
void setFilePath(const std::string &filePath);
int rackCount() const ;
int shelvesCount() const;
Book* getBook( int r, int s, int b);
private:
void load( std::ifstream& ifs );
void save( std::ofstream& ofs );
void init( std::ofstream& ofs );
bool askPosition(int *r, int *s, int *b);
private:
std::string _filePath;
Rack* racks = nullptr;
int rack_count = 0;
};
#endif
| [
"noreply@github.com"
] | noreply@github.com |
2f6620125a3b182b3488630e04ff1aa2379aed1a | 650b45dc73f6e11db663c58e71bbf1c3da3ddb8c | /libvast/vast/address.hpp | 9244449a65be0d84d86406f44a6e7e253315c347 | [
"BSD-3-Clause"
] | permissive | sbilly/vast | 82e4d5a16e6c6bc40d1d19a4f7b1b1f7dea17645 | 9c39ac2edd0acd36c501805b55951704d42a938e | refs/heads/master | 2021-01-17T23:45:39.633710 | 2016-04-22T02:22:29 | 2016-04-22T02:22:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,349 | hpp | #ifndef VAST_ADDRESS_HPP
#define VAST_ADDRESS_HPP
#include <array>
#include <string>
#include "vast/util/operators.hpp"
namespace vast {
struct access;
/// An IP address.
class address : util::totally_ordered<address>, util::bitwise<address> {
friend access;
/// Top 96 bits of v4-mapped-addr.
static std::array<uint8_t, 12> const v4_mapped_prefix;
public:
/// Address family.
enum family { ipv4, ipv6 };
/// Address byte order.
enum byte_order { host, network };
/// Default-constructs an (invalid) address.
address();
/// Constructs an address from raw bytes.
/// @param bytes A pointer to the raw byte representation. This must point
/// to 4 bytes if *fam* is `ipv4`, and to 16 bytes if *fam* is
/// `ipv6`.
/// @param fam The address family.
/// @param order The byte order in which the address pointed to by *bytes*
/// is stored in.
address(uint32_t const* bytes, family fam, byte_order order);
friend bool operator==(address const& x, address const& y);
friend bool operator<(address const& x, address const& y);
/// Determines whether the address is IPv4.
/// @returns @c true iff the address is an IPv4 address.
bool is_v4() const;
/// Determines whether the address is IPv4.
/// @returns `true` iff the address is an IPv4 address.
bool is_v6() const;
/// Determines whether the address is an IPv4 loopback address.
/// @returns `true` if the address is v4 and its first byte has the
/// value 127.
bool is_loopback() const;
/// Determines whether the address is an IPv4 broadcast address.
/// @returns `true` if the address is v4 and has the value 255.255.255.255.
bool is_broadcast() const;
/// Determines whether the address is a multicast address. For v4
/// addresses, this means the first byte equals to 224. For v6 addresses,
/// this means the first bytes equals 255.
/// @returns `true` if the address is a multicast address.
bool is_multicast() const;
/// Masks out lower bits of the address.
/// @param top_bits_to_keep The number of bits *not* to mask out,
/// counting from the highest order bit. The value is
/// always interpreted relative to the IPv6 bit
/// width, even if the address is IPv4. That means if
/// we compute 192.168.1.2/16, we need to pass in
/// 112 (i.e., 96 + 16). The value must be in the
/// range from 0 to 128.
/// @returns `true` on success.
bool mask(unsigned top_bits_to_keep);
/// AND's another address to this instance.
/// @param other The other address.
/// @returns A reference to `*this`.
address& operator&=(address const& other);
/// OR's another address to this instance.
/// @param other The other address.
/// @returns A reference to `*this`.
address& operator|=(address const& other);
/// XOR's another address to this instance.
/// @param other The other address.
/// @returns A reference to `*this`.
address& operator^=(address const& other);
/// Retrieves the underlying byte array.
/// @returns A reference to an array of 16 bytes.
std::array<uint8_t, 16> const& data() const;
private:
std::array<uint8_t, 16> bytes_;
};
} // namespace vast
#endif
| [
"vallentin@icir.org"
] | vallentin@icir.org |
5fbc978deace793cbe679299f36d947e3758e769 | 63337c456e56f58dd053a7a1147b6ca73a4ecd72 | /SWEA/뱀.cpp | 7fd1b1b61c356eec14a54984be5dda4fbc92964c | [] | no_license | Cat613/AlgoProblem | d8eefa0c7de52a5b54aca74a31e9ed3ad065b842 | 8fd20a867bbaf1d6caa4b6dd9b0db2f00047cc3d | refs/heads/master | 2022-04-27T00:39:10.831944 | 2020-04-15T04:57:46 | 2020-04-15T04:57:46 | 255,790,723 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 3,201 | cpp | //#include <iostream>
//#include <stack>
//#include <string>
//#include <stdio.h>
//
//using namespace std;
//
//int answer;
//int N, K, L, order_index;
//int map[100][100];
//int head_r, head_c;
//
//struct Order {
// int t;
// char d;
//};
//struct Dir {
// int rd;
// int cd;
//};
//
//Order orders[100];
//Dir r, l, up, down, current;
//
//void change_d(Dir d, char c) {
// if (c == 'D') { //현재 방향에서 오른쪽으로 전환
// if (d.rd == r.rd && d.cd == r.cd) { //오른쪽에서 아래
// current = down;
// }
// else if (d.rd == l.rd && d.cd == l.cd) //왼쪽에서 위
// {
// current = up;
// }
// else if (d.rd == up.rd && d.cd == up.cd) //위에서 오른쪽
// {
// current = r;
// }
// else //아래에서 왼쪽
// {
// current = l;
// }
// }
// else { //현재 방향에서 왼쪽으로 전환
// if (d.rd == r.rd && d.cd == r.cd) { //오른쪽에서 위
// current = up;
// }
// else if (d.rd == l.rd && d.cd == l.cd) //왼쪽에서 아래
// {
// current = down;
// }
// else if (d.rd == up.rd && d.cd == up.cd) //위에서 왼쪽
// {
// current = l;
// }
// else //아래에서 오른쪽
// {
// current = r;
// }
// }
//}
//
//bool isIn(int r, int c) {
// if (0 <= r && r < N && 0 <= c && c < N) {
// return true;
// }
// return false;
//}
//void game_start() {
// int next_r, next_c;
// map[0][0] = 1; //뱀 시작 위치
// current = r; //시작 방향 오른쪽
// while (true) {
// answer++; //처음에 0->1
//
// //머리 들이미려는 칸이 벽인지 뱀 몸인지 확인
// next_r = head_r + current.rd;
// next_c = head_c + current.cd;
// if (isIn(next_r, next_c) && map[next_r][next_c] <= 0) { //안부딛히면
// //다음 칸 머리 들이밀기
// if (map[next_r][next_c] == 0) { //다음 칸에 사과 없는 경우
// map[next_r][next_c] = map[head_r][head_c]; //머리 값 복사 후 머리 제외 나머지 -1
// for (int i = 0; i < N; i++) {
// for (int j = 0; j < N; j++) {
// if (map[i][j] > 0 && !(i == next_r && j == next_c)) {
// map[i][j] -= 1;
// }
// }
// }
// }
// else if (map[next_r][next_c] == -1) { //다음 칸에 사과 있는 경우
// map[next_r][next_c] = map[head_r][head_c]+1;
// }
// head_r = next_r;
// head_c = next_c;
// }
// else //부딛히면
// {
// break;
// }
// if (answer == orders[order_index].t) { //명령 있으면
// change_d(current, orders[order_index].d); //방향 전환
// order_index++;
// }
// }
//}
//
//void init() {
// answer = 0;
// r.rd = 0;
// r.cd = 1;
// l.rd = 0;
// l.cd = -1;
// up.rd = -1;
// up.cd = 0;
// down.rd = 1;
// down.cd = 0;
// order_index = 0;
// head_r = 0;
// head_c = 0;
// cin >> N >> K;
// for (int i = 0; i < K; i++) {
// int r, c;
// cin >> r >> c;
// map[r-1][c-1] = -1; //사과는 -1
// }
// cin >> L;
// for (int i = 0; i < L; i++) {
// cin >> orders[i].t >> orders[i].d;
// }
//}
//
//int main(void) {
//
// init();
//
// // 뱀 게임 시작!
// game_start();
//
// cout << answer;
// return 0;
//} | [
"noreply@github.com"
] | noreply@github.com |
3954c08ee41bf5754e0ee4e6a9181f4048ef2cc3 | 02fec111191ecede92d844422125ac8482171bde | /BixeCamp/mkthnum.cpp | 0ed209a7f05bb2c12238df9fbf56060336930204 | [] | no_license | Lucas3H/Maratona | 475825b249659e376a1f63a6b3b6a1e15c0d4287 | 97a2e2a91fb60243124fc2ffb4193e1b72924c3c | refs/heads/master | 2020-11-24T18:35:24.456960 | 2020-11-06T14:00:56 | 2020-11-06T14:00:56 | 228,292,025 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,453 | cpp | #include<bits/stdc++.h>
using namespace std;
#define fr(i, n) for(int i = 0; i < n; i++)
#define frr(i, n) for(int i = 1; i <= n; i++)
#define frm(i, n) for(int i = n-1; i >= 0; i--)
#define pb push_back
typedef pair<int,int> pii;
typedef pair<int, int> ponto;
#define mem(v, k) memset(v, k, sizeof(v));
#define mp make_pair
#define pq priority_queue
#define ll long long
#define MAXN 100010
pq<int, vector<int>, greater<int>> s[4*MAXN];
int v[MAXN];
void build(int i, int l, int r){
if(l == r) s[i].push(v[l]);
else{
int mid = (l+r)/2;
build(2*i, l, mid);
build(2*i+1, mid+1, r);
s[i] = s[2*i];
pq<int, vector<int>, greater<int>> aux = s[2*i+1];
while(!aux.empty()){
s[i].push(aux.top());
aux.pop();
}
}
}
pq<int> query(int i, int l, int r, int ql, int qr){
if(ql <= l && r <= qr){
pq<int, vector<int>, greater<int>> resp = s[i];
while(resp.size() > k) resp.pop();
return resp;
}
if(ql > r || l > qr){
pq<int> S;
return S;
}
int mid = (l+r)/2;
pq<int, vector<int>, greater<int>> s1 = query(2*i, l, mid, ql, qr), s2 = query(2*i+1, mid+1, r, ql, qr);
pq<int, vector<int>, greater<int>> S;
while()
if(s1.top())
return s1;
}
int main(){
int n, m;
cin >> n >> m;
frr(i, n) cin >> v[i];
build(1, 1, n);
fr(i, m){
int a, b, c;
cin >> a >> b >> c;
set<int> resp = query(1, 1, n, a, b);
for(auto x: resp){
if(c==1){
cout << x << endl;
break;
}
c--;
}
}
} | [
"lucashhh@usp.br"
] | lucashhh@usp.br |
7e28c537cfce4f77ebd905e6c751f91de71d0a89 | 0c37e5ee5e28effce7b1ec577fec512e0901b9fd | /src/tree_ai_player.h | e00cf882a203d8b70d9ca347f254c3a3de4ebc6f | [
"ISC"
] | permissive | tiaanl/tic-tac-ai | 1d780185afd5862e04cb0188f45f9fff4c8c188e | 131a7bee30be0a80232bfd6fdaf9da0cb0a6138b | refs/heads/master | 2021-01-22T14:33:02.631242 | 2015-06-08T07:19:15 | 2015-06-08T07:19:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,105 | h | // Copyright (c) 2015, Tiaan Louw
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.
#ifndef TREE_AI_PLAYER_H_
#define TREE_AI_PLAYER_H_
#include "player.h"
class TreeAIPlayer : public Player {
public:
TreeAIPlayer();
~TreeAIPlayer() override;
// Set whether the player is training of playing.
void setIsTraining(bool isTraining);
size_t getMove(const Board& board, char you) override;
void reportWinner(const Board& board, WinType winType) override;
private:
struct BoardNode;
// Given a |parentNode|, find a child node who's board is the same as the
// given |board|.
BoardNode* findBoardInNode(BoardNode* parentNode, const Board& board) const;
// Play a move we haven't encountered before. |board| is the current board we
// are playing against.
void playUnknownMove(const Board& board);
size_t getBestMoveForNode(BoardNode* startingNode);
// Log the current move in our database of moves. Returns the newly inserted
// node.
BoardNode* logMove(BoardNode* node, const Board& board, size_t move,
char you);
// Log a move from the other player.
BoardNode* logOtherMove(BoardNode* node, const Board board);
// The root of all the board nodes.
BoardNode* m_rootNode;
// The current node we are looking at.
BoardNode* m_currentNode{nullptr};
// Whether the player is playing or training.
bool m_isTraining{false};
};
#endif // PLAYER_H_
| [
"tiaanl@gmail.com"
] | tiaanl@gmail.com |
30e4fdf77404599ceed5a134a525e99dbf5791aa | 260e5dec446d12a7dd3f32e331c1fde8157e5cea | /Indi/SDK/Indi_Spacer_06_Var3_functions.cpp | a30606b80e183986a84df346f966ce9fce43e02c | [] | no_license | jfmherokiller/TheOuterWorldsSdkDump | 6e140fde4fcd1cade94ce0d7ea69f8a3f769e1c0 | 18a8c6b1f5d87bb1ad4334be4a9f22c52897f640 | refs/heads/main | 2023-08-30T09:27:17.723265 | 2021-09-17T00:24:52 | 2021-09-17T00:24:52 | 407,437,218 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 349 | cpp | // TheOuterWorlds SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "Indi_Spacer_06_Var3_parameters.hpp"
namespace SDK
{
//---------------------------------------------------------------------------
//Functions
//---------------------------------------------------------------------------
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"peterpan0413@live.com"
] | peterpan0413@live.com |
993c8352296289a2044e79932fbadd47b475b40a | 90047daeb462598a924d76ddf4288e832e86417c | /device/usb/usb_service_impl.cc | 9881c7443bc157ec306166d51ed0aa016d7deee6 | [
"BSD-3-Clause"
] | permissive | massbrowser/android | 99b8c21fa4552a13c06bbedd0f9c88dd4a4ad080 | a9c4371682c9443d6e1d66005d4db61a24a9617c | refs/heads/master | 2022-11-04T21:15:50.656802 | 2017-06-08T12:31:39 | 2017-06-08T12:31:39 | 93,747,579 | 2 | 2 | BSD-3-Clause | 2022-10-31T10:34:25 | 2017-06-08T12:36:07 | null | UTF-8 | C++ | false | false | 19,250 | cc | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/usb/usb_service_impl.h"
#include <stdint.h>
#include <list>
#include <memory>
#include <set>
#include <utility>
#include "base/barrier_closure.h"
#include "base/bind.h"
#include "base/location.h"
#include "base/memory/weak_ptr.h"
#include "base/single_thread_task_runner.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/task_scheduler/post_task.h"
#include "build/build_config.h"
#include "components/device_event_log/device_event_log.h"
#include "device/usb/usb_device_handle.h"
#include "device/usb/usb_error.h"
#include "device/usb/webusb_descriptors.h"
#include "net/base/io_buffer.h"
#include "third_party/libusb/src/libusb/libusb.h"
#if defined(OS_WIN)
#define INITGUID
#include <devpkey.h>
#include <setupapi.h>
#include <usbiodef.h>
#include "base/strings/string_util.h"
#include "device/base/device_info_query_win.h"
#endif // OS_WIN
using net::IOBufferWithSize;
namespace device {
namespace {
// Standard USB requests and descriptor types:
const uint16_t kUsbVersion2_1 = 0x0210;
#if defined(OS_WIN)
bool IsWinUsbInterface(const std::string& device_path) {
DeviceInfoQueryWin device_info_query;
if (!device_info_query.device_info_list_valid()) {
USB_PLOG(ERROR) << "Failed to create a device information set";
return false;
}
// This will add the device so we can query driver info.
if (!device_info_query.AddDevice(device_path)) {
USB_PLOG(ERROR) << "Failed to get device interface data for "
<< device_path;
return false;
}
if (!device_info_query.GetDeviceInfo()) {
USB_PLOG(ERROR) << "Failed to get device info for " << device_path;
return false;
}
std::string buffer;
if (!device_info_query.GetDeviceStringProperty(DEVPKEY_Device_Service,
&buffer)) {
USB_PLOG(ERROR) << "Failed to get device service property";
return false;
}
USB_LOG(DEBUG) << "Driver for " << device_path << " is " << buffer << ".";
if (base::StartsWith(buffer, "WinUSB", base::CompareCase::INSENSITIVE_ASCII))
return true;
return false;
}
#endif // OS_WIN
void InitializeUsbContextOnBlockingThread(
scoped_refptr<base::SequencedTaskRunner> task_runner,
const base::Callback<void(scoped_refptr<UsbContext>)>& callback) {
scoped_refptr<UsbContext> context;
PlatformUsbContext platform_context = nullptr;
int rv = libusb_init(&platform_context);
if (rv == LIBUSB_SUCCESS && platform_context) {
context = new UsbContext(platform_context);
} else {
USB_LOG(DEBUG) << "Failed to initialize libusb: "
<< ConvertPlatformUsbErrorToString(rv);
}
task_runner->PostTask(FROM_HERE,
base::Bind(callback, base::Passed(&context)));
}
void GetDeviceListOnBlockingThread(
const std::string& new_device_path,
scoped_refptr<UsbContext> usb_context,
scoped_refptr<base::SequencedTaskRunner> task_runner,
const base::Callback<void(libusb_device**, size_t)>& callback) {
#if defined(OS_WIN)
if (!new_device_path.empty()) {
if (!IsWinUsbInterface(new_device_path)) {
// Wait to call libusb_get_device_list until libusb will be able to find
// a WinUSB interface for the device.
task_runner->PostTask(FROM_HERE, base::Bind(callback, nullptr, 0));
return;
}
}
#endif // defined(OS_WIN)
libusb_device** platform_devices = NULL;
const ssize_t device_count =
libusb_get_device_list(usb_context->context(), &platform_devices);
if (device_count < 0) {
USB_LOG(ERROR) << "Failed to get device list: "
<< ConvertPlatformUsbErrorToString(device_count);
task_runner->PostTask(FROM_HERE, base::Bind(callback, nullptr, 0));
return;
}
task_runner->PostTask(FROM_HERE,
base::Bind(callback, platform_devices, device_count));
}
void CloseHandleAndRunContinuation(scoped_refptr<UsbDeviceHandle> device_handle,
const base::Closure& continuation) {
device_handle->Close();
continuation.Run();
}
void SaveStringsAndRunContinuation(
scoped_refptr<UsbDeviceImpl> device,
uint8_t manufacturer,
uint8_t product,
uint8_t serial_number,
const base::Closure& continuation,
std::unique_ptr<std::map<uint8_t, base::string16>> string_map) {
if (manufacturer != 0)
device->set_manufacturer_string((*string_map)[manufacturer]);
if (product != 0)
device->set_product_string((*string_map)[product]);
if (serial_number != 0)
device->set_serial_number((*string_map)[serial_number]);
continuation.Run();
}
void OnReadBosDescriptor(scoped_refptr<UsbDeviceHandle> device_handle,
const base::Closure& barrier,
std::unique_ptr<WebUsbAllowedOrigins> allowed_origins,
const GURL& landing_page) {
scoped_refptr<UsbDeviceImpl> device =
static_cast<UsbDeviceImpl*>(device_handle->GetDevice().get());
if (allowed_origins)
device->set_webusb_allowed_origins(std::move(allowed_origins));
if (landing_page.is_valid())
device->set_webusb_landing_page(landing_page);
barrier.Run();
}
void OnDeviceOpenedReadDescriptors(
uint8_t manufacturer,
uint8_t product,
uint8_t serial_number,
bool read_bos_descriptors,
const base::Closure& success_closure,
const base::Closure& failure_closure,
scoped_refptr<UsbDeviceHandle> device_handle) {
if (device_handle) {
std::unique_ptr<std::map<uint8_t, base::string16>> string_map(
new std::map<uint8_t, base::string16>());
if (manufacturer != 0)
(*string_map)[manufacturer] = base::string16();
if (product != 0)
(*string_map)[product] = base::string16();
if (serial_number != 0)
(*string_map)[serial_number] = base::string16();
int count = 0;
if (!string_map->empty())
count++;
if (read_bos_descriptors)
count++;
DCHECK_GT(count, 0);
base::Closure barrier =
base::BarrierClosure(count, base::Bind(&CloseHandleAndRunContinuation,
device_handle, success_closure));
if (!string_map->empty()) {
scoped_refptr<UsbDeviceImpl> device =
static_cast<UsbDeviceImpl*>(device_handle->GetDevice().get());
ReadUsbStringDescriptors(
device_handle, std::move(string_map),
base::Bind(&SaveStringsAndRunContinuation, device, manufacturer,
product, serial_number, barrier));
}
if (read_bos_descriptors) {
ReadWebUsbDescriptors(device_handle, base::Bind(&OnReadBosDescriptor,
device_handle, barrier));
}
} else {
failure_closure.Run();
}
}
} // namespace
UsbServiceImpl::UsbServiceImpl()
: UsbService(nullptr),
#if defined(OS_WIN)
device_observer_(this),
#endif
weak_factory_(this) {
base::PostTaskWithTraits(
FROM_HERE,
{base::MayBlock(), base::TaskPriority::USER_VISIBLE,
base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
base::Bind(&InitializeUsbContextOnBlockingThread, task_runner(),
base::Bind(&UsbServiceImpl::OnUsbContext,
weak_factory_.GetWeakPtr())));
}
UsbServiceImpl::~UsbServiceImpl() {
if (hotplug_enabled_)
libusb_hotplug_deregister_callback(context_->context(), hotplug_handle_);
for (auto* platform_device : ignored_devices_)
libusb_unref_device(platform_device);
}
void UsbServiceImpl::GetDevices(const GetDevicesCallback& callback) {
DCHECK(CalledOnValidThread());
if (usb_unavailable_) {
task_runner()->PostTask(
FROM_HERE,
base::Bind(callback, std::vector<scoped_refptr<UsbDevice>>()));
return;
}
if (hotplug_enabled_ && !enumeration_in_progress_) {
// The device list is updated live when hotplug events are supported.
UsbService::GetDevices(callback);
} else {
pending_enumeration_callbacks_.push_back(callback);
RefreshDevices();
}
}
#if defined(OS_WIN)
void UsbServiceImpl::OnDeviceAdded(const GUID& class_guid,
const std::string& device_path) {
// Only the root node of a composite USB device has the class GUID
// GUID_DEVINTERFACE_USB_DEVICE but we want to wait until WinUSB is loaded.
// This first pass filter will catch anything that's sitting on the USB bus
// (including devices on 3rd party USB controllers) to avoid the more
// expensive driver check that needs to be done on the FILE thread.
if (device_path.find("usb") != std::string::npos) {
pending_path_enumerations_.push(device_path);
RefreshDevices();
}
}
void UsbServiceImpl::OnDeviceRemoved(const GUID& class_guid,
const std::string& device_path) {
// The root USB device node is removed last.
if (class_guid == GUID_DEVINTERFACE_USB_DEVICE) {
RefreshDevices();
}
}
#endif // OS_WIN
void UsbServiceImpl::OnUsbContext(scoped_refptr<UsbContext> context) {
if (!context) {
usb_unavailable_ = true;
return;
}
context_ = std::move(context);
int rv = libusb_hotplug_register_callback(
context_->context(),
static_cast<libusb_hotplug_event>(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED |
LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT),
static_cast<libusb_hotplug_flag>(0), LIBUSB_HOTPLUG_MATCH_ANY,
LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
&UsbServiceImpl::HotplugCallback, this, &hotplug_handle_);
if (rv == LIBUSB_SUCCESS)
hotplug_enabled_ = true;
// This will call any enumeration callbacks queued while initializing.
RefreshDevices();
#if defined(OS_WIN)
DeviceMonitorWin* device_monitor = DeviceMonitorWin::GetForAllInterfaces();
if (device_monitor)
device_observer_.Add(device_monitor);
#endif // OS_WIN
}
void UsbServiceImpl::RefreshDevices() {
DCHECK(CalledOnValidThread());
if (!context_ || enumeration_in_progress_)
return;
enumeration_in_progress_ = true;
DCHECK(devices_being_enumerated_.empty());
std::string device_path;
if (!pending_path_enumerations_.empty()) {
device_path = pending_path_enumerations_.front();
pending_path_enumerations_.pop();
}
base::PostTaskWithTraits(FROM_HERE,
{base::MayBlock(), base::TaskPriority::USER_VISIBLE,
base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
base::Bind(&GetDeviceListOnBlockingThread,
device_path, context_, task_runner(),
base::Bind(&UsbServiceImpl::OnDeviceList,
weak_factory_.GetWeakPtr())));
}
void UsbServiceImpl::OnDeviceList(libusb_device** platform_devices,
size_t device_count) {
DCHECK(CalledOnValidThread());
if (!platform_devices) {
RefreshDevicesComplete();
return;
}
base::Closure refresh_complete =
base::BarrierClosure(static_cast<int>(device_count),
base::Bind(&UsbServiceImpl::RefreshDevicesComplete,
weak_factory_.GetWeakPtr()));
std::list<PlatformUsbDevice> new_devices;
std::set<PlatformUsbDevice> existing_ignored_devices;
// Look for new and existing devices.
for (size_t i = 0; i < device_count; ++i) {
PlatformUsbDevice platform_device = platform_devices[i];
// Ignore some devices.
if (base::ContainsValue(ignored_devices_, platform_device)) {
existing_ignored_devices.insert(platform_device);
refresh_complete.Run();
continue;
}
auto it = platform_devices_.find(platform_device);
if (it == platform_devices_.end()) {
new_devices.push_back(platform_device);
} else {
it->second->set_visited(true);
refresh_complete.Run();
}
}
// Remove devices not seen in this enumeration.
for (PlatformDeviceMap::iterator it = platform_devices_.begin();
it != platform_devices_.end();
/* incremented internally */) {
PlatformDeviceMap::iterator current = it++;
const scoped_refptr<UsbDeviceImpl>& device = current->second;
if (device->was_visited()) {
device->set_visited(false);
} else {
RemoveDevice(device);
}
}
// Remove devices not seen in this enumeration from |ignored_devices_|.
for (auto it = ignored_devices_.begin(); it != ignored_devices_.end();
/* incremented internally */) {
auto current = it++;
if (!base::ContainsValue(existing_ignored_devices, *current)) {
libusb_unref_device(*current);
ignored_devices_.erase(current);
}
}
for (PlatformUsbDevice platform_device : new_devices) {
EnumerateDevice(platform_device, refresh_complete);
}
libusb_free_device_list(platform_devices, true);
}
void UsbServiceImpl::RefreshDevicesComplete() {
DCHECK(CalledOnValidThread());
DCHECK(enumeration_in_progress_);
enumeration_ready_ = true;
enumeration_in_progress_ = false;
devices_being_enumerated_.clear();
if (!pending_enumeration_callbacks_.empty()) {
std::vector<scoped_refptr<UsbDevice>> result;
result.reserve(devices().size());
for (const auto& map_entry : devices())
result.push_back(map_entry.second);
std::vector<GetDevicesCallback> callbacks;
callbacks.swap(pending_enumeration_callbacks_);
for (const GetDevicesCallback& callback : callbacks)
callback.Run(result);
}
if (!pending_path_enumerations_.empty()) {
RefreshDevices();
}
}
void UsbServiceImpl::EnumerateDevice(PlatformUsbDevice platform_device,
const base::Closure& refresh_complete) {
DCHECK(context_);
devices_being_enumerated_.insert(platform_device);
libusb_device_descriptor descriptor;
int rv = libusb_get_device_descriptor(platform_device, &descriptor);
if (rv == LIBUSB_SUCCESS) {
if (descriptor.bDeviceClass == LIBUSB_CLASS_HUB) {
// Don't try to enumerate hubs. We never want to connect to a hub.
libusb_ref_device(platform_device);
ignored_devices_.insert(platform_device);
refresh_complete.Run();
return;
}
scoped_refptr<UsbDeviceImpl> device(
new UsbDeviceImpl(context_, platform_device, descriptor));
base::Closure add_device =
base::Bind(&UsbServiceImpl::AddDevice, weak_factory_.GetWeakPtr(),
refresh_complete, device);
base::Closure enumeration_failed = base::Bind(
&UsbServiceImpl::EnumerationFailed, weak_factory_.GetWeakPtr(),
platform_device, refresh_complete);
bool read_bos_descriptors = descriptor.bcdUSB >= kUsbVersion2_1;
if (descriptor.iManufacturer == 0 && descriptor.iProduct == 0 &&
descriptor.iSerialNumber == 0 && !read_bos_descriptors) {
// Don't bother disturbing the device if it has no descriptors to offer.
add_device.Run();
} else {
device->Open(base::Bind(&OnDeviceOpenedReadDescriptors,
descriptor.iManufacturer, descriptor.iProduct,
descriptor.iSerialNumber, read_bos_descriptors,
add_device, enumeration_failed));
}
} else {
USB_LOG(EVENT) << "Failed to get device descriptor: "
<< ConvertPlatformUsbErrorToString(rv);
refresh_complete.Run();
}
}
void UsbServiceImpl::AddDevice(const base::Closure& refresh_complete,
scoped_refptr<UsbDeviceImpl> device) {
auto it = devices_being_enumerated_.find(device->platform_device());
if (it == devices_being_enumerated_.end()) {
// Device was removed while being enumerated.
refresh_complete.Run();
return;
}
platform_devices_[device->platform_device()] = device;
DCHECK(!base::ContainsKey(devices(), device->guid()));
devices()[device->guid()] = device;
USB_LOG(USER) << "USB device added: vendor=" << device->vendor_id() << " \""
<< device->manufacturer_string()
<< "\", product=" << device->product_id() << " \""
<< device->product_string() << "\", serial=\""
<< device->serial_number() << "\", guid=" << device->guid();
if (enumeration_ready_) {
NotifyDeviceAdded(device);
}
refresh_complete.Run();
}
void UsbServiceImpl::RemoveDevice(scoped_refptr<UsbDeviceImpl> device) {
platform_devices_.erase(device->platform_device());
devices().erase(device->guid());
USB_LOG(USER) << "USB device removed: guid=" << device->guid();
NotifyDeviceRemoved(device);
device->OnDisconnect();
}
// static
int LIBUSB_CALL UsbServiceImpl::HotplugCallback(libusb_context* context,
PlatformUsbDevice device,
libusb_hotplug_event event,
void* user_data) {
// It is safe to access the UsbServiceImpl* here because libusb takes a lock
// around registering, deregistering and calling hotplug callback functions
// and so guarantees that this function will not be called by the event
// processing thread after it has been deregistered.
UsbServiceImpl* self = reinterpret_cast<UsbServiceImpl*>(user_data);
DCHECK(!self->task_runner()->BelongsToCurrentThread());
switch (event) {
case LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED:
libusb_ref_device(device); // Released in OnPlatformDeviceAdded.
self->task_runner()->PostTask(
FROM_HERE, base::Bind(&UsbServiceImpl::OnPlatformDeviceAdded,
base::Unretained(self), device));
break;
case LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT:
libusb_ref_device(device); // Released in OnPlatformDeviceRemoved.
self->task_runner()->PostTask(
FROM_HERE, base::Bind(&UsbServiceImpl::OnPlatformDeviceRemoved,
base::Unretained(self), device));
break;
default:
NOTREACHED();
}
return 0;
}
void UsbServiceImpl::OnPlatformDeviceAdded(PlatformUsbDevice platform_device) {
DCHECK(CalledOnValidThread());
DCHECK(!base::ContainsKey(platform_devices_, platform_device));
EnumerateDevice(platform_device, base::Bind(&base::DoNothing));
libusb_unref_device(platform_device);
}
void UsbServiceImpl::OnPlatformDeviceRemoved(
PlatformUsbDevice platform_device) {
DCHECK(CalledOnValidThread());
PlatformDeviceMap::iterator it = platform_devices_.find(platform_device);
if (it != platform_devices_.end()) {
RemoveDevice(it->second);
} else {
devices_being_enumerated_.erase(platform_device);
}
libusb_unref_device(platform_device);
}
void UsbServiceImpl::EnumerationFailed(PlatformUsbDevice platform_device,
const base::Closure& refresh_complete) {
libusb_ref_device(platform_device);
ignored_devices_.insert(platform_device);
refresh_complete.Run();
}
} // namespace device
| [
"xElvis89x@gmail.com"
] | xElvis89x@gmail.com |
394109d8e6fc6324b710cea296f279d73c5aaa73 | d80fd3a98114f5b0a260e558768d1188a96ee85a | /src/qml/qt_native/optionsmodel.h | 848376be7fedbf10f4f2c4d2ed90b18b13cfbec5 | [
"MIT"
] | permissive | gkcproject/gkccash_core | 9c599c5377683b25d9974d8c0f8983ce820676ab | 1bec1d5dd91fde93276f2ddb2cc63b93f02ba3e9 | refs/heads/master | 2023-06-16T01:10:42.286710 | 2021-06-28T09:49:04 | 2021-06-28T09:49:04 | 257,286,295 | 67 | 17 | MIT | 2021-01-04T01:39:57 | 2020-04-20T13:16:14 | C++ | UTF-8 | C++ | false | false | 3,508 | h | // Copyright (c) 2011-2013 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_QT_OPTIONSMODEL_H
#define BITCOIN_QT_OPTIONSMODEL_H
#include "amount.h"
#include <QAbstractListModel>
QT_BEGIN_NAMESPACE
class QNetworkProxy;
QT_END_NAMESPACE
/** Interface from Qt to configuration data structure for Bitcoin client.
To Qt, the options are presented as a list with the different options
laid out vertically.
This can be changed to a tree once the settings become sufficiently
complex.
*/
class OptionsModel : public QAbstractListModel
{
Q_OBJECT
Q_PROPERTY(int displayUnit MEMBER nDisplayUnit NOTIFY displayUnitChanged)
public:
explicit OptionsModel(QObject* parent = 0);
enum OptionID {
StartAtStartup, // bool
MinimizeToTray, // bool
MapPortUPnP, // bool
MinimizeOnClose, // bool
ProxyUse, // bool
ProxyIP, // QString
ProxyPort, // int
DisplayUnit, // BitcoinUnits::Unit
ThirdPartyTxUrls, // QString
Digits, // QString
Theme, // QString
Language, // QString
CoinControlFeatures, // bool
ThreadsScriptVerif, // int
DatabaseCache, // int
SpendZeroConfChange, // bool
ZeromintPercentage, // int
ZeromintPrefDenom, // int
AnonymizeGkcAmount, //int
ShowMasternodesTab, // bool
Listen, // bool
OptionIDRowCount,
};
void Init();
void Reset();
int rowCount(const QModelIndex& parent = QModelIndex()) const;
QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
/** Updates current unit in memory, settings and emits displayUnitChanged(newUnit) signal */
Q_INVOKABLE void setDisplayUnit(const int &index);
Q_INVOKABLE int getDisplayUnit() { return nDisplayUnit; }
/* Explicit getters */
bool getMinimizeToTray() { return fMinimizeToTray; }
bool getMinimizeOnClose() { return fMinimizeOnClose; }
QString getThirdPartyTxUrls() { return strThirdPartyTxUrls; }
bool getProxySettings(QNetworkProxy& proxy) const;
bool getCoinControlFeatures() { return fCoinControlFeatures; }
const QString& getOverriddenByCommandLine() { return strOverriddenByCommandLine; }
/* Restart flag helper */
void setRestartRequired(bool fRequired);
bool isRestartRequired();
bool resetSettings;
private:
/* Qt-only settings */
bool fMinimizeToTray;
bool fMinimizeOnClose;
QString language;
int nDisplayUnit;
QString strThirdPartyTxUrls;
bool fCoinControlFeatures;
/* settings that were overriden by command-line */
QString strOverriddenByCommandLine;
/// Add option to list of GUI options overridden through command line/config file
void addOverriddenOption(const std::string& option);
signals:
void displayUnitChanged(int unit);
void zeromintPercentageChanged(int);
void preferredDenomChanged(int);
void anonymizeGkcAmountChanged(int);
void coinControlFeaturesChanged(bool);
};
#endif // BITCOIN_QT_OPTIONSMODEL_H
| [
"gkcproject@hotmail.com"
] | gkcproject@hotmail.com |
a92a1a36d5b6c49753b9a74bfa465d2e9ecb5be1 | 58dd0ae5ebc75d284fc38787165e9799d26fce96 | /Praktikum 3 - 3.cpp | 8c47330816c8ec5e850046b35da6ef9e6f0ecd53 | [] | no_license | wahid7077/Praktikum-1 | f6cc0113835cdabac6210b98e72bc77585eaf6a4 | 4b7f64efba501e565a0212a1949b634f80e5e41e | refs/heads/main | 2023-02-05T17:12:17.300706 | 2020-12-25T11:04:50 | 2020-12-25T11:04:50 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 378 | cpp | #include<iostream>
#include<conio.h>
//Wahid Amin Samsudin
//20051397077
//2020A
using namespace std;
main() {
int n,i,j;
cout<<"Masukkan Segitiga Angka : ";
cin>>n;
cout<<"\n";
for (i=1;i<=n;i++){
for (j=1;j<=i;j++){
cout<<" "<<j;
}
cout<<" \n";
}
for (i=n-1;i>=1;i--){
for(j=1;j<=i;j++){
cout<<" "<<j;
}
cout<<" \n";
}
getch();
}
| [
"noreply@github.com"
] | noreply@github.com |
97948e2dfcc6242af7c8e55ef7298eae2969db1a | 10dea130f32ff1adb4d1a693b410f948827134c6 | /src/libtsduck/dtv/tsTablesLoggerFilter.cpp | 217dd876c61e16fc853a3e5f313e6227bf80a6fd | [
"BSD-2-Clause"
] | permissive | manuelmann/tsduck-test | a9bc598c175a93a5cb2c774da0df0d6b992920a5 | 04ac912fa0d6a2da0bf25ac2c9facf4a1136b31d | refs/heads/master | 2023-08-10T17:10:27.645659 | 2023-07-28T20:53:53 | 2023-07-28T20:53:53 | 153,752,933 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,367 | cpp | //----------------------------------------------------------------------------
//
// TSDuck - The MPEG Transport Stream Toolkit
// Copyright (c) 2005-2020, Thierry Lelegard
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
//
//----------------------------------------------------------------------------
#include "tsTablesLoggerFilter.h"
#include "tsTablesLoggerFilterRepository.h"
#include "tsDuckContext.h"
#include "tsSection.h"
#include "tsArgs.h"
#include "tsPAT.h"
TSDUCK_SOURCE;
// Register this section filter in the reposity.
TS_REGISTER_SECTION_FILTER(ts::TablesLoggerFilter);
//----------------------------------------------------------------------------
// Constructors and destructors.
//----------------------------------------------------------------------------
ts::TablesLoggerFilter::TablesLoggerFilter() :
_diversified(false),
_negate_tid(false),
_negate_tidext(false),
_psi_si(false),
_pids(),
_tids(),
_tidexts(),
_pat()
{
}
//----------------------------------------------------------------------------
// Define section filtering command line options in an Args.
//----------------------------------------------------------------------------
void ts::TablesLoggerFilter::defineFilterOptions(Args& args) const
{
args.option(u"diversified-payload", 'd');
args.help(u"diversified-payload",
u"Select only sections with \"diversified\" payload. This means that "
u"section payloads containing the same byte value (all 0x00 or all 0xFF "
u"for instance) are ignored. Typically, such sections are stuffing and "
u"can be ignored that way.");
args.option(u"negate-pid");
args.help(u"negate-pid",
u"Negate the PID filter: specified PID's are excluded. "
u"Warning: this can be a dangerous option on complete transport "
u"streams since PID's not containing sections can be accidentally "
u"selected.");
args.option(u"negate-tid", 'n');
args.help(u"negate-tid", u"Negate the TID filter: specified TID's are excluded.");
args.option(u"negate-tid-ext");
args.help(u"negate-tid-ext", u"Negate the TID extension filter: specified TID extensions are excluded.");
args.option(u"pid", 'p', Args::PIDVAL, 0, Args::UNLIMITED_COUNT);
args.help(u"pid", u"pid1[-pid2]",
u"PID filter: select packets with this PID value or range of PID values. "
u"Several -p or --pid options may be specified. "
u"Without -p or --pid option, all PID's are used (this can be a "
u"dangerous option on complete transport streams since PID's not "
u"containing sections can be accidentally selected).");
args.option(u"psi-si");
args.help(u"psi-si",
u"Add all PID's containing PSI/SI tables, ie. PAT, CAT, PMT, NIT, SDT "
u"and BAT. Note that EIT, TDT and TOT are not included. Use --pid 18 "
u"to get EIT and --pid 20 to get TDT and TOT.");
args.option(u"tid", 't', Args::UINT8, 0, Args::UNLIMITED_COUNT);
args.help(u"tid", u"tid1[-tid2]",
u"TID filter: select sections with this TID (table id) value or range of TID values. "
u"Several -t or --tid options may be specified. "
u"Without -t or --tid option, all tables are saved.");
args.option(u"tid-ext", 'e', Args::UINT16, 0, Args::UNLIMITED_COUNT);
args.help(u"tid-ext", u"ext1[-ext2]",
u"TID extension filter: select sections with this table id "
u"extension value or range of values (apply to long sections only). "
u"Several -e or --tid-ext options may be specified. "
u"Without -e or --tid-ext option, all tables are saved.");
}
//----------------------------------------------------------------------------
// Load arguments from command line.
//----------------------------------------------------------------------------
bool ts::TablesLoggerFilter::loadFilterOptions(DuckContext& duck, Args& args, PIDSet& initial_pids)
{
_diversified = args.present(u"diversified-payload");
_negate_tid = args.present(u"negate-tid");
_negate_tidext = args.present(u"negate-tid-ext");
_psi_si = args.present(u"psi-si");
args.getIntValues(_pids, u"pid");
args.getIntValues(_tids, u"tid");
args.getIntValues(_tidexts, u"tid-ext");
// If any PID was selected, then --negate-pid means all but them.
if (args.present(u"negate-pid") && _pids.any()) {
_pids.flip();
}
// With --psi-si, accumulate all PSI/SI PID's/
// Build the list of PID's to filter (--pid and/or --psi-si).
if (_psi_si) {
_pids.set(PID_PAT);
_pids.set(PID_CAT);
_pids.set(PID_SDT); // also BAT
_pids.set(PID_NIT);
}
// Inform the tables logger of which PID's we initially need.
if (_pids.any()) {
// Some PID's are selected, so we want only them.
initial_pids = _pids;
}
else {
// We do not specify any PID, this means we want them all.
initial_pids.set();
}
// Clear the current PAT.
_pat.clear();
return true;
}
//----------------------------------------------------------------------------
// Check if a specific section must be filtered and displayed.
//----------------------------------------------------------------------------
bool ts::TablesLoggerFilter::filterSection(DuckContext& duck, const Section& section, uint16_t cas, PIDSet& more_pids)
{
// Accumulate PAT data when --psi-si is specified to detect PMT PID's.
if (_psi_si && section.tableId() == TID_PAT) {
// Previous state of the PAT.
const bool was_valid = _pat.isValid();
const uint8_t previous_version = _pat.version();
// Clear previous PAT on new version.
if (_pat.sectionCount() > 0 && previous_version != section.version()) {
_pat.clear();
}
// Add the current section in the PAT if it was not already there.
if (_pat.sectionCount() <= section.sectionNumber() || _pat.sectionAt(section.sectionNumber()).isNull()) {
_pat.addSection(SectionPtr(new Section(section, ShareMode::SHARE)), true, true);
}
// If a new PAT is now available, analyze it to grab PSI/SI information.
if (_pat.isValid() && (!was_valid || _pat.version() != previous_version)) {
const PAT new_pat(duck, _pat);
if (new_pat.isValid()) {
// Check NIT PID, if present.
if (new_pat.nit_pid != PID_NULL && !_pids.test(new_pat.nit_pid)) {
// The NIT PID was not yet known.
_pids.set(new_pat.nit_pid);
more_pids.set(new_pat.nit_pid);
}
// Check all PMT PID's.
for (auto it = new_pat.pmts.begin(); it != new_pat.pmts.end(); ++it) {
const PID pmt_pid = it->second;
if (pmt_pid != PID_NULL && !_pids.test(pmt_pid)) {
// This PMT PID was not yet known.
_pids.set(pmt_pid);
more_pids.set(pmt_pid);
}
}
}
}
}
// Is this a selected TID or TID-ext?
const bool tid_set = _tids.find(section.tableId()) != _tids.end();
const bool tidext_set = _tidexts.find(section.tableIdExtension()) != _tidexts.end();
// Return final verdict. For each criteria (--pid, --tid, etc), either the criteria is
// not specified or the corresponding value matches.
return
// Check PID:
(_pids.none() || _pids.test(section.sourcePID())) &&
// Check TID:
(_tids.empty() || (tid_set && !_negate_tid) || (!tid_set && _negate_tid)) &&
// Check TIDext:
(!section.isLongSection() || _tidexts.empty() || (tidext_set && !_negate_tidext) || (!tidext_set && _negate_tidext)) &&
// Diversified payload ok
(!_diversified || section.hasDiversifiedPayload());
}
| [
"root@fedora-manuel.fe.poc"
] | root@fedora-manuel.fe.poc |
222074f7e2ba5de39c963b0709e60dbcb0ad8640 | 05c50fda6d0d330bc54dbec2a56f69058a741138 | /Recursion/4.HeadRecursion.cpp | 5d4b3fba0d8923669bb409d8fad135f80d0b97f3 | [] | no_license | mynameispathak/Data-Structures-Algorithms-Code | 45e7905b97a15c97977b5fcc69f567bbd2c3f47d | feff299640509c972825ec2e1b6393fc6ff90c91 | refs/heads/master | 2022-11-17T12:22:15.177844 | 2020-07-06T02:14:58 | 2020-07-06T02:14:58 | 259,728,583 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 181 | cpp | #include <iostream>
using namespace std;
void fun1(int n)
{
if (n > 0)
{
fun1(n - 1);
cout << n << endl;
}
}
int main()
{
int x = 3;
fun1(x);
} | [
"171230012@nitdelhi.ac.in"
] | 171230012@nitdelhi.ac.in |
8ce82f3ace7cb9c13fe849f621f4328f2036835f | 740d4583041886722706d15094697719da4748ea | /iGraphics Project/Before_iDraw.h | 78cf2f2d0ca79600704e45d010c660c034fe4847 | [] | no_license | SanjidaAziz/Multiplayer-Snake-Game | 06b5b21c76f5fef8b7e23a5bc518b284191ff471 | 0ee7b4b4c3fc970a5cb94bdabb6d10dde927eaf9 | refs/heads/master | 2020-08-26T18:21:53.141831 | 2019-11-10T13:12:57 | 2019-11-10T13:12:57 | 217,101,997 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,618 | h | #ifndef BEFORE
#define BEFORE
# include "snake.h"
#include "iGraphics.h"
#include "bitmap_loader.h"
using namespace std;
string message="Press Space to continue";
Button but[10];
//For game play
int box=25,box2=25;
char background[]={"i\\ground3.bmp"};
bool gameover=false;
eDirection dir,dir2;
int snakeX=10,snakeY=10,score=0,speed=box,r=7,foodX=400,foodY=400;
int snake2X=10,snake2Y=10,r2=7,speed2=box2,food2X=500,food2Y=300;
Snake newHead,newHead2;
vector <Snake> snake;
vector <Snake> snake2;
Food food,food2;
/*bool collision(Snake s,const vector<Snake> &vect){
for(unsigned int i=0;i<snake.size();i++){
if(s.x == vect[i].x && s.y==vect[i].y)
return true;
}
return false;
}
*/
void Logic(){
//old head position
snakeX = snake[0].x;
snakeY = snake[0].y;
//which direction
switch(dir)
{
case LEFT:
snakeX -= speed;
break;
case RIGHT:
snakeX += speed;
break;
case UP:
snakeY += speed;
break;
case DOWN:
snakeY -= speed;
break;
default :
break;
}
//if the snake eats the food
if(snakeX-r<(food.x) && snakeY-r<(food.y) && (food.x) < (snakeX+box+r) && (food.y) < (snakeY+box+r))
{
score += 10;
cout<<score<<endl;
food.x=rand()%541+10;
food.y=rand()%479+10;
}else{
// remove the tail
snake.pop_back();
}
//add new Head
newHead.x=snakeX;
newHead.y=snakeY;
if(snakeX<0 || snakeX >scrW || snakeY <0 || snakeY>scrH ){
gameover=true;
}
snake.insert(snake.begin(),newHead);
}
void Logic2(){
//old head position
snake2X = snake2[0].x;
snake2Y = snake2[0].y;
//which direction
switch(dir2)
{
case LEFT:
snake2X -= speed;
break;
case RIGHT:
snake2X += speed;
break;
case UP:
snake2Y += speed;
break;
case DOWN:
snake2Y -= speed;
break;
default :
break;
}
//if the snake eats the food
if(snake2X-r<(food.x) && snake2Y-r<(food.y) && (food.x) < (snake2X+box+r) && (food.y) < (snake2Y+box+r))
{
score += 10;
cout<<score<<endl;
food.x=rand()%541+10;
food.y=rand()%479+10;
}else{
// remove the tail
snake2.pop_back();
}
//add new Head
newHead2.x=snake2X;
newHead2.y=snake2Y;
if(snake2X<0 || snake2X >scrW || snake2Y <0 || snake2Y>scrH ){
gameover=true;
}
snake2.insert(snake2.begin(),newHead2);
}
//ball represents the current screen in game
int ball=-2;
//Menu sound location
char sound[]="necessary\\2.wav";
//Main menu buttons
char button[10][30]={"necessary\\but1s.bmp","necessary\\but2s.bmp","necessary\\but3s.bmp","necessary\\but4s.bmp"};
//initial co ordinates oF the running text
int x=10,y=10;
//changing speed through x axis
int dx=10;
#endif | [
"sunjidaaziz58@gmail.com"
] | sunjidaaziz58@gmail.com |
1e69139a06814a24a4e17fe4ff583bbc146f4409 | 4530046f22b6fa7cd13b13a17844162d6b2f02b6 | /Adobe_finalSDK/dng_sdk/source/dng_pixel_buffer.h | 4685bcf0a4a6bc7016555bdf6290ee1215e84aa0 | [] | no_license | karaimer/camera-pipeline-dng-sdk | 783f5e13738d67d318e36b449ff9b09d84f85171 | 6fc4e8fa892da17b289583f5cd33f9ee7d4d72b4 | refs/heads/master | 2023-07-12T00:07:40.369307 | 2023-07-01T00:33:53 | 2023-07-01T00:33:53 | 64,812,785 | 29 | 13 | null | null | null | null | UTF-8 | C++ | false | false | 19,481 | h | /*****************************************************************************/
// Copyright 2006-2008 Adobe Systems Incorporated
// All Rights Reserved.
//
// NOTICE: Adobe permits you to use, modify, and distribute this file in
// accordance with the terms of the Adobe license agreement accompanying it.
/*****************************************************************************/
/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_pixel_buffer.h#1 $ */
/* $DateTime: 2012/05/30 13:28:51 $ */
/* $Change: 832332 $ */
/* $Author: tknoll $ */
/** \file
* Support for holding buffers of sample data.
*/
/*****************************************************************************/
#ifndef __dng_pixel_buffer__
#define __dng_pixel_buffer__
/*****************************************************************************/
#include "dng_assertions.h"
#include "dng_rect.h"
#include "dng_tag_types.h"
/*****************************************************************************/
/// Compute best set of step values for a given source and destination area and stride.
void OptimizeOrder (const void *&sPtr,
void *&dPtr,
uint32 sPixelSize,
uint32 dPixelSize,
uint32 &count0,
uint32 &count1,
uint32 &count2,
int32 &sStep0,
int32 &sStep1,
int32 &sStep2,
int32 &dStep0,
int32 &dStep1,
int32 &dStep2);
void OptimizeOrder (const void *&sPtr,
uint32 sPixelSize,
uint32 &count0,
uint32 &count1,
uint32 &count2,
int32 &sStep0,
int32 &sStep1,
int32 &sStep2);
void OptimizeOrder (void *&dPtr,
uint32 dPixelSize,
uint32 &count0,
uint32 &count1,
uint32 &count2,
int32 &dStep0,
int32 &dStep1,
int32 &dStep2);
/*****************************************************************************/
#define qDebugPixelType 0
#if qDebugPixelType
#define ASSERT_PIXEL_TYPE(typeVal) CheckPixelType (typeVal)
#else
#define ASSERT_PIXEL_TYPE(typeVal) DNG_ASSERT (fPixelType == typeVal, "Pixel type access mismatch")
#endif
/*****************************************************************************/
/// \brief Holds a buffer of pixel data with "pixel geometry" metadata.
///
/// The pixel geometry describes the layout in terms of how many planes, rows and columns
/// plus the steps (in bytes) between each column, row and plane.
class dng_pixel_buffer
{
public:
// Area this buffer holds.
dng_rect fArea;
// Range of planes this buffer holds.
uint32 fPlane;
uint32 fPlanes;
// Steps between pixels.
int32 fRowStep;
int32 fColStep;
int32 fPlaneStep;
// Basic pixel type (TIFF tag type code).
uint32 fPixelType;
// Size of pixel type in bytes.
uint32 fPixelSize;
// Pointer to buffer's data.
void *fData;
// Do we have write-access to this data?
bool fDirty;
private:
void * InternalPixel (int32 row,
int32 col,
uint32 plane = 0) const
{
return (void *)
(((uint8 *) fData) + (int32)fPixelSize *
(fRowStep * (row - fArea.t) +
fColStep * (col - fArea.l) +
fPlaneStep * (int32)(plane - fPlane )));
}
#if qDebugPixelType
void CheckPixelType (uint32 pixelType) const;
#endif
public:
dng_pixel_buffer ();
dng_pixel_buffer (const dng_pixel_buffer &buffer);
dng_pixel_buffer & operator= (const dng_pixel_buffer &buffer);
virtual ~dng_pixel_buffer ();
/// Get the range of pixel values.
/// \retval Range of value a pixel can take. (Meaning [0, max] for unsigned case. Signed case is biased so [-32768, max - 32768].)
uint32 PixelRange () const;
/// Get extent of pixels in buffer
/// \retval Rectangle giving valid extent of buffer.
const dng_rect & Area () const
{
return fArea;
}
/// Number of planes of image data.
/// \retval Number of planes held in buffer.
uint32 Planes () const
{
return fPlanes;
}
/// Step, in pixels not bytes, between rows of data in buffer.
/// \retval row step in pixels. May be negative.
int32 RowStep () const
{
return fRowStep;
}
/// Step, in pixels not bytes, between planes of data in buffer.
/// \retval plane step in pixels. May be negative.
int32 PlaneStep () const
{
return fPlaneStep;
}
/// Get read-only untyped (void *) pointer to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as void *.
const void * ConstPixel (int32 row,
int32 col,
uint32 plane = 0) const
{
return InternalPixel (row, col, plane);
}
/// Get a writable untyped (void *) pointer to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as void *.
void * DirtyPixel (int32 row,
int32 col,
uint32 plane = 0)
{
DNG_ASSERT (fDirty, "Dirty access to const pixel buffer");
return InternalPixel (row, col, plane);
}
/// Get read-only uint8 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as uint8 *.
const uint8 * ConstPixel_uint8 (int32 row,
int32 col,
uint32 plane = 0) const
{
ASSERT_PIXEL_TYPE (ttByte);
return (const uint8 *) ConstPixel (row, col, plane);
}
/// Get a writable uint8 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as uint8 *.
uint8 * DirtyPixel_uint8 (int32 row,
int32 col,
uint32 plane = 0)
{
ASSERT_PIXEL_TYPE (ttByte);
return (uint8 *) DirtyPixel (row, col, plane);
}
/// Get read-only int8 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as int8 *.
const int8 * ConstPixel_int8 (int32 row,
int32 col,
uint32 plane = 0) const
{
ASSERT_PIXEL_TYPE (ttSByte);
return (const int8 *) ConstPixel (row, col, plane);
}
/// Get a writable int8 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as int8 *.
int8 * DirtyPixel_int8 (int32 row,
int32 col,
uint32 plane = 0)
{
ASSERT_PIXEL_TYPE (ttSByte);
return (int8 *) DirtyPixel (row, col, plane);
}
/// Get read-only uint16 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as uint16 *.
const uint16 * ConstPixel_uint16 (int32 row,
int32 col,
uint32 plane = 0) const
{
ASSERT_PIXEL_TYPE (ttShort);
return (const uint16 *) ConstPixel (row, col, plane);
}
/// Get a writable uint16 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as uint16 *.
uint16 * DirtyPixel_uint16 (int32 row,
int32 col,
uint32 plane = 0)
{
ASSERT_PIXEL_TYPE (ttShort);
return (uint16 *) DirtyPixel (row, col, plane);
}
/// Get read-only int16 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as int16 *.
const int16 * ConstPixel_int16 (int32 row,
int32 col,
uint32 plane = 0) const
{
ASSERT_PIXEL_TYPE (ttSShort);
return (const int16 *) ConstPixel (row, col, plane);
}
/// Get a writable int16 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as int16 *.
int16 * DirtyPixel_int16 (int32 row,
int32 col,
uint32 plane = 0)
{
ASSERT_PIXEL_TYPE (ttSShort);
return (int16 *) DirtyPixel (row, col, plane);
}
/// Get read-only uint32 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as uint32 *.
const uint32 * ConstPixel_uint32 (int32 row,
int32 col,
uint32 plane = 0) const
{
ASSERT_PIXEL_TYPE (ttLong);
return (const uint32 *) ConstPixel (row, col, plane);
}
/// Get a writable uint32 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as uint32 *.
uint32 * DirtyPixel_uint32 (int32 row,
int32 col,
uint32 plane = 0)
{
ASSERT_PIXEL_TYPE (ttLong);
return (uint32 *) DirtyPixel (row, col, plane);
}
/// Get read-only int32 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as int32 *.
const int32 * ConstPixel_int32 (int32 row,
int32 col,
uint32 plane = 0) const
{
ASSERT_PIXEL_TYPE (ttSLong);
return (const int32 *) ConstPixel (row, col, plane);
}
/// Get a writable int32 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as int32 *.
int32 * DirtyPixel_int32 (int32 row,
int32 col,
uint32 plane = 0)
{
ASSERT_PIXEL_TYPE (ttSLong);
return (int32 *) DirtyPixel (row, col, plane);
}
/// Get read-only real32 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as real32 *.
const real32 * ConstPixel_real32 (int32 row,
int32 col,
uint32 plane = 0) const
{
ASSERT_PIXEL_TYPE (ttFloat);
return (const real32 *) ConstPixel (row, col, plane);
}
/// Get a writable real32 * to pixel data starting at a specific pixel in the buffer.
/// \param row Start row for buffer pointer.
/// \param col Start column for buffer pointer.
/// \param plane Start plane for buffer pointer.
/// \retval Pointer to pixel data as real32 *.
real32 * DirtyPixel_real32 (int32 row,
int32 col,
uint32 plane = 0)
{
ASSERT_PIXEL_TYPE (ttFloat);
return (real32 *) DirtyPixel (row, col, plane);
}
/// Initialize a rectangular area of pixel buffer to a constant.
/// \param area Rectangle of pixel buffer to set.
/// \param plane Plane to start filling on.
/// \param planes Number of planes to fill.
/// \param value Constant value to set pixels to.
void SetConstant (const dng_rect &area,
uint32 plane,
uint32 planes,
uint32 value);
/// Initialize a rectangular area of pixel buffer to a constant unsigned 8-bit value.
/// \param area Rectangle of pixel buffer to set.
/// \param plane Plane to start filling on.
/// \param planes Number of planes to fill.
/// \param value Constant uint8 value to set pixels to.
void SetConstant_uint8 (const dng_rect &area,
uint32 plane,
uint32 planes,
uint8 value)
{
DNG_ASSERT (fPixelType == ttByte, "Mismatched pixel type");
SetConstant (area, plane, planes, (uint32) value);
}
/// Initialize a rectangular area of pixel buffer to a constant unsigned 16-bit value.
/// \param area Rectangle of pixel buffer to set.
/// \param plane Plane to start filling on.
/// \param planes Number of planes to fill.
/// \param value Constant uint16 value to set pixels to.
void SetConstant_uint16 (const dng_rect &area,
uint32 plane,
uint32 planes,
uint16 value)
{
DNG_ASSERT (fPixelType == ttShort, "Mismatched pixel type");
SetConstant (area, plane, planes, (uint32) value);
}
/// Initialize a rectangular area of pixel buffer to a constant signed 16-bit value.
/// \param area Rectangle of pixel buffer to set.
/// \param plane Plane to start filling on.
/// \param planes Number of planes to fill.
/// \param value Constant int16 value to set pixels to.
void SetConstant_int16 (const dng_rect &area,
uint32 plane,
uint32 planes,
int16 value)
{
DNG_ASSERT (fPixelType == ttSShort, "Mismatched pixel type");
SetConstant (area, plane, planes, (uint32) (uint16) value);
}
/// Initialize a rectangular area of pixel buffer to a constant unsigned 32-bit value.
/// \param area Rectangle of pixel buffer to set.
/// \param plane Plane to start filling on.
/// \param planes Number of planes to fill.
/// \param value Constant uint32 value to set pixels to.
void SetConstant_uint32 (const dng_rect &area,
uint32 plane,
uint32 planes,
uint32 value)
{
DNG_ASSERT (fPixelType == ttLong, "Mismatched pixel type");
SetConstant (area, plane, planes, value);
}
/// Initialize a rectangular area of pixel buffer to a constant real 32-bit value.
/// \param area Rectangle of pixel buffer to set.
/// \param plane Plane to start filling on.
/// \param planes Number of planes to fill.
/// \param value Constant real32 value to set pixels to.
void SetConstant_real32 (const dng_rect &area,
uint32 plane,
uint32 planes,
real32 value)
{
DNG_ASSERT (fPixelType == ttFloat, "Mismatched pixel type");
union
{
uint32 i;
real32 f;
} x;
x.f = value;
SetConstant (area, plane, planes, x.i);
}
/// Initialize a rectangular area of pixel buffer to zeros.
/// \param area Rectangle of pixel buffer to zero.
/// \param area Area to zero
/// \param plane Plane to start filling on.
/// \param planes Number of planes to fill.
void SetZero (const dng_rect &area,
uint32 plane,
uint32 planes);
/// Copy image data from an area of one pixel buffer to same area of another.
/// \param src Buffer to copy from.
/// \param area Rectangle of pixel buffer to copy.
/// \param srcPlane Plane to start copy in src.
/// \param dstPlane Plane to start copy in dst.
/// \param planes Number of planes to copy.
void CopyArea (const dng_pixel_buffer &src,
const dng_rect &area,
uint32 srcPlane,
uint32 dstPlane,
uint32 planes);
/// Copy image data from an area of one pixel buffer to same area of another.
/// \param src Buffer to copy from.
/// \param area Rectangle of pixel buffer to copy.
/// \param plane Plane to start copy in src and this.
/// \param planes Number of planes to copy.
void CopyArea (const dng_pixel_buffer &src,
const dng_rect &area,
uint32 plane,
uint32 planes)
{
CopyArea (src, area, plane, plane, planes);
}
/// Calculate the offset phase of destination rectangle relative to source rectangle.
/// Phase is based on a 0,0 origin and the notion of repeating srcArea across dstArea.
/// It is the number of pixels into srcArea to start repeating from when tiling dstArea.
/// \retval dng_point containing horizontal and vertical phase.
static dng_point RepeatPhase (const dng_rect &srcArea,
const dng_rect &dstArea);
/// Repeat the image data in srcArea across dstArea.
/// (Generally used for padding operations.)
/// \param srcArea Area to repeat from.
/// \param dstArea Area to fill with data from srcArea.
void RepeatArea (const dng_rect &srcArea,
const dng_rect &dstArea);
/// Replicates a sub-area of a buffer to fill the entire buffer.
void RepeatSubArea (const dng_rect subArea,
uint32 repeatV = 1,
uint32 repeatH = 1);
/// Apply a right shift (C++ oerpator >>) to all pixel values. Only implemented for 16-bit (signed or unsigned) pixel buffers.
/// \param shift Number of bits by which to right shift each pixel value.
void ShiftRight (uint32 shift);
/// Change metadata so pixels are iterated in opposite horizontal order.
/// This operation does not require movement of actual pixel data.
void FlipH ();
/// Change metadata so pixels are iterated in opposite vertical order.
/// This operation does not require movement of actual pixel data.
void FlipV ();
/// Change metadata so pixels are iterated in opposite plane order.
/// This operation does not require movement of actual pixel data.
void FlipZ (); // Flip planes
/// Return true if the contents of an area of the pixel buffer area are the same as those of another.
/// \param rhs Buffer to compare against.
/// \param area Rectangle of pixel buffer to test.
/// \param plane Plane to start comparing.
/// \param planes Number of planes to compare.
/// \retval bool true if areas are equal, false otherwise.
bool EqualArea (const dng_pixel_buffer &rhs,
const dng_rect &area,
uint32 plane,
uint32 planes) const;
/// Return the absolute value of the maximum difference between two pixel buffers. Used for comparison testing with tolerance
/// \param rhs Buffer to compare against.
/// \param area Rectangle of pixel buffer to test.
/// \param plane Plane to start comparing.
/// \param planes Number of planes to compare.
/// \retval larges absolute value difference between the corresponding pixels each buffer across area.
real64 MaximumDifference (const dng_pixel_buffer &rhs,
const dng_rect &area,
uint32 plane,
uint32 planes) const;
};
/*****************************************************************************/
#endif
/*****************************************************************************/
| [
"cankaraimer@gmail.com"
] | cankaraimer@gmail.com |
8344231de1f6f62c1a5bc88397f362d3e2991d70 | 9fd0b6465570129c86f4892e54da27d0e9842f9b | /src/runtime/libc++/test/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp | 68dcf6eab8f15de1240f12ea5ee0dac96284c9ba | [
"BSL-1.0"
] | permissive | metta-systems/metta | cdbdcda872c5b13ae4047a7ceec6c34fc6184cbf | 170dd91b5653626fb3b9bfab01547612efe531c5 | refs/heads/develop | 2022-04-06T07:25:16.069905 | 2020-02-17T08:22:10 | 2020-02-17T08:22:10 | 6,562,050 | 39 | 11 | BSL-1.0 | 2019-02-22T08:53:20 | 2012-11-06T12:54:03 | C++ | UTF-8 | C++ | false | false | 1,190 | cpp | //===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <streambuf>
// template <class charT, class traits = char_traits<charT> >
// class basic_streambuf;
// void setg(char_type* gbeg, char_type* gnext, char_type* gend);
#include <streambuf>
#include <cassert>
template <class CharT>
struct test
: public std::basic_streambuf<CharT>
{
typedef std::basic_streambuf<CharT> base;
test() {}
void setg(CharT* gbeg, CharT* gnext, CharT* gend)
{
base::setg(gbeg, gnext, gend);
assert(base::eback() == gbeg);
assert(base::gptr() == gnext);
assert(base::egptr() == gend);
}
};
int main()
{
{
test<char> t;
char in[] = "ABC";
t.setg(in, in+1, in+sizeof(in)/sizeof(in[0]));
}
{
test<wchar_t> t;
wchar_t in[] = L"ABC";
t.setg(in, in+1, in+sizeof(in)/sizeof(in[0]));
}
}
| [
"berkus@exquance.com"
] | berkus@exquance.com |
ec517e92ba0162b23e6b9ffff9e62d966d786857 | bda0a44e32559082176f3646d90503f903ec0d2e | /Temp/StagingArea/Data/il2cppOutput/Bulk_UnityEngine_1.cpp | cc1f28a3c50530b30960bc14913c468cf7dab347 | [] | no_license | Petenickx74/ZeldaRPG | 44af3101d0a247f7ee84ae5fab44e9a3dc9d03d3 | 6ea7995a2c8f70abe288ab5cdecca1724a0eefe0 | refs/heads/master | 2021-01-21T14:16:24.886613 | 2017-06-30T00:05:19 | 2017-06-30T00:05:19 | 95,257,307 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,007,501 | cpp | #include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include "class-internals.h"
#include "codegen/il2cpp-codegen.h"
#include "mscorlib_System_Array3829468939.h"
#include "UnityEngine_UnityEngine_Experimental_Director_Scri4067966717.h"
#include "mscorlib_System_Void1841601450.h"
#include "UnityEngine_UnityEngine_Experimental_Director_Play3667545548.h"
#include "UnityEngine_UnityEngine_Experimental_Director_Fram1120735295.h"
#include "mscorlib_System_Object2689449295.h"
#include "UnityEngine_UnityEngine_Experimental_Director_Play3250302433.h"
#include "UnityEngine_UnityEngine_Experimental_Rendering_Rend984453155.h"
#include "mscorlib_System_IntPtr2504060609.h"
#include "mscorlib_System_Boolean3825574718.h"
#include "UnityEngine_UnityEngine_Camera189460977.h"
#include "UnityEngine_UnityEngine_Experimental_Rendering_Script4271526.h"
#include "UnityEngine_UnityEngine_Font4239498691.h"
#include "UnityEngine_UnityEngine_Material193706927.h"
#include "mscorlib_System_Char3454481338.h"
#include "mscorlib_System_Action_1_gen4041298073.h"
#include "mscorlib_System_Delegate3022476291.h"
#include "UnityEngine_UnityEngine_Font_FontTextureRebuildCal1272078033.h"
#include "mscorlib_System_Int322071877448.h"
#include "mscorlib_System_AsyncCallback163412349.h"
#include "UnityEngine_UnityEngine_FontStyle2764949590.h"
#include "UnityEngine_UnityEngine_GameObject1756533147.h"
#include "mscorlib_System_String2029220233.h"
#include "UnityEngine_UnityEngine_Object1021602117.h"
#include "mscorlib_System_Type1303803226.h"
#include "UnityEngine_UnityEngine_Component3819376471.h"
#include "UnityEngine_UnityEngine_Transform3275118058.h"
#include "UnityEngine_UnityEngine_SendMessageOptions1414041951.h"
#include "UnityEngine_UnityEngine_Gradient3600583008.h"
#include "UnityEngine_UnityEngine_GUI4082743951.h"
#include "mscorlib_System_DateTime693205669.h"
#include "mscorlib_System_Single2076509932.h"
#include "UnityEngine_UnityEngineInternal_GenericStack3718539591.h"
#include "UnityEngine_UnityEngine_GUISkin1436893342.h"
#include "UnityEngine_UnityEngine_GUI_WindowFunction3486805455.h"
#include "UnityEngine_UnityEngine_GUIStyle1799908754.h"
#include "UnityEngine_UnityEngine_EventType3919834026.h"
#include "UnityEngine_UnityEngine_GUILayoutOption4183744904.h"
#include "UnityEngine_UnityEngine_GUILayoutUtility_LayoutCac3120781045.h"
#include "UnityEngine_UnityEngine_Event3028476042.h"
#include "UnityEngine_UnityEngine_GUIContent4210063000.h"
#include "UnityEngine_UnityEngine_Texture2243626319.h"
#include "UnityEngine_UnityEngine_GUIElement3381083099.h"
#include "UnityEngine_UnityEngine_GUILayer3254902478.h"
#include "UnityEngine_UnityEngine_Vector32243707580.h"
#include "UnityEngine_UnityEngine_GUILayout2579273657.h"
#include "UnityEngine_UnityEngine_GUILayoutOption_Type4024155706.h"
#include "UnityEngine_UnityEngine_GUILayoutEntry3828586629.h"
#include "UnityEngine_UnityEngine_Rect3681755626.h"
#include "UnityEngine_UnityEngine_RectOffset3387826427.h"
#include "UnityEngine_UnityEngine_GUILayoutGroup3975363388.h"
#include "mscorlib_System_Collections_Generic_List_1_gen3197707761.h"
#include "mscorlib_System_Collections_Generic_List_1_Enumera2732437435.h"
#include "mscorlib_System_Collections_Generic_List_1_Enumera1593300101.h"
#include "UnityEngine_UnityEngine_GUILayoutUtility996096873.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_g2128606680.h"
#include "mscorlib_System_Collections_Stack1043988394.h"
#include "UnityEngine_UnityEngine_GUIScrollGroup755788567.h"
#include "UnityEngine_UnityEngine_GUISettings622856320.h"
#include "UnityEngine_UnityEngine_Color2020392075.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_g3714688016.h"
#include "UnityEngine_UnityEngine_ScriptableObject1975622470.h"
#include "mscorlib_System_StringComparer1574862926.h"
#include "UnityEngine_UnityEngine_GUIStyleState3801000545.h"
#include "UnityEngine_UnityEngine_GUISkin_SkinChangedDelegat3594822336.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V1106253484.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V3968042187.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V2417747859.h"
#include "UnityEngine_UnityEngine_Vector22243707579.h"
#include "UnityEngine_UnityEngine_Internal_DrawArguments2834709342.h"
#include "UnityEngine_UnityEngine_Internal_DrawWithTextSelec1327795077.h"
#include "UnityEngine_UnityEngine_ImagePosition3491916276.h"
#include "UnityEngine_UnityEngine_TextAnchor112990806.h"
#include "UnityEngine_UnityEngine_TextClipping2573530411.h"
#include "UnityEngine_UnityEngine_Texture2D3542995729.h"
#include "UnityEngine_UnityEngine_GUITargetAttribute863467180.h"
#include "mscorlib_System_Reflection_BindingFlags1082350898.h"
#include "mscorlib_System_RuntimeTypeHandle2330101084.h"
#include "mscorlib_System_Reflection_MethodInfo3330546337.h"
#include "mscorlib_System_Reflection_MemberInfo4043097260.h"
#include "UnityEngine_UnityEngine_GUIUtility3275770671.h"
#include "mscorlib_System_Exception1927440687.h"
#include "mscorlib_System_Reflection_TargetInvocationExcepti4098620458.h"
#include "UnityEngine_UnityEngine_ExitGUIException1618397098.h"
#include "mscorlib_System_ArgumentException3259014390.h"
#include "UnityEngine_UnityEngine_Gyroscope1705362817.h"
#include "UnityEngine_UnityEngine_HideFlags1434274199.h"
#include "UnityEngine_UnityEngine_HorizontalWrapMode2027154177.h"
#include "UnityEngine_UnityEngine_HumanBone1529896151.h"
#include "UnityEngine_UnityEngine_HumanLimit250797648.h"
#include "UnityEngine_UnityEngine_IL2CPPStructAlignmentAttrib130316838.h"
#include "mscorlib_System_Attribute542643598.h"
#include "UnityEngine_UnityEngine_IMECompositionMode1898275508.h"
#include "UnityEngine_UnityEngine_Input1785128008.h"
#include "UnityEngine_UnityEngine_KeyCode2283395152.h"
#include "UnityEngine_UnityEngine_Touch407273883.h"
#include "UnityEngine_UnityEngine_Internal_DefaultValueAttri1027170048.h"
#include "UnityEngine_UnityEngine_Internal_ExcludeFromDocsAtt665825653.h"
#include "UnityEngine_UnityEngine_Keyframe1449471340.h"
#include "UnityEngine_UnityEngine_LayerMask3188175821.h"
#include "UnityEngine_UnityEngine_Logger3328995178.h"
#include "UnityEngine_UnityEngine_LogType1559732862.h"
#include "UnityEngine_UnityEngine_Mathf2336485820.h"
#include "mscorlib_System_Double4078015681.h"
#include "UnityEngine_UnityEngineInternal_MathfInternal715669973.h"
#include "UnityEngine_UnityEngine_Matrix4x42933234003.h"
#include "mscorlib_System_IndexOutOfRangeException3527622107.h"
#include "UnityEngine_UnityEngine_Vector42243707581.h"
#include "UnityEngine_UnityEngine_Mesh1356156583.h"
#include "UnityEngine_UnityEngine_Mesh_InternalShaderChannel3331827198.h"
#include "UnityEngine_UnityEngine_Mesh_InternalVertexChannel2178520045.h"
#include "mscorlib_System_Collections_Generic_List_1_gen1440998580.h"
#include "UnityEngine_UnityEngine_Color32874517518.h"
#include "mscorlib_System_Collections_Generic_List_1_gen1612828712.h"
#include "mscorlib_System_Collections_Generic_List_1_gen1612828713.h"
#include "mscorlib_System_Collections_Generic_List_1_gen243638650.h"
#include "mscorlib_System_Collections_Generic_List_1_gen1612828711.h"
#include "UnityEngine_UnityEngine_MonoBehaviour1158329972.h"
#include "UnityEngine_UnityEngine_Behaviour955675639.h"
#include "UnityEngine_UnityEngine_Coroutine2299508840.h"
#include "UnityEngine_UnityEngine_Motion2415020824.h"
#include "UnityEngine_UnityEngine_NativeClassAttribute1576243993.h"
#include "UnityEngine_UnityEngine_Networking_PlayerConnection301283622.h"
#include "UnityEngine_UnityEngine_Networking_PlayerConnectio3517219175.h"
#include "UnityEngine_UnityEngine_Networking_PlayerConnectio2252784345.h"
#include "mscorlib_System_UInt642909196914.h"
#include "mscorlib_System_Guid2533601593.h"
#include "mscorlib_System_Byte3683104436.h"
#include "UnityEngine_UnityEngine_Networking_PlayerConnection536719976.h"
#include "UnityEngine_UnityEngine_Events_UnityEvent_1_gen2110227463.h"
#include "mscorlib_System_Collections_Generic_List_1_gen1660627182.h"
#include "UnityEngine_UnityEngine_Networking_PlayerConnectio1899782350.h"
#include "UnityEngine_UnityEngine_Networking_PlayerConnectio2291506050.h"
#include "System_Core_System_Func_2_gen2919696197.h"
#include "UnityEngine_UnityEngine_Networking_PlayerConnectio2167079021.h"
#include "UnityEngine_UnityEngine_Events_UnityEvent_1_gen339633637.h"
#include "UnityEngine_UnityEngine_Quaternion4030073918.h"
#include "mscorlib_System_Int64909078037.h"
#include "UnityEngine_UnityEngine_OperatingSystemFamily1896948788.h"
#include "UnityEngine_UnityEngine_Physics634932869.h"
#include "UnityEngine_UnityEngine_Physics2D2540166467.h"
#include "UnityEngine_UnityEngine_RaycastHit2D4063908774.h"
#include "UnityEngine_UnityEngine_ContactFilter2D1672660996.h"
#include "UnityEngine_UnityEngine_Ray2469606224.h"
#include "UnityEngine_UnityEngine_Rigidbody2D502193897.h"
#include "UnityEngine_UnityEngine_Collider2D646061738.h"
#include "mscorlib_System_Collections_Generic_List_1_gen4166282325.h"
#include "UnityEngine_UnityEngine_Plane3727654732.h"
#include "UnityEngine_UnityEngine_PreferBinarySerialization2472773525.h"
#include "UnityEngine_UnityEngine_PropertyAttribute2606999759.h"
#include "UnityEngine_UnityEngine_Random1170710517.h"
#include "UnityEngine_UnityEngine_RangeAttribute3336560921.h"
#include "UnityEngine_UnityEngine_RangeInt2323401134.h"
#include "UnityEngine_UnityEngine_RaycastHit87180320.h"
#include "UnityEngine_UnityEngine_Collider3497673348.h"
#include "UnityEngine_UnityEngine_RectTransform3349966182.h"
#include "UnityEngine_UnityEngine_RectTransform_ReapplyDrive2020713228.h"
#include "UnityEngine_UnityEngine_RectTransform_Edge3306019089.h"
#include "UnityEngine_UnityEngine_RectTransform_Axis3420330537.h"
#include "UnityEngine_UnityEngine_RectTransformUtility2941082270.h"
#include "UnityEngine_UnityEngine_Canvas209405766.h"
#include "UnityEngine_UnityEngine_RemoteSettings392466225.h"
#include "UnityEngine_UnityEngine_RemoteSettings_UpdatedEven3033456180.h"
#include "UnityEngine_UnityEngine_Renderer257310565.h"
#include "UnityEngine_UnityEngine_Rendering_ColorWriteMask926634530.h"
#include "UnityEngine_UnityEngine_Rendering_CompareFunction457874581.h"
#include "UnityEngine_UnityEngine_Rendering_StencilOp2936374925.h"
#include "UnityEngine_UnityEngine_RenderMode4280533217.h"
#include "UnityEngine_UnityEngine_RenderTexture2666733923.h"
#include "UnityEngine_UnityEngine_RequireComponent864575032.h"
#include "UnityEngine_UnityEngine_ResourceRequest2560315377.h"
#include "UnityEngine_UnityEngine_AsyncOperation3814632279.h"
#include "UnityEngine_UnityEngine_Resources339470017.h"
#include "UnityEngine_UnityEngine_RuntimeAnimatorController670468573.h"
#include "UnityEngine_UnityEngine_RuntimePlatform1869584967.h"
#include "UnityEngine_UnityEngine_SceneManagement_LoadSceneM2981886439.h"
#include "UnityEngine_UnityEngine_SceneManagement_Scene1684909666.h"
#include "UnityEngine_UnityEngine_SceneManagement_SceneManager90660965.h"
#include "UnityEngine_UnityEngine_Events_UnityAction_2_gen1903595547.h"
#include "UnityEngine_UnityEngine_Events_UnityAction_1_gen3051495417.h"
#include "UnityEngine_UnityEngine_Events_UnityAction_2_gen606618774.h"
// UnityEngine.Experimental.Director.ScriptPlayable
struct ScriptPlayable_t4067966717;
// UnityEngine.Experimental.Director.Playable
struct Playable_t3667545548;
// System.Object
struct Il2CppObject;
// UnityEngine.Experimental.Rendering.IRenderPipeline
struct IRenderPipeline_t2611978095;
// UnityEngine.Experimental.Rendering.IRenderPipelineAsset
struct IRenderPipelineAsset_t345810019;
// UnityEngine.Camera[]
struct CameraU5BU5D_t3079764780;
// UnityEngine.Camera
struct Camera_t189460977;
// UnityEngine.Font
struct Font_t4239498691;
// UnityEngine.Material
struct Material_t193706927;
// System.Action`1<UnityEngine.Font>
struct Action_1_t4041298073;
// System.Delegate
struct Delegate_t3022476291;
// System.Action`1<System.Object>
struct Action_1_t2491248677;
// UnityEngine.Font/FontTextureRebuildCallback
struct FontTextureRebuildCallback_t1272078033;
// System.IAsyncResult
struct IAsyncResult_t1999651008;
// System.AsyncCallback
struct AsyncCallback_t163412349;
// UnityEngine.GameObject
struct GameObject_t1756533147;
// System.String
struct String_t;
// UnityEngine.Object
struct Object_t1021602117;
// System.Type[]
struct TypeU5BU5D_t1664964607;
// System.Type
struct Type_t;
// UnityEngine.Component
struct Component_t3819376471;
// UnityEngine.Component[]
struct ComponentU5BU5D_t4136971630;
// System.Array
struct Il2CppArray;
// UnityEngine.Transform
struct Transform_t3275118058;
// UnityEngine.Gradient
struct Gradient_t3600583008;
// UnityEngineInternal.GenericStack
struct GenericStack_t3718539591;
// UnityEngine.GUISkin
struct GUISkin_t1436893342;
// UnityEngine.GUI/WindowFunction
struct WindowFunction_t3486805455;
// UnityEngine.GUIStyle
struct GUIStyle_t1799908754;
// UnityEngine.GUILayoutUtility/LayoutCache
struct LayoutCache_t3120781045;
// UnityEngine.Event
struct Event_t3028476042;
// UnityEngine.GUILayoutOption
struct GUILayoutOption_t4183744904;
// UnityEngine.GUILayoutOption[]
struct GUILayoutOptionU5BU5D_t2108882777;
// UnityEngine.GUIContent
struct GUIContent_t4210063000;
// UnityEngine.Texture
struct Texture_t2243626319;
// UnityEngine.GUILayer
struct GUILayer_t3254902478;
// UnityEngine.GUIElement
struct GUIElement_t3381083099;
// UnityEngine.GUILayoutEntry
struct GUILayoutEntry_t3828586629;
// UnityEngine.RectOffset
struct RectOffset_t3387826427;
// System.Object[]
struct ObjectU5BU5D_t3614634134;
// UnityEngine.GUILayoutGroup
struct GUILayoutGroup_t3975363388;
// System.Collections.Generic.List`1<UnityEngine.GUILayoutEntry>
struct List_1_t3197707761;
// System.Collections.Generic.List`1<System.Object>
struct List_1_t2058570427;
// System.Collections.Generic.Dictionary`2<System.Int32,UnityEngine.GUILayoutUtility/LayoutCache>
struct Dictionary_2_t2128606680;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Object>
struct Dictionary_2_t1697274930;
// UnityEngine.GUIScrollGroup
struct GUIScrollGroup_t755788567;
// UnityEngine.GUISettings
struct GUISettings_t622856320;
// UnityEngine.ScriptableObject
struct ScriptableObject_t1975622470;
// UnityEngine.GUIStyle[]
struct GUIStyleU5BU5D_t2497716199;
// System.StringComparer
struct StringComparer_t1574862926;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.GUIStyle>
struct Dictionary_2_t3714688016;
// System.Collections.Generic.IEqualityComparer`1<System.String>
struct IEqualityComparer_1_t1241853011;
// System.Collections.Generic.Dictionary`2<System.Object,System.Object>
struct Dictionary_2_t2281509423;
// System.Collections.Generic.IEqualityComparer`1<System.Object>
struct IEqualityComparer_1_t1902082073;
// UnityEngine.GUIStyleState
struct GUIStyleState_t3801000545;
// UnityEngine.GUISkin/SkinChangedDelegate
struct SkinChangedDelegate_t3594822336;
// System.Collections.IEnumerator
struct IEnumerator_t1466026749;
// System.Collections.Generic.Dictionary`2/ValueCollection<System.String,UnityEngine.GUIStyle>
struct ValueCollection_t2417747859;
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>
struct ValueCollection_t984569266;
// UnityEngine.Texture2D
struct Texture2D_t3542995729;
// System.Reflection.MethodInfo
struct MethodInfo_t;
// System.Exception
struct Exception_t1927440687;
// System.ArgumentException
struct ArgumentException_t3259014390;
// UnityEngine.IL2CPPStructAlignmentAttribute
struct IL2CPPStructAlignmentAttribute_t130316838;
// System.Attribute
struct Attribute_t542643598;
// UnityEngine.Internal.DefaultValueAttribute
struct DefaultValueAttribute_t1027170048;
// UnityEngine.Internal.ExcludeFromDocsAttribute
struct ExcludeFromDocsAttribute_t665825653;
// UnityEngine.Logger
struct Logger_t3328995178;
// UnityEngine.ILogHandler
struct ILogHandler_t264057413;
// System.IndexOutOfRangeException
struct IndexOutOfRangeException_t3527622107;
// UnityEngine.Mesh
struct Mesh_t1356156583;
// System.Int32[]
struct Int32U5BU5D_t3030399641;
// System.Collections.Generic.List`1<System.Int32>
struct List_1_t1440998580;
// UnityEngine.Vector3[]
struct Vector3U5BU5D_t1172311765;
// UnityEngine.Vector4[]
struct Vector4U5BU5D_t1658499504;
// UnityEngine.Vector2[]
struct Vector2U5BU5D_t686124026;
// UnityEngine.Color32[]
struct Color32U5BU5D_t30278651;
// System.Collections.Generic.List`1<UnityEngine.Vector3>
struct List_1_t1612828712;
// System.Collections.Generic.List`1<UnityEngine.Vector4>
struct List_1_t1612828713;
// System.Collections.Generic.List`1<UnityEngine.Color32>
struct List_1_t243638650;
// System.Collections.Generic.List`1<UnityEngine.Vector2>
struct List_1_t1612828711;
// UnityEngine.MonoBehaviour
struct MonoBehaviour_t1158329972;
// UnityEngine.Behaviour
struct Behaviour_t955675639;
// UnityEngine.Coroutine
struct Coroutine_t2299508840;
// UnityEngine.NativeClassAttribute
struct NativeClassAttribute_t1576243993;
// UnityEngine.Networking.PlayerConnection.MessageEventArgs
struct MessageEventArgs_t301283622;
// UnityEngine.Networking.PlayerConnection.PlayerConnection
struct PlayerConnection_t3517219175;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents
struct PlayerEditorConnectionEvents_t2252784345;
// System.Byte[]
struct ByteU5BU5D_t3397334013;
// UnityEngine.Events.UnityEvent`1<System.Int32>
struct UnityEvent_1_t2110227463;
// System.Collections.Generic.List`1<UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers>
struct List_1_t1660627182;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/ConnectionChangeEvent
struct ConnectionChangeEvent_t536719976;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/<InvokeMessageIdSubscribers>c__AnonStorey0
struct U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350;
// System.Func`2<UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers,System.Boolean>
struct Func_2_t2919696197;
// System.Func`2<System.Object,System.Boolean>
struct Func_2_t3961629604;
// System.Collections.Generic.IEnumerable`1<UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers>
struct IEnumerable_1_t2583633095;
// System.Collections.Generic.IEnumerable`1<System.Object>
struct IEnumerable_1_t2981576340;
// UnityEngine.Events.UnityEvent`1<UnityEngine.Networking.PlayerConnection.MessageEventArgs>
struct UnityEvent_1_t339633637;
// UnityEngine.Events.UnityEvent`1<System.Object>
struct UnityEvent_1_t2727799310;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers
struct MessageTypeSubscribers_t2291506050;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageEvent
struct MessageEvent_t2167079021;
// UnityEngine.Object[]
struct ObjectU5BU5D_t4217747464;
// UnityEngine.RaycastHit2D[]
struct RaycastHit2DU5BU5D_t4176517891;
// UnityEngine.Rigidbody2D
struct Rigidbody2D_t502193897;
// UnityEngine.Collider2D
struct Collider2D_t646061738;
// System.Collections.Generic.List`1<UnityEngine.Rigidbody2D>
struct List_1_t4166282325;
// UnityEngine.PreferBinarySerialization
struct PreferBinarySerialization_t2472773525;
// UnityEngine.PropertyAttribute
struct PropertyAttribute_t2606999759;
// UnityEngine.RangeAttribute
struct RangeAttribute_t3336560921;
// UnityEngine.Collider
struct Collider_t3497673348;
// UnityEngine.RectTransform
struct RectTransform_t3349966182;
// UnityEngine.RectTransform/ReapplyDrivenProperties
struct ReapplyDrivenProperties_t2020713228;
// UnityEngine.Canvas
struct Canvas_t209405766;
// UnityEngine.RemoteSettings/UpdatedEventHandler
struct UpdatedEventHandler_t3033456180;
// UnityEngine.Renderer
struct Renderer_t257310565;
// UnityEngine.RenderTexture
struct RenderTexture_t2666733923;
// UnityEngine.RequireComponent
struct RequireComponent_t864575032;
// UnityEngine.ResourceRequest
struct ResourceRequest_t2560315377;
// UnityEngine.AsyncOperation
struct AsyncOperation_t3814632279;
// UnityEngine.Events.UnityAction`2<UnityEngine.SceneManagement.Scene,UnityEngine.SceneManagement.LoadSceneMode>
struct UnityAction_2_t1903595547;
// UnityEngine.Events.UnityAction`1<UnityEngine.SceneManagement.Scene>
struct UnityAction_1_t3051495417;
// UnityEngine.Events.UnityAction`2<UnityEngine.SceneManagement.Scene,UnityEngine.SceneManagement.Scene>
struct UnityAction_2_t606618774;
extern Il2CppClass* RenderPipelineManager_t984453155_il2cpp_TypeInfo_var;
extern const uint32_t RenderPipelineManager_get_currentPipeline_m679160301_MetadataUsageId;
extern const uint32_t RenderPipelineManager_set_currentPipeline_m3825706412_MetadataUsageId;
extern Il2CppClass* IRenderPipelineAsset_t345810019_il2cpp_TypeInfo_var;
extern const uint32_t RenderPipelineManager_CleanupRenderPipeline_m2242901458_MetadataUsageId;
extern Il2CppClass* ScriptableRenderContext_t4271526_il2cpp_TypeInfo_var;
extern Il2CppClass* IRenderPipeline_t2611978095_il2cpp_TypeInfo_var;
extern const uint32_t RenderPipelineManager_DoRenderLoop_Internal_m2267530247_MetadataUsageId;
extern const uint32_t RenderPipelineManager_PrepareRenderPipeline_m4209257657_MetadataUsageId;
extern Il2CppClass* Font_t4239498691_il2cpp_TypeInfo_var;
extern Il2CppClass* Action_1_t4041298073_il2cpp_TypeInfo_var;
extern const uint32_t Font_add_textureRebuilt_m1282639736_MetadataUsageId;
extern const uint32_t Font_remove_textureRebuilt_m2672217591_MetadataUsageId;
extern const MethodInfo* Action_1_Invoke_m1059548733_MethodInfo_var;
extern const uint32_t Font_InvokeTextureRebuilt_Internal_m2007522718_MetadataUsageId;
extern Il2CppClass* Object_t1021602117_il2cpp_TypeInfo_var;
extern const uint32_t GameObject__ctor_m962601984_MetadataUsageId;
extern const uint32_t GameObject__ctor_m1633632305_MetadataUsageId;
extern Il2CppClass* ComponentU5BU5D_t4136971630_il2cpp_TypeInfo_var;
extern const uint32_t GameObject_GetComponents_m297658252_MetadataUsageId;
extern const uint32_t GameObject_GetComponentsInChildren_m993725821_MetadataUsageId;
extern const uint32_t GameObject_GetComponentsInParent_m1568786844_MetadataUsageId;
extern Il2CppClass* GUI_t4082743951_il2cpp_TypeInfo_var;
extern Il2CppClass* GenericStack_t3718539591_il2cpp_TypeInfo_var;
extern Il2CppClass* DateTime_t693205669_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral1502599537;
extern Il2CppCodeGenString* _stringLiteral3916321877;
extern Il2CppCodeGenString* _stringLiteral4217853282;
extern Il2CppCodeGenString* _stringLiteral2555502078;
extern Il2CppCodeGenString* _stringLiteral2877295445;
extern Il2CppCodeGenString* _stringLiteral1731085918;
extern Il2CppCodeGenString* _stringLiteral3501964962;
extern const uint32_t GUI__cctor_m1321863889_MetadataUsageId;
extern const uint32_t GUI_set_nextScrollStepTime_m2724006954_MetadataUsageId;
extern Il2CppClass* GUIUtility_t3275770671_il2cpp_TypeInfo_var;
extern const uint32_t GUI_set_skin_m3391676555_MetadataUsageId;
extern const uint32_t GUI_get_skin_m2309570990_MetadataUsageId;
extern const uint32_t GUI_DoSetSkin_m3603287387_MetadataUsageId;
extern Il2CppClass* GUILayoutUtility_t996096873_il2cpp_TypeInfo_var;
extern Il2CppClass* GUILayoutOptionU5BU5D_t2108882777_il2cpp_TypeInfo_var;
extern Il2CppClass* GUIStyle_t1799908754_il2cpp_TypeInfo_var;
extern const uint32_t GUI_CallWindowDelegate_m2039577415_MetadataUsageId;
extern Il2CppClass* Int32_t2071877448_il2cpp_TypeInfo_var;
extern const uint32_t WindowFunction_BeginInvoke_m322627481_MetadataUsageId;
extern Il2CppClass* String_t_il2cpp_TypeInfo_var;
extern const uint32_t GUIContent__ctor_m3889310883_MetadataUsageId;
extern const uint32_t GUIContent__ctor_m845353549_MetadataUsageId;
extern const uint32_t GUIContent__ctor_m3472047579_MetadataUsageId;
extern Il2CppClass* GUIContent_t4210063000_il2cpp_TypeInfo_var;
extern const uint32_t GUIContent_Temp_m1650198655_MetadataUsageId;
extern const uint32_t GUIContent_Temp_m1937454133_MetadataUsageId;
extern const uint32_t GUIContent_ClearStaticCache_m3271816250_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral371857150;
extern const uint32_t GUIContent__cctor_m2212772596_MetadataUsageId;
extern Il2CppClass* Single_t2076509932_il2cpp_TypeInfo_var;
extern Il2CppClass* GUILayoutOption_t4183744904_il2cpp_TypeInfo_var;
extern const uint32_t GUILayout_Width_m261136689_MetadataUsageId;
extern const uint32_t GUILayout_Height_m607115982_MetadataUsageId;
extern const uint32_t GUILayoutEntry__ctor_m4007465719_MetadataUsageId;
extern const uint32_t GUILayoutEntry_ApplyOptions_m115321759_MetadataUsageId;
extern Il2CppClass* GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var;
extern Il2CppClass* ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral372029310;
extern Il2CppCodeGenString* _stringLiteral3798370932;
extern Il2CppCodeGenString* _stringLiteral3390779443;
extern Il2CppCodeGenString* _stringLiteral3932457658;
extern Il2CppCodeGenString* _stringLiteral372029313;
extern Il2CppCodeGenString* _stringLiteral372029319;
extern Il2CppCodeGenString* _stringLiteral384197212;
extern const uint32_t GUILayoutEntry_ToString_m1331406279_MetadataUsageId;
extern const uint32_t GUILayoutEntry__cctor_m3710308127_MetadataUsageId;
extern Il2CppClass* List_1_t3197707761_il2cpp_TypeInfo_var;
extern Il2CppClass* RectOffset_t3387826427_il2cpp_TypeInfo_var;
extern const MethodInfo* List_1__ctor_m3098209370_MethodInfo_var;
extern const uint32_t GUILayoutGroup__ctor_m992523271_MetadataUsageId;
extern const uint32_t GUILayoutGroup_ApplyOptions_m1748499012_MetadataUsageId;
extern Il2CppClass* Mathf_t2336485820_il2cpp_TypeInfo_var;
extern const MethodInfo* List_1_get_Count_m3575634194_MethodInfo_var;
extern const MethodInfo* List_1_GetEnumerator_m529646903_MethodInfo_var;
extern const MethodInfo* Enumerator_get_Current_m2724498415_MethodInfo_var;
extern const MethodInfo* Enumerator_MoveNext_m672443923_MethodInfo_var;
extern const MethodInfo* Enumerator_Dispose_m4028763464_MethodInfo_var;
extern const MethodInfo* List_1_get_Item_m3153062965_MethodInfo_var;
extern const uint32_t GUILayoutGroup_CalcWidth_m4107152934_MetadataUsageId;
extern const uint32_t GUILayoutGroup_SetHorizontal_m15325071_MetadataUsageId;
extern const uint32_t GUILayoutGroup_CalcHeight_m1454440153_MetadataUsageId;
extern const uint32_t GUILayoutGroup_SetVertical_m2197915999_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral1159361143;
extern Il2CppCodeGenString* _stringLiteral2759504069;
extern Il2CppCodeGenString* _stringLiteral372029352;
extern Il2CppCodeGenString* _stringLiteral372029393;
extern const uint32_t GUILayoutGroup_ToString_m2654218848_MetadataUsageId;
extern Il2CppClass* LayoutCache_t3120781045_il2cpp_TypeInfo_var;
extern const MethodInfo* Dictionary_2_TryGetValue_m1480015700_MethodInfo_var;
extern const MethodInfo* Dictionary_2_set_Item_m1800215906_MethodInfo_var;
extern const uint32_t GUILayoutUtility_SelectIDList_m756828237_MetadataUsageId;
extern Il2CppClass* GUILayoutGroup_t3975363388_il2cpp_TypeInfo_var;
extern const uint32_t GUILayoutUtility_Begin_m2360858304_MetadataUsageId;
extern const uint32_t GUILayoutUtility_BeginWindow_m488834212_MetadataUsageId;
extern const uint32_t GUILayoutUtility_Layout_m3812180708_MetadataUsageId;
extern const uint32_t GUILayoutUtility_LayoutFromEditorWindow_m1847418289_MetadataUsageId;
extern const uint32_t GUILayoutUtility_LayoutFreeGroup_m1173219546_MetadataUsageId;
extern const uint32_t GUILayoutUtility_LayoutSingleGroup_m3547078816_MetadataUsageId;
extern const uint32_t GUILayoutUtility_get_spaceStyle_m1918520192_MetadataUsageId;
extern const uint32_t GUILayoutUtility_Internal_GetWindowRect_m1287880151_MetadataUsageId;
extern const uint32_t GUILayoutUtility_Internal_MoveWindow_m3217449419_MetadataUsageId;
extern Il2CppClass* Dictionary_2_t2128606680_il2cpp_TypeInfo_var;
extern const MethodInfo* Dictionary_2__ctor_m853591007_MethodInfo_var;
extern const uint32_t GUILayoutUtility__cctor_m2957755459_MetadataUsageId;
extern const uint32_t LayoutCache__ctor_m2805543017_MetadataUsageId;
extern Il2CppClass* GUISettings_t622856320_il2cpp_TypeInfo_var;
extern Il2CppClass* GUIStyleU5BU5D_t2497716199_il2cpp_TypeInfo_var;
extern const uint32_t GUISkin__ctor_m1526071177_MetadataUsageId;
extern Il2CppClass* GUISkin_t1436893342_il2cpp_TypeInfo_var;
extern const uint32_t GUISkin_CleanupRoots_m1306395062_MetadataUsageId;
extern const uint32_t GUISkin_set_font_m4009958323_MetadataUsageId;
extern const uint32_t GUISkin_get_error_m1687921970_MetadataUsageId;
extern Il2CppClass* Debug_t1368543263_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2300850132;
extern const uint32_t GUISkin_Apply_m3789936953_MetadataUsageId;
extern Il2CppClass* StringComparer_t1574862926_il2cpp_TypeInfo_var;
extern Il2CppClass* Dictionary_2_t3714688016_il2cpp_TypeInfo_var;
extern const MethodInfo* Dictionary_2__ctor_m2582671449_MethodInfo_var;
extern const MethodInfo* Dictionary_2_set_Item_m1398559205_MethodInfo_var;
extern Il2CppCodeGenString* _stringLiteral1502598545;
extern Il2CppCodeGenString* _stringLiteral1993738382;
extern Il2CppCodeGenString* _stringLiteral4217812034;
extern Il2CppCodeGenString* _stringLiteral2515770764;
extern Il2CppCodeGenString* _stringLiteral2523094542;
extern Il2CppCodeGenString* _stringLiteral2693452707;
extern Il2CppCodeGenString* _stringLiteral276680784;
extern Il2CppCodeGenString* _stringLiteral3942610267;
extern Il2CppCodeGenString* _stringLiteral4223230861;
extern Il2CppCodeGenString* _stringLiteral641410427;
extern Il2CppCodeGenString* _stringLiteral31520553;
extern Il2CppCodeGenString* _stringLiteral2511075584;
extern Il2CppCodeGenString* _stringLiteral1174722496;
extern Il2CppCodeGenString* _stringLiteral876328135;
extern Il2CppCodeGenString* _stringLiteral597299030;
extern Il2CppCodeGenString* _stringLiteral4042931670;
extern Il2CppCodeGenString* _stringLiteral2359823790;
extern Il2CppCodeGenString* _stringLiteral2304878361;
extern Il2CppCodeGenString* _stringLiteral530814794;
extern Il2CppCodeGenString* _stringLiteral3501965954;
extern const uint32_t GUISkin_BuildStyleCache_m3553586894_MetadataUsageId;
extern Il2CppClass* EventType_t3919834026_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral3073647763;
extern Il2CppCodeGenString* _stringLiteral2704271486;
extern Il2CppCodeGenString* _stringLiteral811305467;
extern const uint32_t GUISkin_GetStyle_m3594137272_MetadataUsageId;
extern const MethodInfo* Dictionary_2_TryGetValue_m595022037_MethodInfo_var;
extern Il2CppCodeGenString* _stringLiteral3853863397;
extern const uint32_t GUISkin_FindStyle_m4277712965_MetadataUsageId;
extern const uint32_t GUISkin_MakeCurrent_m126414424_MetadataUsageId;
extern Il2CppClass* Enumerator_t1106253484_il2cpp_TypeInfo_var;
extern const MethodInfo* Dictionary_2_get_Values_m2837248370_MethodInfo_var;
extern const MethodInfo* ValueCollection_GetEnumerator_m1549252400_MethodInfo_var;
extern const uint32_t GUISkin_GetEnumerator_m3501317101_MetadataUsageId;
struct GUIStyleState_t3801000545_marshaled_pinvoke;
struct GUIStyleState_t3801000545;;
struct GUIStyleState_t3801000545_marshaled_pinvoke;;
struct RectOffset_t3387826427_marshaled_pinvoke;
struct RectOffset_t3387826427;;
struct RectOffset_t3387826427_marshaled_pinvoke;;
struct GUIStyleState_t3801000545_marshaled_com;
struct GUIStyleState_t3801000545_marshaled_com;;
struct RectOffset_t3387826427_marshaled_com;
struct RectOffset_t3387826427_marshaled_com;;
extern const uint32_t GUIStyle_CleanupRoots_m1437637400_MetadataUsageId;
extern const uint32_t GUIStyle_get_border_m2676279601_MetadataUsageId;
extern const uint32_t GUIStyle_get_margin_m1012250163_MetadataUsageId;
extern const uint32_t GUIStyle_get_padding_m4076916754_MetadataUsageId;
extern const uint32_t GUIStyle_get_overflow_m1125058093_MetadataUsageId;
extern const uint32_t GUIStyle_get_lineHeight_m2132859383_MetadataUsageId;
extern Il2CppClass* Internal_DrawArguments_t2834709342_il2cpp_TypeInfo_var;
extern const uint32_t GUIStyle_Internal_Draw_m3610093213_MetadataUsageId;
extern const uint32_t GUIStyle_Draw_m4006459684_MetadataUsageId;
extern const uint32_t GUIStyle_Draw_m3134455812_MetadataUsageId;
extern const uint32_t GUIStyle_Draw_m3521010226_MetadataUsageId;
extern const uint32_t GUIStyle_Draw_m2284294803_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral3255618103;
extern const uint32_t GUIStyle_Draw_m1435796321_MetadataUsageId;
extern const uint32_t GUIStyle_DrawCursor_m3727336857_MetadataUsageId;
extern Il2CppClass* Internal_DrawWithTextSelectionArguments_t1327795077_il2cpp_TypeInfo_var;
extern const uint32_t GUIStyle_DrawWithTextSelection_m2215181902_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral763681067;
extern const uint32_t GUIStyle_op_Implicit_m781448948_MetadataUsageId;
extern const uint32_t GUIStyle_get_none_m4224270950_MetadataUsageId;
extern const uint32_t GUIStyle_GetCursorPixelPosition_m2488570694_MetadataUsageId;
extern const uint32_t GUIStyle_GetCursorStringIndex_m326283516_MetadataUsageId;
extern const uint32_t GUIStyle_GetNumCharactersThatFitWithinWidth_m3760066083_MetadataUsageId;
extern const uint32_t GUIStyle_CalcSize_m4254746879_MetadataUsageId;
extern const uint32_t GUIStyle_CalcSizeWithConstraints_m4117833199_MetadataUsageId;
extern const uint32_t GUIStyle_CalcScreenSize_m1349129130_MetadataUsageId;
extern const uint32_t GUIStyle_CalcHeight_m1685124037_MetadataUsageId;
extern const uint32_t GUIStyle_CalcMinMaxWidth_m2027503105_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral232734272;
extern const uint32_t GUIStyle_ToString_m3046670236_MetadataUsageId;
extern const uint32_t GUIStyle_GetStyleStatePtr_m1972527409_MetadataUsageId;
extern const uint32_t GUIStyle_GetRectOffsetPtr_m4223228888_MetadataUsageId;
extern const uint32_t GUIStyle_Internal_Draw2_m878252945_MetadataUsageId;
extern const uint32_t GUIStyle_SetMouseTooltip_m2239589192_MetadataUsageId;
extern const uint32_t GUIStyle_Internal_DrawPrefixLabel_m1693575069_MetadataUsageId;
extern const uint32_t GUIStyle_Internal_DrawCursor_m1394927592_MetadataUsageId;
extern const uint32_t GUIStyle_Internal_GetCursorPixelPosition_m823797035_MetadataUsageId;
extern const uint32_t GUIStyle_Internal_GetCursorStringIndex_m1491806746_MetadataUsageId;
extern const uint32_t GUIStyle_Internal_CalcSizeWithConstraints_m3375255978_MetadataUsageId;
extern const uint32_t GUIStyle__cctor_m1781956100_MetadataUsageId;
struct GUIStyle_t1799908754_marshaled_pinvoke;
struct GUIStyle_t1799908754;;
struct GUIStyle_t1799908754_marshaled_pinvoke;;
struct GUIStyle_t1799908754_marshaled_com;
struct GUIStyle_t1799908754_marshaled_com;;
extern Il2CppClass* GUIStyleState_t3801000545_il2cpp_TypeInfo_var;
extern const uint32_t GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976_MetadataUsageId;
extern const uint32_t GUIStyleState_GetGUIStyleState_m2816150617_MetadataUsageId;
extern const Il2CppType* GUITargetAttribute_t863467180_0_0_0_var;
extern Il2CppClass* Type_t_il2cpp_TypeInfo_var;
extern Il2CppClass* GUITargetAttribute_t863467180_il2cpp_TypeInfo_var;
extern const uint32_t GUITargetAttribute_GetGUITargetAttrValue_m3740620102_MetadataUsageId;
extern const uint32_t GUIUtility_get_pixelsPerPoint_m2667928361_MetadataUsageId;
extern const uint32_t GUIUtility_set_guiIsExiting_m2362636745_MetadataUsageId;
extern const uint32_t GUIUtility_get_hotControl_m466901769_MetadataUsageId;
extern const uint32_t GUIUtility_get_keyboardControl_m2418463643_MetadataUsageId;
extern const uint32_t GUIUtility_GetDefaultSkin_m2022075576_MetadataUsageId;
extern const uint32_t GUIUtility_BeginGUI_m2907220931_MetadataUsageId;
extern const uint32_t GUIUtility_EndGUI_m3538781391_MetadataUsageId;
extern const uint32_t GUIUtility_EndGUIFromException_m2091524531_MetadataUsageId;
extern const uint32_t GUIUtility_EndContainerGUIFromException_m8097082_MetadataUsageId;
extern Il2CppClass* TargetInvocationException_t4098620458_il2cpp_TypeInfo_var;
extern Il2CppClass* ExitGUIException_t1618397098_il2cpp_TypeInfo_var;
extern const uint32_t GUIUtility_ShouldRethrowException_m1990329277_MetadataUsageId;
extern Il2CppClass* ArgumentException_t3259014390_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral4248023613;
extern const uint32_t GUIUtility_CheckOnGUI_m4284398968_MetadataUsageId;
extern const uint32_t GUIUtility__cctor_m46116445_MetadataUsageId;
extern Il2CppClass* Input_t1785128008_il2cpp_TypeInfo_var;
extern const uint32_t Input_GetKeyDown_m1771960377_MetadataUsageId;
extern const uint32_t Input_GetKeyUp_m1008512962_MetadataUsageId;
extern const uint32_t Input_get_mousePosition_m146923508_MetadataUsageId;
extern const uint32_t Input_get_mouseScrollDelta_m3430638853_MetadataUsageId;
extern const uint32_t Input_GetTouch_m1463942798_MetadataUsageId;
extern const uint32_t Input_get_compositionCursorPos_m1262302043_MetadataUsageId;
extern const uint32_t Input_set_compositionCursorPos_m1615567306_MetadataUsageId;
extern const uint32_t Input__cctor_m829848544_MetadataUsageId;
extern Il2CppClass* DefaultValueAttribute_t1027170048_il2cpp_TypeInfo_var;
extern const uint32_t DefaultValueAttribute_Equals_m3216982933_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral1743625299;
extern const uint32_t Logger_GetString_m4086587133_MetadataUsageId;
extern Il2CppClass* ILogHandler_t264057413_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral104529068;
extern const uint32_t Logger_Log_m3587255568_MetadataUsageId;
extern const uint32_t Logger_Log_m4012064130_MetadataUsageId;
extern const uint32_t Logger_LogFormat_m193464629_MetadataUsageId;
extern const uint32_t Logger_LogException_m206035446_MetadataUsageId;
extern const uint32_t Material__ctor_m1440882780_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral4026354833;
extern const uint32_t Material_get_mainTexture_m432794412_MetadataUsageId;
extern const uint32_t Mathf_Lerp_m1686556575_MetadataUsageId;
extern const uint32_t Mathf_Approximately_m1064446634_MetadataUsageId;
extern const uint32_t Mathf_SmoothDamp_m1604773625_MetadataUsageId;
extern const uint32_t Mathf_Repeat_m943844734_MetadataUsageId;
extern const uint32_t Mathf_InverseLerp_m55890283_MetadataUsageId;
extern Il2CppClass* MathfInternal_t715669973_il2cpp_TypeInfo_var;
extern const uint32_t Mathf__cctor_m326403828_MetadataUsageId;
extern Il2CppClass* IndexOutOfRangeException_t3527622107_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral1338169977;
extern const uint32_t Matrix4x4_get_Item_m3317262185_MetadataUsageId;
extern Il2CppClass* Matrix4x4_t2933234003_il2cpp_TypeInfo_var;
extern Il2CppClass* Vector4_t2243707581_il2cpp_TypeInfo_var;
extern const uint32_t Matrix4x4_Equals_m1321236479_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral3991437666;
extern const uint32_t Matrix4x4_ToString_m1982554457_MetadataUsageId;
extern const uint32_t Mesh__ctor_m2975981674_MetadataUsageId;
extern const MethodInfo* Mesh_SafeLength_TisInt32_t2071877448_m2504367186_MethodInfo_var;
extern const uint32_t Mesh_SetTriangles_m2506325172_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral1489833396;
extern Il2CppCodeGenString* _stringLiteral1296238845;
extern const uint32_t Mesh_GetUVChannel_m364477864_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral1066778515;
extern Il2CppCodeGenString* _stringLiteral3637194755;
extern const uint32_t Mesh_DefaultDimensionForChannel_m153181993_MetadataUsageId;
extern const MethodInfo* Mesh_GetAllocArrayFromChannel_TisVector3_t2243707580_m2367580537_MethodInfo_var;
extern const uint32_t Mesh_get_vertices_m626989480_MetadataUsageId;
extern const uint32_t Mesh_get_normals_m1837187359_MetadataUsageId;
extern const MethodInfo* Mesh_GetAllocArrayFromChannel_TisVector4_t2243707581_m295947442_MethodInfo_var;
extern const uint32_t Mesh_get_tangents_m2910922714_MetadataUsageId;
extern const MethodInfo* Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716_MethodInfo_var;
extern const uint32_t Mesh_get_uv_m3811151337_MetadataUsageId;
extern const uint32_t Mesh_get_uv2_m3215494975_MetadataUsageId;
extern const uint32_t Mesh_get_uv3_m3215494880_MetadataUsageId;
extern const uint32_t Mesh_get_uv4_m3215494777_MetadataUsageId;
extern const MethodInfo* Mesh_GetAllocArrayFromChannel_TisColor32_t874517518_m2030100417_MethodInfo_var;
extern const uint32_t Mesh_get_colors32_m4153271224_MetadataUsageId;
extern const MethodInfo* Mesh_SetListForChannel_TisVector3_t2243707580_m2514561521_MethodInfo_var;
extern const uint32_t Mesh_SetVertices_m3500868388_MetadataUsageId;
extern const uint32_t Mesh_SetNormals_m3341225499_MetadataUsageId;
extern const MethodInfo* Mesh_SetListForChannel_TisVector4_t2243707581_m3238986708_MethodInfo_var;
extern const uint32_t Mesh_SetTangents_m282399504_MetadataUsageId;
extern const MethodInfo* Mesh_SetListForChannel_TisColor32_t874517518_m1056672865_MethodInfo_var;
extern const uint32_t Mesh_SetColors_m3438776703_MetadataUsageId;
extern const MethodInfo* Mesh_SetUvsImpl_TisVector2_t2243707579_m3939959910_MethodInfo_var;
extern const uint32_t Mesh_SetUVs_m841280343_MetadataUsageId;
extern Il2CppClass* Int32U5BU5D_t3030399641_il2cpp_TypeInfo_var;
extern const uint32_t Mesh_GetIndices_m3085881884_MetadataUsageId;
extern const uint32_t MonoBehaviour_print_m3437620292_MetadataUsageId;
extern Il2CppClass* PlayerEditorConnectionEvents_t2252784345_il2cpp_TypeInfo_var;
extern Il2CppClass* List_1_t1440998580_il2cpp_TypeInfo_var;
extern const MethodInfo* List_1__ctor_m1598946593_MethodInfo_var;
extern const uint32_t PlayerConnection__ctor_m956924263_MetadataUsageId;
extern Il2CppClass* PlayerConnection_t3517219175_il2cpp_TypeInfo_var;
extern const uint32_t PlayerConnection_get_instance_m3885313185_MetadataUsageId;
extern const MethodInfo* ScriptableObject_CreateInstance_TisPlayerConnection_t3517219175_m2823640524_MethodInfo_var;
extern const uint32_t PlayerConnection_CreateInstance_m2276347858_MetadataUsageId;
extern Il2CppClass* ByteU5BU5D_t3397334013_il2cpp_TypeInfo_var;
extern Il2CppClass* Marshal_t785896760_il2cpp_TypeInfo_var;
extern const uint32_t PlayerConnection_MessageCallbackInternal_m267902474_MetadataUsageId;
extern const MethodInfo* List_1_Add_m688682013_MethodInfo_var;
extern const MethodInfo* UnityEvent_1_Invoke_m1903741765_MethodInfo_var;
extern const uint32_t PlayerConnection_ConnectedCallbackInternal_m2685675347_MetadataUsageId;
extern const uint32_t PlayerConnection_DisconnectedCallback_m4115432464_MetadataUsageId;
extern Il2CppClass* List_1_t1660627182_il2cpp_TypeInfo_var;
extern Il2CppClass* ConnectionChangeEvent_t536719976_il2cpp_TypeInfo_var;
extern const MethodInfo* List_1__ctor_m1357675898_MethodInfo_var;
extern const uint32_t PlayerEditorConnectionEvents__ctor_m603950945_MetadataUsageId;
extern Il2CppClass* U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350_il2cpp_TypeInfo_var;
extern Il2CppClass* Func_2_t2919696197_il2cpp_TypeInfo_var;
extern Il2CppClass* Guid_t_il2cpp_TypeInfo_var;
extern Il2CppClass* MessageEventArgs_t301283622_il2cpp_TypeInfo_var;
extern Il2CppClass* IEnumerable_1_t2583633095_il2cpp_TypeInfo_var;
extern Il2CppClass* IEnumerator_1_t4061997173_il2cpp_TypeInfo_var;
extern Il2CppClass* IEnumerator_t1466026749_il2cpp_TypeInfo_var;
extern Il2CppClass* IDisposable_t2427283555_il2cpp_TypeInfo_var;
extern const MethodInfo* U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_U3CU3Em__0_m520813337_MethodInfo_var;
extern const MethodInfo* Func_2__ctor_m2608774846_MethodInfo_var;
extern const MethodInfo* Enumerable_Where_TisMessageTypeSubscribers_t2291506050_m887802803_MethodInfo_var;
extern const MethodInfo* Enumerable_Any_TisMessageTypeSubscribers_t2291506050_m3682874628_MethodInfo_var;
extern const MethodInfo* UnityEvent_1_Invoke_m354862256_MethodInfo_var;
extern Il2CppCodeGenString* _stringLiteral1281569593;
extern const uint32_t PlayerEditorConnectionEvents_InvokeMessageIdSubscribers_m3217020342_MetadataUsageId;
extern const uint32_t U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_U3CU3Em__0_m520813337_MetadataUsageId;
extern const MethodInfo* UnityEvent_1__ctor_m2948712401_MethodInfo_var;
extern const uint32_t ConnectionChangeEvent__ctor_m616483304_MetadataUsageId;
extern const MethodInfo* UnityEvent_1__ctor_m3765336006_MethodInfo_var;
extern const uint32_t MessageEvent__ctor_m3253032545_MetadataUsageId;
extern Il2CppClass* MessageEvent_t2167079021_il2cpp_TypeInfo_var;
extern const uint32_t MessageTypeSubscribers__ctor_m743474932_MetadataUsageId;
extern const uint32_t Object_Internal_InstantiateSingle_m2776302597_MetadataUsageId;
extern const uint32_t Object_Internal_InstantiateSingleWithParent_m509082884_MetadataUsageId;
extern const uint32_t Object_Destroy_m4145850038_MetadataUsageId;
extern const uint32_t Object_DestroyImmediate_m95027445_MetadataUsageId;
extern const uint32_t Object_DestroyObject_m2343493981_MetadataUsageId;
extern Il2CppClass* IntPtr_t_il2cpp_TypeInfo_var;
extern const uint32_t Object_GetInstanceID_m1920497914_MetadataUsageId;
extern const uint32_t Object_Equals_m4029628913_MetadataUsageId;
extern const uint32_t Object_op_Implicit_m2856731593_MetadataUsageId;
extern const uint32_t Object_CompareBaseObjects_m3953996214_MetadataUsageId;
extern const uint32_t Object_IsNativeObjectAlive_m4056217615_MetadataUsageId;
extern Il2CppClass* ScriptableObject_t1975622470_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral444318565;
extern Il2CppCodeGenString* _stringLiteral1912870611;
extern const uint32_t Object_Instantiate_m938141395_MetadataUsageId;
extern const uint32_t Object_Instantiate_m2160322936_MetadataUsageId;
extern const uint32_t Object_Instantiate_m2439155489_MetadataUsageId;
extern const uint32_t Object_Instantiate_m2177117080_MetadataUsageId;
extern const uint32_t Object_Instantiate_m2489341053_MetadataUsageId;
extern const uint32_t Object_CheckNullArgument_m1711119106_MetadataUsageId;
extern const uint32_t Object_FindObjectOfType_m2330404063_MetadataUsageId;
extern const uint32_t Object_op_Equality_m3764089466_MetadataUsageId;
extern const uint32_t Object_op_Inequality_m2402264703_MetadataUsageId;
extern const uint32_t Object__cctor_m2991092887_MetadataUsageId;
extern Il2CppClass* Physics2D_t2540166467_il2cpp_TypeInfo_var;
extern const uint32_t Physics2D_Raycast_m1220041042_MetadataUsageId;
extern const uint32_t Physics2D_Raycast_m122312471_MetadataUsageId;
extern const uint32_t Physics2D_Raycast_m3913913442_MetadataUsageId;
extern const uint32_t Physics2D_Raycast_m2560154475_MetadataUsageId;
extern const uint32_t Physics2D_Raycast_m2303387255_MetadataUsageId;
extern const uint32_t Physics2D_Raycast_m2368200185_MetadataUsageId;
extern const uint32_t Physics2D_Raycast_m564567838_MetadataUsageId;
extern const uint32_t Physics2D_Internal_Raycast_m2213595168_MetadataUsageId;
extern const uint32_t Physics2D_Internal_RaycastNonAlloc_m1874107548_MetadataUsageId;
extern const uint32_t Physics2D_GetRayIntersectionAll_m253330691_MetadataUsageId;
extern const uint32_t Physics2D_GetRayIntersectionAll_m2808325432_MetadataUsageId;
extern const uint32_t Physics2D_GetRayIntersectionAll_m120415839_MetadataUsageId;
extern Il2CppClass* List_1_t4166282325_il2cpp_TypeInfo_var;
extern const MethodInfo* List_1__ctor_m2338710192_MethodInfo_var;
extern const uint32_t Physics2D__cctor_m3532647019_MetadataUsageId;
extern const uint32_t Plane_Raycast_m2870142810_MetadataUsageId;
extern Il2CppClass* Quaternion_t4030073918_il2cpp_TypeInfo_var;
extern const uint32_t Quaternion_Equals_m3730391696_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral3587482509;
extern const uint32_t Quaternion_ToString_m2638853272_MetadataUsageId;
extern Il2CppClass* Vector3_t2243707580_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral1807026812;
extern const uint32_t Ray_ToString_m2019179238_MetadataUsageId;
extern Il2CppClass* Rect_t3681755626_il2cpp_TypeInfo_var;
extern const uint32_t Rect_Equals_m3806390726_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral1853817013;
extern const uint32_t Rect_ToString_m2728794442_MetadataUsageId;
extern Il2CppClass* Il2CppComObject_il2cpp_TypeInfo_var;
extern const uint32_t RectOffset_t3387826427_pinvoke_FromNativeMethodDefinition_MetadataUsageId;
extern const uint32_t RectOffset_t3387826427_com_FromNativeMethodDefinition_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral3899275604;
extern const uint32_t RectOffset_ToString_m1281517011_MetadataUsageId;
extern Il2CppClass* RectTransform_t3349966182_il2cpp_TypeInfo_var;
extern Il2CppClass* ReapplyDrivenProperties_t2020713228_il2cpp_TypeInfo_var;
extern const uint32_t RectTransform_add_reapplyDrivenProperties_m1603911943_MetadataUsageId;
extern const uint32_t RectTransform_remove_reapplyDrivenProperties_m4209881182_MetadataUsageId;
extern const uint32_t RectTransform_SendReapplyDrivenProperties_m90487700_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral895140023;
extern const uint32_t RectTransform_GetLocalCorners_m1836626405_MetadataUsageId;
extern Il2CppCodeGenString* _stringLiteral3518247078;
extern const uint32_t RectTransform_GetWorldCorners_m3873546362_MetadataUsageId;
extern const uint32_t RectTransform_GetParentSize_m1571597933_MetadataUsageId;
extern Il2CppClass* RectTransformUtility_t2941082270_il2cpp_TypeInfo_var;
extern const uint32_t RectTransformUtility_ScreenPointToWorldPointInRectangle_m2304638810_MetadataUsageId;
extern const uint32_t RectTransformUtility_ScreenPointToLocalPointInRectangle_m2398565080_MetadataUsageId;
extern const uint32_t RectTransformUtility_ScreenPointToRay_m1842507230_MetadataUsageId;
extern const uint32_t RectTransformUtility_FlipLayoutOnAxis_m3920364518_MetadataUsageId;
extern const uint32_t RectTransformUtility_FlipLayoutAxes_m532748168_MetadataUsageId;
extern const uint32_t RectTransformUtility_RectangleContainsScreenPoint_m1244853728_MetadataUsageId;
extern const uint32_t RectTransformUtility_PixelAdjustPoint_m560908615_MetadataUsageId;
extern const uint32_t RectTransformUtility_PixelAdjustRect_m93024038_MetadataUsageId;
extern Il2CppClass* Vector3U5BU5D_t1172311765_il2cpp_TypeInfo_var;
extern const uint32_t RectTransformUtility__cctor_m1866023382_MetadataUsageId;
extern Il2CppClass* RemoteSettings_t392466225_il2cpp_TypeInfo_var;
extern const uint32_t RemoteSettings_CallOnUpdate_m1624968574_MetadataUsageId;
extern Il2CppClass* Scene_t1684909666_il2cpp_TypeInfo_var;
extern const uint32_t Scene_Equals_m3588907349_MetadataUsageId;
extern Il2CppClass* SceneManager_t90660965_il2cpp_TypeInfo_var;
extern const MethodInfo* UnityAction_2_Invoke_m1528820797_MethodInfo_var;
extern const uint32_t SceneManager_Internal_SceneLoaded_m4005732915_MetadataUsageId;
extern const MethodInfo* UnityAction_1_Invoke_m3061904506_MethodInfo_var;
extern const uint32_t SceneManager_Internal_SceneUnloaded_m4108957131_MetadataUsageId;
extern const MethodInfo* UnityAction_2_Invoke_m670567184_MethodInfo_var;
extern const uint32_t SceneManager_Internal_ActiveSceneChanged_m1162592635_MetadataUsageId;
// UnityEngine.Camera[]
struct CameraU5BU5D_t3079764780 : public Il2CppArray
{
public:
ALIGN_FIELD (8) Camera_t189460977 * m_Items[1];
public:
inline Camera_t189460977 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Camera_t189460977 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Camera_t189460977 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
inline Camera_t189460977 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Camera_t189460977 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Camera_t189460977 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
};
// System.Type[]
struct TypeU5BU5D_t1664964607 : public Il2CppArray
{
public:
ALIGN_FIELD (8) Type_t * m_Items[1];
public:
inline Type_t * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Type_t ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Type_t * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
inline Type_t * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Type_t ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Type_t * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
};
// UnityEngine.Component[]
struct ComponentU5BU5D_t4136971630 : public Il2CppArray
{
public:
ALIGN_FIELD (8) Component_t3819376471 * m_Items[1];
public:
inline Component_t3819376471 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Component_t3819376471 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Component_t3819376471 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
inline Component_t3819376471 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Component_t3819376471 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Component_t3819376471 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
};
// UnityEngine.GUILayoutOption[]
struct GUILayoutOptionU5BU5D_t2108882777 : public Il2CppArray
{
public:
ALIGN_FIELD (8) GUILayoutOption_t4183744904 * m_Items[1];
public:
inline GUILayoutOption_t4183744904 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline GUILayoutOption_t4183744904 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, GUILayoutOption_t4183744904 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
inline GUILayoutOption_t4183744904 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline GUILayoutOption_t4183744904 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, GUILayoutOption_t4183744904 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
};
// System.Object[]
struct ObjectU5BU5D_t3614634134 : public Il2CppArray
{
public:
ALIGN_FIELD (8) Il2CppObject * m_Items[1];
public:
inline Il2CppObject * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Il2CppObject ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Il2CppObject * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
inline Il2CppObject * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Il2CppObject ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Il2CppObject * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
};
// UnityEngine.GUIStyle[]
struct GUIStyleU5BU5D_t2497716199 : public Il2CppArray
{
public:
ALIGN_FIELD (8) GUIStyle_t1799908754 * m_Items[1];
public:
inline GUIStyle_t1799908754 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline GUIStyle_t1799908754 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, GUIStyle_t1799908754 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
inline GUIStyle_t1799908754 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline GUIStyle_t1799908754 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, GUIStyle_t1799908754 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
};
// System.Int32[]
struct Int32U5BU5D_t3030399641 : public Il2CppArray
{
public:
ALIGN_FIELD (8) int32_t m_Items[1];
public:
inline int32_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline int32_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, int32_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline int32_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline int32_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, int32_t value)
{
m_Items[index] = value;
}
};
// UnityEngine.Vector3[]
struct Vector3U5BU5D_t1172311765 : public Il2CppArray
{
public:
ALIGN_FIELD (8) Vector3_t2243707580 m_Items[1];
public:
inline Vector3_t2243707580 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Vector3_t2243707580 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Vector3_t2243707580 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline Vector3_t2243707580 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Vector3_t2243707580 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Vector3_t2243707580 value)
{
m_Items[index] = value;
}
};
// UnityEngine.Vector4[]
struct Vector4U5BU5D_t1658499504 : public Il2CppArray
{
public:
ALIGN_FIELD (8) Vector4_t2243707581 m_Items[1];
public:
inline Vector4_t2243707581 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Vector4_t2243707581 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Vector4_t2243707581 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline Vector4_t2243707581 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Vector4_t2243707581 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Vector4_t2243707581 value)
{
m_Items[index] = value;
}
};
// UnityEngine.Vector2[]
struct Vector2U5BU5D_t686124026 : public Il2CppArray
{
public:
ALIGN_FIELD (8) Vector2_t2243707579 m_Items[1];
public:
inline Vector2_t2243707579 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Vector2_t2243707579 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Vector2_t2243707579 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline Vector2_t2243707579 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Vector2_t2243707579 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Vector2_t2243707579 value)
{
m_Items[index] = value;
}
};
// UnityEngine.Color32[]
struct Color32U5BU5D_t30278651 : public Il2CppArray
{
public:
ALIGN_FIELD (8) Color32_t874517518 m_Items[1];
public:
inline Color32_t874517518 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Color32_t874517518 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Color32_t874517518 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline Color32_t874517518 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Color32_t874517518 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Color32_t874517518 value)
{
m_Items[index] = value;
}
};
// System.Byte[]
struct ByteU5BU5D_t3397334013 : public Il2CppArray
{
public:
ALIGN_FIELD (8) uint8_t m_Items[1];
public:
inline uint8_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline uint8_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, uint8_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline uint8_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline uint8_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, uint8_t value)
{
m_Items[index] = value;
}
};
// UnityEngine.Object[]
struct ObjectU5BU5D_t4217747464 : public Il2CppArray
{
public:
ALIGN_FIELD (8) Object_t1021602117 * m_Items[1];
public:
inline Object_t1021602117 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Object_t1021602117 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Object_t1021602117 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
inline Object_t1021602117 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Object_t1021602117 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Object_t1021602117 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
};
// UnityEngine.RaycastHit2D[]
struct RaycastHit2DU5BU5D_t4176517891 : public Il2CppArray
{
public:
ALIGN_FIELD (8) RaycastHit2D_t4063908774 m_Items[1];
public:
inline RaycastHit2D_t4063908774 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline RaycastHit2D_t4063908774 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, RaycastHit2D_t4063908774 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline RaycastHit2D_t4063908774 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline RaycastHit2D_t4063908774 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, RaycastHit2D_t4063908774 value)
{
m_Items[index] = value;
}
};
extern "C" void GUIStyleState_t3801000545_marshal_pinvoke(const GUIStyleState_t3801000545& unmarshaled, GUIStyleState_t3801000545_marshaled_pinvoke& marshaled);
extern "C" void GUIStyleState_t3801000545_marshal_pinvoke_back(const GUIStyleState_t3801000545_marshaled_pinvoke& marshaled, GUIStyleState_t3801000545& unmarshaled);
extern "C" void GUIStyleState_t3801000545_marshal_pinvoke_cleanup(GUIStyleState_t3801000545_marshaled_pinvoke& marshaled);
extern "C" void RectOffset_t3387826427_marshal_pinvoke(const RectOffset_t3387826427& unmarshaled, RectOffset_t3387826427_marshaled_pinvoke& marshaled);
extern "C" void RectOffset_t3387826427_marshal_pinvoke_back(const RectOffset_t3387826427_marshaled_pinvoke& marshaled, RectOffset_t3387826427& unmarshaled);
extern "C" void RectOffset_t3387826427_marshal_pinvoke_cleanup(RectOffset_t3387826427_marshaled_pinvoke& marshaled);
extern "C" void GUIStyleState_t3801000545_marshal_com(const GUIStyleState_t3801000545& unmarshaled, GUIStyleState_t3801000545_marshaled_com& marshaled);
extern "C" void GUIStyleState_t3801000545_marshal_com_back(const GUIStyleState_t3801000545_marshaled_com& marshaled, GUIStyleState_t3801000545& unmarshaled);
extern "C" void GUIStyleState_t3801000545_marshal_com_cleanup(GUIStyleState_t3801000545_marshaled_com& marshaled);
extern "C" void RectOffset_t3387826427_marshal_com(const RectOffset_t3387826427& unmarshaled, RectOffset_t3387826427_marshaled_com& marshaled);
extern "C" void RectOffset_t3387826427_marshal_com_back(const RectOffset_t3387826427_marshaled_com& marshaled, RectOffset_t3387826427& unmarshaled);
extern "C" void RectOffset_t3387826427_marshal_com_cleanup(RectOffset_t3387826427_marshaled_com& marshaled);
extern "C" void GUIStyle_t1799908754_marshal_pinvoke(const GUIStyle_t1799908754& unmarshaled, GUIStyle_t1799908754_marshaled_pinvoke& marshaled);
extern "C" void GUIStyle_t1799908754_marshal_pinvoke_back(const GUIStyle_t1799908754_marshaled_pinvoke& marshaled, GUIStyle_t1799908754& unmarshaled);
extern "C" void GUIStyle_t1799908754_marshal_pinvoke_cleanup(GUIStyle_t1799908754_marshaled_pinvoke& marshaled);
extern "C" void GUIStyle_t1799908754_marshal_com(const GUIStyle_t1799908754& unmarshaled, GUIStyle_t1799908754_marshaled_com& marshaled);
extern "C" void GUIStyle_t1799908754_marshal_com_back(const GUIStyle_t1799908754_marshaled_com& marshaled, GUIStyle_t1799908754& unmarshaled);
extern "C" void GUIStyle_t1799908754_marshal_com_cleanup(GUIStyle_t1799908754_marshaled_com& marshaled);
// System.Void System.Action`1<System.Object>::Invoke(!0)
extern "C" void Action_1_Invoke_m4180501989_gshared (Action_1_t2491248677 * __this, Il2CppObject * p0, const MethodInfo* method);
// System.Void System.Collections.Generic.List`1<System.Object>::.ctor()
extern "C" void List_1__ctor_m310736118_gshared (List_1_t2058570427 * __this, const MethodInfo* method);
// System.Int32 System.Collections.Generic.List`1<System.Object>::get_Count()
extern "C" int32_t List_1_get_Count_m2375293942_gshared (List_1_t2058570427 * __this, const MethodInfo* method);
// System.Collections.Generic.List`1/Enumerator<!0> System.Collections.Generic.List`1<System.Object>::GetEnumerator()
extern "C" Enumerator_t1593300101 List_1_GetEnumerator_m2837081829_gshared (List_1_t2058570427 * __this, const MethodInfo* method);
// !0 System.Collections.Generic.List`1/Enumerator<System.Object>::get_Current()
extern "C" Il2CppObject * Enumerator_get_Current_m2577424081_gshared (Enumerator_t1593300101 * __this, const MethodInfo* method);
// System.Boolean System.Collections.Generic.List`1/Enumerator<System.Object>::MoveNext()
extern "C" bool Enumerator_MoveNext_m44995089_gshared (Enumerator_t1593300101 * __this, const MethodInfo* method);
// System.Void System.Collections.Generic.List`1/Enumerator<System.Object>::Dispose()
extern "C" void Enumerator_Dispose_m3736175406_gshared (Enumerator_t1593300101 * __this, const MethodInfo* method);
// !0 System.Collections.Generic.List`1<System.Object>::get_Item(System.Int32)
extern "C" Il2CppObject * List_1_get_Item_m2062981835_gshared (List_1_t2058570427 * __this, int32_t p0, const MethodInfo* method);
// System.Boolean System.Collections.Generic.Dictionary`2<System.Int32,System.Object>::TryGetValue(!0,!1&)
extern "C" bool Dictionary_2_TryGetValue_m2140744741_gshared (Dictionary_2_t1697274930 * __this, int32_t p0, Il2CppObject ** p1, const MethodInfo* method);
// System.Void System.Collections.Generic.Dictionary`2<System.Int32,System.Object>::set_Item(!0,!1)
extern "C" void Dictionary_2_set_Item_m3180425769_gshared (Dictionary_2_t1697274930 * __this, int32_t p0, Il2CppObject * p1, const MethodInfo* method);
// System.Void System.Collections.Generic.Dictionary`2<System.Int32,System.Object>::.ctor()
extern "C" void Dictionary_2__ctor_m1868603968_gshared (Dictionary_2_t1697274930 * __this, const MethodInfo* method);
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::.ctor(System.Collections.Generic.IEqualityComparer`1<!0>)
extern "C" void Dictionary_2__ctor_m2849528578_gshared (Dictionary_2_t2281509423 * __this, Il2CppObject* p0, const MethodInfo* method);
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::set_Item(!0,!1)
extern "C" void Dictionary_2_set_Item_m1004257024_gshared (Dictionary_2_t2281509423 * __this, Il2CppObject * p0, Il2CppObject * p1, const MethodInfo* method);
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::TryGetValue(!0,!1&)
extern "C" bool Dictionary_2_TryGetValue_m3975825838_gshared (Dictionary_2_t2281509423 * __this, Il2CppObject * p0, Il2CppObject ** p1, const MethodInfo* method);
// System.Collections.Generic.Dictionary`2/ValueCollection<!0,!1> System.Collections.Generic.Dictionary`2<System.Object,System.Object>::get_Values()
extern "C" ValueCollection_t984569266 * Dictionary_2_get_Values_m2233445381_gshared (Dictionary_2_t2281509423 * __this, const MethodInfo* method);
// System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<!0,!1> System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::GetEnumerator()
extern "C" Enumerator_t3968042187 ValueCollection_GetEnumerator_m379930731_gshared (ValueCollection_t984569266 * __this, const MethodInfo* method);
// System.Int32 UnityEngine.Mesh::SafeLength<System.Int32>(System.Collections.Generic.List`1<T>)
extern "C" int32_t Mesh_SafeLength_TisInt32_t2071877448_m2504367186_gshared (Mesh_t1356156583 * __this, List_1_t1440998580 * ___values0, const MethodInfo* method);
// T[] UnityEngine.Mesh::GetAllocArrayFromChannel<UnityEngine.Vector3>(UnityEngine.Mesh/InternalShaderChannel)
extern "C" Vector3U5BU5D_t1172311765* Mesh_GetAllocArrayFromChannel_TisVector3_t2243707580_m2367580537_gshared (Mesh_t1356156583 * __this, int32_t ___channel0, const MethodInfo* method);
// T[] UnityEngine.Mesh::GetAllocArrayFromChannel<UnityEngine.Vector4>(UnityEngine.Mesh/InternalShaderChannel)
extern "C" Vector4U5BU5D_t1658499504* Mesh_GetAllocArrayFromChannel_TisVector4_t2243707581_m295947442_gshared (Mesh_t1356156583 * __this, int32_t ___channel0, const MethodInfo* method);
// T[] UnityEngine.Mesh::GetAllocArrayFromChannel<UnityEngine.Vector2>(UnityEngine.Mesh/InternalShaderChannel)
extern "C" Vector2U5BU5D_t686124026* Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716_gshared (Mesh_t1356156583 * __this, int32_t ___channel0, const MethodInfo* method);
// T[] UnityEngine.Mesh::GetAllocArrayFromChannel<UnityEngine.Color32>(UnityEngine.Mesh/InternalShaderChannel,UnityEngine.Mesh/InternalVertexChannelType,System.Int32)
extern "C" Color32U5BU5D_t30278651* Mesh_GetAllocArrayFromChannel_TisColor32_t874517518_m2030100417_gshared (Mesh_t1356156583 * __this, int32_t ___channel0, int32_t ___format1, int32_t ___dim2, const MethodInfo* method);
// System.Void UnityEngine.Mesh::SetListForChannel<UnityEngine.Vector3>(UnityEngine.Mesh/InternalShaderChannel,System.Collections.Generic.List`1<T>)
extern "C" void Mesh_SetListForChannel_TisVector3_t2243707580_m2514561521_gshared (Mesh_t1356156583 * __this, int32_t ___channel0, List_1_t1612828712 * ___values1, const MethodInfo* method);
// System.Void UnityEngine.Mesh::SetListForChannel<UnityEngine.Vector4>(UnityEngine.Mesh/InternalShaderChannel,System.Collections.Generic.List`1<T>)
extern "C" void Mesh_SetListForChannel_TisVector4_t2243707581_m3238986708_gshared (Mesh_t1356156583 * __this, int32_t ___channel0, List_1_t1612828713 * ___values1, const MethodInfo* method);
// System.Void UnityEngine.Mesh::SetListForChannel<UnityEngine.Color32>(UnityEngine.Mesh/InternalShaderChannel,UnityEngine.Mesh/InternalVertexChannelType,System.Int32,System.Collections.Generic.List`1<T>)
extern "C" void Mesh_SetListForChannel_TisColor32_t874517518_m1056672865_gshared (Mesh_t1356156583 * __this, int32_t ___channel0, int32_t ___format1, int32_t ___dim2, List_1_t243638650 * ___values3, const MethodInfo* method);
// System.Void UnityEngine.Mesh::SetUvsImpl<UnityEngine.Vector2>(System.Int32,System.Int32,System.Collections.Generic.List`1<T>)
extern "C" void Mesh_SetUvsImpl_TisVector2_t2243707579_m3939959910_gshared (Mesh_t1356156583 * __this, int32_t ___uvIndex0, int32_t ___dim1, List_1_t1612828711 * ___uvs2, const MethodInfo* method);
// System.Void System.Collections.Generic.List`1<System.Int32>::.ctor()
extern "C" void List_1__ctor_m1598946593_gshared (List_1_t1440998580 * __this, const MethodInfo* method);
// T UnityEngine.ScriptableObject::CreateInstance<System.Object>()
extern "C" Il2CppObject * ScriptableObject_CreateInstance_TisIl2CppObject_m926060499_gshared (Il2CppObject * __this /* static, unused */, const MethodInfo* method);
// System.Void System.Collections.Generic.List`1<System.Int32>::Add(!0)
extern "C" void List_1_Add_m688682013_gshared (List_1_t1440998580 * __this, int32_t p0, const MethodInfo* method);
// System.Void UnityEngine.Events.UnityEvent`1<System.Int32>::Invoke(T0)
extern "C" void UnityEvent_1_Invoke_m1903741765_gshared (UnityEvent_1_t2110227463 * __this, int32_t p0, const MethodInfo* method);
// System.Void System.Func`2<System.Object,System.Boolean>::.ctor(System.Object,System.IntPtr)
extern "C" void Func_2__ctor_m1354888807_gshared (Func_2_t3961629604 * __this, Il2CppObject * p0, IntPtr_t p1, const MethodInfo* method);
// System.Collections.Generic.IEnumerable`1<!!0> System.Linq.Enumerable::Where<System.Object>(System.Collections.Generic.IEnumerable`1<!!0>,System.Func`2<!!0,System.Boolean>)
extern "C" Il2CppObject* Enumerable_Where_TisIl2CppObject_m1516493223_gshared (Il2CppObject * __this /* static, unused */, Il2CppObject* p0, Func_2_t3961629604 * p1, const MethodInfo* method);
// System.Boolean System.Linq.Enumerable::Any<System.Object>(System.Collections.Generic.IEnumerable`1<!!0>)
extern "C" bool Enumerable_Any_TisIl2CppObject_m2208185096_gshared (Il2CppObject * __this /* static, unused */, Il2CppObject* p0, const MethodInfo* method);
// System.Void UnityEngine.Events.UnityEvent`1<System.Object>::Invoke(T0)
extern "C" void UnityEvent_1_Invoke_m838874366_gshared (UnityEvent_1_t2727799310 * __this, Il2CppObject * p0, const MethodInfo* method);
// System.Void UnityEngine.Events.UnityEvent`1<System.Int32>::.ctor()
extern "C" void UnityEvent_1__ctor_m2948712401_gshared (UnityEvent_1_t2110227463 * __this, const MethodInfo* method);
// System.Void UnityEngine.Events.UnityEvent`1<System.Object>::.ctor()
extern "C" void UnityEvent_1__ctor_m2073978020_gshared (UnityEvent_1_t2727799310 * __this, const MethodInfo* method);
// System.Void UnityEngine.Events.UnityAction`2<UnityEngine.SceneManagement.Scene,UnityEngine.SceneManagement.LoadSceneMode>::Invoke(T0,T1)
extern "C" void UnityAction_2_Invoke_m1528820797_gshared (UnityAction_2_t1903595547 * __this, Scene_t1684909666 p0, int32_t p1, const MethodInfo* method);
// System.Void UnityEngine.Events.UnityAction`1<UnityEngine.SceneManagement.Scene>::Invoke(T0)
extern "C" void UnityAction_1_Invoke_m3061904506_gshared (UnityAction_1_t3051495417 * __this, Scene_t1684909666 p0, const MethodInfo* method);
// System.Void UnityEngine.Events.UnityAction`2<UnityEngine.SceneManagement.Scene,UnityEngine.SceneManagement.Scene>::Invoke(T0,T1)
extern "C" void UnityAction_2_Invoke_m670567184_gshared (UnityAction_2_t606618774 * __this, Scene_t1684909666 p0, Scene_t1684909666 p1, const MethodInfo* method);
// System.Void UnityEngine.Experimental.Director.Playable::.ctor()
extern "C" void Playable__ctor_m334077411 (Playable_t3667545548 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Experimental.Rendering.RenderPipelineManager::set_currentPipeline(UnityEngine.Experimental.Rendering.IRenderPipeline)
extern "C" void RenderPipelineManager_set_currentPipeline_m3825706412 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Experimental.Rendering.RenderPipelineManager::PrepareRenderPipeline(UnityEngine.Experimental.Rendering.IRenderPipelineAsset)
extern "C" bool RenderPipelineManager_PrepareRenderPipeline_m4209257657 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___pipe0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Experimental.Rendering.ScriptableRenderContext::Initialize(System.IntPtr)
extern "C" void ScriptableRenderContext_Initialize_m1349011973 (ScriptableRenderContext_t4271526 * __this, IntPtr_t ___ptr0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Experimental.Rendering.IRenderPipeline UnityEngine.Experimental.Rendering.RenderPipelineManager::get_currentPipeline()
extern "C" Il2CppObject * RenderPipelineManager_get_currentPipeline_m679160301 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Experimental.Rendering.RenderPipelineManager::CleanupRenderPipeline()
extern "C" void RenderPipelineManager_CleanupRenderPipeline_m2242901458 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Delegate System.Delegate::Combine(System.Delegate,System.Delegate)
extern "C" Delegate_t3022476291 * Delegate_Combine_m3791207084 (Il2CppObject * __this /* static, unused */, Delegate_t3022476291 * p0, Delegate_t3022476291 * p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Delegate System.Delegate::Remove(System.Delegate,System.Delegate)
extern "C" Delegate_t3022476291 * Delegate_Remove_m2626518725 (Il2CppObject * __this /* static, unused */, Delegate_t3022476291 * p0, Delegate_t3022476291 * p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Action`1<UnityEngine.Font>::Invoke(!0)
#define Action_1_Invoke_m1059548733(__this, p0, method) (( void (*) (Action_1_t4041298073 *, Font_t4239498691 *, const MethodInfo*))Action_1_Invoke_m4180501989_gshared)(__this, p0, method)
// System.Void UnityEngine.Font/FontTextureRebuildCallback::Invoke()
extern "C" void FontTextureRebuildCallback_Invoke_m3940800729 (FontTextureRebuildCallback_t1272078033 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Object::.ctor()
extern "C" void Object__ctor_m197157284 (Object_t1021602117 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GameObject::Internal_CreateGameObject(UnityEngine.GameObject,System.String)
extern "C" void GameObject_Internal_CreateGameObject_m3428198595 (Il2CppObject * __this /* static, unused */, GameObject_t1756533147 * ___mono0, String_t* ___name1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Component UnityEngine.GameObject::AddComponent(System.Type)
extern "C" Component_t3819376471 * GameObject_AddComponent_m3757565614 (GameObject_t1756533147 * __this, Type_t * ___componentType0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Array UnityEngine.GameObject::GetComponentsInternal(System.Type,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Object)
extern "C" Il2CppArray * GameObject_GetComponentsInternal_m3486524399 (GameObject_t1756533147 * __this, Type_t * ___type0, bool ___useSearchTypeAsArrayReturnType1, bool ___recursive2, bool ___includeInactive3, bool ___reverse4, Il2CppObject * ___resultList5, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Component UnityEngine.GameObject::Internal_AddComponentWithType(System.Type)
extern "C" Component_t3819376471 * GameObject_Internal_AddComponentWithType_m214735204 (GameObject_t1756533147 * __this, Type_t * ___componentType0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Object::.ctor()
extern "C" void Object__ctor_m2551263788 (Il2CppObject * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Gradient::Init()
extern "C" void Gradient_Init_m4156899649 (Gradient_t3600583008 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Gradient::Cleanup()
extern "C" void Gradient_Cleanup_m3573871739 (Gradient_t3600583008 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Object::Finalize()
extern "C" void Object_Finalize_m4087144328 (Il2CppObject * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngineInternal.GenericStack::.ctor()
extern "C" void GenericStack__ctor_m1256224477 (GenericStack_t3718539591 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.DateTime System.DateTime::get_Now()
extern "C" DateTime_t693205669 DateTime_get_Now_m24136300 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUI::set_nextScrollStepTime(System.DateTime)
extern "C" void GUI_set_nextScrollStepTime_m2724006954 (Il2CppObject * __this /* static, unused */, DateTime_t693205669 ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIUtility::CheckOnGUI()
extern "C" void GUIUtility_CheckOnGUI_m4284398968 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUI::DoSetSkin(UnityEngine.GUISkin)
extern "C" void GUI_DoSetSkin_m3603287387 (Il2CppObject * __this /* static, unused */, GUISkin_t1436893342 * ___newSkin0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Object::op_Implicit(UnityEngine.Object)
extern "C" bool Object_op_Implicit_m2856731593 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___exists0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUISkin UnityEngine.GUIUtility::GetDefaultSkin()
extern "C" GUISkin_t1436893342 * GUIUtility_GetDefaultSkin_m2022075576 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUISkin::MakeCurrent()
extern "C" void GUISkin_MakeCurrent_m126414424 (GUISkin_t1436893342 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUILayoutUtility/LayoutCache UnityEngine.GUILayoutUtility::SelectIDList(System.Int32,System.Boolean)
extern "C" LayoutCache_t3120781045 * GUILayoutUtility_SelectIDList_m756828237 (Il2CppObject * __this /* static, unused */, int32_t ___instanceID0, bool ___isWindow1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUISkin UnityEngine.GUI::get_skin()
extern "C" GUISkin_t1436893342 * GUI_get_skin_m2309570990 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Event UnityEngine.Event::get_current()
extern "C" Event_t3028476042 * Event_get_current_m2901774193 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.EventType UnityEngine.Event::get_type()
extern "C" int32_t Event_get_type_m2426033198 (Event_t3028476042 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUILayoutOption UnityEngine.GUILayout::Width(System.Single)
extern "C" GUILayoutOption_t4183744904 * GUILayout_Width_m261136689 (Il2CppObject * __this /* static, unused */, float ___width0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUILayoutOption UnityEngine.GUILayout::Height(System.Single)
extern "C" GUILayoutOption_t4183744904 * GUILayout_Height_m607115982 (Il2CppObject * __this /* static, unused */, float ___height0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutUtility::BeginWindow(System.Int32,UnityEngine.GUIStyle,UnityEngine.GUILayoutOption[])
extern "C" void GUILayoutUtility_BeginWindow_m488834212 (Il2CppObject * __this /* static, unused */, int32_t ___windowID0, GUIStyle_t1799908754 * ___style1, GUILayoutOptionU5BU5D_t2108882777* ___options2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIStyle UnityEngine.GUIStyle::get_none()
extern "C" GUIStyle_t1799908754 * GUIStyle_get_none_m4224270950 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUI::set_skin(UnityEngine.GUISkin)
extern "C" void GUI_set_skin_m3391676555 (Il2CppObject * __this /* static, unused */, GUISkin_t1436893342 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUI/WindowFunction::Invoke(System.Int32)
extern "C" void WindowFunction_Invoke_m3108181420 (WindowFunction_t3486805455 * __this, int32_t ___id0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutUtility::Layout()
extern "C" void GUILayoutUtility_Layout_m3812180708 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIContent::.ctor(System.String,UnityEngine.Texture,System.String)
extern "C" void GUIContent__ctor_m3472047579 (GUIContent_t4210063000 * __this, String_t* ___text0, Texture_t2243626319 * ___image1, String_t* ___tooltip2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIContent::set_text(System.String)
extern "C" void GUIContent_set_text_m1170206441 (GUIContent_t4210063000 * __this, String_t* ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIContent::set_image(UnityEngine.Texture)
extern "C" void GUIContent_set_image_m3973549709 (GUIContent_t4210063000 * __this, Texture_t2243626319 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIContent::set_tooltip(System.String)
extern "C" void GUIContent_set_tooltip_m3561669977 (GUIContent_t4210063000 * __this, String_t* ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIContent::.ctor()
extern "C" void GUIContent__ctor_m3889310883 (GUIContent_t4210063000 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIContent::.ctor(System.String)
extern "C" void GUIContent__ctor_m845353549 (GUIContent_t4210063000 * __this, String_t* ___text0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIElement UnityEngine.GUILayer::INTERNAL_CALL_HitTest(UnityEngine.GUILayer,UnityEngine.Vector3&)
extern "C" GUIElement_t3381083099 * GUILayer_INTERNAL_CALL_HitTest_m693512502 (Il2CppObject * __this /* static, unused */, GUILayer_t3254902478 * ___self0, Vector3_t2243707580 * ___screenPosition1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutOption::.ctor(UnityEngine.GUILayoutOption/Type,System.Object)
extern "C" void GUILayoutOption__ctor_m1607805343 (GUILayoutOption_t4183744904 * __this, int32_t ___type0, Il2CppObject * ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rect::.ctor(System.Single,System.Single,System.Single,System.Single)
extern "C" void Rect__ctor_m1220545469 (Rect_t3681755626 * __this, float ___x0, float ___y1, float ___width2, float ___height3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutEntry::set_style(UnityEngine.GUIStyle)
extern "C" void GUILayoutEntry_set_style_m70917293 (GUILayoutEntry_t3828586629 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIStyle UnityEngine.GUILayoutEntry::get_style()
extern "C" GUIStyle_t1799908754 * GUILayoutEntry_get_style_m998192810 (GUILayoutEntry_t3828586629 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.RectOffset UnityEngine.GUIStyle::get_margin()
extern "C" RectOffset_t3387826427 * GUIStyle_get_margin_m1012250163 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rect::set_x(System.Single)
extern "C" void Rect_set_x_m3783700513 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rect::set_width(System.Single)
extern "C" void Rect_set_width_m1921257731 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rect::set_y(System.Single)
extern "C" void Rect_set_y_m4294916608 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rect::set_height(System.Single)
extern "C" void Rect_set_height_m2019122814 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.GUIStyle::get_fixedWidth()
extern "C" float GUIStyle_get_fixedWidth_m97997484 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.GUIStyle::get_stretchWidth()
extern "C" bool GUIStyle_get_stretchWidth_m1223411161 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.GUIStyle::get_fixedHeight()
extern "C" float GUIStyle_get_fixedHeight_m414733479 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.GUIStyle::get_stretchHeight()
extern "C" bool GUIStyle_get_stretchHeight_m3396762700 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String System.String::Concat(System.String,System.String)
extern "C" String_t* String_Concat_m2596409543 (Il2CppObject * __this /* static, unused */, String_t* p0, String_t* p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.GUIStyle::get_name()
extern "C" String_t* GUIStyle_get_name_m753291950 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Type System.Object::GetType()
extern "C" Type_t * Object_GetType_m191970594 (Il2CppObject * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Rect::get_x()
extern "C" float Rect_get_x_m1393582490 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Rect::get_xMax()
extern "C" float Rect_get_xMax_m2915145014 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Rect::get_y()
extern "C" float Rect_get_y_m1393582395 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Rect::get_yMax()
extern "C" float Rect_get_yMax_m2915146103 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.UnityString::Format(System.String,System.Object[])
extern "C" String_t* UnityString_Format_m2949645127 (Il2CppObject * __this /* static, unused */, String_t* ___fmt0, ObjectU5BU5D_t3614634134* ___args1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String System.String::Concat(System.Object[])
extern "C" String_t* String_Concat_m3881798623 (Il2CppObject * __this /* static, unused */, ObjectU5BU5D_t3614634134* p0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Collections.Generic.List`1<UnityEngine.GUILayoutEntry>::.ctor()
#define List_1__ctor_m3098209370(__this, method) (( void (*) (List_1_t3197707761 *, const MethodInfo*))List_1__ctor_m310736118_gshared)(__this, method)
// System.Void UnityEngine.RectOffset::.ctor()
extern "C" void RectOffset__ctor_m2227510254 (RectOffset_t3387826427 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutEntry::.ctor(System.Single,System.Single,System.Single,System.Single,UnityEngine.GUIStyle)
extern "C" void GUILayoutEntry__ctor_m4007465719 (GUILayoutEntry_t3828586629 * __this, float ____minWidth0, float ____maxWidth1, float ____minHeight2, float ____maxHeight3, GUIStyle_t1799908754 * ____style4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutEntry::ApplyOptions(UnityEngine.GUILayoutOption[])
extern "C" void GUILayoutEntry_ApplyOptions_m115321759 (GUILayoutEntry_t3828586629 * __this, GUILayoutOptionU5BU5D_t2108882777* ___options0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutEntry::ApplyStyleSettings(UnityEngine.GUIStyle)
extern "C" void GUILayoutEntry_ApplyStyleSettings_m371609721 (GUILayoutEntry_t3828586629 * __this, GUIStyle_t1799908754 * ___style0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.RectOffset::get_left()
extern "C" int32_t RectOffset_get_left_m439065308 (RectOffset_t3387826427 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectOffset::set_left(System.Int32)
extern "C" void RectOffset_set_left_m620681523 (RectOffset_t3387826427 * __this, int32_t ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.RectOffset::get_right()
extern "C" int32_t RectOffset_get_right_m281378687 (RectOffset_t3387826427 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectOffset::set_right(System.Int32)
extern "C" void RectOffset_set_right_m1671272302 (RectOffset_t3387826427 * __this, int32_t ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.RectOffset::get_top()
extern "C" int32_t RectOffset_get_top_m3629049358 (RectOffset_t3387826427 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectOffset::set_top(System.Int32)
extern "C" void RectOffset_set_top_m3579196427 (RectOffset_t3387826427 * __this, int32_t ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.RectOffset::get_bottom()
extern "C" int32_t RectOffset_get_bottom_m4112328858 (RectOffset_t3387826427 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectOffset::set_bottom(System.Int32)
extern "C" void RectOffset_set_bottom_m4065521443 (RectOffset_t3387826427 * __this, int32_t ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Collections.Generic.List`1<UnityEngine.GUILayoutEntry>::get_Count()
#define List_1_get_Count_m3575634194(__this, method) (( int32_t (*) (List_1_t3197707761 *, const MethodInfo*))List_1_get_Count_m2375293942_gshared)(__this, method)
// UnityEngine.RectOffset UnityEngine.GUIStyle::get_padding()
extern "C" RectOffset_t3387826427 * GUIStyle_get_padding_m4076916754 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.RectOffset::get_horizontal()
extern "C" int32_t RectOffset_get_horizontal_m3818523637 (RectOffset_t3387826427 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Collections.Generic.List`1/Enumerator<!0> System.Collections.Generic.List`1<UnityEngine.GUILayoutEntry>::GetEnumerator()
#define List_1_GetEnumerator_m529646903(__this, method) (( Enumerator_t2732437435 (*) (List_1_t3197707761 *, const MethodInfo*))List_1_GetEnumerator_m2837081829_gshared)(__this, method)
// !0 System.Collections.Generic.List`1/Enumerator<UnityEngine.GUILayoutEntry>::get_Current()
#define Enumerator_get_Current_m2724498415(__this, method) (( GUILayoutEntry_t3828586629 * (*) (Enumerator_t2732437435 *, const MethodInfo*))Enumerator_get_Current_m2577424081_gshared)(__this, method)
// UnityEngine.GUIStyle UnityEngine.GUILayoutUtility::get_spaceStyle()
extern "C" GUIStyle_t1799908754 * GUILayoutUtility_get_spaceStyle_m1918520192 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Mathf::Min(System.Int32,System.Int32)
extern "C" int32_t Mathf_Min_m2906823867 (Il2CppObject * __this /* static, unused */, int32_t ___a0, int32_t ___b1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Mathf::Max(System.Single,System.Single)
extern "C" float Mathf_Max_m2564622569 (Il2CppObject * __this /* static, unused */, float ___a0, float ___b1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Collections.Generic.List`1/Enumerator<UnityEngine.GUILayoutEntry>::MoveNext()
#define Enumerator_MoveNext_m672443923(__this, method) (( bool (*) (Enumerator_t2732437435 *, const MethodInfo*))Enumerator_MoveNext_m44995089_gshared)(__this, method)
// System.Void System.Collections.Generic.List`1/Enumerator<UnityEngine.GUILayoutEntry>::Dispose()
#define Enumerator_Dispose_m4028763464(__this, method) (( void (*) (Enumerator_t2732437435 *, const MethodInfo*))Enumerator_Dispose_m3736175406_gshared)(__this, method)
// !0 System.Collections.Generic.List`1<UnityEngine.GUILayoutEntry>::get_Item(System.Int32)
#define List_1_get_Item_m3153062965(__this, p0, method) (( GUILayoutEntry_t3828586629 * (*) (List_1_t3197707761 *, int32_t, const MethodInfo*))List_1_get_Item_m2062981835_gshared)(__this, p0, method)
// System.Int32 UnityEngine.Mathf::Max(System.Int32,System.Int32)
extern "C" int32_t Mathf_Max_m1875893177 (Il2CppObject * __this /* static, unused */, int32_t ___a0, int32_t ___b1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single)
extern "C" void GUILayoutEntry_SetHorizontal_m1828181654 (GUILayoutEntry_t3828586629 * __this, float ___x0, float ___width1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Mathf::Clamp(System.Single,System.Single,System.Single)
extern "C" float Mathf_Clamp_m2354025655 (Il2CppObject * __this /* static, unused */, float ___value0, float ___min1, float ___max2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Mathf::Lerp(System.Single,System.Single,System.Single)
extern "C" float Mathf_Lerp_m1686556575 (Il2CppObject * __this /* static, unused */, float ___a0, float ___b1, float ___t2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.RectOffset::get_vertical()
extern "C" int32_t RectOffset_get_vertical_m3856345169 (RectOffset_t3387826427 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single)
extern "C" void GUILayoutEntry_SetVertical_m2328603448 (GUILayoutEntry_t3828586629 * __this, float ___y0, float ___height1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.GUILayoutEntry::ToString()
extern "C" String_t* GUILayoutEntry_ToString_m1331406279 (GUILayoutEntry_t3828586629 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String System.String::Concat(System.String,System.String,System.String)
extern "C" String_t* String_Concat_m612901809 (Il2CppObject * __this /* static, unused */, String_t* p0, String_t* p1, String_t* p2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Collections.Generic.Dictionary`2<System.Int32,UnityEngine.GUILayoutUtility/LayoutCache>::TryGetValue(!0,!1&)
#define Dictionary_2_TryGetValue_m1480015700(__this, p0, p1, method) (( bool (*) (Dictionary_2_t2128606680 *, int32_t, LayoutCache_t3120781045 **, const MethodInfo*))Dictionary_2_TryGetValue_m2140744741_gshared)(__this, p0, p1, method)
// System.Void UnityEngine.GUILayoutUtility/LayoutCache::.ctor()
extern "C" void LayoutCache__ctor_m2805543017 (LayoutCache_t3120781045 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Collections.Generic.Dictionary`2<System.Int32,UnityEngine.GUILayoutUtility/LayoutCache>::set_Item(!0,!1)
#define Dictionary_2_set_Item_m1800215906(__this, p0, p1, method) (( void (*) (Dictionary_2_t2128606680 *, int32_t, LayoutCache_t3120781045 *, const MethodInfo*))Dictionary_2_set_Item_m3180425769_gshared)(__this, p0, p1, method)
// System.Void UnityEngine.GUILayoutGroup::.ctor()
extern "C" void GUILayoutGroup__ctor_m992523271 (GUILayoutGroup_t3975363388 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Screen::get_width()
extern "C" int32_t Screen_get_width_m41137238 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.GUIUtility::get_pixelsPerPoint()
extern "C" float GUIUtility_get_pixelsPerPoint_m2667928361 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Mathf::Min(System.Single,System.Single)
extern "C" float Mathf_Min_m1648492575 (Il2CppObject * __this /* static, unused */, float ___a0, float ___b1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Screen::get_height()
extern "C" int32_t Screen_get_height_m1051800773 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutUtility::LayoutFreeGroup(UnityEngine.GUILayoutGroup)
extern "C" void GUILayoutUtility_LayoutFreeGroup_m1173219546 (Il2CppObject * __this /* static, unused */, GUILayoutGroup_t3975363388 * ___toplevel0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutUtility::LayoutSingleGroup(UnityEngine.GUILayoutGroup)
extern "C" void GUILayoutUtility_LayoutSingleGroup_m3547078816 (Il2CppObject * __this /* static, unused */, GUILayoutGroup_t3975363388 * ___i0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutGroup::ResetCursor()
extern "C" void GUILayoutGroup_ResetCursor_m3160916532 (GUILayoutGroup_t3975363388 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Rect UnityEngine.GUILayoutUtility::Internal_GetWindowRect(System.Int32)
extern "C" Rect_t3681755626 GUILayoutUtility_Internal_GetWindowRect_m1287880151 (Il2CppObject * __this /* static, unused */, int32_t ___windowID0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Rect::get_width()
extern "C" float Rect_get_width_m1138015702 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Rect::get_height()
extern "C" float Rect_get_height_m3128694305 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutUtility::Internal_MoveWindow(System.Int32,UnityEngine.Rect)
extern "C" void GUILayoutUtility_Internal_MoveWindow_m3217449419 (Il2CppObject * __this /* static, unused */, int32_t ___windowID0, Rect_t3681755626 ___r1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::.ctor()
extern "C" void GUIStyle__ctor_m3665892801 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::set_stretchWidth(System.Boolean)
extern "C" void GUIStyle_set_stretchWidth_m1198647818 (GUIStyle_t1799908754 * __this, bool ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutUtility::INTERNAL_CALL_Internal_GetWindowRect(System.Int32,UnityEngine.Rect&)
extern "C" void GUILayoutUtility_INTERNAL_CALL_Internal_GetWindowRect_m3236664463 (Il2CppObject * __this /* static, unused */, int32_t ___windowID0, Rect_t3681755626 * ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutUtility::INTERNAL_CALL_Internal_MoveWindow(System.Int32,UnityEngine.Rect&)
extern "C" void GUILayoutUtility_INTERNAL_CALL_Internal_MoveWindow_m1347894376 (Il2CppObject * __this /* static, unused */, int32_t ___windowID0, Rect_t3681755626 * ___r1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Collections.Generic.Dictionary`2<System.Int32,UnityEngine.GUILayoutUtility/LayoutCache>::.ctor()
#define Dictionary_2__ctor_m853591007(__this, method) (( void (*) (Dictionary_2_t2128606680 *, const MethodInfo*))Dictionary_2__ctor_m1868603968_gshared)(__this, method)
// System.Void UnityEngine.GUILayoutGroup::CalcWidth()
extern "C" void GUILayoutGroup_CalcWidth_m4107152934 (GUILayoutGroup_t3975363388 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutGroup::SetHorizontal(System.Single,System.Single)
extern "C" void GUILayoutGroup_SetHorizontal_m15325071 (GUILayoutGroup_t3975363388 * __this, float ___x0, float ___width1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutGroup::CalcHeight()
extern "C" void GUILayoutGroup_CalcHeight_m1454440153 (GUILayoutGroup_t3975363388 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutGroup::SetVertical(System.Single,System.Single)
extern "C" void GUILayoutGroup_SetVertical_m2197915999 (GUILayoutGroup_t3975363388 * __this, float ___y0, float ___height1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Color UnityEngine.Color::get_white()
extern "C" Color_t2020392075 Color_get_white_m3987539815 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Color::.ctor(System.Single,System.Single,System.Single)
extern "C" void Color__ctor_m3811852957 (Color_t2020392075 * __this, float ___r0, float ___g1, float ___b2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.GUISettings::Internal_GetCursorFlashSpeed()
extern "C" float GUISettings_Internal_GetCursorFlashSpeed_m3799968572 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUISettings::.ctor()
extern "C" void GUISettings__ctor_m2453724887 (GUISettings_t622856320 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.ScriptableObject::.ctor()
extern "C" void ScriptableObject__ctor_m2671490429 (ScriptableObject_t1975622470 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUISkin::Apply()
extern "C" void GUISkin_Apply_m3789936953 (GUISkin_t1436893342 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Object::op_Equality(UnityEngine.Object,UnityEngine.Object)
extern "C" bool Object_op_Equality_m3764089466 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___x0, Object_t1021602117 * ___y1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::SetDefaultFont(UnityEngine.Font)
extern "C" void GUIStyle_SetDefaultFont_m2095841351 (Il2CppObject * __this /* static, unused */, Font_t4239498691 * ___font0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Debug::Log(System.Object)
extern "C" void Debug_Log_m920475918 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___message0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUISkin::BuildStyleCache()
extern "C" void GUISkin_BuildStyleCache_m3553586894 (GUISkin_t1436893342 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.StringComparer System.StringComparer::get_OrdinalIgnoreCase()
extern "C" StringComparer_t1574862926 * StringComparer_get_OrdinalIgnoreCase_m3428639861 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Collections.Generic.Dictionary`2<System.String,UnityEngine.GUIStyle>::.ctor(System.Collections.Generic.IEqualityComparer`1<!0>)
#define Dictionary_2__ctor_m2582671449(__this, p0, method) (( void (*) (Dictionary_2_t3714688016 *, Il2CppObject*, const MethodInfo*))Dictionary_2__ctor_m2849528578_gshared)(__this, p0, method)
// System.Void System.Collections.Generic.Dictionary`2<System.String,UnityEngine.GUIStyle>::set_Item(!0,!1)
#define Dictionary_2_set_Item_m1398559205(__this, p0, p1, method) (( void (*) (Dictionary_2_t3714688016 *, String_t*, GUIStyle_t1799908754 *, const MethodInfo*))Dictionary_2_set_Item_m1004257024_gshared)(__this, p0, p1, method)
// System.Void UnityEngine.GUIStyle::set_name(System.String)
extern "C" void GUIStyle_set_name_m1034188361 (GUIStyle_t1799908754 * __this, String_t* ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_error()
extern "C" GUIStyle_t1799908754 * GUISkin_get_error_m1687921970 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::set_stretchHeight(System.Boolean)
extern "C" void GUIStyle_set_stretchHeight_m421727883 (GUIStyle_t1799908754 * __this, bool ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIStyleState UnityEngine.GUIStyle::get_normal()
extern "C" GUIStyleState_t3801000545 * GUIStyle_get_normal_m2789468942 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Color UnityEngine.Color::get_red()
extern "C" Color_t2020392075 Color_get_red_m2410286591 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyleState::set_textColor(UnityEngine.Color)
extern "C" void GUIStyleState_set_textColor_m3970174237 (GUIStyleState_t3801000545 * __this, Color_t2020392075 ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIStyle UnityEngine.GUISkin::FindStyle(System.String)
extern "C" GUIStyle_t1799908754 * GUISkin_FindStyle_m4277712965 (GUISkin_t1436893342 * __this, String_t* ___styleName0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.Object::get_name()
extern "C" String_t* Object_get_name_m2079638459 (Object_t1021602117 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Debug::LogWarning(System.Object)
extern "C" void Debug_LogWarning_m2503577968 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___message0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Debug::LogError(System.Object)
extern "C" void Debug_LogError_m3715728798 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___message0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Collections.Generic.Dictionary`2<System.String,UnityEngine.GUIStyle>::TryGetValue(!0,!1&)
#define Dictionary_2_TryGetValue_m595022037(__this, p0, p1, method) (( bool (*) (Dictionary_2_t3714688016 *, String_t*, GUIStyle_t1799908754 **, const MethodInfo*))Dictionary_2_TryGetValue_m3975825838_gshared)(__this, p0, p1, method)
// UnityEngine.Font UnityEngine.GUISkin::get_font()
extern "C" Font_t4239498691 * GUISkin_get_font_m3373823514 (GUISkin_t1436893342 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUISkin/SkinChangedDelegate::Invoke()
extern "C" void SkinChangedDelegate_Invoke_m2801964040 (SkinChangedDelegate_t3594822336 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Collections.Generic.Dictionary`2/ValueCollection<!0,!1> System.Collections.Generic.Dictionary`2<System.String,UnityEngine.GUIStyle>::get_Values()
#define Dictionary_2_get_Values_m2837248370(__this, method) (( ValueCollection_t2417747859 * (*) (Dictionary_2_t3714688016 *, const MethodInfo*))Dictionary_2_get_Values_m2233445381_gshared)(__this, method)
// System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<!0,!1> System.Collections.Generic.Dictionary`2/ValueCollection<System.String,UnityEngine.GUIStyle>::GetEnumerator()
#define ValueCollection_GetEnumerator_m1549252400(__this, method) (( Enumerator_t1106253484 (*) (ValueCollection_t2417747859 *, const MethodInfo*))ValueCollection_GetEnumerator_m379930731_gshared)(__this, method)
// System.Void UnityEngine.GUIStyle::Init()
extern "C" void GUIStyle_Init_m3872198731 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::InitCopy(UnityEngine.GUIStyle)
extern "C" void GUIStyle_InitCopy_m3676786505 (GUIStyle_t1799908754 * __this, GUIStyle_t1799908754 * ___other0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Cleanup()
extern "C" void GUIStyle_Cleanup_m1915255373 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Font UnityEngine.GUIStyle::GetFontInternalDuringLoadingThread()
extern "C" Font_t4239498691 * GUIStyle_GetFontInternalDuringLoadingThread_m229734483 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.IntPtr UnityEngine.GUIStyle::GetStyleStatePtr(System.Int32)
extern "C" IntPtr_t GUIStyle_GetStyleStatePtr_m1972527409 (GUIStyle_t1799908754 * __this, int32_t ___idx0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIStyleState UnityEngine.GUIStyleState::ProduceGUIStyleStateFromDeserialization(UnityEngine.GUIStyle,System.IntPtr)
extern "C" GUIStyleState_t3801000545 * GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976 (Il2CppObject * __this /* static, unused */, GUIStyle_t1799908754 * ___sourceStyle0, IntPtr_t ___source1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIStyleState UnityEngine.GUIStyleState::GetGUIStyleState(UnityEngine.GUIStyle,System.IntPtr)
extern "C" GUIStyleState_t3801000545 * GUIStyleState_GetGUIStyleState_m2816150617 (Il2CppObject * __this /* static, unused */, GUIStyle_t1799908754 * ___sourceStyle0, IntPtr_t ___source1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::AssignStyleState(System.Int32,System.IntPtr)
extern "C" void GUIStyle_AssignStyleState_m2665274947 (GUIStyle_t1799908754 * __this, int32_t ___idx0, IntPtr_t ___srcStyleState1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.IntPtr UnityEngine.GUIStyle::GetRectOffsetPtr(System.Int32)
extern "C" IntPtr_t GUIStyle_GetRectOffsetPtr_m4223228888 (GUIStyle_t1799908754 * __this, int32_t ___idx0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectOffset::.ctor(System.Object,System.IntPtr)
extern "C" void RectOffset__ctor_m1265077918 (RectOffset_t3387826427 * __this, Il2CppObject * ___sourceStyle0, IntPtr_t ___source1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::AssignRectOffset(System.Int32,System.IntPtr)
extern "C" void GUIStyle_AssignRectOffset_m2998103580 (GUIStyle_t1799908754 * __this, int32_t ___idx0, IntPtr_t ___srcRectOffset1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.GUIStyle::get_Internal_clipOffset()
extern "C" Vector2_t2243707579 GUIStyle_get_Internal_clipOffset_m4237737448 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::set_Internal_clipOffset(UnityEngine.Vector2)
extern "C" void GUIStyle_set_Internal_clipOffset_m118330819 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Font UnityEngine.GUIStyle::GetFontInternal()
extern "C" Font_t4239498691 * GUIStyle_GetFontInternal_m3509743324 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::SetFontInternal(UnityEngine.Font)
extern "C" void GUIStyle_SetFontInternal_m4135062999 (GUIStyle_t1799908754 * __this, Font_t4239498691 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.GUIStyle::Internal_GetLineHeight(System.IntPtr)
extern "C" float GUIStyle_Internal_GetLineHeight_m2503294326 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Internal_Draw(UnityEngine.GUIContent,UnityEngine.Internal_DrawArguments&)
extern "C" void GUIStyle_Internal_Draw_m694122665 (Il2CppObject * __this /* static, unused */, GUIContent_t4210063000 * ___content0, Internal_DrawArguments_t2834709342 * ___arguments1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Internal_Draw(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,System.Boolean,System.Boolean,System.Boolean,System.Boolean)
extern "C" void GUIStyle_Internal_Draw_m3610093213 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, bool ___isHover3, bool ___isActive4, bool ___on5, bool ___hasKeyboardFocus6, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIContent UnityEngine.GUIContent::Temp(System.String)
extern "C" GUIContent_t4210063000 * GUIContent_Temp_m1650198655 (Il2CppObject * __this /* static, unused */, String_t* ___t0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIContent UnityEngine.GUIContent::Temp(UnityEngine.Texture)
extern "C" GUIContent_t4210063000 * GUIContent_Temp_m1937454133 (Il2CppObject * __this /* static, unused */, Texture_t2243626319 * ___i0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Draw(UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,System.Boolean)
extern "C" void GUIStyle_Draw_m1435796321 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, GUIContent_t4210063000 * ___content1, int32_t ___controlID2, bool ___on3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Internal_Draw2(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,System.Boolean)
extern "C" void GUIStyle_Internal_Draw2_m878252945 (Il2CppObject * __this /* static, unused */, IntPtr_t ___style0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, int32_t ___controlID3, bool ___on4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Color::.ctor(System.Single,System.Single,System.Single,System.Single)
extern "C" void Color__ctor_m1909920690 (Color_t2020392075 * __this, float ___r0, float ___g1, float ___b2, float ___a3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUISettings UnityEngine.GUISkin::get_settings()
extern "C" GUISettings_t622856320 * GUISkin_get_settings_m626844463 (GUISkin_t1436893342 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.GUISettings::get_cursorFlashSpeed()
extern "C" float GUISettings_get_cursorFlashSpeed_m3722011925 (GUISettings_t622856320 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Time::get_realtimeSinceStartup()
extern "C" float Time_get_realtimeSinceStartup_m357614587 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.GUIStyle::Internal_GetCursorFlashOffset()
extern "C" float GUIStyle_Internal_GetCursorFlashOffset_m3177259302 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Color UnityEngine.GUISettings::get_cursorColor()
extern "C" Color_t2020392075 GUISettings_get_cursorColor_m3884075294 (GUISettings_t622856320 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Internal_DrawCursor(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,UnityEngine.Color)
extern "C" void GUIStyle_Internal_DrawCursor_m1394927592 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, int32_t ___pos3, Color_t2020392075 ___cursorColor4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Color UnityEngine.GUISettings::get_selectionColor()
extern "C" Color_t2020392075 GUISettings_get_selectionColor_m1824063266 (GUISettings_t622856320 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Event::get_mousePosition()
extern "C" Vector2_t2243707579 Event_get_mousePosition_m3789571399 (Event_t3028476042 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Rect::Contains(UnityEngine.Vector2)
extern "C" bool Rect_Contains_m1334685290 (Rect_t3681755626 * __this, Vector2_t2243707579 ___point0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.GUIUtility::get_hotControl()
extern "C" int32_t GUIUtility_get_hotControl_m466901769 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.GUIUtility::get_keyboardControl()
extern "C" int32_t GUIUtility_get_keyboardControl_m2418463643 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Internal_DrawWithTextSelection(UnityEngine.GUIContent,UnityEngine.Internal_DrawWithTextSelectionArguments&)
extern "C" void GUIStyle_Internal_DrawWithTextSelection_m2258778613 (Il2CppObject * __this /* static, unused */, GUIContent_t4210063000 * ___content0, Internal_DrawWithTextSelectionArguments_t1327795077 * ___arguments1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::DrawWithTextSelection(UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,System.Int32,System.Int32,System.Boolean)
extern "C" void GUIStyle_DrawWithTextSelection_m2215181902 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, GUIContent_t4210063000 * ___content1, int32_t ___controlID2, int32_t ___firstSelectedCharacter3, int32_t ___lastSelectedCharacter4, bool ___drawSelectionAsComposition5, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUIStyle UnityEngine.GUISkin::GetStyle(System.String)
extern "C" GUIStyle_t1799908754 * GUISkin_GetStyle_m3594137272 (GUISkin_t1436893342 * __this, String_t* ___styleName0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Internal_GetCursorPixelPosition(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,UnityEngine.Vector2&)
extern "C" void GUIStyle_Internal_GetCursorPixelPosition_m823797035 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, int32_t ___cursorStringIndex3, Vector2_t2243707579 * ___ret4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.GUIStyle::Internal_GetCursorStringIndex(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,UnityEngine.Vector2)
extern "C" int32_t GUIStyle_Internal_GetCursorStringIndex_m1491806746 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, Vector2_t2243707579 ___cursorPixelPosition3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.GUIStyle::Internal_GetNumCharactersThatFitWithinWidth(System.IntPtr,System.String,System.Single)
extern "C" int32_t GUIStyle_Internal_GetNumCharactersThatFitWithinWidth_m2132182605 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, String_t* ___text1, float ___width2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Internal_CalcSize(System.IntPtr,UnityEngine.GUIContent,UnityEngine.Vector2&)
extern "C" void GUIStyle_Internal_CalcSize_m1309259680 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, GUIContent_t4210063000 * ___content1, Vector2_t2243707579 * ___ret2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Internal_CalcSizeWithConstraints(System.IntPtr,UnityEngine.GUIContent,UnityEngine.Vector2,UnityEngine.Vector2&)
extern "C" void GUIStyle_Internal_CalcSizeWithConstraints_m3375255978 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, GUIContent_t4210063000 * ___content1, Vector2_t2243707579 ___maxSize2, Vector2_t2243707579 * ___ret3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Vector2::.ctor(System.Single,System.Single)
extern "C" void Vector2__ctor_m3067419446 (Vector2_t2243707579 * __this, float ___x0, float ___y1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.GUIStyle::Internal_CalcHeight(System.IntPtr,UnityEngine.GUIContent,System.Single)
extern "C" float GUIStyle_Internal_CalcHeight_m350880591 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, GUIContent_t4210063000 * ___content1, float ___width2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.GUIStyle::get_wordWrap()
extern "C" bool GUIStyle_get_wordWrap_m3655049112 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.ImagePosition UnityEngine.GUIStyle::get_imagePosition()
extern "C" int32_t GUIStyle_get_imagePosition_m1104201320 (GUIStyle_t1799908754 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::Internal_CalcMinMaxWidth(System.IntPtr,UnityEngine.GUIContent,System.Single&,System.Single&)
extern "C" void GUIStyle_Internal_CalcMinMaxWidth_m3660306863 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, GUIContent_t4210063000 * ___content1, float* ___minWidth2, float* ___maxWidth3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_GetStyleStatePtr(UnityEngine.GUIStyle,System.Int32,System.IntPtr&)
extern "C" void GUIStyle_INTERNAL_CALL_GetStyleStatePtr_m976729086 (Il2CppObject * __this /* static, unused */, GUIStyle_t1799908754 * ___self0, int32_t ___idx1, IntPtr_t* ___value2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_GetRectOffsetPtr(UnityEngine.GUIStyle,System.Int32,System.IntPtr&)
extern "C" void GUIStyle_INTERNAL_CALL_GetRectOffsetPtr_m1971938403 (Il2CppObject * __this /* static, unused */, GUIStyle_t1799908754 * ___self0, int32_t ___idx1, IntPtr_t* ___value2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_get_contentOffset(UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_get_contentOffset_m2667265678 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_set_contentOffset(UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_set_contentOffset_m1314037746 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_get_Internal_clipOffset(UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_get_Internal_clipOffset_m3336627565 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_set_Internal_clipOffset(UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_set_Internal_clipOffset_m2024478897 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_Internal_Draw2(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,System.Boolean)
extern "C" void GUIStyle_INTERNAL_CALL_Internal_Draw2_m2973483786 (Il2CppObject * __this /* static, unused */, IntPtr_t ___style0, Rect_t3681755626 * ___position1, GUIContent_t4210063000 * ___content2, int32_t ___controlID3, bool ___on4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_SetMouseTooltip(UnityEngine.GUIStyle,System.String,UnityEngine.Rect&)
extern "C" void GUIStyle_INTERNAL_CALL_SetMouseTooltip_m1802284884 (Il2CppObject * __this /* static, unused */, GUIStyle_t1799908754 * ___self0, String_t* ___tooltip1, Rect_t3681755626 * ___screenRect2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_Internal_DrawPrefixLabel(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,System.Boolean)
extern "C" void GUIStyle_INTERNAL_CALL_Internal_DrawPrefixLabel_m557487542 (Il2CppObject * __this /* static, unused */, IntPtr_t ___style0, Rect_t3681755626 * ___position1, GUIContent_t4210063000 * ___content2, int32_t ___controlID3, bool ___on4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_Internal_DrawCursor(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,UnityEngine.Color&)
extern "C" void GUIStyle_INTERNAL_CALL_Internal_DrawCursor_m512401185 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 * ___position1, GUIContent_t4210063000 * ___content2, int32_t ___pos3, Color_t2020392075 * ___cursorColor4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_Internal_GetCursorPixelPosition(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_CALL_Internal_GetCursorPixelPosition_m562482816 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 * ___position1, GUIContent_t4210063000 * ___content2, int32_t ___cursorStringIndex3, Vector2_t2243707579 * ___ret4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.GUIStyle::INTERNAL_CALL_Internal_GetCursorStringIndex(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,UnityEngine.Vector2&)
extern "C" int32_t GUIStyle_INTERNAL_CALL_Internal_GetCursorStringIndex_m3074318281 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 * ___position1, GUIContent_t4210063000 * ___content2, Vector2_t2243707579 * ___cursorPixelPosition3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_Internal_CalcSizeWithConstraints(System.IntPtr,UnityEngine.GUIContent,UnityEngine.Vector2&,UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_CALL_Internal_CalcSizeWithConstraints_m1203344891 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, GUIContent_t4210063000 * ___content1, Vector2_t2243707579 * ___maxSize2, Vector2_t2243707579 * ___ret3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyleState::Init()
extern "C" void GUIStyleState_Init_m2434147050 (GUIStyleState_t3801000545 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyleState::.ctor(UnityEngine.GUIStyle,System.IntPtr)
extern "C" void GUIStyleState__ctor_m2708667747 (GUIStyleState_t3801000545 * __this, GUIStyle_t1799908754 * ___sourceStyle0, IntPtr_t ___source1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Texture2D UnityEngine.GUIStyleState::GetBackgroundInternalFromDeserialization()
extern "C" Texture2D_t3542995729 * GUIStyleState_GetBackgroundInternalFromDeserialization_m1892089769 (GUIStyleState_t3801000545 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Texture2D UnityEngine.GUIStyleState::GetBackgroundInternal()
extern "C" Texture2D_t3542995729 * GUIStyleState_GetBackgroundInternal_m439046630 (GUIStyleState_t3801000545 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyleState::Cleanup()
extern "C" void GUIStyleState_Cleanup_m705006206 (GUIStyleState_t3801000545 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIStyleState::INTERNAL_set_textColor(UnityEngine.Color&)
extern "C" void GUIStyleState_INTERNAL_set_textColor_m3876928435 (GUIStyleState_t3801000545 * __this, Color_t2020392075 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Reflection.MethodInfo System.Type::GetMethod(System.String,System.Reflection.BindingFlags)
extern "C" MethodInfo_t * Type_GetMethod_m475234662 (Type_t * __this, String_t* p0, int32_t p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)
extern "C" Type_t * Type_GetTypeFromHandle_m432505302 (Il2CppObject * __this /* static, unused */, RuntimeTypeHandle_t2330101084 p0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.GUIUtility::Internal_GetPixelsPerPoint()
extern "C" float GUIUtility_Internal_GetPixelsPerPoint_m1770975086 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.GUIUtility::Internal_GetHotControl()
extern "C" int32_t GUIUtility_Internal_GetHotControl_m2510727642 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.GUIUtility::Internal_GetKeyboardControl()
extern "C" int32_t GUIUtility_Internal_GetKeyboardControl_m973220286 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.GUISkin UnityEngine.GUIUtility::Internal_GetDefaultSkin(System.Int32)
extern "C" GUISkin_t1436893342 * GUIUtility_Internal_GetDefaultSkin_m2135852437 (Il2CppObject * __this /* static, unused */, int32_t ___skinMode0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIUtility::set_guiIsExiting(System.Boolean)
extern "C" void GUIUtility_set_guiIsExiting_m2362636745 (Il2CppObject * __this /* static, unused */, bool ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutUtility::Begin(System.Int32)
extern "C" void GUILayoutUtility_Begin_m2360858304 (Il2CppObject * __this /* static, unused */, int32_t ___instanceID0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUI::set_changed(System.Boolean)
extern "C" void GUI_set_changed_m470833806 (Il2CppObject * __this /* static, unused */, bool ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUILayoutUtility::LayoutFromEditorWindow()
extern "C" void GUILayoutUtility_LayoutFromEditorWindow_m1847418289 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIContent::ClearStaticCache()
extern "C" void GUIContent_ClearStaticCache_m3271816250 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.GUIUtility::Internal_ExitGUI()
extern "C" void GUIUtility_Internal_ExitGUI_m2271097629 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.GUIUtility::ShouldRethrowException(System.Exception)
extern "C" bool GUIUtility_ShouldRethrowException_m1990329277 (Il2CppObject * __this /* static, unused */, Exception_t1927440687 * ___exception0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Exception System.Exception::get_InnerException()
extern "C" Exception_t1927440687 * Exception_get_InnerException_m3722561235 (Exception_t1927440687 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.GUIUtility::Internal_GetGUIDepth()
extern "C" int32_t GUIUtility_Internal_GetGUIDepth_m1699616910 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.ArgumentException::.ctor(System.String)
extern "C" void ArgumentException__ctor_m3739475201 (ArgumentException_t3259014390 * __this, String_t* p0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Vector2::get_zero()
extern "C" Vector2_t2243707579 Vector2_get_zero_m3966848876 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.HumanBone::get_boneName()
extern "C" String_t* HumanBone_get_boneName_m1281040133 (HumanBone_t1529896151 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.HumanBone::set_boneName(System.String)
extern "C" void HumanBone_set_boneName_m2410239828 (HumanBone_t1529896151 * __this, String_t* ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.HumanBone::get_humanName()
extern "C" String_t* HumanBone_get_humanName_m2091758568 (HumanBone_t1529896151 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.HumanBone::set_humanName(System.String)
extern "C" void HumanBone_set_humanName_m1385708911 (HumanBone_t1529896151 * __this, String_t* ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Attribute::.ctor()
extern "C" void Attribute__ctor_m1730479323 (Attribute_t542643598 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Input::GetKeyDownInt(System.Int32)
extern "C" bool Input_GetKeyDownInt_m2930607648 (Il2CppObject * __this /* static, unused */, int32_t ___key0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Input::GetKeyUpInt(System.Int32)
extern "C" bool Input_GetKeyUpInt_m2486491081 (Il2CppObject * __this /* static, unused */, int32_t ___key0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Input::INTERNAL_get_mousePosition(UnityEngine.Vector3&)
extern "C" void Input_INTERNAL_get_mousePosition_m2302165941 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Input::INTERNAL_get_mouseScrollDelta(UnityEngine.Vector2&)
extern "C" void Input_INTERNAL_get_mouseScrollDelta_m1140491498 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Input::INTERNAL_CALL_GetTouch(System.Int32,UnityEngine.Touch&)
extern "C" void Input_INTERNAL_CALL_GetTouch_m1737132542 (Il2CppObject * __this /* static, unused */, int32_t ___index0, Touch_t407273883 * ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Input::INTERNAL_get_compositionCursorPos(UnityEngine.Vector2&)
extern "C" void Input_INTERNAL_get_compositionCursorPos_m2426914348 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Input::INTERNAL_set_compositionCursorPos(UnityEngine.Vector2&)
extern "C" void Input_INTERNAL_set_compositionCursorPos_m1501857600 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Object UnityEngine.Internal.DefaultValueAttribute::get_Value()
extern "C" Il2CppObject * DefaultValueAttribute_get_Value_m397428899 (DefaultValueAttribute_t1027170048 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Attribute::GetHashCode()
extern "C" int32_t Attribute_GetHashCode_m2653962112 (Attribute_t542643598 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Keyframe::.ctor(System.Single,System.Single)
extern "C" void Keyframe__ctor_m2042404667 (Keyframe_t1449471340 * __this, float ___time0, float ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Keyframe::.ctor(System.Single,System.Single,System.Single,System.Single)
extern "C" void Keyframe__ctor_m140082843 (Keyframe_t1449471340 * __this, float ___time0, float ___value1, float ___inTangent2, float ___outTangent3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Keyframe::get_time()
extern "C" float Keyframe_get_time_m2226372497 (Keyframe_t1449471340 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Keyframe::set_time(System.Single)
extern "C" void Keyframe_set_time_m848496062 (Keyframe_t1449471340 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Keyframe::get_value()
extern "C" float Keyframe_get_value_m979894315 (Keyframe_t1449471340 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Keyframe::set_value(System.Single)
extern "C" void Keyframe_set_value_m2184486356 (Keyframe_t1449471340 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Keyframe::get_inTangent()
extern "C" float Keyframe_get_inTangent_m3256944616 (Keyframe_t1449471340 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Keyframe::set_inTangent(System.Single)
extern "C" void Keyframe_set_inTangent_m4280114775 (Keyframe_t1449471340 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Keyframe::get_outTangent()
extern "C" float Keyframe_get_outTangent_m1894374085 (Keyframe_t1449471340 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Keyframe::set_outTangent(System.Single)
extern "C" void Keyframe_set_outTangent_m1054927214 (Keyframe_t1449471340 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Keyframe::get_tangentMode()
extern "C" int32_t Keyframe_get_tangentMode_m1869200796 (Keyframe_t1449471340 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Keyframe::set_tangentMode(System.Int32)
extern "C" void Keyframe_set_tangentMode_m1073266123 (Keyframe_t1449471340 * __this, int32_t ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Logger::set_logHandler(UnityEngine.ILogHandler)
extern "C" void Logger_set_logHandler_m2851576632 (Logger_t3328995178 * __this, Il2CppObject * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Logger::set_logEnabled(System.Boolean)
extern "C" void Logger_set_logEnabled_m3852234466 (Logger_t3328995178 * __this, bool ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Logger::set_filterLogType(UnityEngine.LogType)
extern "C" void Logger_set_filterLogType_m1452353615 (Logger_t3328995178 * __this, int32_t ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Logger::get_logEnabled()
extern "C" bool Logger_get_logEnabled_m3807759477 (Logger_t3328995178 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.LogType UnityEngine.Logger::get_filterLogType()
extern "C" int32_t Logger_get_filterLogType_m3672438698 (Logger_t3328995178 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Logger::IsLogTypeAllowed(UnityEngine.LogType)
extern "C" bool Logger_IsLogTypeAllowed_m1750132386 (Logger_t3328995178 * __this, int32_t ___logType0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.ILogHandler UnityEngine.Logger::get_logHandler()
extern "C" Il2CppObject * Logger_get_logHandler_m4190583509 (Logger_t3328995178 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.Logger::GetString(System.Object)
extern "C" String_t* Logger_GetString_m4086587133 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___message0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Material::Internal_CreateWithMaterial(UnityEngine.Material,UnityEngine.Material)
extern "C" void Material_Internal_CreateWithMaterial_m2907597451 (Il2CppObject * __this /* static, unused */, Material_t193706927 * ___mono0, Material_t193706927 * ___source1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Texture UnityEngine.Material::GetTexture(System.String)
extern "C" Texture_t2243626319 * Material_GetTexture_m1257877102 (Material_t193706927 * __this, String_t* ___name0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Shader::PropertyToID(System.String)
extern "C" int32_t Shader_PropertyToID_m678579425 (Il2CppObject * __this /* static, unused */, String_t* ___name0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Material::HasProperty(System.Int32)
extern "C" bool Material_HasProperty_m3175512802 (Material_t193706927 * __this, int32_t ___nameID0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Material::SetFloatImpl(System.Int32,System.Single)
extern "C" void Material_SetFloatImpl_m2784769558 (Material_t193706927 * __this, int32_t ___nameID0, float ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Material::SetInt(System.Int32,System.Int32)
extern "C" void Material_SetInt_m977568583 (Material_t193706927 * __this, int32_t ___nameID0, int32_t ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Material::SetIntImpl(System.Int32,System.Int32)
extern "C" void Material_SetIntImpl_m4157631275 (Material_t193706927 * __this, int32_t ___nameID0, int32_t ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Texture UnityEngine.Material::GetTexture(System.Int32)
extern "C" Texture_t2243626319 * Material_GetTexture_m648312929 (Material_t193706927 * __this, int32_t ___nameID0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Texture UnityEngine.Material::GetTextureImpl(System.Int32)
extern "C" Texture_t2243626319 * Material_GetTextureImpl_m623159197 (Material_t193706927 * __this, int32_t ___nameID0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Double System.Math::Log(System.Double,System.Double)
extern "C" double Math_Log_m3325929366 (Il2CppObject * __this /* static, unused */, double p0, double p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Mathf::Clamp01(System.Single)
extern "C" float Mathf_Clamp01_m3888954684 (Il2CppObject * __this /* static, unused */, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Matrix4x4::get_Item(System.Int32)
extern "C" float Matrix4x4_get_Item_m3317262185 (Matrix4x4_t2933234003 * __this, int32_t ___index0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Matrix4x4::get_Item(System.Int32,System.Int32)
extern "C" float Matrix4x4_get_Item_m312280350 (Matrix4x4_t2933234003 * __this, int32_t ___row0, int32_t ___column1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.IndexOutOfRangeException::.ctor(System.String)
extern "C" void IndexOutOfRangeException__ctor_m1847153122 (IndexOutOfRangeException_t3527622107 * __this, String_t* p0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector4 UnityEngine.Matrix4x4::GetColumn(System.Int32)
extern "C" Vector4_t2243707581 Matrix4x4_GetColumn_m1367096730 (Matrix4x4_t2933234003 * __this, int32_t ___i0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Vector4::GetHashCode()
extern "C" int32_t Vector4_GetHashCode_m1576457715 (Vector4_t2243707581 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Matrix4x4::GetHashCode()
extern "C" int32_t Matrix4x4_GetHashCode_m3649708037 (Matrix4x4_t2933234003 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Vector4::Equals(System.Object)
extern "C" bool Vector4_Equals_m3783731577 (Vector4_t2243707581 * __this, Il2CppObject * ___other0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Matrix4x4::Equals(System.Object)
extern "C" bool Matrix4x4_Equals_m1321236479 (Matrix4x4_t2933234003 * __this, Il2CppObject * ___other0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Vector4::.ctor(System.Single,System.Single,System.Single,System.Single)
extern "C" void Vector4__ctor_m1222289168 (Vector4_t2243707581 * __this, float ___x0, float ___y1, float ___z2, float ___w3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Matrix4x4::MultiplyPoint3x4(UnityEngine.Vector3)
extern "C" Vector3_t2243707580 Matrix4x4_MultiplyPoint3x4_m1007952212 (Matrix4x4_t2933234003 * __this, Vector3_t2243707580 ___v0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.Matrix4x4::ToString()
extern "C" String_t* Matrix4x4_ToString_m1982554457 (Matrix4x4_t2933234003 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Mesh::Internal_Create(UnityEngine.Mesh)
extern "C" void Mesh_Internal_Create_m1486058998 (Il2CppObject * __this /* static, unused */, Mesh_t1356156583 * ___mono0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Mesh::Clear(System.Boolean)
extern "C" void Mesh_Clear_m3100797454 (Mesh_t1356156583 * __this, bool ___keepVertexLayout0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Mesh::SetTriangles(System.Collections.Generic.List`1<System.Int32>,System.Int32,System.Boolean)
extern "C" void Mesh_SetTriangles_m2506325172 (Mesh_t1356156583 * __this, List_1_t1440998580 * ___triangles0, int32_t ___submesh1, bool ___calculateBounds2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Mesh::CheckCanAccessSubmeshTriangles(System.Int32)
extern "C" bool Mesh_CheckCanAccessSubmeshTriangles_m3203185587 (Mesh_t1356156583 * __this, int32_t ___submesh0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Array UnityEngine.Mesh::ExtractArrayFromList(System.Object)
extern "C" Il2CppArray * Mesh_ExtractArrayFromList_m1349408169 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___list0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Mesh::SafeLength<System.Int32>(System.Collections.Generic.List`1<T>)
#define Mesh_SafeLength_TisInt32_t2071877448_m2504367186(__this, ___values0, method) (( int32_t (*) (Mesh_t1356156583 *, List_1_t1440998580 *, const MethodInfo*))Mesh_SafeLength_TisInt32_t2071877448_m2504367186_gshared)(__this, ___values0, method)
// System.Void UnityEngine.Mesh::SetTrianglesImpl(System.Int32,System.Array,System.Int32,System.Boolean)
extern "C" void Mesh_SetTrianglesImpl_m2743099196 (Mesh_t1356156583 * __this, int32_t ___submesh0, Il2CppArray * ___triangles1, int32_t ___arraySize2, bool ___calculateBounds3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.ArgumentException::.ctor(System.String,System.String)
extern "C" void ArgumentException__ctor_m544251339 (ArgumentException_t3259014390 * __this, String_t* p0, String_t* p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Mesh::get_canAccess()
extern "C" bool Mesh_get_canAccess_m2763498171 (Mesh_t1356156583 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Mesh::SetArrayForChannelImpl(UnityEngine.Mesh/InternalShaderChannel,UnityEngine.Mesh/InternalVertexChannelType,System.Int32,System.Array,System.Int32)
extern "C" void Mesh_SetArrayForChannelImpl_m271696022 (Mesh_t1356156583 * __this, int32_t ___channel0, int32_t ___format1, int32_t ___dim2, Il2CppArray * ___values3, int32_t ___arraySize4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Mesh::PrintErrorCantAccessMesh(UnityEngine.Mesh/InternalShaderChannel)
extern "C" void Mesh_PrintErrorCantAccessMesh_m2827771108 (Mesh_t1356156583 * __this, int32_t ___channel0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// T[] UnityEngine.Mesh::GetAllocArrayFromChannel<UnityEngine.Vector3>(UnityEngine.Mesh/InternalShaderChannel)
#define Mesh_GetAllocArrayFromChannel_TisVector3_t2243707580_m2367580537(__this, ___channel0, method) (( Vector3U5BU5D_t1172311765* (*) (Mesh_t1356156583 *, int32_t, const MethodInfo*))Mesh_GetAllocArrayFromChannel_TisVector3_t2243707580_m2367580537_gshared)(__this, ___channel0, method)
// T[] UnityEngine.Mesh::GetAllocArrayFromChannel<UnityEngine.Vector4>(UnityEngine.Mesh/InternalShaderChannel)
#define Mesh_GetAllocArrayFromChannel_TisVector4_t2243707581_m295947442(__this, ___channel0, method) (( Vector4U5BU5D_t1658499504* (*) (Mesh_t1356156583 *, int32_t, const MethodInfo*))Mesh_GetAllocArrayFromChannel_TisVector4_t2243707581_m295947442_gshared)(__this, ___channel0, method)
// T[] UnityEngine.Mesh::GetAllocArrayFromChannel<UnityEngine.Vector2>(UnityEngine.Mesh/InternalShaderChannel)
#define Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716(__this, ___channel0, method) (( Vector2U5BU5D_t686124026* (*) (Mesh_t1356156583 *, int32_t, const MethodInfo*))Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716_gshared)(__this, ___channel0, method)
// T[] UnityEngine.Mesh::GetAllocArrayFromChannel<UnityEngine.Color32>(UnityEngine.Mesh/InternalShaderChannel,UnityEngine.Mesh/InternalVertexChannelType,System.Int32)
#define Mesh_GetAllocArrayFromChannel_TisColor32_t874517518_m2030100417(__this, ___channel0, ___format1, ___dim2, method) (( Color32U5BU5D_t30278651* (*) (Mesh_t1356156583 *, int32_t, int32_t, int32_t, const MethodInfo*))Mesh_GetAllocArrayFromChannel_TisColor32_t874517518_m2030100417_gshared)(__this, ___channel0, ___format1, ___dim2, method)
// System.Void UnityEngine.Mesh::SetListForChannel<UnityEngine.Vector3>(UnityEngine.Mesh/InternalShaderChannel,System.Collections.Generic.List`1<T>)
#define Mesh_SetListForChannel_TisVector3_t2243707580_m2514561521(__this, ___channel0, ___values1, method) (( void (*) (Mesh_t1356156583 *, int32_t, List_1_t1612828712 *, const MethodInfo*))Mesh_SetListForChannel_TisVector3_t2243707580_m2514561521_gshared)(__this, ___channel0, ___values1, method)
// System.Void UnityEngine.Mesh::SetListForChannel<UnityEngine.Vector4>(UnityEngine.Mesh/InternalShaderChannel,System.Collections.Generic.List`1<T>)
#define Mesh_SetListForChannel_TisVector4_t2243707581_m3238986708(__this, ___channel0, ___values1, method) (( void (*) (Mesh_t1356156583 *, int32_t, List_1_t1612828713 *, const MethodInfo*))Mesh_SetListForChannel_TisVector4_t2243707581_m3238986708_gshared)(__this, ___channel0, ___values1, method)
// System.Void UnityEngine.Mesh::SetListForChannel<UnityEngine.Color32>(UnityEngine.Mesh/InternalShaderChannel,UnityEngine.Mesh/InternalVertexChannelType,System.Int32,System.Collections.Generic.List`1<T>)
#define Mesh_SetListForChannel_TisColor32_t874517518_m1056672865(__this, ___channel0, ___format1, ___dim2, ___values3, method) (( void (*) (Mesh_t1356156583 *, int32_t, int32_t, int32_t, List_1_t243638650 *, const MethodInfo*))Mesh_SetListForChannel_TisColor32_t874517518_m1056672865_gshared)(__this, ___channel0, ___format1, ___dim2, ___values3, method)
// System.Void UnityEngine.Mesh::SetUvsImpl<UnityEngine.Vector2>(System.Int32,System.Int32,System.Collections.Generic.List`1<T>)
#define Mesh_SetUvsImpl_TisVector2_t2243707579_m3939959910(__this, ___uvIndex0, ___dim1, ___uvs2, method) (( void (*) (Mesh_t1356156583 *, int32_t, int32_t, List_1_t1612828711 *, const MethodInfo*))Mesh_SetUvsImpl_TisVector2_t2243707579_m3939959910_gshared)(__this, ___uvIndex0, ___dim1, ___uvs2, method)
// System.Void UnityEngine.Mesh::PrintErrorCantAccessMeshForIndices()
extern "C" void Mesh_PrintErrorCantAccessMeshForIndices_m3276222682 (Mesh_t1356156583 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Mesh::get_subMeshCount()
extern "C" int32_t Mesh_get_subMeshCount_m1945011773 (Mesh_t1356156583 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Mesh::PrintErrorBadSubmeshIndexTriangles()
extern "C" void Mesh_PrintErrorBadSubmeshIndexTriangles_m3830862268 (Mesh_t1356156583 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Mesh::PrintErrorBadSubmeshIndexIndices()
extern "C" void Mesh_PrintErrorBadSubmeshIndexIndices_m2104981732 (Mesh_t1356156583 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Mesh::CheckCanAccessSubmesh(System.Int32,System.Boolean)
extern "C" bool Mesh_CheckCanAccessSubmesh_m1826512193 (Mesh_t1356156583 * __this, int32_t ___submesh0, bool ___errorAboutTriangles1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Mesh::CheckCanAccessSubmeshIndices(System.Int32)
extern "C" bool Mesh_CheckCanAccessSubmeshIndices_m2098382465 (Mesh_t1356156583 * __this, int32_t ___submesh0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32[] UnityEngine.Mesh::GetIndicesImpl(System.Int32)
extern "C" Int32U5BU5D_t3030399641* Mesh_GetIndicesImpl_m2398977086 (Mesh_t1356156583 * __this, int32_t ___submesh0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Behaviour::.ctor()
extern "C" void Behaviour__ctor_m2699265412 (Behaviour_t955675639 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.MonoBehaviour::Internal_CancelInvokeAll()
extern "C" void MonoBehaviour_Internal_CancelInvokeAll_m3154116776 (MonoBehaviour_t1158329972 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.MonoBehaviour::Internal_IsInvokingAll()
extern "C" bool MonoBehaviour_Internal_IsInvokingAll_m3504849565 (MonoBehaviour_t1158329972 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Coroutine UnityEngine.MonoBehaviour::StartCoroutine_Auto_Internal(System.Collections.IEnumerator)
extern "C" Coroutine_t2299508840 * MonoBehaviour_StartCoroutine_Auto_Internal_m1014513456 (MonoBehaviour_t1158329972 * __this, Il2CppObject * ___routine0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Coroutine UnityEngine.MonoBehaviour::StartCoroutine(System.Collections.IEnumerator)
extern "C" Coroutine_t2299508840 * MonoBehaviour_StartCoroutine_m2470621050 (MonoBehaviour_t1158329972 * __this, Il2CppObject * ___routine0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Coroutine UnityEngine.MonoBehaviour::StartCoroutine(System.String,System.Object)
extern "C" Coroutine_t2299508840 * MonoBehaviour_StartCoroutine_m296997955 (MonoBehaviour_t1158329972 * __this, String_t* ___methodName0, Il2CppObject * ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.MonoBehaviour::StopCoroutineViaEnumerator_Auto(System.Collections.IEnumerator)
extern "C" void MonoBehaviour_StopCoroutineViaEnumerator_Auto_m4046945826 (MonoBehaviour_t1158329972 * __this, Il2CppObject * ___routine0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.MonoBehaviour::StopCoroutine_Auto(UnityEngine.Coroutine)
extern "C" void MonoBehaviour_StopCoroutine_Auto_m1923670638 (MonoBehaviour_t1158329972 * __this, Coroutine_t2299508840 * ___routine0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.NativeClassAttribute::set_QualifiedNativeName(System.String)
extern "C" void NativeClassAttribute_set_QualifiedNativeName_m2790580781 (NativeClassAttribute_t1576243993 * __this, String_t* ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents::.ctor()
extern "C" void PlayerEditorConnectionEvents__ctor_m603950945 (PlayerEditorConnectionEvents_t2252784345 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Collections.Generic.List`1<System.Int32>::.ctor()
#define List_1__ctor_m1598946593(__this, method) (( void (*) (List_1_t1440998580 *, const MethodInfo*))List_1__ctor_m1598946593_gshared)(__this, method)
// UnityEngine.Networking.PlayerConnection.PlayerConnection UnityEngine.Networking.PlayerConnection.PlayerConnection::CreateInstance()
extern "C" PlayerConnection_t3517219175 * PlayerConnection_CreateInstance_m2276347858 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// T UnityEngine.ScriptableObject::CreateInstance<UnityEngine.Networking.PlayerConnection.PlayerConnection>()
#define ScriptableObject_CreateInstance_TisPlayerConnection_t3517219175_m2823640524(__this /* static, unused */, method) (( PlayerConnection_t3517219175 * (*) (Il2CppObject * /* static, unused */, const MethodInfo*))ScriptableObject_CreateInstance_TisIl2CppObject_m926060499_gshared)(__this /* static, unused */, method)
// System.Void UnityEngine.Object::set_hideFlags(UnityEngine.HideFlags)
extern "C" void Object_set_hideFlags_m2204253440 (Object_t1021602117 * __this, int32_t ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.InteropServices.Marshal::Copy(System.IntPtr,System.Byte[],System.Int32,System.Int32)
extern "C" void Marshal_Copy_m1683535972 (Il2CppObject * __this /* static, unused */, IntPtr_t p0, ByteU5BU5D_t3397334013* p1, int32_t p2, int32_t p3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Networking.PlayerConnection.PlayerConnection UnityEngine.Networking.PlayerConnection.PlayerConnection::get_instance()
extern "C" PlayerConnection_t3517219175 * PlayerConnection_get_instance_m3885313185 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Guid::.ctor(System.String)
extern "C" void Guid__ctor_m2599802704 (Guid_t * __this, String_t* p0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents::InvokeMessageIdSubscribers(System.Guid,System.Byte[],System.Int32)
extern "C" void PlayerEditorConnectionEvents_InvokeMessageIdSubscribers_m3217020342 (PlayerEditorConnectionEvents_t2252784345 * __this, Guid_t ___messageId0, ByteU5BU5D_t3397334013* ___data1, int32_t ___playerId2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Collections.Generic.List`1<System.Int32>::Add(!0)
#define List_1_Add_m688682013(__this, p0, method) (( void (*) (List_1_t1440998580 *, int32_t, const MethodInfo*))List_1_Add_m688682013_gshared)(__this, p0, method)
// System.Void UnityEngine.Events.UnityEvent`1<System.Int32>::Invoke(T0)
#define UnityEvent_1_Invoke_m1903741765(__this, p0, method) (( void (*) (UnityEvent_1_t2110227463 *, int32_t, const MethodInfo*))UnityEvent_1_Invoke_m1903741765_gshared)(__this, p0, method)
// System.Void System.Collections.Generic.List`1<UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers>::.ctor()
#define List_1__ctor_m1357675898(__this, method) (( void (*) (List_1_t1660627182 *, const MethodInfo*))List_1__ctor_m310736118_gshared)(__this, method)
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/ConnectionChangeEvent::.ctor()
extern "C" void ConnectionChangeEvent__ctor_m616483304 (ConnectionChangeEvent_t536719976 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/<InvokeMessageIdSubscribers>c__AnonStorey0::.ctor()
extern "C" void U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0__ctor_m4027042344 (U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Func`2<UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers,System.Boolean>::.ctor(System.Object,System.IntPtr)
#define Func_2__ctor_m2608774846(__this, p0, p1, method) (( void (*) (Func_2_t2919696197 *, Il2CppObject *, IntPtr_t, const MethodInfo*))Func_2__ctor_m1354888807_gshared)(__this, p0, p1, method)
// System.Collections.Generic.IEnumerable`1<!!0> System.Linq.Enumerable::Where<UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers>(System.Collections.Generic.IEnumerable`1<!!0>,System.Func`2<!!0,System.Boolean>)
#define Enumerable_Where_TisMessageTypeSubscribers_t2291506050_m887802803(__this /* static, unused */, p0, p1, method) (( Il2CppObject* (*) (Il2CppObject * /* static, unused */, Il2CppObject*, Func_2_t2919696197 *, const MethodInfo*))Enumerable_Where_TisIl2CppObject_m1516493223_gshared)(__this /* static, unused */, p0, p1, method)
// System.Boolean System.Linq.Enumerable::Any<UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers>(System.Collections.Generic.IEnumerable`1<!!0>)
#define Enumerable_Any_TisMessageTypeSubscribers_t2291506050_m3682874628(__this /* static, unused */, p0, method) (( bool (*) (Il2CppObject * /* static, unused */, Il2CppObject*, const MethodInfo*))Enumerable_Any_TisIl2CppObject_m2208185096_gshared)(__this /* static, unused */, p0, method)
// System.String System.String::Concat(System.Object,System.Object)
extern "C" String_t* String_Concat_m56707527 (Il2CppObject * __this /* static, unused */, Il2CppObject * p0, Il2CppObject * p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Networking.PlayerConnection.MessageEventArgs::.ctor()
extern "C" void MessageEventArgs__ctor_m2154443826 (MessageEventArgs_t301283622 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Events.UnityEvent`1<UnityEngine.Networking.PlayerConnection.MessageEventArgs>::Invoke(T0)
#define UnityEvent_1_Invoke_m354862256(__this, p0, method) (( void (*) (UnityEvent_1_t339633637 *, MessageEventArgs_t301283622 *, const MethodInfo*))UnityEvent_1_Invoke_m838874366_gshared)(__this, p0, method)
// System.Guid UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers::get_MessageTypeId()
extern "C" Guid_t MessageTypeSubscribers_get_MessageTypeId_m1191914268 (MessageTypeSubscribers_t2291506050 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Guid::op_Equality(System.Guid,System.Guid)
extern "C" bool Guid_op_Equality_m789465560 (Il2CppObject * __this /* static, unused */, Guid_t p0, Guid_t p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Events.UnityEvent`1<System.Int32>::.ctor()
#define UnityEvent_1__ctor_m2948712401(__this, method) (( void (*) (UnityEvent_1_t2110227463 *, const MethodInfo*))UnityEvent_1__ctor_m2948712401_gshared)(__this, method)
// System.Void UnityEngine.Events.UnityEvent`1<UnityEngine.Networking.PlayerConnection.MessageEventArgs>::.ctor()
#define UnityEvent_1__ctor_m3765336006(__this, method) (( void (*) (UnityEvent_1_t339633637 *, const MethodInfo*))UnityEvent_1__ctor_m2073978020_gshared)(__this, method)
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageEvent::.ctor()
extern "C" void MessageEvent__ctor_m3253032545 (MessageEvent_t2167079021 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Object UnityEngine.Object::INTERNAL_CALL_Internal_InstantiateSingle(UnityEngine.Object,UnityEngine.Vector3&,UnityEngine.Quaternion&)
extern "C" Object_t1021602117 * Object_INTERNAL_CALL_Internal_InstantiateSingle_m3932420250 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, Vector3_t2243707580 * ___pos1, Quaternion_t4030073918 * ___rot2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Object UnityEngine.Object::INTERNAL_CALL_Internal_InstantiateSingleWithParent(UnityEngine.Object,UnityEngine.Transform,UnityEngine.Vector3&,UnityEngine.Quaternion&)
extern "C" Object_t1021602117 * Object_INTERNAL_CALL_Internal_InstantiateSingleWithParent_m1401308849 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, Transform_t3275118058 * ___parent1, Vector3_t2243707580 * ___pos2, Quaternion_t4030073918 * ___rot3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Object::Destroy(UnityEngine.Object,System.Single)
extern "C" void Object_Destroy_m4279412553 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___obj0, float ___t1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Object::DestroyImmediate(UnityEngine.Object,System.Boolean)
extern "C" void Object_DestroyImmediate_m3563317232 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___obj0, bool ___allowDestroyingAssets1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Object::DestroyObject(UnityEngine.Object,System.Single)
extern "C" void Object_DestroyObject_m282495858 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___obj0, float ___t1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.IntPtr::op_Equality(System.IntPtr,System.IntPtr)
extern "C" bool IntPtr_op_Equality_m1573482188 (Il2CppObject * __this /* static, unused */, IntPtr_t p0, IntPtr_t p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Object::GetOffsetOfInstanceIDInCPlusPlusObject()
extern "C" int32_t Object_GetOffsetOfInstanceIDInCPlusPlusObject_m1587840561 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int64 System.IntPtr::ToInt64()
extern "C" int64_t IntPtr_ToInt64_m39971741 (IntPtr_t* __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.IntPtr::.ctor(System.Int64)
extern "C" void IntPtr__ctor_m3803259710 (IntPtr_t* __this, int64_t p0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void* System.IntPtr::op_Explicit(System.IntPtr)
extern "C" void* IntPtr_op_Explicit_m1073656736 (Il2CppObject * __this /* static, unused */, IntPtr_t p0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Object::GetHashCode()
extern "C" int32_t Object_GetHashCode_m1715190285 (Il2CppObject * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Object::CompareBaseObjects(UnityEngine.Object,UnityEngine.Object)
extern "C" bool Object_CompareBaseObjects_m3953996214 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___lhs0, Object_t1021602117 * ___rhs1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Object::IsNativeObjectAlive(UnityEngine.Object)
extern "C" bool Object_IsNativeObjectAlive_m4056217615 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___o0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Object::ReferenceEquals(System.Object,System.Object)
extern "C" bool Object_ReferenceEquals_m3900584722 (Il2CppObject * __this /* static, unused */, Il2CppObject * p0, Il2CppObject * p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.IntPtr UnityEngine.Object::GetCachedPtr()
extern "C" IntPtr_t Object_GetCachedPtr_m943750213 (Object_t1021602117 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.IntPtr::op_Inequality(System.IntPtr,System.IntPtr)
extern "C" bool IntPtr_op_Inequality_m3044532593 (Il2CppObject * __this /* static, unused */, IntPtr_t p0, IntPtr_t p1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Object::CheckNullArgument(System.Object,System.String)
extern "C" void Object_CheckNullArgument_m1711119106 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___arg0, String_t* ___message1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Object UnityEngine.Object::Internal_InstantiateSingle(UnityEngine.Object,UnityEngine.Vector3,UnityEngine.Quaternion)
extern "C" Object_t1021602117 * Object_Internal_InstantiateSingle_m2776302597 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, Vector3_t2243707580 ___pos1, Quaternion_t4030073918 ___rot2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Object UnityEngine.Object::Internal_InstantiateSingleWithParent(UnityEngine.Object,UnityEngine.Transform,UnityEngine.Vector3,UnityEngine.Quaternion)
extern "C" Object_t1021602117 * Object_Internal_InstantiateSingleWithParent_m509082884 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, Transform_t3275118058 * ___parent1, Vector3_t2243707580 ___pos2, Quaternion_t4030073918 ___rot3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Object UnityEngine.Object::Internal_CloneSingle(UnityEngine.Object)
extern "C" Object_t1021602117 * Object_Internal_CloneSingle_m260620116 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Object UnityEngine.Object::Instantiate(UnityEngine.Object,UnityEngine.Transform,System.Boolean)
extern "C" Object_t1021602117 * Object_Instantiate_m2489341053 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___original0, Transform_t3275118058 * ___parent1, bool ___instantiateInWorldSpace2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Object UnityEngine.Object::Internal_CloneSingleWithParent(UnityEngine.Object,UnityEngine.Transform,System.Boolean)
extern "C" Object_t1021602117 * Object_Internal_CloneSingleWithParent_m665572246 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, Transform_t3275118058 * ___parent1, bool ___worldPositionStays2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Object[] UnityEngine.Object::FindObjectsOfType(System.Type)
extern "C" ObjectU5BU5D_t4217747464* Object_FindObjectsOfType_m2121813744 (Il2CppObject * __this /* static, unused */, Type_t * ___type0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.RaycastHit2D UnityEngine.Physics2D::Raycast(UnityEngine.Vector2,UnityEngine.Vector2,System.Single,System.Int32,System.Single,System.Single)
extern "C" RaycastHit2D_t4063908774 Physics2D_Raycast_m2303387255 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, float ___distance2, int32_t ___layerMask3, float ___minDepth4, float ___maxDepth5, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.ContactFilter2D UnityEngine.ContactFilter2D::CreateLegacyFilter(System.Int32,System.Single,System.Single)
extern "C" ContactFilter2D_t1672660996 ContactFilter2D_CreateLegacyFilter_m1912787689 (Il2CppObject * __this /* static, unused */, int32_t ___layerMask0, float ___minDepth1, float ___maxDepth2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Physics2D::Internal_Raycast(UnityEngine.Vector2,UnityEngine.Vector2,System.Single,UnityEngine.ContactFilter2D,UnityEngine.RaycastHit2D&)
extern "C" void Physics2D_Internal_Raycast_m2213595168 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, float ___distance2, ContactFilter2D_t1672660996 ___contactFilter3, RaycastHit2D_t4063908774 * ___raycastHit4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Physics2D::Raycast(UnityEngine.Vector2,UnityEngine.Vector2,UnityEngine.ContactFilter2D,UnityEngine.RaycastHit2D[],System.Single)
extern "C" int32_t Physics2D_Raycast_m564567838 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, ContactFilter2D_t1672660996 ___contactFilter2, RaycastHit2DU5BU5D_t4176517891* ___results3, float ___distance4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Physics2D::Internal_RaycastNonAlloc(UnityEngine.Vector2,UnityEngine.Vector2,System.Single,UnityEngine.ContactFilter2D,UnityEngine.RaycastHit2D[])
extern "C" int32_t Physics2D_Internal_RaycastNonAlloc_m1874107548 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, float ___distance2, ContactFilter2D_t1672660996 ___contactFilter3, RaycastHit2DU5BU5D_t4176517891* ___results4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Physics2D::INTERNAL_CALL_Internal_Raycast(UnityEngine.Vector2&,UnityEngine.Vector2&,System.Single,UnityEngine.ContactFilter2D&,UnityEngine.RaycastHit2D&)
extern "C" void Physics2D_INTERNAL_CALL_Internal_Raycast_m489831109 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___origin0, Vector2_t2243707579 * ___direction1, float ___distance2, ContactFilter2D_t1672660996 * ___contactFilter3, RaycastHit2D_t4063908774 * ___raycastHit4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Physics2D::INTERNAL_CALL_Internal_RaycastNonAlloc(UnityEngine.Vector2&,UnityEngine.Vector2&,System.Single,UnityEngine.ContactFilter2D&,UnityEngine.RaycastHit2D[])
extern "C" int32_t Physics2D_INTERNAL_CALL_Internal_RaycastNonAlloc_m2253171281 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___origin0, Vector2_t2243707579 * ___direction1, float ___distance2, ContactFilter2D_t1672660996 * ___contactFilter3, RaycastHit2DU5BU5D_t4176517891* ___results4, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.RaycastHit2D[] UnityEngine.Physics2D::INTERNAL_CALL_GetRayIntersectionAll(UnityEngine.Ray&,System.Single,System.Int32)
extern "C" RaycastHit2DU5BU5D_t4176517891* Physics2D_INTERNAL_CALL_GetRayIntersectionAll_m161475998 (Il2CppObject * __this /* static, unused */, Ray_t2469606224 * ___ray0, float ___distance1, int32_t ___layerMask2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Collections.Generic.List`1<UnityEngine.Rigidbody2D>::.ctor()
#define List_1__ctor_m2338710192(__this, method) (( void (*) (List_1_t4166282325 *, const MethodInfo*))List_1__ctor_m310736118_gshared)(__this, method)
// UnityEngine.Vector3 UnityEngine.Vector3::Normalize(UnityEngine.Vector3)
extern "C" Vector3_t2243707580 Vector3_Normalize_m2140428981 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Vector3::Dot(UnityEngine.Vector3,UnityEngine.Vector3)
extern "C" float Vector3_Dot_m3161182818 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 ___lhs0, Vector3_t2243707580 ___rhs1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Plane::.ctor(UnityEngine.Vector3,UnityEngine.Vector3)
extern "C" void Plane__ctor_m3187718367 (Plane_t3727654732 * __this, Vector3_t2243707580 ___inNormal0, Vector3_t2243707580 ___inPoint1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Plane::get_normal()
extern "C" Vector3_t2243707580 Plane_get_normal_m1872443823 (Plane_t3727654732 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Plane::get_distance()
extern "C" float Plane_get_distance_m1834776091 (Plane_t3727654732 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Ray::get_direction()
extern "C" Vector3_t2243707580 Ray_get_direction_m4059191533 (Ray_t2469606224 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Ray::get_origin()
extern "C" Vector3_t2243707580 Ray_get_origin_m3339262500 (Ray_t2469606224 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Mathf::Approximately(System.Single,System.Single)
extern "C" bool Mathf_Approximately_m1064446634 (Il2CppObject * __this /* static, unused */, float ___a0, float ___b1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Plane::Raycast(UnityEngine.Ray,System.Single&)
extern "C" bool Plane_Raycast_m2870142810 (Plane_t3727654732 * __this, Ray_t2469606224 ___ray0, float* ___enter1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Quaternion::INTERNAL_CALL_Inverse(UnityEngine.Quaternion&,UnityEngine.Quaternion&)
extern "C" void Quaternion_INTERNAL_CALL_Inverse_m1043108654 (Il2CppObject * __this /* static, unused */, Quaternion_t4030073918 * ___rotation0, Quaternion_t4030073918 * ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Vector3::op_Multiply(UnityEngine.Vector3,System.Single)
extern "C" Vector3_t2243707580 Vector3_op_Multiply_m1351554733 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 ___a0, float ___d1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Quaternion UnityEngine.Quaternion::Internal_FromEulerRad(UnityEngine.Vector3)
extern "C" Quaternion_t4030073918 Quaternion_Internal_FromEulerRad_m1121344272 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 ___euler0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Quaternion::INTERNAL_CALL_Internal_FromEulerRad(UnityEngine.Vector3&,UnityEngine.Quaternion&)
extern "C" void Quaternion_INTERNAL_CALL_Internal_FromEulerRad_m1113788132 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 * ___euler0, Quaternion_t4030073918 * ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Quaternion::Dot(UnityEngine.Quaternion,UnityEngine.Quaternion)
extern "C" float Quaternion_Dot_m952616600 (Il2CppObject * __this /* static, unused */, Quaternion_t4030073918 ___a0, Quaternion_t4030073918 ___b1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Quaternion::op_Equality(UnityEngine.Quaternion,UnityEngine.Quaternion)
extern "C" bool Quaternion_op_Equality_m2308156925 (Il2CppObject * __this /* static, unused */, Quaternion_t4030073918 ___lhs0, Quaternion_t4030073918 ___rhs1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Single::GetHashCode()
extern "C" int32_t Single_GetHashCode_m3102305584 (float* __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Quaternion::GetHashCode()
extern "C" int32_t Quaternion_GetHashCode_m2270520528 (Quaternion_t4030073918 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Single::Equals(System.Single)
extern "C" bool Single_Equals_m3359827399 (float* __this, float p0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Quaternion::Equals(System.Object)
extern "C" bool Quaternion_Equals_m3730391696 (Quaternion_t4030073918 * __this, Il2CppObject * ___other0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.Quaternion::ToString()
extern "C" String_t* Quaternion_ToString_m2638853272 (Quaternion_t4030073918 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Random::RandomRangeInt(System.Int32,System.Int32)
extern "C" int32_t Random_RandomRangeInt_m374035151 (Il2CppObject * __this /* static, unused */, int32_t ___min0, int32_t ___max1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.PropertyAttribute::.ctor()
extern "C" void PropertyAttribute__ctor_m3663555848 (PropertyAttribute_t2606999759 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RangeInt::.ctor(System.Int32,System.Int32)
extern "C" void RangeInt__ctor_m2462675305 (RangeInt_t2323401134 * __this, int32_t ___start0, int32_t ___length1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.RangeInt::get_end()
extern "C" int32_t RangeInt_get_end_m913869897 (RangeInt_t2323401134 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Vector3::get_normalized()
extern "C" Vector3_t2243707580 Vector3_get_normalized_m936072361 (Vector3_t2243707580 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Ray::.ctor(UnityEngine.Vector3,UnityEngine.Vector3)
extern "C" void Ray__ctor_m3379034047 (Ray_t2469606224 * __this, Vector3_t2243707580 ___origin0, Vector3_t2243707580 ___direction1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Vector3::op_Addition(UnityEngine.Vector3,UnityEngine.Vector3)
extern "C" Vector3_t2243707580 Vector3_op_Addition_m3146764857 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 ___a0, Vector3_t2243707580 ___b1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Ray::GetPoint(System.Single)
extern "C" Vector3_t2243707580 Ray_GetPoint_m1353702366 (Ray_t2469606224 * __this, float ___distance0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.Ray::ToString()
extern "C" String_t* Ray_ToString_m2019179238 (Ray_t2469606224 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.RaycastHit::get_point()
extern "C" Vector3_t2243707580 RaycastHit_get_point_m326143462 (RaycastHit_t87180320 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.RaycastHit::get_normal()
extern "C" Vector3_t2243707580 RaycastHit_get_normal_m817665579 (RaycastHit_t87180320 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.RaycastHit::get_distance()
extern "C" float RaycastHit_get_distance_m1178709367 (RaycastHit_t87180320 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Collider UnityEngine.RaycastHit::get_collider()
extern "C" Collider_t3497673348 * RaycastHit_get_collider_m301198172 (RaycastHit_t87180320 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::get_point()
extern "C" Vector2_t2243707579 RaycastHit2D_get_point_m442317739 (RaycastHit2D_t4063908774 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::get_normal()
extern "C" Vector2_t2243707579 RaycastHit2D_get_normal_m3768105386 (RaycastHit2D_t4063908774 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.RaycastHit2D::get_fraction()
extern "C" float RaycastHit2D_get_fraction_m1296150410 (RaycastHit2D_t4063908774 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Collider2D UnityEngine.RaycastHit2D::get_collider()
extern "C" Collider2D_t646061738 * RaycastHit2D_get_collider_m2568504212 (RaycastHit2D_t4063908774 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Rect::get_position()
extern "C" Vector2_t2243707579 Rect_get_position_m24550734 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Rect::get_center()
extern "C" Vector2_t2243707579 Rect_get_center_m3049923624 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Rect::get_xMin()
extern "C" float Rect_get_xMin_m1161102488 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Rect::get_yMin()
extern "C" float Rect_get_yMin_m1161103577 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Rect::get_min()
extern "C" Vector2_t2243707579 Rect_get_min_m2549872833 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Rect::get_max()
extern "C" Vector2_t2243707579 Rect_get_max_m96665935 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Rect::get_size()
extern "C" Vector2_t2243707579 Rect_get_size_m3833121112 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rect::set_xMin(System.Single)
extern "C" void Rect_set_xMin_m4214255623 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rect::set_yMin(System.Single)
extern "C" void Rect_set_yMin_m734445288 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rect::set_xMax(System.Single)
extern "C" void Rect_set_xMax_m3501625033 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rect::set_yMax(System.Single)
extern "C" void Rect_set_yMax_m21814698 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Rect::Contains(UnityEngine.Vector3)
extern "C" bool Rect_Contains_m1334685291 (Rect_t3681755626 * __this, Vector3_t2243707580 ___point0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Rect::Overlaps(UnityEngine.Rect)
extern "C" bool Rect_Overlaps_m210444568 (Rect_t3681755626 * __this, Rect_t3681755626 ___other0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Rect UnityEngine.Rect::OrderMinMax(UnityEngine.Rect)
extern "C" Rect_t3681755626 Rect_OrderMinMax_m1783437776 (Il2CppObject * __this /* static, unused */, Rect_t3681755626 ___rect0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Rect::Overlaps(UnityEngine.Rect,System.Boolean)
extern "C" bool Rect_Overlaps_m4145874649 (Rect_t3681755626 * __this, Rect_t3681755626 ___other0, bool ___allowInverse1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Rect::op_Equality(UnityEngine.Rect,UnityEngine.Rect)
extern "C" bool Rect_op_Equality_m2793663577 (Il2CppObject * __this /* static, unused */, Rect_t3681755626 ___lhs0, Rect_t3681755626 ___rhs1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Rect::GetHashCode()
extern "C" int32_t Rect_GetHashCode_m559954498 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Rect::Equals(System.Object)
extern "C" bool Rect_Equals_m3806390726 (Rect_t3681755626 * __this, Il2CppObject * ___other0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.String UnityEngine.Rect::ToString()
extern "C" String_t* Rect_ToString_m2728794442 (Rect_t3681755626 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectOffset::Init()
extern "C" void RectOffset_Init_m4361650 (RectOffset_t3387826427 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectOffset::Cleanup()
extern "C" void RectOffset_Cleanup_m3198970074 (RectOffset_t3387826427 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_get_rect(UnityEngine.Rect&)
extern "C" void RectTransform_INTERNAL_get_rect_m1177342209 (RectTransform_t3349966182 * __this, Rect_t3681755626 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_get_anchorMin(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_get_anchorMin_m3180545469 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_set_anchorMin(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_set_anchorMin_m885423409 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_get_anchorMax(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_get_anchorMax_m834202955 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_set_anchorMax(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_set_anchorMax_m1551648727 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_get_anchoredPosition(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_get_anchoredPosition_m3564306187 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_set_anchoredPosition(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_set_anchoredPosition_m693024247 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_get_sizeDelta(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_get_sizeDelta_m3975625099 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_set_sizeDelta(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_set_sizeDelta_m1402803191 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_get_pivot(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_get_pivot_m3003734630 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::INTERNAL_set_pivot(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_set_pivot_m2764958706 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform/ReapplyDrivenProperties::Invoke(UnityEngine.RectTransform)
extern "C" void ReapplyDrivenProperties_Invoke_m1090213637 (ReapplyDrivenProperties_t2020713228 * __this, RectTransform_t3349966182 * ___driven0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Rect UnityEngine.RectTransform::get_rect()
extern "C" Rect_t3681755626 RectTransform_get_rect_m73954734 (RectTransform_t3349966182 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Vector3::.ctor(System.Single,System.Single,System.Single)
extern "C" void Vector3__ctor_m2638739322 (Vector3_t2243707580 * __this, float ___x0, float ___y1, float ___z2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::GetLocalCorners(UnityEngine.Vector3[])
extern "C" void RectTransform_GetLocalCorners_m1836626405 (RectTransform_t3349966182 * __this, Vector3U5BU5D_t1172311765* ___fourCornersArray0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Transform UnityEngine.Component::get_transform()
extern "C" Transform_t3275118058 * Component_get_transform_m2697483695 (Component_t3819376471 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Transform::TransformPoint(UnityEngine.Vector3)
extern "C" Vector3_t2243707580 Transform_TransformPoint_m3272254198 (Transform_t3275118058 * __this, Vector3_t2243707580 ___position0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.RectTransform::get_anchoredPosition()
extern "C" Vector2_t2243707579 RectTransform_get_anchoredPosition_m3570822376 (RectTransform_t3349966182 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.RectTransform::get_sizeDelta()
extern "C" Vector2_t2243707579 RectTransform_get_sizeDelta_m2157326342 (RectTransform_t3349966182 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.RectTransform::get_pivot()
extern "C" Vector2_t2243707579 RectTransform_get_pivot_m759087479 (RectTransform_t3349966182 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Vector2::Scale(UnityEngine.Vector2,UnityEngine.Vector2)
extern "C" Vector2_t2243707579 Vector2_Scale_m3228063809 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___a0, Vector2_t2243707579 ___b1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Vector2::op_Subtraction(UnityEngine.Vector2,UnityEngine.Vector2)
extern "C" Vector2_t2243707579 Vector2_op_Subtraction_m1984215297 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___a0, Vector2_t2243707579 ___b1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::set_sizeDelta(UnityEngine.Vector2)
extern "C" void RectTransform_set_sizeDelta_m2319668137 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Vector2::get_one()
extern "C" Vector2_t2243707579 Vector2_get_one_m3174311904 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Vector2::op_Addition(UnityEngine.Vector2,UnityEngine.Vector2)
extern "C" Vector2_t2243707579 Vector2_op_Addition_m1389598521 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___a0, Vector2_t2243707579 ___b1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::set_anchoredPosition(UnityEngine.Vector2)
extern "C" void RectTransform_set_anchoredPosition_m2077229449 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.RectTransform::get_anchorMin()
extern "C" Vector2_t2243707579 RectTransform_get_anchorMin_m1497323108 (RectTransform_t3349966182 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Vector2::set_Item(System.Int32,System.Single)
extern "C" void Vector2_set_Item_m3881967114 (Vector2_t2243707579 * __this, int32_t ___index0, float ___value1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::set_anchorMin(UnityEngine.Vector2)
extern "C" void RectTransform_set_anchorMin_m4247668187 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.RectTransform::get_anchorMax()
extern "C" Vector2_t2243707579 RectTransform_get_anchorMax_m3816015142 (RectTransform_t3349966182 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::set_anchorMax(UnityEngine.Vector2)
extern "C" void RectTransform_set_anchorMax_m2955899993 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Single UnityEngine.Vector2::get_Item(System.Int32)
extern "C" float Vector2_get_Item_m2792130561 (Vector2_t2243707579 * __this, int32_t ___index0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.RectTransform::GetParentSize()
extern "C" Vector2_t2243707579 RectTransform_GetParentSize_m1571597933 (RectTransform_t3349966182 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Transform UnityEngine.Transform::get_parent()
extern "C" Transform_t3275118058 * Transform_get_parent_m147407266 (Transform_t3275118058 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Vector2::op_Implicit(UnityEngine.Vector2)
extern "C" Vector3_t2243707580 Vector2_op_Implicit_m176791411 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___v0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Ray UnityEngine.RectTransformUtility::ScreenPointToRay(UnityEngine.Camera,UnityEngine.Vector2)
extern "C" Ray_t2469606224 RectTransformUtility_ScreenPointToRay_m1842507230 (Il2CppObject * __this /* static, unused */, Camera_t189460977 * ___cam0, Vector2_t2243707579 ___screenPos1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Quaternion UnityEngine.Transform::get_rotation()
extern "C" Quaternion_t4030073918 Transform_get_rotation_m1033555130 (Transform_t3275118058 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Vector3::get_back()
extern "C" Vector3_t2243707580 Vector3_get_back_m4246539215 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Quaternion::op_Multiply(UnityEngine.Quaternion,UnityEngine.Vector3)
extern "C" Vector3_t2243707580 Quaternion_op_Multiply_m1483423721 (Il2CppObject * __this /* static, unused */, Quaternion_t4030073918 ___rotation0, Vector3_t2243707580 ___point1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Transform::get_position()
extern "C" Vector3_t2243707580 Transform_get_position_m1104419803 (Transform_t3275118058 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.RectTransformUtility::ScreenPointToWorldPointInRectangle(UnityEngine.RectTransform,UnityEngine.Vector2,UnityEngine.Camera,UnityEngine.Vector3&)
extern "C" bool RectTransformUtility_ScreenPointToWorldPointInRectangle_m2304638810 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rect0, Vector2_t2243707579 ___screenPoint1, Camera_t189460977 * ___cam2, Vector3_t2243707580 * ___worldPoint3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Transform::InverseTransformPoint(UnityEngine.Vector3)
extern "C" Vector3_t2243707580 Transform_InverseTransformPoint_m2648491174 (Transform_t3275118058 * __this, Vector3_t2243707580 ___position0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.Vector2::op_Implicit(UnityEngine.Vector3)
extern "C" Vector2_t2243707579 Vector2_op_Implicit_m1064335535 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 ___v0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.Object::op_Inequality(UnityEngine.Object,UnityEngine.Object)
extern "C" bool Object_op_Inequality_m2402264703 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___x0, Object_t1021602117 * ___y1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Ray UnityEngine.Camera::ScreenPointToRay(UnityEngine.Vector3)
extern "C" Ray_t2469606224 Camera_ScreenPointToRay_m614889538 (Camera_t189460977 * __this, Vector3_t2243707580 ___position0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector3 UnityEngine.Vector3::get_forward()
extern "C" Vector3_t2243707580 Vector3_get_forward_m1201659139 (Il2CppObject * __this /* static, unused */, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Transform UnityEngine.Transform::GetChild(System.Int32)
extern "C" Transform_t3275118058 * Transform_GetChild_m3838588184 (Transform_t3275118058 * __this, int32_t ___index0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransformUtility::FlipLayoutOnAxis(UnityEngine.RectTransform,System.Int32,System.Boolean,System.Boolean)
extern "C" void RectTransformUtility_FlipLayoutOnAxis_m3920364518 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rect0, int32_t ___axis1, bool ___keepPositioning2, bool ___recursive3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.Transform::get_childCount()
extern "C" int32_t Transform_get_childCount_m881385315 (Transform_t3275118058 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransform::set_pivot(UnityEngine.Vector2)
extern "C" void RectTransform_set_pivot_m1360548980 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransformUtility::FlipLayoutAxes(UnityEngine.RectTransform,System.Boolean,System.Boolean)
extern "C" void RectTransformUtility_FlipLayoutAxes_m532748168 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rect0, bool ___keepPositioning1, bool ___recursive2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Vector2 UnityEngine.RectTransformUtility::GetTransposed(UnityEngine.Vector2)
extern "C" Vector2_t2243707579 RectTransformUtility_GetTransposed_m1770338235 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___input0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.RectTransformUtility::INTERNAL_CALL_RectangleContainsScreenPoint(UnityEngine.RectTransform,UnityEngine.Vector2&,UnityEngine.Camera)
extern "C" bool RectTransformUtility_INTERNAL_CALL_RectangleContainsScreenPoint_m3362263993 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rect0, Vector2_t2243707579 * ___screenPoint1, Camera_t189460977 * ___cam2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransformUtility::INTERNAL_CALL_PixelAdjustPoint(UnityEngine.Vector2&,UnityEngine.Transform,UnityEngine.Canvas,UnityEngine.Vector2&)
extern "C" void RectTransformUtility_INTERNAL_CALL_PixelAdjustPoint_m2153046669 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___point0, Transform_t3275118058 * ___elementTransform1, Canvas_t209405766 * ___canvas2, Vector2_t2243707579 * ___value3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RectTransformUtility::INTERNAL_CALL_PixelAdjustRect(UnityEngine.RectTransform,UnityEngine.Canvas,UnityEngine.Rect&)
extern "C" void RectTransformUtility_INTERNAL_CALL_PixelAdjustRect_m1237215542 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rectTransform0, Canvas_t209405766 * ___canvas1, Rect_t3681755626 * ___value2, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.RemoteSettings/UpdatedEventHandler::Invoke()
extern "C" void UpdatedEventHandler_Invoke_m159598802 (UpdatedEventHandler_t3033456180 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.RenderTexture::Internal_GetWidth(UnityEngine.RenderTexture)
extern "C" int32_t RenderTexture_Internal_GetWidth_m2317917654 (Il2CppObject * __this /* static, unused */, RenderTexture_t2666733923 * ___mono0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.RenderTexture::Internal_GetHeight(UnityEngine.RenderTexture)
extern "C" int32_t RenderTexture_Internal_GetHeight_m2780941261 (Il2CppObject * __this /* static, unused */, RenderTexture_t2666733923 * ___mono0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.AsyncOperation::.ctor()
extern "C" void AsyncOperation__ctor_m2914860946 (AsyncOperation_t3814632279 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.Object UnityEngine.Resources::Load(System.String,System.Type)
extern "C" Object_t1021602117 * Resources_Load_m243305716 (Il2CppObject * __this /* static, unused */, String_t* ___path0, Type_t * ___systemTypeInstance1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rigidbody2D::INTERNAL_get_velocity(UnityEngine.Vector2&)
extern "C" void Rigidbody2D_INTERNAL_get_velocity_m3018296454 (Rigidbody2D_t502193897 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Rigidbody2D::INTERNAL_set_velocity(UnityEngine.Vector2&)
extern "C" void Rigidbody2D_INTERNAL_set_velocity_m1537663346 (Rigidbody2D_t502193897 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.SceneManagement.Scene::get_handle()
extern "C" int32_t Scene_get_handle_m1555912301 (Scene_t1684909666 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.SceneManagement.Scene::GetBuildIndexInternal(System.Int32)
extern "C" int32_t Scene_GetBuildIndexInternal_m287561822 (Il2CppObject * __this /* static, unused */, int32_t ___sceneHandle0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.SceneManagement.Scene::get_buildIndex()
extern "C" int32_t Scene_get_buildIndex_m3735680091 (Scene_t1684909666 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Int32 UnityEngine.SceneManagement.Scene::GetHashCode()
extern "C" int32_t Scene_GetHashCode_m3223653899 (Scene_t1684909666 * __this, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Boolean UnityEngine.SceneManagement.Scene::Equals(System.Object)
extern "C" bool Scene_Equals_m3588907349 (Scene_t1684909666 * __this, Il2CppObject * ___other0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.SceneManagement.SceneManager::INTERNAL_CALL_GetActiveScene(UnityEngine.SceneManagement.Scene&)
extern "C" void SceneManager_INTERNAL_CALL_GetActiveScene_m1595803318 (Il2CppObject * __this /* static, unused */, Scene_t1684909666 * ___value0, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.SceneManagement.SceneManager::LoadScene(System.Int32,UnityEngine.SceneManagement.LoadSceneMode)
extern "C" void SceneManager_LoadScene_m592643733 (Il2CppObject * __this /* static, unused */, int32_t ___sceneBuildIndex0, int32_t ___mode1, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// UnityEngine.AsyncOperation UnityEngine.SceneManagement.SceneManager::LoadSceneAsyncNameIndexInternal(System.String,System.Int32,System.Boolean,System.Boolean)
extern "C" AsyncOperation_t3814632279 * SceneManager_LoadSceneAsyncNameIndexInternal_m3279056043 (Il2CppObject * __this /* static, unused */, String_t* ___sceneName0, int32_t ___sceneBuildIndex1, bool ___isAdditive2, bool ___mustCompleteNextFrame3, const MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void UnityEngine.Events.UnityAction`2<UnityEngine.SceneManagement.Scene,UnityEngine.SceneManagement.LoadSceneMode>::Invoke(T0,T1)
#define UnityAction_2_Invoke_m1528820797(__this, p0, p1, method) (( void (*) (UnityAction_2_t1903595547 *, Scene_t1684909666 , int32_t, const MethodInfo*))UnityAction_2_Invoke_m1528820797_gshared)(__this, p0, p1, method)
// System.Void UnityEngine.Events.UnityAction`1<UnityEngine.SceneManagement.Scene>::Invoke(T0)
#define UnityAction_1_Invoke_m3061904506(__this, p0, method) (( void (*) (UnityAction_1_t3051495417 *, Scene_t1684909666 , const MethodInfo*))UnityAction_1_Invoke_m3061904506_gshared)(__this, p0, method)
// System.Void UnityEngine.Events.UnityAction`2<UnityEngine.SceneManagement.Scene,UnityEngine.SceneManagement.Scene>::Invoke(T0,T1)
#define UnityAction_2_Invoke_m670567184(__this, p0, p1, method) (( void (*) (UnityAction_2_t606618774 *, Scene_t1684909666 , Scene_t1684909666 , const MethodInfo*))UnityAction_2_Invoke_m670567184_gshared)(__this, p0, p1, method)
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Experimental.Director.ScriptPlayable::.ctor()
extern "C" void ScriptPlayable__ctor_m1712674040 (ScriptPlayable_t4067966717 * __this, const MethodInfo* method)
{
{
Playable__ctor_m334077411(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Experimental.Director.ScriptPlayable::OnGraphStart()
extern "C" void ScriptPlayable_OnGraphStart_m3208513529 (ScriptPlayable_t4067966717 * __this, const MethodInfo* method)
{
{
return;
}
}
// System.Void UnityEngine.Experimental.Director.ScriptPlayable::OnGraphStop()
extern "C" void ScriptPlayable_OnGraphStop_m4241519609 (ScriptPlayable_t4067966717 * __this, const MethodInfo* method)
{
{
return;
}
}
// System.Void UnityEngine.Experimental.Director.ScriptPlayable::OnDestroy()
extern "C" void ScriptPlayable_OnDestroy_m2705420547 (ScriptPlayable_t4067966717 * __this, const MethodInfo* method)
{
{
return;
}
}
// System.Void UnityEngine.Experimental.Director.ScriptPlayable::PrepareFrame(UnityEngine.Experimental.Director.FrameData)
extern "C" void ScriptPlayable_PrepareFrame_m1510577058 (ScriptPlayable_t4067966717 * __this, FrameData_t1120735295 ___info0, const MethodInfo* method)
{
{
return;
}
}
// System.Void UnityEngine.Experimental.Director.ScriptPlayable::ProcessFrame(UnityEngine.Experimental.Director.FrameData,System.Object)
extern "C" void ScriptPlayable_ProcessFrame_m4240263490 (ScriptPlayable_t4067966717 * __this, FrameData_t1120735295 ___info0, Il2CppObject * ___playerData1, const MethodInfo* method)
{
{
return;
}
}
// System.Void UnityEngine.Experimental.Director.ScriptPlayable::OnPlayStateChanged(UnityEngine.Experimental.Director.FrameData,UnityEngine.Experimental.Director.PlayState)
extern "C" void ScriptPlayable_OnPlayStateChanged_m2776325746 (ScriptPlayable_t4067966717 * __this, FrameData_t1120735295 ___info0, int32_t ___newState1, const MethodInfo* method)
{
{
return;
}
}
// UnityEngine.Experimental.Rendering.IRenderPipeline UnityEngine.Experimental.Rendering.RenderPipelineManager::get_currentPipeline()
extern "C" Il2CppObject * RenderPipelineManager_get_currentPipeline_m679160301 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RenderPipelineManager_get_currentPipeline_m679160301_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Il2CppObject * V_0 = NULL;
{
Il2CppObject * L_0 = ((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->get_U3CcurrentPipelineU3Ek__BackingField_1();
V_0 = L_0;
goto IL_000b;
}
IL_000b:
{
Il2CppObject * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.Experimental.Rendering.RenderPipelineManager::set_currentPipeline(UnityEngine.Experimental.Rendering.IRenderPipeline)
extern "C" void RenderPipelineManager_set_currentPipeline_m3825706412 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___value0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RenderPipelineManager_set_currentPipeline_m3825706412_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Il2CppObject * L_0 = ___value0;
((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->set_U3CcurrentPipelineU3Ek__BackingField_1(L_0);
return;
}
}
// System.Void UnityEngine.Experimental.Rendering.RenderPipelineManager::CleanupRenderPipeline()
extern "C" void RenderPipelineManager_CleanupRenderPipeline_m2242901458 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RenderPipelineManager_CleanupRenderPipeline_m2242901458_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Il2CppObject * L_0 = ((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->get_s_CurrentPipelineAsset_0();
if (!L_0)
{
goto IL_0015;
}
}
{
Il2CppObject * L_1 = ((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->get_s_CurrentPipelineAsset_0();
InterfaceActionInvoker0::Invoke(0 /* System.Void UnityEngine.Experimental.Rendering.IRenderPipelineAsset::DestroyCreatedInstances() */, IRenderPipelineAsset_t345810019_il2cpp_TypeInfo_var, L_1);
}
IL_0015:
{
((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->set_s_CurrentPipelineAsset_0((Il2CppObject *)NULL);
RenderPipelineManager_set_currentPipeline_m3825706412(NULL /*static, unused*/, (Il2CppObject *)NULL, /*hidden argument*/NULL);
return;
}
}
// System.Boolean UnityEngine.Experimental.Rendering.RenderPipelineManager::DoRenderLoop_Internal(UnityEngine.Experimental.Rendering.IRenderPipelineAsset,UnityEngine.Camera[],System.IntPtr)
extern "C" bool RenderPipelineManager_DoRenderLoop_Internal_m2267530247 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___pipe0, CameraU5BU5D_t3079764780* ___cameras1, IntPtr_t ___loopPtr2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RenderPipelineManager_DoRenderLoop_Internal_m2267530247_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
ScriptableRenderContext_t4271526 V_1;
memset(&V_1, 0, sizeof(V_1));
{
Il2CppObject * L_0 = ___pipe0;
bool L_1 = RenderPipelineManager_PrepareRenderPipeline_m4209257657(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
if (L_1)
{
goto IL_0013;
}
}
{
V_0 = (bool)0;
goto IL_0036;
}
IL_0013:
{
Initobj (ScriptableRenderContext_t4271526_il2cpp_TypeInfo_var, (&V_1));
IntPtr_t L_2 = ___loopPtr2;
ScriptableRenderContext_Initialize_m1349011973((&V_1), L_2, /*hidden argument*/NULL);
Il2CppObject * L_3 = RenderPipelineManager_get_currentPipeline_m679160301(NULL /*static, unused*/, /*hidden argument*/NULL);
ScriptableRenderContext_t4271526 L_4 = V_1;
CameraU5BU5D_t3079764780* L_5 = ___cameras1;
InterfaceActionInvoker2< ScriptableRenderContext_t4271526 , CameraU5BU5D_t3079764780* >::Invoke(1 /* System.Void UnityEngine.Experimental.Rendering.IRenderPipeline::Render(UnityEngine.Experimental.Rendering.ScriptableRenderContext,UnityEngine.Camera[]) */, IRenderPipeline_t2611978095_il2cpp_TypeInfo_var, L_3, L_4, L_5);
V_0 = (bool)1;
goto IL_0036;
}
IL_0036:
{
bool L_6 = V_0;
return L_6;
}
}
// System.Boolean UnityEngine.Experimental.Rendering.RenderPipelineManager::PrepareRenderPipeline(UnityEngine.Experimental.Rendering.IRenderPipelineAsset)
extern "C" bool RenderPipelineManager_PrepareRenderPipeline_m4209257657 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___pipe0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RenderPipelineManager_PrepareRenderPipeline_m4209257657_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
Il2CppObject * L_0 = ((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->get_s_CurrentPipelineAsset_0();
Il2CppObject * L_1 = ___pipe0;
if ((((Il2CppObject*)(Il2CppObject *)L_0) == ((Il2CppObject*)(Il2CppObject *)L_1)))
{
goto IL_0025;
}
}
{
Il2CppObject * L_2 = ((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->get_s_CurrentPipelineAsset_0();
if (!L_2)
{
goto IL_001e;
}
}
{
RenderPipelineManager_CleanupRenderPipeline_m2242901458(NULL /*static, unused*/, /*hidden argument*/NULL);
}
IL_001e:
{
Il2CppObject * L_3 = ___pipe0;
((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->set_s_CurrentPipelineAsset_0(L_3);
}
IL_0025:
{
Il2CppObject * L_4 = ((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->get_s_CurrentPipelineAsset_0();
if (!L_4)
{
goto IL_0057;
}
}
{
Il2CppObject * L_5 = RenderPipelineManager_get_currentPipeline_m679160301(NULL /*static, unused*/, /*hidden argument*/NULL);
if (!L_5)
{
goto IL_0048;
}
}
{
Il2CppObject * L_6 = RenderPipelineManager_get_currentPipeline_m679160301(NULL /*static, unused*/, /*hidden argument*/NULL);
bool L_7 = InterfaceFuncInvoker0< bool >::Invoke(0 /* System.Boolean UnityEngine.Experimental.Rendering.IRenderPipeline::get_disposed() */, IRenderPipeline_t2611978095_il2cpp_TypeInfo_var, L_6);
if (!L_7)
{
goto IL_0057;
}
}
IL_0048:
{
Il2CppObject * L_8 = ((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->get_s_CurrentPipelineAsset_0();
Il2CppObject * L_9 = InterfaceFuncInvoker0< Il2CppObject * >::Invoke(1 /* UnityEngine.Experimental.Rendering.IRenderPipeline UnityEngine.Experimental.Rendering.IRenderPipelineAsset::CreatePipeline() */, IRenderPipelineAsset_t345810019_il2cpp_TypeInfo_var, L_8);
RenderPipelineManager_set_currentPipeline_m3825706412(NULL /*static, unused*/, L_9, /*hidden argument*/NULL);
}
IL_0057:
{
Il2CppObject * L_10 = ((RenderPipelineManager_t984453155_StaticFields*)RenderPipelineManager_t984453155_il2cpp_TypeInfo_var->static_fields)->get_s_CurrentPipelineAsset_0();
V_0 = (bool)((((int32_t)((((Il2CppObject*)(Il2CppObject *)L_10) == ((Il2CppObject*)(Il2CppObject *)NULL))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0068;
}
IL_0068:
{
bool L_11 = V_0;
return L_11;
}
}
// System.Void UnityEngine.Experimental.Rendering.ScriptableRenderContext::Initialize(System.IntPtr)
extern "C" void ScriptableRenderContext_Initialize_m1349011973 (ScriptableRenderContext_t4271526 * __this, IntPtr_t ___ptr0, const MethodInfo* method)
{
{
IntPtr_t L_0 = ___ptr0;
__this->set_m_Ptr_0(L_0);
return;
}
}
extern "C" void ScriptableRenderContext_Initialize_m1349011973_AdjustorThunk (Il2CppObject * __this, IntPtr_t ___ptr0, const MethodInfo* method)
{
ScriptableRenderContext_t4271526 * _thisAdjusted = reinterpret_cast<ScriptableRenderContext_t4271526 *>(__this + 1);
ScriptableRenderContext_Initialize_m1349011973(_thisAdjusted, ___ptr0, method);
}
// UnityEngine.Material UnityEngine.Font::get_material()
extern "C" Material_t193706927 * Font_get_material_m2086804907 (Font_t4239498691 * __this, const MethodInfo* method)
{
typedef Material_t193706927 * (*Font_get_material_m2086804907_ftn) (Font_t4239498691 *);
static Font_get_material_m2086804907_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Font_get_material_m2086804907_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Font::get_material()");
return _il2cpp_icall_func(__this);
}
// System.Boolean UnityEngine.Font::HasCharacter(System.Char)
extern "C" bool Font_HasCharacter_m538120140 (Font_t4239498691 * __this, Il2CppChar ___c0, const MethodInfo* method)
{
typedef bool (*Font_HasCharacter_m538120140_ftn) (Font_t4239498691 *, Il2CppChar);
static Font_HasCharacter_m538120140_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Font_HasCharacter_m538120140_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Font::HasCharacter(System.Char)");
return _il2cpp_icall_func(__this, ___c0);
}
// System.Void UnityEngine.Font::add_textureRebuilt(System.Action`1<UnityEngine.Font>)
extern "C" void Font_add_textureRebuilt_m1282639736 (Il2CppObject * __this /* static, unused */, Action_1_t4041298073 * ___value0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Font_add_textureRebuilt_m1282639736_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Action_1_t4041298073 * V_0 = NULL;
Action_1_t4041298073 * V_1 = NULL;
{
Action_1_t4041298073 * L_0 = ((Font_t4239498691_StaticFields*)Font_t4239498691_il2cpp_TypeInfo_var->static_fields)->get_textureRebuilt_2();
V_0 = L_0;
}
IL_0006:
{
Action_1_t4041298073 * L_1 = V_0;
V_1 = L_1;
Action_1_t4041298073 * L_2 = V_1;
Action_1_t4041298073 * L_3 = ___value0;
Delegate_t3022476291 * L_4 = Delegate_Combine_m3791207084(NULL /*static, unused*/, L_2, L_3, /*hidden argument*/NULL);
Action_1_t4041298073 * L_5 = V_0;
Action_1_t4041298073 * L_6 = InterlockedCompareExchangeImpl<Action_1_t4041298073 *>((((Font_t4239498691_StaticFields*)Font_t4239498691_il2cpp_TypeInfo_var->static_fields)->get_address_of_textureRebuilt_2()), ((Action_1_t4041298073 *)CastclassSealed(L_4, Action_1_t4041298073_il2cpp_TypeInfo_var)), L_5);
V_0 = L_6;
Action_1_t4041298073 * L_7 = V_0;
Action_1_t4041298073 * L_8 = V_1;
if ((!(((Il2CppObject*)(Action_1_t4041298073 *)L_7) == ((Il2CppObject*)(Action_1_t4041298073 *)L_8))))
{
goto IL_0006;
}
}
{
return;
}
}
// System.Void UnityEngine.Font::remove_textureRebuilt(System.Action`1<UnityEngine.Font>)
extern "C" void Font_remove_textureRebuilt_m2672217591 (Il2CppObject * __this /* static, unused */, Action_1_t4041298073 * ___value0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Font_remove_textureRebuilt_m2672217591_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Action_1_t4041298073 * V_0 = NULL;
Action_1_t4041298073 * V_1 = NULL;
{
Action_1_t4041298073 * L_0 = ((Font_t4239498691_StaticFields*)Font_t4239498691_il2cpp_TypeInfo_var->static_fields)->get_textureRebuilt_2();
V_0 = L_0;
}
IL_0006:
{
Action_1_t4041298073 * L_1 = V_0;
V_1 = L_1;
Action_1_t4041298073 * L_2 = V_1;
Action_1_t4041298073 * L_3 = ___value0;
Delegate_t3022476291 * L_4 = Delegate_Remove_m2626518725(NULL /*static, unused*/, L_2, L_3, /*hidden argument*/NULL);
Action_1_t4041298073 * L_5 = V_0;
Action_1_t4041298073 * L_6 = InterlockedCompareExchangeImpl<Action_1_t4041298073 *>((((Font_t4239498691_StaticFields*)Font_t4239498691_il2cpp_TypeInfo_var->static_fields)->get_address_of_textureRebuilt_2()), ((Action_1_t4041298073 *)CastclassSealed(L_4, Action_1_t4041298073_il2cpp_TypeInfo_var)), L_5);
V_0 = L_6;
Action_1_t4041298073 * L_7 = V_0;
Action_1_t4041298073 * L_8 = V_1;
if ((!(((Il2CppObject*)(Action_1_t4041298073 *)L_7) == ((Il2CppObject*)(Action_1_t4041298073 *)L_8))))
{
goto IL_0006;
}
}
{
return;
}
}
// System.Void UnityEngine.Font::InvokeTextureRebuilt_Internal(UnityEngine.Font)
extern "C" void Font_InvokeTextureRebuilt_Internal_m2007522718 (Il2CppObject * __this /* static, unused */, Font_t4239498691 * ___font0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Font_InvokeTextureRebuilt_Internal_m2007522718_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Action_1_t4041298073 * V_0 = NULL;
{
Action_1_t4041298073 * L_0 = ((Font_t4239498691_StaticFields*)Font_t4239498691_il2cpp_TypeInfo_var->static_fields)->get_textureRebuilt_2();
V_0 = L_0;
Action_1_t4041298073 * L_1 = V_0;
if (!L_1)
{
goto IL_0014;
}
}
{
Action_1_t4041298073 * L_2 = V_0;
Font_t4239498691 * L_3 = ___font0;
Action_1_Invoke_m1059548733(L_2, L_3, /*hidden argument*/Action_1_Invoke_m1059548733_MethodInfo_var);
}
IL_0014:
{
Font_t4239498691 * L_4 = ___font0;
FontTextureRebuildCallback_t1272078033 * L_5 = L_4->get_m_FontTextureRebuildCallback_3();
if (!L_5)
{
goto IL_002a;
}
}
{
Font_t4239498691 * L_6 = ___font0;
FontTextureRebuildCallback_t1272078033 * L_7 = L_6->get_m_FontTextureRebuildCallback_3();
FontTextureRebuildCallback_Invoke_m3940800729(L_7, /*hidden argument*/NULL);
}
IL_002a:
{
return;
}
}
// System.Boolean UnityEngine.Font::get_dynamic()
extern "C" bool Font_get_dynamic_m1803576936 (Font_t4239498691 * __this, const MethodInfo* method)
{
typedef bool (*Font_get_dynamic_m1803576936_ftn) (Font_t4239498691 *);
static Font_get_dynamic_m1803576936_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Font_get_dynamic_m1803576936_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Font::get_dynamic()");
return _il2cpp_icall_func(__this);
}
// System.Int32 UnityEngine.Font::get_fontSize()
extern "C" int32_t Font_get_fontSize_m1732593415 (Font_t4239498691 * __this, const MethodInfo* method)
{
typedef int32_t (*Font_get_fontSize_m1732593415_ftn) (Font_t4239498691 *);
static Font_get_fontSize_m1732593415_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Font_get_fontSize_m1732593415_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Font::get_fontSize()");
return _il2cpp_icall_func(__this);
}
extern "C" void DelegatePInvokeWrapper_FontTextureRebuildCallback_t1272078033 (FontTextureRebuildCallback_t1272078033 * __this, const MethodInfo* method)
{
typedef void (STDCALL *PInvokeFunc)();
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(((Il2CppDelegate*)__this)->method->methodPointer);
// Native function invocation
il2cppPInvokeFunc();
}
// System.Void UnityEngine.Font/FontTextureRebuildCallback::.ctor(System.Object,System.IntPtr)
extern "C" void FontTextureRebuildCallback__ctor_m2544331289 (FontTextureRebuildCallback_t1272078033 * __this, Il2CppObject * ___object0, IntPtr_t ___method1, const MethodInfo* method)
{
__this->set_method_ptr_0((Il2CppMethodPointer)((MethodInfo*)___method1.get_m_value_0())->methodPointer);
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Font/FontTextureRebuildCallback::Invoke()
extern "C" void FontTextureRebuildCallback_Invoke_m3940800729 (FontTextureRebuildCallback_t1272078033 * __this, const MethodInfo* method)
{
if(__this->get_prev_9() != NULL)
{
FontTextureRebuildCallback_Invoke_m3940800729((FontTextureRebuildCallback_t1272078033 *)__this->get_prev_9(), method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->get_method_3().get_m_value_0()));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->get_method_3().get_m_value_0()));
if ((__this->get_m_target_2() != NULL || MethodHasParameters((MethodInfo*)(__this->get_method_3().get_m_value_0()))) && ___methodIsStatic)
{
typedef void (*FunctionPointerType) (Il2CppObject *, void* __this, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(NULL,__this->get_m_target_2(),(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
else
{
typedef void (*FunctionPointerType) (void* __this, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(__this->get_m_target_2(),(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
}
// System.IAsyncResult UnityEngine.Font/FontTextureRebuildCallback::BeginInvoke(System.AsyncCallback,System.Object)
extern "C" Il2CppObject * FontTextureRebuildCallback_BeginInvoke_m381807774 (FontTextureRebuildCallback_t1272078033 * __this, AsyncCallback_t163412349 * ___callback0, Il2CppObject * ___object1, const MethodInfo* method)
{
void *__d_args[1] = {0};
return (Il2CppObject *)il2cpp_codegen_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback0, (Il2CppObject*)___object1);
}
// System.Void UnityEngine.Font/FontTextureRebuildCallback::EndInvoke(System.IAsyncResult)
extern "C" void FontTextureRebuildCallback_EndInvoke_m4275555211 (FontTextureRebuildCallback_t1272078033 * __this, Il2CppObject * ___result0, const MethodInfo* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
// System.Void UnityEngine.GameObject::.ctor(System.String)
extern "C" void GameObject__ctor_m962601984 (GameObject_t1756533147 * __this, String_t* ___name0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GameObject__ctor_m962601984_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object__ctor_m197157284(__this, /*hidden argument*/NULL);
String_t* L_0 = ___name0;
GameObject_Internal_CreateGameObject_m3428198595(NULL /*static, unused*/, __this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GameObject::.ctor(System.String,System.Type[])
extern "C" void GameObject__ctor_m1633632305 (GameObject_t1756533147 * __this, String_t* ___name0, TypeU5BU5D_t1664964607* ___components1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GameObject__ctor_m1633632305_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Type_t * V_0 = NULL;
TypeU5BU5D_t1664964607* V_1 = NULL;
int32_t V_2 = 0;
{
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object__ctor_m197157284(__this, /*hidden argument*/NULL);
String_t* L_0 = ___name0;
GameObject_Internal_CreateGameObject_m3428198595(NULL /*static, unused*/, __this, L_0, /*hidden argument*/NULL);
TypeU5BU5D_t1664964607* L_1 = ___components1;
V_1 = L_1;
V_2 = 0;
goto IL_0028;
}
IL_0018:
{
TypeU5BU5D_t1664964607* L_2 = V_1;
int32_t L_3 = V_2;
int32_t L_4 = L_3;
Type_t * L_5 = (L_2)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_4));
V_0 = L_5;
Type_t * L_6 = V_0;
GameObject_AddComponent_m3757565614(__this, L_6, /*hidden argument*/NULL);
int32_t L_7 = V_2;
V_2 = ((int32_t)((int32_t)L_7+(int32_t)1));
}
IL_0028:
{
int32_t L_8 = V_2;
TypeU5BU5D_t1664964607* L_9 = V_1;
if ((((int32_t)L_8) < ((int32_t)(((int32_t)((int32_t)(((Il2CppArray *)L_9)->max_length)))))))
{
goto IL_0018;
}
}
{
return;
}
}
// UnityEngine.Component UnityEngine.GameObject::GetComponent(System.Type)
extern "C" Component_t3819376471 * GameObject_GetComponent_m306258075 (GameObject_t1756533147 * __this, Type_t * ___type0, const MethodInfo* method)
{
typedef Component_t3819376471 * (*GameObject_GetComponent_m306258075_ftn) (GameObject_t1756533147 *, Type_t *);
static GameObject_GetComponent_m306258075_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_GetComponent_m306258075_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::GetComponent(System.Type)");
return _il2cpp_icall_func(__this, ___type0);
}
// UnityEngine.Component UnityEngine.GameObject::GetComponentInChildren(System.Type,System.Boolean)
extern "C" Component_t3819376471 * GameObject_GetComponentInChildren_m4263325740 (GameObject_t1756533147 * __this, Type_t * ___type0, bool ___includeInactive1, const MethodInfo* method)
{
typedef Component_t3819376471 * (*GameObject_GetComponentInChildren_m4263325740_ftn) (GameObject_t1756533147 *, Type_t *, bool);
static GameObject_GetComponentInChildren_m4263325740_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_GetComponentInChildren_m4263325740_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::GetComponentInChildren(System.Type,System.Boolean)");
return _il2cpp_icall_func(__this, ___type0, ___includeInactive1);
}
// UnityEngine.Component UnityEngine.GameObject::GetComponentInParent(System.Type)
extern "C" Component_t3819376471 * GameObject_GetComponentInParent_m1235194528 (GameObject_t1756533147 * __this, Type_t * ___type0, const MethodInfo* method)
{
typedef Component_t3819376471 * (*GameObject_GetComponentInParent_m1235194528_ftn) (GameObject_t1756533147 *, Type_t *);
static GameObject_GetComponentInParent_m1235194528_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_GetComponentInParent_m1235194528_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::GetComponentInParent(System.Type)");
return _il2cpp_icall_func(__this, ___type0);
}
// UnityEngine.Component[] UnityEngine.GameObject::GetComponents(System.Type)
extern "C" ComponentU5BU5D_t4136971630* GameObject_GetComponents_m297658252 (GameObject_t1756533147 * __this, Type_t * ___type0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GameObject_GetComponents_m297658252_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ComponentU5BU5D_t4136971630* V_0 = NULL;
{
Type_t * L_0 = ___type0;
Il2CppArray * L_1 = GameObject_GetComponentsInternal_m3486524399(__this, L_0, (bool)0, (bool)0, (bool)1, (bool)0, NULL, /*hidden argument*/NULL);
V_0 = ((ComponentU5BU5D_t4136971630*)Castclass(L_1, ComponentU5BU5D_t4136971630_il2cpp_TypeInfo_var));
goto IL_0018;
}
IL_0018:
{
ComponentU5BU5D_t4136971630* L_2 = V_0;
return L_2;
}
}
// UnityEngine.Component[] UnityEngine.GameObject::GetComponentsInChildren(System.Type,System.Boolean)
extern "C" ComponentU5BU5D_t4136971630* GameObject_GetComponentsInChildren_m993725821 (GameObject_t1756533147 * __this, Type_t * ___type0, bool ___includeInactive1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GameObject_GetComponentsInChildren_m993725821_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ComponentU5BU5D_t4136971630* V_0 = NULL;
{
Type_t * L_0 = ___type0;
bool L_1 = ___includeInactive1;
Il2CppArray * L_2 = GameObject_GetComponentsInternal_m3486524399(__this, L_0, (bool)0, (bool)1, L_1, (bool)0, NULL, /*hidden argument*/NULL);
V_0 = ((ComponentU5BU5D_t4136971630*)Castclass(L_2, ComponentU5BU5D_t4136971630_il2cpp_TypeInfo_var));
goto IL_0018;
}
IL_0018:
{
ComponentU5BU5D_t4136971630* L_3 = V_0;
return L_3;
}
}
// UnityEngine.Component[] UnityEngine.GameObject::GetComponentsInParent(System.Type,System.Boolean)
extern "C" ComponentU5BU5D_t4136971630* GameObject_GetComponentsInParent_m1568786844 (GameObject_t1756533147 * __this, Type_t * ___type0, bool ___includeInactive1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GameObject_GetComponentsInParent_m1568786844_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ComponentU5BU5D_t4136971630* V_0 = NULL;
{
Type_t * L_0 = ___type0;
bool L_1 = ___includeInactive1;
Il2CppArray * L_2 = GameObject_GetComponentsInternal_m3486524399(__this, L_0, (bool)0, (bool)1, L_1, (bool)1, NULL, /*hidden argument*/NULL);
V_0 = ((ComponentU5BU5D_t4136971630*)Castclass(L_2, ComponentU5BU5D_t4136971630_il2cpp_TypeInfo_var));
goto IL_0018;
}
IL_0018:
{
ComponentU5BU5D_t4136971630* L_3 = V_0;
return L_3;
}
}
// System.Array UnityEngine.GameObject::GetComponentsInternal(System.Type,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Object)
extern "C" Il2CppArray * GameObject_GetComponentsInternal_m3486524399 (GameObject_t1756533147 * __this, Type_t * ___type0, bool ___useSearchTypeAsArrayReturnType1, bool ___recursive2, bool ___includeInactive3, bool ___reverse4, Il2CppObject * ___resultList5, const MethodInfo* method)
{
typedef Il2CppArray * (*GameObject_GetComponentsInternal_m3486524399_ftn) (GameObject_t1756533147 *, Type_t *, bool, bool, bool, bool, Il2CppObject *);
static GameObject_GetComponentsInternal_m3486524399_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_GetComponentsInternal_m3486524399_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::GetComponentsInternal(System.Type,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Object)");
return _il2cpp_icall_func(__this, ___type0, ___useSearchTypeAsArrayReturnType1, ___recursive2, ___includeInactive3, ___reverse4, ___resultList5);
}
// UnityEngine.Transform UnityEngine.GameObject::get_transform()
extern "C" Transform_t3275118058 * GameObject_get_transform_m909382139 (GameObject_t1756533147 * __this, const MethodInfo* method)
{
typedef Transform_t3275118058 * (*GameObject_get_transform_m909382139_ftn) (GameObject_t1756533147 *);
static GameObject_get_transform_m909382139_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_get_transform_m909382139_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::get_transform()");
return _il2cpp_icall_func(__this);
}
// System.Int32 UnityEngine.GameObject::get_layer()
extern "C" int32_t GameObject_get_layer_m725607808 (GameObject_t1756533147 * __this, const MethodInfo* method)
{
typedef int32_t (*GameObject_get_layer_m725607808_ftn) (GameObject_t1756533147 *);
static GameObject_get_layer_m725607808_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_get_layer_m725607808_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::get_layer()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GameObject::set_layer(System.Int32)
extern "C" void GameObject_set_layer_m2712461877 (GameObject_t1756533147 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*GameObject_set_layer_m2712461877_ftn) (GameObject_t1756533147 *, int32_t);
static GameObject_set_layer_m2712461877_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_set_layer_m2712461877_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::set_layer(System.Int32)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.GameObject::SetActive(System.Boolean)
extern "C" void GameObject_SetActive_m2887581199 (GameObject_t1756533147 * __this, bool ___value0, const MethodInfo* method)
{
typedef void (*GameObject_SetActive_m2887581199_ftn) (GameObject_t1756533147 *, bool);
static GameObject_SetActive_m2887581199_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_SetActive_m2887581199_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::SetActive(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Boolean UnityEngine.GameObject::get_activeSelf()
extern "C" bool GameObject_get_activeSelf_m313590879 (GameObject_t1756533147 * __this, const MethodInfo* method)
{
typedef bool (*GameObject_get_activeSelf_m313590879_ftn) (GameObject_t1756533147 *);
static GameObject_get_activeSelf_m313590879_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_get_activeSelf_m313590879_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::get_activeSelf()");
return _il2cpp_icall_func(__this);
}
// System.Boolean UnityEngine.GameObject::get_activeInHierarchy()
extern "C" bool GameObject_get_activeInHierarchy_m4242915935 (GameObject_t1756533147 * __this, const MethodInfo* method)
{
typedef bool (*GameObject_get_activeInHierarchy_m4242915935_ftn) (GameObject_t1756533147 *);
static GameObject_get_activeInHierarchy_m4242915935_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_get_activeInHierarchy_m4242915935_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::get_activeInHierarchy()");
return _il2cpp_icall_func(__this);
}
// System.String UnityEngine.GameObject::get_tag()
extern "C" String_t* GameObject_get_tag_m1425941094 (GameObject_t1756533147 * __this, const MethodInfo* method)
{
typedef String_t* (*GameObject_get_tag_m1425941094_ftn) (GameObject_t1756533147 *);
static GameObject_get_tag_m1425941094_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_get_tag_m1425941094_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::get_tag()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GameObject::set_tag(System.String)
extern "C" void GameObject_set_tag_m717375123 (GameObject_t1756533147 * __this, String_t* ___value0, const MethodInfo* method)
{
typedef void (*GameObject_set_tag_m717375123_ftn) (GameObject_t1756533147 *, String_t*);
static GameObject_set_tag_m717375123_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_set_tag_m717375123_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::set_tag(System.String)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.GameObject::SendMessage(System.String,System.Object,UnityEngine.SendMessageOptions)
extern "C" void GameObject_SendMessage_m71956653 (GameObject_t1756533147 * __this, String_t* ___methodName0, Il2CppObject * ___value1, int32_t ___options2, const MethodInfo* method)
{
typedef void (*GameObject_SendMessage_m71956653_ftn) (GameObject_t1756533147 *, String_t*, Il2CppObject *, int32_t);
static GameObject_SendMessage_m71956653_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_SendMessage_m71956653_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::SendMessage(System.String,System.Object,UnityEngine.SendMessageOptions)");
_il2cpp_icall_func(__this, ___methodName0, ___value1, ___options2);
}
// UnityEngine.Component UnityEngine.GameObject::Internal_AddComponentWithType(System.Type)
extern "C" Component_t3819376471 * GameObject_Internal_AddComponentWithType_m214735204 (GameObject_t1756533147 * __this, Type_t * ___componentType0, const MethodInfo* method)
{
typedef Component_t3819376471 * (*GameObject_Internal_AddComponentWithType_m214735204_ftn) (GameObject_t1756533147 *, Type_t *);
static GameObject_Internal_AddComponentWithType_m214735204_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_Internal_AddComponentWithType_m214735204_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::Internal_AddComponentWithType(System.Type)");
return _il2cpp_icall_func(__this, ___componentType0);
}
// UnityEngine.Component UnityEngine.GameObject::AddComponent(System.Type)
extern "C" Component_t3819376471 * GameObject_AddComponent_m3757565614 (GameObject_t1756533147 * __this, Type_t * ___componentType0, const MethodInfo* method)
{
Component_t3819376471 * V_0 = NULL;
{
Type_t * L_0 = ___componentType0;
Component_t3819376471 * L_1 = GameObject_Internal_AddComponentWithType_m214735204(__this, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000e;
}
IL_000e:
{
Component_t3819376471 * L_2 = V_0;
return L_2;
}
}
// System.Void UnityEngine.GameObject::Internal_CreateGameObject(UnityEngine.GameObject,System.String)
extern "C" void GameObject_Internal_CreateGameObject_m3428198595 (Il2CppObject * __this /* static, unused */, GameObject_t1756533147 * ___mono0, String_t* ___name1, const MethodInfo* method)
{
typedef void (*GameObject_Internal_CreateGameObject_m3428198595_ftn) (GameObject_t1756533147 *, String_t*);
static GameObject_Internal_CreateGameObject_m3428198595_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GameObject_Internal_CreateGameObject_m3428198595_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GameObject::Internal_CreateGameObject(UnityEngine.GameObject,System.String)");
_il2cpp_icall_func(___mono0, ___name1);
}
// Conversion methods for marshalling of: UnityEngine.Gradient
extern "C" void Gradient_t3600583008_marshal_pinvoke(const Gradient_t3600583008& unmarshaled, Gradient_t3600583008_marshaled_pinvoke& marshaled)
{
marshaled.___m_Ptr_0 = reinterpret_cast<intptr_t>((unmarshaled.get_m_Ptr_0()).get_m_value_0());
}
extern "C" void Gradient_t3600583008_marshal_pinvoke_back(const Gradient_t3600583008_marshaled_pinvoke& marshaled, Gradient_t3600583008& unmarshaled)
{
IntPtr_t unmarshaled_m_Ptr_temp_0;
memset(&unmarshaled_m_Ptr_temp_0, 0, sizeof(unmarshaled_m_Ptr_temp_0));
IntPtr_t unmarshaled_m_Ptr_temp_0_temp;
unmarshaled_m_Ptr_temp_0_temp.set_m_value_0(reinterpret_cast<void*>((intptr_t)(marshaled.___m_Ptr_0)));
unmarshaled_m_Ptr_temp_0 = unmarshaled_m_Ptr_temp_0_temp;
unmarshaled.set_m_Ptr_0(unmarshaled_m_Ptr_temp_0);
}
// Conversion method for clean up from marshalling of: UnityEngine.Gradient
extern "C" void Gradient_t3600583008_marshal_pinvoke_cleanup(Gradient_t3600583008_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.Gradient
extern "C" void Gradient_t3600583008_marshal_com(const Gradient_t3600583008& unmarshaled, Gradient_t3600583008_marshaled_com& marshaled)
{
marshaled.___m_Ptr_0 = reinterpret_cast<intptr_t>((unmarshaled.get_m_Ptr_0()).get_m_value_0());
}
extern "C" void Gradient_t3600583008_marshal_com_back(const Gradient_t3600583008_marshaled_com& marshaled, Gradient_t3600583008& unmarshaled)
{
IntPtr_t unmarshaled_m_Ptr_temp_0;
memset(&unmarshaled_m_Ptr_temp_0, 0, sizeof(unmarshaled_m_Ptr_temp_0));
IntPtr_t unmarshaled_m_Ptr_temp_0_temp;
unmarshaled_m_Ptr_temp_0_temp.set_m_value_0(reinterpret_cast<void*>((intptr_t)(marshaled.___m_Ptr_0)));
unmarshaled_m_Ptr_temp_0 = unmarshaled_m_Ptr_temp_0_temp;
unmarshaled.set_m_Ptr_0(unmarshaled_m_Ptr_temp_0);
}
// Conversion method for clean up from marshalling of: UnityEngine.Gradient
extern "C" void Gradient_t3600583008_marshal_com_cleanup(Gradient_t3600583008_marshaled_com& marshaled)
{
}
// System.Void UnityEngine.Gradient::.ctor()
extern "C" void Gradient__ctor_m954570311 (Gradient_t3600583008 * __this, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
Gradient_Init_m4156899649(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Gradient::Init()
extern "C" void Gradient_Init_m4156899649 (Gradient_t3600583008 * __this, const MethodInfo* method)
{
typedef void (*Gradient_Init_m4156899649_ftn) (Gradient_t3600583008 *);
static Gradient_Init_m4156899649_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Gradient_Init_m4156899649_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Gradient::Init()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.Gradient::Cleanup()
extern "C" void Gradient_Cleanup_m3573871739 (Gradient_t3600583008 * __this, const MethodInfo* method)
{
typedef void (*Gradient_Cleanup_m3573871739_ftn) (Gradient_t3600583008 *);
static Gradient_Cleanup_m3573871739_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Gradient_Cleanup_m3573871739_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Gradient::Cleanup()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.Gradient::Finalize()
extern "C" void Gradient_Finalize_m2023716701 (Gradient_t3600583008 * __this, const MethodInfo* method)
{
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
{
}
IL_0001:
try
{ // begin try (depth: 1)
Gradient_Cleanup_m3573871739(__this, /*hidden argument*/NULL);
IL2CPP_LEAVE(0x13, FINALLY_000c);
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_000c;
}
FINALLY_000c:
{ // begin finally (depth: 1)
Object_Finalize_m4087144328(__this, /*hidden argument*/NULL);
IL2CPP_END_FINALLY(12)
} // end finally (depth: 1)
IL2CPP_CLEANUP(12)
{
IL2CPP_JUMP_TBL(0x13, IL_0013)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_0013:
{
return;
}
}
// System.Void UnityEngine.GUI::.cctor()
extern "C" void GUI__cctor_m1321863889 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUI__cctor_m1321863889_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_ScrollStepSize_0((10.0f));
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_HotTextField_1((-1));
int32_t L_0 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, _stringLiteral1502599537);
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_BoxHash_2(L_0);
int32_t L_1 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, _stringLiteral3916321877);
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_RepeatButtonHash_3(L_1);
int32_t L_2 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, _stringLiteral4217853282);
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_ToggleHash_4(L_2);
int32_t L_3 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, _stringLiteral2555502078);
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_ButtonGridHash_5(L_3);
int32_t L_4 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, _stringLiteral2877295445);
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_SliderHash_6(L_4);
int32_t L_5 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, _stringLiteral1731085918);
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_BeginGroupHash_7(L_5);
int32_t L_6 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, _stringLiteral3501964962);
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_ScrollviewHash_8(L_6);
GenericStack_t3718539591 * L_7 = (GenericStack_t3718539591 *)il2cpp_codegen_object_new(GenericStack_t3718539591_il2cpp_TypeInfo_var);
GenericStack__ctor_m1256224477(L_7, /*hidden argument*/NULL);
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_ScrollViewStates_11(L_7);
IL2CPP_RUNTIME_CLASS_INIT(DateTime_t693205669_il2cpp_TypeInfo_var);
DateTime_t693205669 L_8 = DateTime_get_Now_m24136300(NULL /*static, unused*/, /*hidden argument*/NULL);
GUI_set_nextScrollStepTime_m2724006954(NULL /*static, unused*/, L_8, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUI::set_nextScrollStepTime(System.DateTime)
extern "C" void GUI_set_nextScrollStepTime_m2724006954 (Il2CppObject * __this /* static, unused */, DateTime_t693205669 ___value0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUI_set_nextScrollStepTime_m2724006954_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
DateTime_t693205669 L_0 = ___value0;
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_U3CnextScrollStepTimeU3Ek__BackingField_9(L_0);
return;
}
}
// System.Void UnityEngine.GUI::set_skin(UnityEngine.GUISkin)
extern "C" void GUI_set_skin_m3391676555 (Il2CppObject * __this /* static, unused */, GUISkin_t1436893342 * ___value0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUI_set_skin_m3391676555_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
GUIUtility_CheckOnGUI_m4284398968(NULL /*static, unused*/, /*hidden argument*/NULL);
GUISkin_t1436893342 * L_0 = ___value0;
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUI_DoSetSkin_m3603287387(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUISkin UnityEngine.GUI::get_skin()
extern "C" GUISkin_t1436893342 * GUI_get_skin_m2309570990 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUI_get_skin_m2309570990_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUISkin_t1436893342 * V_0 = NULL;
{
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
GUIUtility_CheckOnGUI_m4284398968(NULL /*static, unused*/, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUISkin_t1436893342 * L_0 = ((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->get_s_Skin_10();
V_0 = L_0;
goto IL_0011;
}
IL_0011:
{
GUISkin_t1436893342 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUI::DoSetSkin(UnityEngine.GUISkin)
extern "C" void GUI_DoSetSkin_m3603287387 (Il2CppObject * __this /* static, unused */, GUISkin_t1436893342 * ___newSkin0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUI_DoSetSkin_m3603287387_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
GUISkin_t1436893342 * L_0 = ___newSkin0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_1 = Object_op_Implicit_m2856731593(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
if (L_1)
{
goto IL_0013;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
GUISkin_t1436893342 * L_2 = GUIUtility_GetDefaultSkin_m2022075576(NULL /*static, unused*/, /*hidden argument*/NULL);
___newSkin0 = L_2;
}
IL_0013:
{
GUISkin_t1436893342 * L_3 = ___newSkin0;
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
((GUI_t4082743951_StaticFields*)GUI_t4082743951_il2cpp_TypeInfo_var->static_fields)->set_s_Skin_10(L_3);
GUISkin_t1436893342 * L_4 = ___newSkin0;
GUISkin_MakeCurrent_m126414424(L_4, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUI::CallWindowDelegate(UnityEngine.GUI/WindowFunction,System.Int32,System.Int32,UnityEngine.GUISkin,System.Int32,System.Single,System.Single,UnityEngine.GUIStyle)
extern "C" void GUI_CallWindowDelegate_m2039577415 (Il2CppObject * __this /* static, unused */, WindowFunction_t3486805455 * ___func0, int32_t ___id1, int32_t ___instanceID2, GUISkin_t1436893342 * ____skin3, int32_t ___forceRect4, float ___width5, float ___height6, GUIStyle_t1799908754 * ___style7, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUI_CallWindowDelegate_m2039577415_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUISkin_t1436893342 * V_0 = NULL;
GUILayoutOptionU5BU5D_t2108882777* V_1 = NULL;
{
int32_t L_0 = ___id1;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_SelectIDList_m756828237(NULL /*static, unused*/, L_0, (bool)1, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUISkin_t1436893342 * L_1 = GUI_get_skin_m2309570990(NULL /*static, unused*/, /*hidden argument*/NULL);
V_0 = L_1;
Event_t3028476042 * L_2 = Event_get_current_m2901774193(NULL /*static, unused*/, /*hidden argument*/NULL);
int32_t L_3 = Event_get_type_m2426033198(L_2, /*hidden argument*/NULL);
if ((!(((uint32_t)L_3) == ((uint32_t)8))))
{
goto IL_0063;
}
}
{
int32_t L_4 = ___forceRect4;
if (!L_4)
{
goto IL_0052;
}
}
{
GUILayoutOptionU5BU5D_t2108882777* L_5 = ((GUILayoutOptionU5BU5D_t2108882777*)SZArrayNew(GUILayoutOptionU5BU5D_t2108882777_il2cpp_TypeInfo_var, (uint32_t)2));
float L_6 = ___width5;
GUILayoutOption_t4183744904 * L_7 = GUILayout_Width_m261136689(NULL /*static, unused*/, L_6, /*hidden argument*/NULL);
ArrayElementTypeCheck (L_5, L_7);
(L_5)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (GUILayoutOption_t4183744904 *)L_7);
GUILayoutOptionU5BU5D_t2108882777* L_8 = L_5;
float L_9 = ___height6;
GUILayoutOption_t4183744904 * L_10 = GUILayout_Height_m607115982(NULL /*static, unused*/, L_9, /*hidden argument*/NULL);
ArrayElementTypeCheck (L_8, L_10);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (GUILayoutOption_t4183744904 *)L_10);
V_1 = L_8;
int32_t L_11 = ___id1;
GUIStyle_t1799908754 * L_12 = ___style7;
GUILayoutOptionU5BU5D_t2108882777* L_13 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_BeginWindow_m488834212(NULL /*static, unused*/, L_11, L_12, L_13, /*hidden argument*/NULL);
goto IL_005d;
}
IL_0052:
{
int32_t L_14 = ___id1;
GUIStyle_t1799908754 * L_15 = ___style7;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_BeginWindow_m488834212(NULL /*static, unused*/, L_14, L_15, (GUILayoutOptionU5BU5D_t2108882777*)(GUILayoutOptionU5BU5D_t2108882777*)NULL, /*hidden argument*/NULL);
}
IL_005d:
{
goto IL_0071;
}
IL_0063:
{
int32_t L_16 = ___id1;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_17 = GUIStyle_get_none_m4224270950(NULL /*static, unused*/, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_BeginWindow_m488834212(NULL /*static, unused*/, L_16, L_17, (GUILayoutOptionU5BU5D_t2108882777*)(GUILayoutOptionU5BU5D_t2108882777*)NULL, /*hidden argument*/NULL);
}
IL_0071:
{
GUISkin_t1436893342 * L_18 = ____skin3;
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUI_set_skin_m3391676555(NULL /*static, unused*/, L_18, /*hidden argument*/NULL);
WindowFunction_t3486805455 * L_19 = ___func0;
int32_t L_20 = ___id1;
WindowFunction_Invoke_m3108181420(L_19, L_20, /*hidden argument*/NULL);
Event_t3028476042 * L_21 = Event_get_current_m2901774193(NULL /*static, unused*/, /*hidden argument*/NULL);
int32_t L_22 = Event_get_type_m2426033198(L_21, /*hidden argument*/NULL);
if ((!(((uint32_t)L_22) == ((uint32_t)8))))
{
goto IL_0095;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_Layout_m3812180708(NULL /*static, unused*/, /*hidden argument*/NULL);
}
IL_0095:
{
GUISkin_t1436893342 * L_23 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUI_set_skin_m3391676555(NULL /*static, unused*/, L_23, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUI::set_changed(System.Boolean)
extern "C" void GUI_set_changed_m470833806 (Il2CppObject * __this /* static, unused */, bool ___value0, const MethodInfo* method)
{
typedef void (*GUI_set_changed_m470833806_ftn) (bool);
static GUI_set_changed_m470833806_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUI_set_changed_m470833806_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUI::set_changed(System.Boolean)");
_il2cpp_icall_func(___value0);
}
extern "C" void DelegatePInvokeWrapper_WindowFunction_t3486805455 (WindowFunction_t3486805455 * __this, int32_t ___id0, const MethodInfo* method)
{
typedef void (STDCALL *PInvokeFunc)(int32_t);
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(((Il2CppDelegate*)__this)->method->methodPointer);
// Native function invocation
il2cppPInvokeFunc(___id0);
}
// System.Void UnityEngine.GUI/WindowFunction::.ctor(System.Object,System.IntPtr)
extern "C" void WindowFunction__ctor_m977095815 (WindowFunction_t3486805455 * __this, Il2CppObject * ___object0, IntPtr_t ___method1, const MethodInfo* method)
{
__this->set_method_ptr_0((Il2CppMethodPointer)((MethodInfo*)___method1.get_m_value_0())->methodPointer);
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.GUI/WindowFunction::Invoke(System.Int32)
extern "C" void WindowFunction_Invoke_m3108181420 (WindowFunction_t3486805455 * __this, int32_t ___id0, const MethodInfo* method)
{
if(__this->get_prev_9() != NULL)
{
WindowFunction_Invoke_m3108181420((WindowFunction_t3486805455 *)__this->get_prev_9(),___id0, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->get_method_3().get_m_value_0()));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->get_method_3().get_m_value_0()));
if (__this->get_m_target_2() != NULL && ___methodIsStatic)
{
typedef void (*FunctionPointerType) (Il2CppObject *, void* __this, int32_t ___id0, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(NULL,__this->get_m_target_2(),___id0,(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
else
{
typedef void (*FunctionPointerType) (void* __this, int32_t ___id0, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(__this->get_m_target_2(),___id0,(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
}
// System.IAsyncResult UnityEngine.GUI/WindowFunction::BeginInvoke(System.Int32,System.AsyncCallback,System.Object)
extern "C" Il2CppObject * WindowFunction_BeginInvoke_m322627481 (WindowFunction_t3486805455 * __this, int32_t ___id0, AsyncCallback_t163412349 * ___callback1, Il2CppObject * ___object2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WindowFunction_BeginInvoke_m322627481_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(Int32_t2071877448_il2cpp_TypeInfo_var, &___id0);
return (Il2CppObject *)il2cpp_codegen_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback1, (Il2CppObject*)___object2);
}
// System.Void UnityEngine.GUI/WindowFunction::EndInvoke(System.IAsyncResult)
extern "C" void WindowFunction_EndInvoke_m1872484397 (WindowFunction_t3486805455 * __this, Il2CppObject * ___result0, const MethodInfo* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
// Conversion methods for marshalling of: UnityEngine.GUIContent
extern "C" void GUIContent_t4210063000_marshal_pinvoke(const GUIContent_t4210063000& unmarshaled, GUIContent_t4210063000_marshaled_pinvoke& marshaled)
{
Il2CppCodeGenException* ___m_Image_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Image' of type 'GUIContent': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Image_1Exception);
}
extern "C" void GUIContent_t4210063000_marshal_pinvoke_back(const GUIContent_t4210063000_marshaled_pinvoke& marshaled, GUIContent_t4210063000& unmarshaled)
{
Il2CppCodeGenException* ___m_Image_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Image' of type 'GUIContent': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Image_1Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.GUIContent
extern "C" void GUIContent_t4210063000_marshal_pinvoke_cleanup(GUIContent_t4210063000_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.GUIContent
extern "C" void GUIContent_t4210063000_marshal_com(const GUIContent_t4210063000& unmarshaled, GUIContent_t4210063000_marshaled_com& marshaled)
{
Il2CppCodeGenException* ___m_Image_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Image' of type 'GUIContent': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Image_1Exception);
}
extern "C" void GUIContent_t4210063000_marshal_com_back(const GUIContent_t4210063000_marshaled_com& marshaled, GUIContent_t4210063000& unmarshaled)
{
Il2CppCodeGenException* ___m_Image_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Image' of type 'GUIContent': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Image_1Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.GUIContent
extern "C" void GUIContent_t4210063000_marshal_com_cleanup(GUIContent_t4210063000_marshaled_com& marshaled)
{
}
// System.Void UnityEngine.GUIContent::.ctor()
extern "C" void GUIContent__ctor_m3889310883 (GUIContent_t4210063000 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIContent__ctor_m3889310883_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_0 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->get_Empty_2();
__this->set_m_Text_0(L_0);
String_t* L_1 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->get_Empty_2();
__this->set_m_Tooltip_2(L_1);
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIContent::.ctor(System.String)
extern "C" void GUIContent__ctor_m845353549 (GUIContent_t4210063000 * __this, String_t* ___text0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIContent__ctor_m845353549_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = ___text0;
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_1 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->get_Empty_2();
GUIContent__ctor_m3472047579(__this, L_0, (Texture_t2243626319 *)NULL, L_1, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIContent::.ctor(System.String,UnityEngine.Texture,System.String)
extern "C" void GUIContent__ctor_m3472047579 (GUIContent_t4210063000 * __this, String_t* ___text0, Texture_t2243626319 * ___image1, String_t* ___tooltip2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIContent__ctor_m3472047579_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_0 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->get_Empty_2();
__this->set_m_Text_0(L_0);
String_t* L_1 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->get_Empty_2();
__this->set_m_Tooltip_2(L_1);
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
String_t* L_2 = ___text0;
GUIContent_set_text_m1170206441(__this, L_2, /*hidden argument*/NULL);
Texture_t2243626319 * L_3 = ___image1;
GUIContent_set_image_m3973549709(__this, L_3, /*hidden argument*/NULL);
String_t* L_4 = ___tooltip2;
GUIContent_set_tooltip_m3561669977(__this, L_4, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIContent::set_text(System.String)
extern "C" void GUIContent_set_text_m1170206441 (GUIContent_t4210063000 * __this, String_t* ___value0, const MethodInfo* method)
{
{
String_t* L_0 = ___value0;
__this->set_m_Text_0(L_0);
return;
}
}
// System.Void UnityEngine.GUIContent::set_image(UnityEngine.Texture)
extern "C" void GUIContent_set_image_m3973549709 (GUIContent_t4210063000 * __this, Texture_t2243626319 * ___value0, const MethodInfo* method)
{
{
Texture_t2243626319 * L_0 = ___value0;
__this->set_m_Image_1(L_0);
return;
}
}
// System.Void UnityEngine.GUIContent::set_tooltip(System.String)
extern "C" void GUIContent_set_tooltip_m3561669977 (GUIContent_t4210063000 * __this, String_t* ___value0, const MethodInfo* method)
{
{
String_t* L_0 = ___value0;
__this->set_m_Tooltip_2(L_0);
return;
}
}
// UnityEngine.GUIContent UnityEngine.GUIContent::Temp(System.String)
extern "C" GUIContent_t4210063000 * GUIContent_Temp_m1650198655 (Il2CppObject * __this /* static, unused */, String_t* ___t0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIContent_Temp_m1650198655_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUIContent_t4210063000 * V_0 = NULL;
{
IL2CPP_RUNTIME_CLASS_INIT(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent_t4210063000 * L_0 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_Text_3();
String_t* L_1 = ___t0;
L_0->set_m_Text_0(L_1);
GUIContent_t4210063000 * L_2 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_Text_3();
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_3 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->get_Empty_2();
L_2->set_m_Tooltip_2(L_3);
GUIContent_t4210063000 * L_4 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_Text_3();
V_0 = L_4;
goto IL_0026;
}
IL_0026:
{
GUIContent_t4210063000 * L_5 = V_0;
return L_5;
}
}
// UnityEngine.GUIContent UnityEngine.GUIContent::Temp(UnityEngine.Texture)
extern "C" GUIContent_t4210063000 * GUIContent_Temp_m1937454133 (Il2CppObject * __this /* static, unused */, Texture_t2243626319 * ___i0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIContent_Temp_m1937454133_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUIContent_t4210063000 * V_0 = NULL;
{
IL2CPP_RUNTIME_CLASS_INIT(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent_t4210063000 * L_0 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_Image_4();
Texture_t2243626319 * L_1 = ___i0;
L_0->set_m_Image_1(L_1);
GUIContent_t4210063000 * L_2 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_Image_4();
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_3 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->get_Empty_2();
L_2->set_m_Tooltip_2(L_3);
GUIContent_t4210063000 * L_4 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_Image_4();
V_0 = L_4;
goto IL_0026;
}
IL_0026:
{
GUIContent_t4210063000 * L_5 = V_0;
return L_5;
}
}
// System.Void UnityEngine.GUIContent::ClearStaticCache()
extern "C" void GUIContent_ClearStaticCache_m3271816250 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIContent_ClearStaticCache_m3271816250_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent_t4210063000 * L_0 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_Text_3();
L_0->set_m_Text_0((String_t*)NULL);
GUIContent_t4210063000 * L_1 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_Text_3();
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_2 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->get_Empty_2();
L_1->set_m_Tooltip_2(L_2);
GUIContent_t4210063000 * L_3 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_Image_4();
L_3->set_m_Image_1((Texture_t2243626319 *)NULL);
GUIContent_t4210063000 * L_4 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_Image_4();
String_t* L_5 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->get_Empty_2();
L_4->set_m_Tooltip_2(L_5);
GUIContent_t4210063000 * L_6 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_TextImage_5();
L_6->set_m_Text_0((String_t*)NULL);
GUIContent_t4210063000 * L_7 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_s_TextImage_5();
L_7->set_m_Image_1((Texture_t2243626319 *)NULL);
return;
}
}
// System.Void UnityEngine.GUIContent::.cctor()
extern "C" void GUIContent__cctor_m2212772596 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIContent__cctor_m2212772596_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
GUIContent_t4210063000 * L_0 = (GUIContent_t4210063000 *)il2cpp_codegen_object_new(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent__ctor_m3889310883(L_0, /*hidden argument*/NULL);
((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->set_s_Text_3(L_0);
GUIContent_t4210063000 * L_1 = (GUIContent_t4210063000 *)il2cpp_codegen_object_new(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent__ctor_m3889310883(L_1, /*hidden argument*/NULL);
((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->set_s_Image_4(L_1);
GUIContent_t4210063000 * L_2 = (GUIContent_t4210063000 *)il2cpp_codegen_object_new(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent__ctor_m3889310883(L_2, /*hidden argument*/NULL);
((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->set_s_TextImage_5(L_2);
GUIContent_t4210063000 * L_3 = (GUIContent_t4210063000 *)il2cpp_codegen_object_new(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent__ctor_m845353549(L_3, _stringLiteral371857150, /*hidden argument*/NULL);
((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->set_none_6(L_3);
return;
}
}
// UnityEngine.GUIElement UnityEngine.GUILayer::HitTest(UnityEngine.Vector3)
extern "C" GUIElement_t3381083099 * GUILayer_HitTest_m2960428006 (GUILayer_t3254902478 * __this, Vector3_t2243707580 ___screenPosition0, const MethodInfo* method)
{
GUIElement_t3381083099 * V_0 = NULL;
{
GUIElement_t3381083099 * L_0 = GUILayer_INTERNAL_CALL_HitTest_m693512502(NULL /*static, unused*/, __this, (&___screenPosition0), /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000f;
}
IL_000f:
{
GUIElement_t3381083099 * L_1 = V_0;
return L_1;
}
}
// UnityEngine.GUIElement UnityEngine.GUILayer::INTERNAL_CALL_HitTest(UnityEngine.GUILayer,UnityEngine.Vector3&)
extern "C" GUIElement_t3381083099 * GUILayer_INTERNAL_CALL_HitTest_m693512502 (Il2CppObject * __this /* static, unused */, GUILayer_t3254902478 * ___self0, Vector3_t2243707580 * ___screenPosition1, const MethodInfo* method)
{
typedef GUIElement_t3381083099 * (*GUILayer_INTERNAL_CALL_HitTest_m693512502_ftn) (GUILayer_t3254902478 *, Vector3_t2243707580 *);
static GUILayer_INTERNAL_CALL_HitTest_m693512502_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUILayer_INTERNAL_CALL_HitTest_m693512502_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUILayer::INTERNAL_CALL_HitTest(UnityEngine.GUILayer,UnityEngine.Vector3&)");
return _il2cpp_icall_func(___self0, ___screenPosition1);
}
// UnityEngine.GUILayoutOption UnityEngine.GUILayout::Width(System.Single)
extern "C" GUILayoutOption_t4183744904 * GUILayout_Width_m261136689 (Il2CppObject * __this /* static, unused */, float ___width0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayout_Width_m261136689_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUILayoutOption_t4183744904 * V_0 = NULL;
{
float L_0 = ___width0;
float L_1 = L_0;
Il2CppObject * L_2 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_1);
GUILayoutOption_t4183744904 * L_3 = (GUILayoutOption_t4183744904 *)il2cpp_codegen_object_new(GUILayoutOption_t4183744904_il2cpp_TypeInfo_var);
GUILayoutOption__ctor_m1607805343(L_3, 0, L_2, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_0013;
}
IL_0013:
{
GUILayoutOption_t4183744904 * L_4 = V_0;
return L_4;
}
}
// UnityEngine.GUILayoutOption UnityEngine.GUILayout::Height(System.Single)
extern "C" GUILayoutOption_t4183744904 * GUILayout_Height_m607115982 (Il2CppObject * __this /* static, unused */, float ___height0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayout_Height_m607115982_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUILayoutOption_t4183744904 * V_0 = NULL;
{
float L_0 = ___height0;
float L_1 = L_0;
Il2CppObject * L_2 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_1);
GUILayoutOption_t4183744904 * L_3 = (GUILayoutOption_t4183744904 *)il2cpp_codegen_object_new(GUILayoutOption_t4183744904_il2cpp_TypeInfo_var);
GUILayoutOption__ctor_m1607805343(L_3, 1, L_2, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_0013;
}
IL_0013:
{
GUILayoutOption_t4183744904 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUILayoutEntry::.ctor(System.Single,System.Single,System.Single,System.Single,UnityEngine.GUIStyle)
extern "C" void GUILayoutEntry__ctor_m4007465719 (GUILayoutEntry_t3828586629 * __this, float ____minWidth0, float ____maxWidth1, float ____minHeight2, float ____maxHeight3, GUIStyle_t1799908754 * ____style4, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutEntry__ctor_m4007465719_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Rect_t3681755626 L_0;
memset(&L_0, 0, sizeof(L_0));
Rect__ctor_m1220545469(&L_0, (0.0f), (0.0f), (0.0f), (0.0f), /*hidden argument*/NULL);
__this->set_rect_4(L_0);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_1 = GUIStyle_get_none_m4224270950(NULL /*static, unused*/, /*hidden argument*/NULL);
__this->set_m_Style_7(L_1);
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
float L_2 = ____minWidth0;
__this->set_minWidth_0(L_2);
float L_3 = ____maxWidth1;
__this->set_maxWidth_1(L_3);
float L_4 = ____minHeight2;
__this->set_minHeight_2(L_4);
float L_5 = ____maxHeight3;
__this->set_maxHeight_3(L_5);
GUIStyle_t1799908754 * L_6 = ____style4;
if (L_6)
{
goto IL_005c;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_7 = GUIStyle_get_none_m4224270950(NULL /*static, unused*/, /*hidden argument*/NULL);
____style4 = L_7;
}
IL_005c:
{
GUIStyle_t1799908754 * L_8 = ____style4;
GUILayoutEntry_set_style_m70917293(__this, L_8, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUILayoutEntry::get_style()
extern "C" GUIStyle_t1799908754 * GUILayoutEntry_get_style_m998192810 (GUILayoutEntry_t3828586629 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_Style_7();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUILayoutEntry::set_style(UnityEngine.GUIStyle)
extern "C" void GUILayoutEntry_set_style_m70917293 (GUILayoutEntry_t3828586629 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_Style_7(L_0);
GUIStyle_t1799908754 * L_1 = ___value0;
VirtActionInvoker1< GUIStyle_t1799908754 * >::Invoke(9 /* System.Void UnityEngine.GUILayoutEntry::ApplyStyleSettings(UnityEngine.GUIStyle) */, __this, L_1);
return;
}
}
// UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin()
extern "C" RectOffset_t3387826427 * GUILayoutEntry_get_margin_m1657422058 (GUILayoutEntry_t3828586629 * __this, const MethodInfo* method)
{
RectOffset_t3387826427 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_1 = GUIStyle_get_margin_m1012250163(L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_0012;
}
IL_0012:
{
RectOffset_t3387826427 * L_2 = V_0;
return L_2;
}
}
// System.Void UnityEngine.GUILayoutEntry::CalcWidth()
extern "C" void GUILayoutEntry_CalcWidth_m2520096159 (GUILayoutEntry_t3828586629 * __this, const MethodInfo* method)
{
{
return;
}
}
// System.Void UnityEngine.GUILayoutEntry::CalcHeight()
extern "C" void GUILayoutEntry_CalcHeight_m1069006192 (GUILayoutEntry_t3828586629 * __this, const MethodInfo* method)
{
{
return;
}
}
// System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single)
extern "C" void GUILayoutEntry_SetHorizontal_m1828181654 (GUILayoutEntry_t3828586629 * __this, float ___x0, float ___width1, const MethodInfo* method)
{
{
Rect_t3681755626 * L_0 = __this->get_address_of_rect_4();
float L_1 = ___x0;
Rect_set_x_m3783700513(L_0, L_1, /*hidden argument*/NULL);
Rect_t3681755626 * L_2 = __this->get_address_of_rect_4();
float L_3 = ___width1;
Rect_set_width_m1921257731(L_2, L_3, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single)
extern "C" void GUILayoutEntry_SetVertical_m2328603448 (GUILayoutEntry_t3828586629 * __this, float ___y0, float ___height1, const MethodInfo* method)
{
{
Rect_t3681755626 * L_0 = __this->get_address_of_rect_4();
float L_1 = ___y0;
Rect_set_y_m4294916608(L_0, L_1, /*hidden argument*/NULL);
Rect_t3681755626 * L_2 = __this->get_address_of_rect_4();
float L_3 = ___height1;
Rect_set_height_m2019122814(L_2, L_3, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUILayoutEntry::ApplyStyleSettings(UnityEngine.GUIStyle)
extern "C" void GUILayoutEntry_ApplyStyleSettings_m371609721 (GUILayoutEntry_t3828586629 * __this, GUIStyle_t1799908754 * ___style0, const MethodInfo* method)
{
GUILayoutEntry_t3828586629 * G_B3_0 = NULL;
GUILayoutEntry_t3828586629 * G_B1_0 = NULL;
GUILayoutEntry_t3828586629 * G_B2_0 = NULL;
int32_t G_B4_0 = 0;
GUILayoutEntry_t3828586629 * G_B4_1 = NULL;
GUILayoutEntry_t3828586629 * G_B7_0 = NULL;
GUILayoutEntry_t3828586629 * G_B5_0 = NULL;
GUILayoutEntry_t3828586629 * G_B6_0 = NULL;
int32_t G_B8_0 = 0;
GUILayoutEntry_t3828586629 * G_B8_1 = NULL;
{
GUIStyle_t1799908754 * L_0 = ___style0;
float L_1 = GUIStyle_get_fixedWidth_m97997484(L_0, /*hidden argument*/NULL);
G_B1_0 = __this;
if ((!(((float)L_1) == ((float)(0.0f)))))
{
G_B3_0 = __this;
goto IL_0023;
}
}
{
GUIStyle_t1799908754 * L_2 = ___style0;
bool L_3 = GUIStyle_get_stretchWidth_m1223411161(L_2, /*hidden argument*/NULL);
G_B2_0 = G_B1_0;
if (!L_3)
{
G_B3_0 = G_B1_0;
goto IL_0023;
}
}
{
G_B4_0 = 1;
G_B4_1 = G_B2_0;
goto IL_0024;
}
IL_0023:
{
G_B4_0 = 0;
G_B4_1 = G_B3_0;
}
IL_0024:
{
G_B4_1->set_stretchWidth_5(G_B4_0);
GUIStyle_t1799908754 * L_4 = ___style0;
float L_5 = GUIStyle_get_fixedHeight_m414733479(L_4, /*hidden argument*/NULL);
G_B5_0 = __this;
if ((!(((float)L_5) == ((float)(0.0f)))))
{
G_B7_0 = __this;
goto IL_004b;
}
}
{
GUIStyle_t1799908754 * L_6 = ___style0;
bool L_7 = GUIStyle_get_stretchHeight_m3396762700(L_6, /*hidden argument*/NULL);
G_B6_0 = G_B5_0;
if (!L_7)
{
G_B7_0 = G_B5_0;
goto IL_004b;
}
}
{
G_B8_0 = 1;
G_B8_1 = G_B6_0;
goto IL_004c;
}
IL_004b:
{
G_B8_0 = 0;
G_B8_1 = G_B7_0;
}
IL_004c:
{
G_B8_1->set_stretchHeight_6(G_B8_0);
GUIStyle_t1799908754 * L_8 = ___style0;
__this->set_m_Style_7(L_8);
return;
}
}
// System.Void UnityEngine.GUILayoutEntry::ApplyOptions(UnityEngine.GUILayoutOption[])
extern "C" void GUILayoutEntry_ApplyOptions_m115321759 (GUILayoutEntry_t3828586629 * __this, GUILayoutOptionU5BU5D_t2108882777* ___options0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutEntry_ApplyOptions_m115321759_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUILayoutOption_t4183744904 * V_0 = NULL;
GUILayoutOptionU5BU5D_t2108882777* V_1 = NULL;
int32_t V_2 = 0;
int32_t V_3 = 0;
float V_4 = 0.0f;
{
GUILayoutOptionU5BU5D_t2108882777* L_0 = ___options0;
if (L_0)
{
goto IL_000c;
}
}
{
goto IL_020b;
}
IL_000c:
{
GUILayoutOptionU5BU5D_t2108882777* L_1 = ___options0;
V_1 = L_1;
V_2 = 0;
goto IL_01a8;
}
IL_0016:
{
GUILayoutOptionU5BU5D_t2108882777* L_2 = V_1;
int32_t L_3 = V_2;
int32_t L_4 = L_3;
GUILayoutOption_t4183744904 * L_5 = (L_2)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_4));
V_0 = L_5;
GUILayoutOption_t4183744904 * L_6 = V_0;
int32_t L_7 = L_6->get_type_0();
V_3 = L_7;
int32_t L_8 = V_3;
switch (L_8)
{
case 0:
{
goto IL_004d;
}
case 1:
{
goto IL_0075;
}
case 2:
{
goto IL_009d;
}
case 3:
{
goto IL_00d0;
}
case 4:
{
goto IL_010a;
}
case 5:
{
goto IL_013d;
}
case 6:
{
goto IL_0177;
}
case 7:
{
goto IL_018d;
}
}
}
{
goto IL_01a3;
}
IL_004d:
{
GUILayoutOption_t4183744904 * L_9 = V_0;
Il2CppObject * L_10 = L_9->get_value_1();
float L_11 = ((*(float*)((float*)UnBox(L_10, Single_t2076509932_il2cpp_TypeInfo_var))));
V_4 = L_11;
__this->set_maxWidth_1(L_11);
float L_12 = V_4;
__this->set_minWidth_0(L_12);
__this->set_stretchWidth_5(0);
goto IL_01a3;
}
IL_0075:
{
GUILayoutOption_t4183744904 * L_13 = V_0;
Il2CppObject * L_14 = L_13->get_value_1();
float L_15 = ((*(float*)((float*)UnBox(L_14, Single_t2076509932_il2cpp_TypeInfo_var))));
V_4 = L_15;
__this->set_maxHeight_3(L_15);
float L_16 = V_4;
__this->set_minHeight_2(L_16);
__this->set_stretchHeight_6(0);
goto IL_01a3;
}
IL_009d:
{
GUILayoutOption_t4183744904 * L_17 = V_0;
Il2CppObject * L_18 = L_17->get_value_1();
__this->set_minWidth_0(((*(float*)((float*)UnBox(L_18, Single_t2076509932_il2cpp_TypeInfo_var)))));
float L_19 = __this->get_maxWidth_1();
float L_20 = __this->get_minWidth_0();
if ((!(((float)L_19) < ((float)L_20))))
{
goto IL_00cb;
}
}
{
float L_21 = __this->get_minWidth_0();
__this->set_maxWidth_1(L_21);
}
IL_00cb:
{
goto IL_01a3;
}
IL_00d0:
{
GUILayoutOption_t4183744904 * L_22 = V_0;
Il2CppObject * L_23 = L_22->get_value_1();
__this->set_maxWidth_1(((*(float*)((float*)UnBox(L_23, Single_t2076509932_il2cpp_TypeInfo_var)))));
float L_24 = __this->get_minWidth_0();
float L_25 = __this->get_maxWidth_1();
if ((!(((float)L_24) > ((float)L_25))))
{
goto IL_00fe;
}
}
{
float L_26 = __this->get_maxWidth_1();
__this->set_minWidth_0(L_26);
}
IL_00fe:
{
__this->set_stretchWidth_5(0);
goto IL_01a3;
}
IL_010a:
{
GUILayoutOption_t4183744904 * L_27 = V_0;
Il2CppObject * L_28 = L_27->get_value_1();
__this->set_minHeight_2(((*(float*)((float*)UnBox(L_28, Single_t2076509932_il2cpp_TypeInfo_var)))));
float L_29 = __this->get_maxHeight_3();
float L_30 = __this->get_minHeight_2();
if ((!(((float)L_29) < ((float)L_30))))
{
goto IL_0138;
}
}
{
float L_31 = __this->get_minHeight_2();
__this->set_maxHeight_3(L_31);
}
IL_0138:
{
goto IL_01a3;
}
IL_013d:
{
GUILayoutOption_t4183744904 * L_32 = V_0;
Il2CppObject * L_33 = L_32->get_value_1();
__this->set_maxHeight_3(((*(float*)((float*)UnBox(L_33, Single_t2076509932_il2cpp_TypeInfo_var)))));
float L_34 = __this->get_minHeight_2();
float L_35 = __this->get_maxHeight_3();
if ((!(((float)L_34) > ((float)L_35))))
{
goto IL_016b;
}
}
{
float L_36 = __this->get_maxHeight_3();
__this->set_minHeight_2(L_36);
}
IL_016b:
{
__this->set_stretchHeight_6(0);
goto IL_01a3;
}
IL_0177:
{
GUILayoutOption_t4183744904 * L_37 = V_0;
Il2CppObject * L_38 = L_37->get_value_1();
__this->set_stretchWidth_5(((*(int32_t*)((int32_t*)UnBox(L_38, Int32_t2071877448_il2cpp_TypeInfo_var)))));
goto IL_01a3;
}
IL_018d:
{
GUILayoutOption_t4183744904 * L_39 = V_0;
Il2CppObject * L_40 = L_39->get_value_1();
__this->set_stretchHeight_6(((*(int32_t*)((int32_t*)UnBox(L_40, Int32_t2071877448_il2cpp_TypeInfo_var)))));
goto IL_01a3;
}
IL_01a3:
{
int32_t L_41 = V_2;
V_2 = ((int32_t)((int32_t)L_41+(int32_t)1));
}
IL_01a8:
{
int32_t L_42 = V_2;
GUILayoutOptionU5BU5D_t2108882777* L_43 = V_1;
if ((((int32_t)L_42) < ((int32_t)(((int32_t)((int32_t)(((Il2CppArray *)L_43)->max_length)))))))
{
goto IL_0016;
}
}
{
float L_44 = __this->get_maxWidth_1();
if ((((float)L_44) == ((float)(0.0f))))
{
goto IL_01de;
}
}
{
float L_45 = __this->get_maxWidth_1();
float L_46 = __this->get_minWidth_0();
if ((!(((float)L_45) < ((float)L_46))))
{
goto IL_01de;
}
}
{
float L_47 = __this->get_minWidth_0();
__this->set_maxWidth_1(L_47);
}
IL_01de:
{
float L_48 = __this->get_maxHeight_3();
if ((((float)L_48) == ((float)(0.0f))))
{
goto IL_020b;
}
}
{
float L_49 = __this->get_maxHeight_3();
float L_50 = __this->get_minHeight_2();
if ((!(((float)L_49) < ((float)L_50))))
{
goto IL_020b;
}
}
{
float L_51 = __this->get_minHeight_2();
__this->set_maxHeight_3(L_51);
}
IL_020b:
{
return;
}
}
// System.String UnityEngine.GUILayoutEntry::ToString()
extern "C" String_t* GUILayoutEntry_ToString_m1331406279 (GUILayoutEntry_t3828586629 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutEntry_ToString_m1331406279_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
int32_t V_1 = 0;
String_t* V_2 = NULL;
int32_t G_B5_0 = 0;
ObjectU5BU5D_t3614634134* G_B5_1 = NULL;
ObjectU5BU5D_t3614634134* G_B5_2 = NULL;
String_t* G_B5_3 = NULL;
int32_t G_B5_4 = 0;
ObjectU5BU5D_t3614634134* G_B5_5 = NULL;
ObjectU5BU5D_t3614634134* G_B5_6 = NULL;
int32_t G_B4_0 = 0;
ObjectU5BU5D_t3614634134* G_B4_1 = NULL;
ObjectU5BU5D_t3614634134* G_B4_2 = NULL;
String_t* G_B4_3 = NULL;
int32_t G_B4_4 = 0;
ObjectU5BU5D_t3614634134* G_B4_5 = NULL;
ObjectU5BU5D_t3614634134* G_B4_6 = NULL;
String_t* G_B6_0 = NULL;
int32_t G_B6_1 = 0;
ObjectU5BU5D_t3614634134* G_B6_2 = NULL;
ObjectU5BU5D_t3614634134* G_B6_3 = NULL;
String_t* G_B6_4 = NULL;
int32_t G_B6_5 = 0;
ObjectU5BU5D_t3614634134* G_B6_6 = NULL;
ObjectU5BU5D_t3614634134* G_B6_7 = NULL;
int32_t G_B8_0 = 0;
ObjectU5BU5D_t3614634134* G_B8_1 = NULL;
ObjectU5BU5D_t3614634134* G_B8_2 = NULL;
int32_t G_B7_0 = 0;
ObjectU5BU5D_t3614634134* G_B7_1 = NULL;
ObjectU5BU5D_t3614634134* G_B7_2 = NULL;
String_t* G_B9_0 = NULL;
int32_t G_B9_1 = 0;
ObjectU5BU5D_t3614634134* G_B9_2 = NULL;
ObjectU5BU5D_t3614634134* G_B9_3 = NULL;
int32_t G_B11_0 = 0;
ObjectU5BU5D_t3614634134* G_B11_1 = NULL;
ObjectU5BU5D_t3614634134* G_B11_2 = NULL;
int32_t G_B10_0 = 0;
ObjectU5BU5D_t3614634134* G_B10_1 = NULL;
ObjectU5BU5D_t3614634134* G_B10_2 = NULL;
String_t* G_B12_0 = NULL;
int32_t G_B12_1 = 0;
ObjectU5BU5D_t3614634134* G_B12_2 = NULL;
ObjectU5BU5D_t3614634134* G_B12_3 = NULL;
{
V_0 = _stringLiteral371857150;
V_1 = 0;
goto IL_001e;
}
IL_000e:
{
String_t* L_0 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_1 = String_Concat_m2596409543(NULL /*static, unused*/, L_0, _stringLiteral372029310, /*hidden argument*/NULL);
V_0 = L_1;
int32_t L_2 = V_1;
V_1 = ((int32_t)((int32_t)L_2+(int32_t)1));
}
IL_001e:
{
int32_t L_3 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var);
int32_t L_4 = ((GUILayoutEntry_t3828586629_StaticFields*)GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var->static_fields)->get_indent_9();
if ((((int32_t)L_3) < ((int32_t)L_4)))
{
goto IL_000e;
}
}
{
ObjectU5BU5D_t3614634134* L_5 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)((int32_t)12)));
String_t* L_6 = V_0;
ArrayElementTypeCheck (L_5, L_6);
(L_5)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)L_6);
ObjectU5BU5D_t3614634134* L_7 = L_5;
ObjectU5BU5D_t3614634134* L_8 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)6));
GUIStyle_t1799908754 * L_9 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
G_B4_0 = 0;
G_B4_1 = L_8;
G_B4_2 = L_8;
G_B4_3 = _stringLiteral3798370932;
G_B4_4 = 1;
G_B4_5 = L_7;
G_B4_6 = L_7;
if (!L_9)
{
G_B5_0 = 0;
G_B5_1 = L_8;
G_B5_2 = L_8;
G_B5_3 = _stringLiteral3798370932;
G_B5_4 = 1;
G_B5_5 = L_7;
G_B5_6 = L_7;
goto IL_005e;
}
}
{
GUIStyle_t1799908754 * L_10 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
String_t* L_11 = GUIStyle_get_name_m753291950(L_10, /*hidden argument*/NULL);
G_B6_0 = L_11;
G_B6_1 = G_B4_0;
G_B6_2 = G_B4_1;
G_B6_3 = G_B4_2;
G_B6_4 = G_B4_3;
G_B6_5 = G_B4_4;
G_B6_6 = G_B4_5;
G_B6_7 = G_B4_6;
goto IL_0063;
}
IL_005e:
{
G_B6_0 = _stringLiteral3390779443;
G_B6_1 = G_B5_0;
G_B6_2 = G_B5_1;
G_B6_3 = G_B5_2;
G_B6_4 = G_B5_3;
G_B6_5 = G_B5_4;
G_B6_6 = G_B5_5;
G_B6_7 = G_B5_6;
}
IL_0063:
{
ArrayElementTypeCheck (G_B6_2, G_B6_0);
(G_B6_2)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(G_B6_1), (Il2CppObject *)G_B6_0);
ObjectU5BU5D_t3614634134* L_12 = G_B6_3;
Type_t * L_13 = Object_GetType_m191970594(__this, /*hidden argument*/NULL);
ArrayElementTypeCheck (L_12, L_13);
(L_12)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (Il2CppObject *)L_13);
ObjectU5BU5D_t3614634134* L_14 = L_12;
Rect_t3681755626 * L_15 = __this->get_address_of_rect_4();
float L_16 = Rect_get_x_m1393582490(L_15, /*hidden argument*/NULL);
float L_17 = L_16;
Il2CppObject * L_18 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_17);
ArrayElementTypeCheck (L_14, L_18);
(L_14)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(2), (Il2CppObject *)L_18);
ObjectU5BU5D_t3614634134* L_19 = L_14;
Rect_t3681755626 * L_20 = __this->get_address_of_rect_4();
float L_21 = Rect_get_xMax_m2915145014(L_20, /*hidden argument*/NULL);
float L_22 = L_21;
Il2CppObject * L_23 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_22);
ArrayElementTypeCheck (L_19, L_23);
(L_19)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(3), (Il2CppObject *)L_23);
ObjectU5BU5D_t3614634134* L_24 = L_19;
Rect_t3681755626 * L_25 = __this->get_address_of_rect_4();
float L_26 = Rect_get_y_m1393582395(L_25, /*hidden argument*/NULL);
float L_27 = L_26;
Il2CppObject * L_28 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_27);
ArrayElementTypeCheck (L_24, L_28);
(L_24)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(4), (Il2CppObject *)L_28);
ObjectU5BU5D_t3614634134* L_29 = L_24;
Rect_t3681755626 * L_30 = __this->get_address_of_rect_4();
float L_31 = Rect_get_yMax_m2915146103(L_30, /*hidden argument*/NULL);
float L_32 = L_31;
Il2CppObject * L_33 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_32);
ArrayElementTypeCheck (L_29, L_33);
(L_29)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(5), (Il2CppObject *)L_33);
String_t* L_34 = UnityString_Format_m2949645127(NULL /*static, unused*/, G_B6_4, L_29, /*hidden argument*/NULL);
ArrayElementTypeCheck (G_B6_6, L_34);
(G_B6_6)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(G_B6_5), (Il2CppObject *)L_34);
ObjectU5BU5D_t3614634134* L_35 = G_B6_7;
ArrayElementTypeCheck (L_35, _stringLiteral3932457658);
(L_35)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(2), (Il2CppObject *)_stringLiteral3932457658);
ObjectU5BU5D_t3614634134* L_36 = L_35;
float L_37 = __this->get_minWidth_0();
float L_38 = L_37;
Il2CppObject * L_39 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_38);
ArrayElementTypeCheck (L_36, L_39);
(L_36)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(3), (Il2CppObject *)L_39);
ObjectU5BU5D_t3614634134* L_40 = L_36;
ArrayElementTypeCheck (L_40, _stringLiteral372029313);
(L_40)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(4), (Il2CppObject *)_stringLiteral372029313);
ObjectU5BU5D_t3614634134* L_41 = L_40;
float L_42 = __this->get_maxWidth_1();
float L_43 = L_42;
Il2CppObject * L_44 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_43);
ArrayElementTypeCheck (L_41, L_44);
(L_41)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(5), (Il2CppObject *)L_44);
ObjectU5BU5D_t3614634134* L_45 = L_41;
int32_t L_46 = __this->get_stretchWidth_5();
G_B7_0 = 6;
G_B7_1 = L_45;
G_B7_2 = L_45;
if (!L_46)
{
G_B8_0 = 6;
G_B8_1 = L_45;
G_B8_2 = L_45;
goto IL_0102;
}
}
{
G_B9_0 = _stringLiteral372029319;
G_B9_1 = G_B7_0;
G_B9_2 = G_B7_1;
G_B9_3 = G_B7_2;
goto IL_0107;
}
IL_0102:
{
G_B9_0 = _stringLiteral371857150;
G_B9_1 = G_B8_0;
G_B9_2 = G_B8_1;
G_B9_3 = G_B8_2;
}
IL_0107:
{
ArrayElementTypeCheck (G_B9_2, G_B9_0);
(G_B9_2)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(G_B9_1), (Il2CppObject *)G_B9_0);
ObjectU5BU5D_t3614634134* L_47 = G_B9_3;
ArrayElementTypeCheck (L_47, _stringLiteral384197212);
(L_47)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(7), (Il2CppObject *)_stringLiteral384197212);
ObjectU5BU5D_t3614634134* L_48 = L_47;
float L_49 = __this->get_minHeight_2();
float L_50 = L_49;
Il2CppObject * L_51 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_50);
ArrayElementTypeCheck (L_48, L_51);
(L_48)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(8), (Il2CppObject *)L_51);
ObjectU5BU5D_t3614634134* L_52 = L_48;
ArrayElementTypeCheck (L_52, _stringLiteral372029313);
(L_52)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(((int32_t)9)), (Il2CppObject *)_stringLiteral372029313);
ObjectU5BU5D_t3614634134* L_53 = L_52;
float L_54 = __this->get_maxHeight_3();
float L_55 = L_54;
Il2CppObject * L_56 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_55);
ArrayElementTypeCheck (L_53, L_56);
(L_53)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(((int32_t)10)), (Il2CppObject *)L_56);
ObjectU5BU5D_t3614634134* L_57 = L_53;
int32_t L_58 = __this->get_stretchHeight_6();
G_B10_0 = ((int32_t)11);
G_B10_1 = L_57;
G_B10_2 = L_57;
if (!L_58)
{
G_B11_0 = ((int32_t)11);
G_B11_1 = L_57;
G_B11_2 = L_57;
goto IL_014e;
}
}
{
G_B12_0 = _stringLiteral372029319;
G_B12_1 = G_B10_0;
G_B12_2 = G_B10_1;
G_B12_3 = G_B10_2;
goto IL_0153;
}
IL_014e:
{
G_B12_0 = _stringLiteral371857150;
G_B12_1 = G_B11_0;
G_B12_2 = G_B11_1;
G_B12_3 = G_B11_2;
}
IL_0153:
{
ArrayElementTypeCheck (G_B12_2, G_B12_0);
(G_B12_2)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(G_B12_1), (Il2CppObject *)G_B12_0);
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_59 = String_Concat_m3881798623(NULL /*static, unused*/, G_B12_3, /*hidden argument*/NULL);
V_2 = L_59;
goto IL_015f;
}
IL_015f:
{
String_t* L_60 = V_2;
return L_60;
}
}
// System.Void UnityEngine.GUILayoutEntry::.cctor()
extern "C" void GUILayoutEntry__cctor_m3710308127 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutEntry__cctor_m3710308127_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Rect_t3681755626 L_0;
memset(&L_0, 0, sizeof(L_0));
Rect__ctor_m1220545469(&L_0, (0.0f), (0.0f), (1.0f), (1.0f), /*hidden argument*/NULL);
((GUILayoutEntry_t3828586629_StaticFields*)GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var->static_fields)->set_kDummyRect_8(L_0);
((GUILayoutEntry_t3828586629_StaticFields*)GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var->static_fields)->set_indent_9(0);
return;
}
}
// System.Void UnityEngine.GUILayoutGroup::.ctor()
extern "C" void GUILayoutGroup__ctor_m992523271 (GUILayoutGroup_t3975363388 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutGroup__ctor_m992523271_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
List_1_t3197707761 * L_0 = (List_1_t3197707761 *)il2cpp_codegen_object_new(List_1_t3197707761_il2cpp_TypeInfo_var);
List_1__ctor_m3098209370(L_0, /*hidden argument*/List_1__ctor_m3098209370_MethodInfo_var);
__this->set_entries_10(L_0);
__this->set_isVertical_11((bool)1);
__this->set_resetCoords_12((bool)0);
__this->set_spacing_13((0.0f));
__this->set_sameSize_14((bool)1);
__this->set_isWindow_15((bool)0);
__this->set_windowID_16((-1));
__this->set_m_Cursor_17(0);
__this->set_m_StretchableCountX_18(((int32_t)100));
__this->set_m_StretchableCountY_19(((int32_t)100));
__this->set_m_UserSpecifiedWidth_20((bool)0);
__this->set_m_UserSpecifiedHeight_21((bool)0);
__this->set_m_ChildMinWidth_22((100.0f));
__this->set_m_ChildMaxWidth_23((100.0f));
__this->set_m_ChildMinHeight_24((100.0f));
__this->set_m_ChildMaxHeight_25((100.0f));
RectOffset_t3387826427 * L_1 = (RectOffset_t3387826427 *)il2cpp_codegen_object_new(RectOffset_t3387826427_il2cpp_TypeInfo_var);
RectOffset__ctor_m2227510254(L_1, /*hidden argument*/NULL);
__this->set_m_Margin_26(L_1);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_2 = GUIStyle_get_none_m4224270950(NULL /*static, unused*/, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var);
GUILayoutEntry__ctor_m4007465719(__this, (0.0f), (0.0f), (0.0f), (0.0f), L_2, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.RectOffset UnityEngine.GUILayoutGroup::get_margin()
extern "C" RectOffset_t3387826427 * GUILayoutGroup_get_margin_m790729149 (GUILayoutGroup_t3975363388 * __this, const MethodInfo* method)
{
RectOffset_t3387826427 * V_0 = NULL;
{
RectOffset_t3387826427 * L_0 = __this->get_m_Margin_26();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
RectOffset_t3387826427 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUILayoutGroup::ApplyOptions(UnityEngine.GUILayoutOption[])
extern "C" void GUILayoutGroup_ApplyOptions_m1748499012 (GUILayoutGroup_t3975363388 * __this, GUILayoutOptionU5BU5D_t2108882777* ___options0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutGroup_ApplyOptions_m1748499012_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUILayoutOption_t4183744904 * V_0 = NULL;
GUILayoutOptionU5BU5D_t2108882777* V_1 = NULL;
int32_t V_2 = 0;
int32_t V_3 = 0;
{
GUILayoutOptionU5BU5D_t2108882777* L_0 = ___options0;
if (L_0)
{
goto IL_000c;
}
}
{
goto IL_00a9;
}
IL_000c:
{
GUILayoutOptionU5BU5D_t2108882777* L_1 = ___options0;
GUILayoutEntry_ApplyOptions_m115321759(__this, L_1, /*hidden argument*/NULL);
GUILayoutOptionU5BU5D_t2108882777* L_2 = ___options0;
V_1 = L_2;
V_2 = 0;
goto IL_00a0;
}
IL_001d:
{
GUILayoutOptionU5BU5D_t2108882777* L_3 = V_1;
int32_t L_4 = V_2;
int32_t L_5 = L_4;
GUILayoutOption_t4183744904 * L_6 = (L_3)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_5));
V_0 = L_6;
GUILayoutOption_t4183744904 * L_7 = V_0;
int32_t L_8 = L_7->get_type_0();
V_3 = L_8;
int32_t L_9 = V_3;
switch (L_9)
{
case 0:
{
goto IL_006c;
}
case 1:
{
goto IL_0078;
}
case 2:
{
goto IL_006c;
}
case 3:
{
goto IL_006c;
}
case 4:
{
goto IL_0078;
}
case 5:
{
goto IL_0078;
}
case 6:
{
goto IL_009b;
}
case 7:
{
goto IL_009b;
}
case 8:
{
goto IL_009b;
}
case 9:
{
goto IL_009b;
}
case 10:
{
goto IL_009b;
}
case 11:
{
goto IL_009b;
}
case 12:
{
goto IL_009b;
}
case 13:
{
goto IL_0084;
}
}
}
{
goto IL_009b;
}
IL_006c:
{
__this->set_m_UserSpecifiedHeight_21((bool)1);
goto IL_009b;
}
IL_0078:
{
__this->set_m_UserSpecifiedWidth_20((bool)1);
goto IL_009b;
}
IL_0084:
{
GUILayoutOption_t4183744904 * L_10 = V_0;
Il2CppObject * L_11 = L_10->get_value_1();
__this->set_spacing_13((((float)((float)((*(int32_t*)((int32_t*)UnBox(L_11, Int32_t2071877448_il2cpp_TypeInfo_var))))))));
goto IL_009b;
}
IL_009b:
{
int32_t L_12 = V_2;
V_2 = ((int32_t)((int32_t)L_12+(int32_t)1));
}
IL_00a0:
{
int32_t L_13 = V_2;
GUILayoutOptionU5BU5D_t2108882777* L_14 = V_1;
if ((((int32_t)L_13) < ((int32_t)(((int32_t)((int32_t)(((Il2CppArray *)L_14)->max_length)))))))
{
goto IL_001d;
}
}
IL_00a9:
{
return;
}
}
// System.Void UnityEngine.GUILayoutGroup::ApplyStyleSettings(UnityEngine.GUIStyle)
extern "C" void GUILayoutGroup_ApplyStyleSettings_m2161650388 (GUILayoutGroup_t3975363388 * __this, GUIStyle_t1799908754 * ___style0, const MethodInfo* method)
{
RectOffset_t3387826427 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = ___style0;
GUILayoutEntry_ApplyStyleSettings_m371609721(__this, L_0, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_1 = ___style0;
RectOffset_t3387826427 * L_2 = GUIStyle_get_margin_m1012250163(L_1, /*hidden argument*/NULL);
V_0 = L_2;
RectOffset_t3387826427 * L_3 = __this->get_m_Margin_26();
RectOffset_t3387826427 * L_4 = V_0;
int32_t L_5 = RectOffset_get_left_m439065308(L_4, /*hidden argument*/NULL);
RectOffset_set_left_m620681523(L_3, L_5, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_6 = __this->get_m_Margin_26();
RectOffset_t3387826427 * L_7 = V_0;
int32_t L_8 = RectOffset_get_right_m281378687(L_7, /*hidden argument*/NULL);
RectOffset_set_right_m1671272302(L_6, L_8, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_9 = __this->get_m_Margin_26();
RectOffset_t3387826427 * L_10 = V_0;
int32_t L_11 = RectOffset_get_top_m3629049358(L_10, /*hidden argument*/NULL);
RectOffset_set_top_m3579196427(L_9, L_11, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_12 = __this->get_m_Margin_26();
RectOffset_t3387826427 * L_13 = V_0;
int32_t L_14 = RectOffset_get_bottom_m4112328858(L_13, /*hidden argument*/NULL);
RectOffset_set_bottom_m4065521443(L_12, L_14, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUILayoutGroup::ResetCursor()
extern "C" void GUILayoutGroup_ResetCursor_m3160916532 (GUILayoutGroup_t3975363388 * __this, const MethodInfo* method)
{
{
__this->set_m_Cursor_17(0);
return;
}
}
// System.Void UnityEngine.GUILayoutGroup::CalcWidth()
extern "C" void GUILayoutGroup_CalcWidth_m4107152934 (GUILayoutGroup_t3975363388 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutGroup_CalcWidth_m4107152934_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
int32_t V_1 = 0;
int32_t V_2 = 0;
bool V_3 = false;
GUILayoutEntry_t3828586629 * V_4 = NULL;
Enumerator_t2732437435 V_5;
memset(&V_5, 0, sizeof(V_5));
RectOffset_t3387826427 * V_6 = NULL;
int32_t V_7 = 0;
GUILayoutEntry_t3828586629 * V_8 = NULL;
Enumerator_t2732437435 V_9;
memset(&V_9, 0, sizeof(V_9));
RectOffset_t3387826427 * V_10 = NULL;
int32_t V_11 = 0;
float V_12 = 0.0f;
float V_13 = 0.0f;
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
int32_t G_B22_0 = 0;
int32_t G_B41_0 = 0;
int32_t G_B41_1 = 0;
GUILayoutGroup_t3975363388 * G_B41_2 = NULL;
int32_t G_B40_0 = 0;
int32_t G_B40_1 = 0;
GUILayoutGroup_t3975363388 * G_B40_2 = NULL;
int32_t G_B42_0 = 0;
int32_t G_B42_1 = 0;
int32_t G_B42_2 = 0;
GUILayoutGroup_t3975363388 * G_B42_3 = NULL;
{
List_1_t3197707761 * L_0 = __this->get_entries_10();
int32_t L_1 = List_1_get_Count_m3575634194(L_0, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
if (L_1)
{
goto IL_0037;
}
}
{
GUIStyle_t1799908754 * L_2 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_3 = GUIStyle_get_padding_m4076916754(L_2, /*hidden argument*/NULL);
int32_t L_4 = RectOffset_get_horizontal_m3818523637(L_3, /*hidden argument*/NULL);
float L_5 = (((float)((float)L_4)));
V_0 = L_5;
((GUILayoutEntry_t3828586629 *)__this)->set_minWidth_0(L_5);
float L_6 = V_0;
((GUILayoutEntry_t3828586629 *)__this)->set_maxWidth_1(L_6);
goto IL_0460;
}
IL_0037:
{
V_1 = 0;
V_2 = 0;
__this->set_m_ChildMinWidth_22((0.0f));
__this->set_m_ChildMaxWidth_23((0.0f));
__this->set_m_StretchableCountX_18(0);
V_3 = (bool)1;
bool L_7 = __this->get_isVertical_11();
if (!L_7)
{
goto IL_0181;
}
}
{
List_1_t3197707761 * L_8 = __this->get_entries_10();
Enumerator_t2732437435 L_9 = List_1_GetEnumerator_m529646903(L_8, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_5 = L_9;
}
IL_0074:
try
{ // begin try (depth: 1)
{
goto IL_013a;
}
IL_0079:
{
GUILayoutEntry_t3828586629 * L_10 = Enumerator_get_Current_m2724498415((&V_5), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_4 = L_10;
GUILayoutEntry_t3828586629 * L_11 = V_4;
VirtActionInvoker0::Invoke(5 /* System.Void UnityEngine.GUILayoutEntry::CalcWidth() */, L_11);
GUILayoutEntry_t3828586629 * L_12 = V_4;
RectOffset_t3387826427 * L_13 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_12);
V_6 = L_13;
GUILayoutEntry_t3828586629 * L_14 = V_4;
GUIStyle_t1799908754 * L_15 = GUILayoutEntry_get_style_m998192810(L_14, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_16 = GUILayoutUtility_get_spaceStyle_m1918520192(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((Il2CppObject*)(GUIStyle_t1799908754 *)L_15) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_16)))
{
goto IL_0125;
}
}
IL_00a4:
{
bool L_17 = V_3;
if (L_17)
{
goto IL_00ce;
}
}
IL_00ab:
{
RectOffset_t3387826427 * L_18 = V_6;
int32_t L_19 = RectOffset_get_left_m439065308(L_18, /*hidden argument*/NULL);
int32_t L_20 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
int32_t L_21 = Mathf_Min_m2906823867(NULL /*static, unused*/, L_19, L_20, /*hidden argument*/NULL);
V_1 = L_21;
RectOffset_t3387826427 * L_22 = V_6;
int32_t L_23 = RectOffset_get_right_m281378687(L_22, /*hidden argument*/NULL);
int32_t L_24 = V_2;
int32_t L_25 = Mathf_Min_m2906823867(NULL /*static, unused*/, L_23, L_24, /*hidden argument*/NULL);
V_2 = L_25;
goto IL_00e2;
}
IL_00ce:
{
RectOffset_t3387826427 * L_26 = V_6;
int32_t L_27 = RectOffset_get_left_m439065308(L_26, /*hidden argument*/NULL);
V_1 = L_27;
RectOffset_t3387826427 * L_28 = V_6;
int32_t L_29 = RectOffset_get_right_m281378687(L_28, /*hidden argument*/NULL);
V_2 = L_29;
V_3 = (bool)0;
}
IL_00e2:
{
GUILayoutEntry_t3828586629 * L_30 = V_4;
float L_31 = L_30->get_minWidth_0();
RectOffset_t3387826427 * L_32 = V_6;
int32_t L_33 = RectOffset_get_horizontal_m3818523637(L_32, /*hidden argument*/NULL);
float L_34 = __this->get_m_ChildMinWidth_22();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_35 = Mathf_Max_m2564622569(NULL /*static, unused*/, ((float)((float)L_31+(float)(((float)((float)L_33))))), L_34, /*hidden argument*/NULL);
__this->set_m_ChildMinWidth_22(L_35);
GUILayoutEntry_t3828586629 * L_36 = V_4;
float L_37 = L_36->get_maxWidth_1();
RectOffset_t3387826427 * L_38 = V_6;
int32_t L_39 = RectOffset_get_horizontal_m3818523637(L_38, /*hidden argument*/NULL);
float L_40 = __this->get_m_ChildMaxWidth_23();
float L_41 = Mathf_Max_m2564622569(NULL /*static, unused*/, ((float)((float)L_37+(float)(((float)((float)L_39))))), L_40, /*hidden argument*/NULL);
__this->set_m_ChildMaxWidth_23(L_41);
}
IL_0125:
{
int32_t L_42 = __this->get_m_StretchableCountX_18();
GUILayoutEntry_t3828586629 * L_43 = V_4;
int32_t L_44 = L_43->get_stretchWidth_5();
__this->set_m_StretchableCountX_18(((int32_t)((int32_t)L_42+(int32_t)L_44)));
}
IL_013a:
{
bool L_45 = Enumerator_MoveNext_m672443923((&V_5), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_45)
{
goto IL_0079;
}
}
IL_0146:
{
IL2CPP_LEAVE(0x159, FINALLY_014b);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_014b;
}
FINALLY_014b:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_5), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(331)
} // end finally (depth: 1)
IL2CPP_CLEANUP(331)
{
IL2CPP_JUMP_TBL(0x159, IL_0159)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_0159:
{
float L_46 = __this->get_m_ChildMinWidth_22();
int32_t L_47 = V_1;
int32_t L_48 = V_2;
__this->set_m_ChildMinWidth_22(((float)((float)L_46-(float)(((float)((float)((int32_t)((int32_t)L_47+(int32_t)L_48))))))));
float L_49 = __this->get_m_ChildMaxWidth_23();
int32_t L_50 = V_1;
int32_t L_51 = V_2;
__this->set_m_ChildMaxWidth_23(((float)((float)L_49-(float)(((float)((float)((int32_t)((int32_t)L_50+(int32_t)L_51))))))));
goto IL_0311;
}
IL_0181:
{
V_7 = 0;
List_1_t3197707761 * L_52 = __this->get_entries_10();
Enumerator_t2732437435 L_53 = List_1_GetEnumerator_m529646903(L_52, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_9 = L_53;
}
IL_0193:
try
{ // begin try (depth: 1)
{
goto IL_0294;
}
IL_0198:
{
GUILayoutEntry_t3828586629 * L_54 = Enumerator_get_Current_m2724498415((&V_9), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_8 = L_54;
GUILayoutEntry_t3828586629 * L_55 = V_8;
VirtActionInvoker0::Invoke(5 /* System.Void UnityEngine.GUILayoutEntry::CalcWidth() */, L_55);
GUILayoutEntry_t3828586629 * L_56 = V_8;
RectOffset_t3387826427 * L_57 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_56);
V_10 = L_57;
GUILayoutEntry_t3828586629 * L_58 = V_8;
GUIStyle_t1799908754 * L_59 = GUILayoutEntry_get_style_m998192810(L_58, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_60 = GUILayoutUtility_get_spaceStyle_m1918520192(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((Il2CppObject*)(GUIStyle_t1799908754 *)L_59) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_60)))
{
goto IL_0255;
}
}
IL_01c3:
{
bool L_61 = V_3;
if (L_61)
{
goto IL_01ed;
}
}
IL_01ca:
{
int32_t L_62 = V_7;
RectOffset_t3387826427 * L_63 = V_10;
int32_t L_64 = RectOffset_get_left_m439065308(L_63, /*hidden argument*/NULL);
if ((((int32_t)L_62) <= ((int32_t)L_64)))
{
goto IL_01df;
}
}
IL_01d8:
{
int32_t L_65 = V_7;
G_B22_0 = L_65;
goto IL_01e6;
}
IL_01df:
{
RectOffset_t3387826427 * L_66 = V_10;
int32_t L_67 = RectOffset_get_left_m439065308(L_66, /*hidden argument*/NULL);
G_B22_0 = L_67;
}
IL_01e6:
{
V_11 = G_B22_0;
goto IL_01f4;
}
IL_01ed:
{
V_11 = 0;
V_3 = (bool)0;
}
IL_01f4:
{
float L_68 = __this->get_m_ChildMinWidth_22();
GUILayoutEntry_t3828586629 * L_69 = V_8;
float L_70 = L_69->get_minWidth_0();
float L_71 = __this->get_spacing_13();
int32_t L_72 = V_11;
__this->set_m_ChildMinWidth_22(((float)((float)L_68+(float)((float)((float)((float)((float)L_70+(float)L_71))+(float)(((float)((float)L_72))))))));
float L_73 = __this->get_m_ChildMaxWidth_23();
GUILayoutEntry_t3828586629 * L_74 = V_8;
float L_75 = L_74->get_maxWidth_1();
float L_76 = __this->get_spacing_13();
int32_t L_77 = V_11;
__this->set_m_ChildMaxWidth_23(((float)((float)L_73+(float)((float)((float)((float)((float)L_75+(float)L_76))+(float)(((float)((float)L_77))))))));
RectOffset_t3387826427 * L_78 = V_10;
int32_t L_79 = RectOffset_get_right_m281378687(L_78, /*hidden argument*/NULL);
V_7 = L_79;
int32_t L_80 = __this->get_m_StretchableCountX_18();
GUILayoutEntry_t3828586629 * L_81 = V_8;
int32_t L_82 = L_81->get_stretchWidth_5();
__this->set_m_StretchableCountX_18(((int32_t)((int32_t)L_80+(int32_t)L_82)));
goto IL_0293;
}
IL_0255:
{
float L_83 = __this->get_m_ChildMinWidth_22();
GUILayoutEntry_t3828586629 * L_84 = V_8;
float L_85 = L_84->get_minWidth_0();
__this->set_m_ChildMinWidth_22(((float)((float)L_83+(float)L_85)));
float L_86 = __this->get_m_ChildMaxWidth_23();
GUILayoutEntry_t3828586629 * L_87 = V_8;
float L_88 = L_87->get_maxWidth_1();
__this->set_m_ChildMaxWidth_23(((float)((float)L_86+(float)L_88)));
int32_t L_89 = __this->get_m_StretchableCountX_18();
GUILayoutEntry_t3828586629 * L_90 = V_8;
int32_t L_91 = L_90->get_stretchWidth_5();
__this->set_m_StretchableCountX_18(((int32_t)((int32_t)L_89+(int32_t)L_91)));
}
IL_0293:
{
}
IL_0294:
{
bool L_92 = Enumerator_MoveNext_m672443923((&V_9), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_92)
{
goto IL_0198;
}
}
IL_02a0:
{
IL2CPP_LEAVE(0x2B3, FINALLY_02a5);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_02a5;
}
FINALLY_02a5:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_9), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(677)
} // end finally (depth: 1)
IL2CPP_CLEANUP(677)
{
IL2CPP_JUMP_TBL(0x2B3, IL_02b3)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_02b3:
{
float L_93 = __this->get_m_ChildMinWidth_22();
float L_94 = __this->get_spacing_13();
__this->set_m_ChildMinWidth_22(((float)((float)L_93-(float)L_94)));
float L_95 = __this->get_m_ChildMaxWidth_23();
float L_96 = __this->get_spacing_13();
__this->set_m_ChildMaxWidth_23(((float)((float)L_95-(float)L_96)));
List_1_t3197707761 * L_97 = __this->get_entries_10();
int32_t L_98 = List_1_get_Count_m3575634194(L_97, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
if (!L_98)
{
goto IL_030a;
}
}
{
List_1_t3197707761 * L_99 = __this->get_entries_10();
GUILayoutEntry_t3828586629 * L_100 = List_1_get_Item_m3153062965(L_99, 0, /*hidden argument*/List_1_get_Item_m3153062965_MethodInfo_var);
RectOffset_t3387826427 * L_101 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_100);
int32_t L_102 = RectOffset_get_left_m439065308(L_101, /*hidden argument*/NULL);
V_1 = L_102;
int32_t L_103 = V_7;
V_2 = L_103;
goto IL_0310;
}
IL_030a:
{
int32_t L_104 = 0;
V_2 = L_104;
V_1 = L_104;
}
IL_0310:
{
}
IL_0311:
{
V_12 = (0.0f);
V_13 = (0.0f);
GUIStyle_t1799908754 * L_105 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_106 = GUIStyle_get_none_m4224270950(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((!(((Il2CppObject*)(GUIStyle_t1799908754 *)L_105) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_106))))
{
goto IL_033a;
}
}
{
bool L_107 = __this->get_m_UserSpecifiedWidth_20();
if (!L_107)
{
goto IL_0373;
}
}
IL_033a:
{
GUIStyle_t1799908754 * L_108 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_109 = GUIStyle_get_padding_m4076916754(L_108, /*hidden argument*/NULL);
int32_t L_110 = RectOffset_get_left_m439065308(L_109, /*hidden argument*/NULL);
int32_t L_111 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
int32_t L_112 = Mathf_Max_m1875893177(NULL /*static, unused*/, L_110, L_111, /*hidden argument*/NULL);
V_12 = (((float)((float)L_112)));
GUIStyle_t1799908754 * L_113 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_114 = GUIStyle_get_padding_m4076916754(L_113, /*hidden argument*/NULL);
int32_t L_115 = RectOffset_get_right_m281378687(L_114, /*hidden argument*/NULL);
int32_t L_116 = V_2;
int32_t L_117 = Mathf_Max_m1875893177(NULL /*static, unused*/, L_115, L_116, /*hidden argument*/NULL);
V_13 = (((float)((float)L_117)));
goto IL_0397;
}
IL_0373:
{
RectOffset_t3387826427 * L_118 = __this->get_m_Margin_26();
int32_t L_119 = V_1;
RectOffset_set_left_m620681523(L_118, L_119, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_120 = __this->get_m_Margin_26();
int32_t L_121 = V_2;
RectOffset_set_right_m1671272302(L_120, L_121, /*hidden argument*/NULL);
float L_122 = (0.0f);
V_13 = L_122;
V_12 = L_122;
}
IL_0397:
{
float L_123 = ((GUILayoutEntry_t3828586629 *)__this)->get_minWidth_0();
float L_124 = __this->get_m_ChildMinWidth_22();
float L_125 = V_12;
float L_126 = V_13;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_127 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_123, ((float)((float)((float)((float)L_124+(float)L_125))+(float)L_126)), /*hidden argument*/NULL);
((GUILayoutEntry_t3828586629 *)__this)->set_minWidth_0(L_127);
float L_128 = ((GUILayoutEntry_t3828586629 *)__this)->get_maxWidth_1();
if ((!(((float)L_128) == ((float)(0.0f)))))
{
goto IL_0408;
}
}
{
int32_t L_129 = ((GUILayoutEntry_t3828586629 *)__this)->get_stretchWidth_5();
int32_t L_130 = __this->get_m_StretchableCountX_18();
GUIStyle_t1799908754 * L_131 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
bool L_132 = GUIStyle_get_stretchWidth_m1223411161(L_131, /*hidden argument*/NULL);
G_B40_0 = L_130;
G_B40_1 = L_129;
G_B40_2 = __this;
if (!L_132)
{
G_B41_0 = L_130;
G_B41_1 = L_129;
G_B41_2 = __this;
goto IL_03e8;
}
}
{
G_B42_0 = 1;
G_B42_1 = G_B40_0;
G_B42_2 = G_B40_1;
G_B42_3 = G_B40_2;
goto IL_03e9;
}
IL_03e8:
{
G_B42_0 = 0;
G_B42_1 = G_B41_0;
G_B42_2 = G_B41_1;
G_B42_3 = G_B41_2;
}
IL_03e9:
{
((GUILayoutEntry_t3828586629 *)G_B42_3)->set_stretchWidth_5(((int32_t)((int32_t)G_B42_2+(int32_t)((int32_t)((int32_t)G_B42_1+(int32_t)G_B42_0)))));
float L_133 = __this->get_m_ChildMaxWidth_23();
float L_134 = V_12;
float L_135 = V_13;
((GUILayoutEntry_t3828586629 *)__this)->set_maxWidth_1(((float)((float)((float)((float)L_133+(float)L_134))+(float)L_135)));
goto IL_0411;
}
IL_0408:
{
((GUILayoutEntry_t3828586629 *)__this)->set_stretchWidth_5(0);
}
IL_0411:
{
float L_136 = ((GUILayoutEntry_t3828586629 *)__this)->get_maxWidth_1();
float L_137 = ((GUILayoutEntry_t3828586629 *)__this)->get_minWidth_0();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_138 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_136, L_137, /*hidden argument*/NULL);
((GUILayoutEntry_t3828586629 *)__this)->set_maxWidth_1(L_138);
GUIStyle_t1799908754 * L_139 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
float L_140 = GUIStyle_get_fixedWidth_m97997484(L_139, /*hidden argument*/NULL);
if ((((float)L_140) == ((float)(0.0f))))
{
goto IL_0460;
}
}
{
GUIStyle_t1799908754 * L_141 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
float L_142 = GUIStyle_get_fixedWidth_m97997484(L_141, /*hidden argument*/NULL);
float L_143 = L_142;
V_0 = L_143;
((GUILayoutEntry_t3828586629 *)__this)->set_minWidth_0(L_143);
float L_144 = V_0;
((GUILayoutEntry_t3828586629 *)__this)->set_maxWidth_1(L_144);
((GUILayoutEntry_t3828586629 *)__this)->set_stretchWidth_5(0);
}
IL_0460:
{
return;
}
}
// System.Void UnityEngine.GUILayoutGroup::SetHorizontal(System.Single,System.Single)
extern "C" void GUILayoutGroup_SetHorizontal_m15325071 (GUILayoutGroup_t3975363388 * __this, float ___x0, float ___width1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutGroup_SetHorizontal_m15325071_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RectOffset_t3387826427 * V_0 = NULL;
GUILayoutEntry_t3828586629 * V_1 = NULL;
Enumerator_t2732437435 V_2;
memset(&V_2, 0, sizeof(V_2));
float V_3 = 0.0f;
float V_4 = 0.0f;
float V_5 = 0.0f;
float V_6 = 0.0f;
float V_7 = 0.0f;
GUILayoutEntry_t3828586629 * V_8 = NULL;
Enumerator_t2732437435 V_9;
memset(&V_9, 0, sizeof(V_9));
float V_10 = 0.0f;
float V_11 = 0.0f;
float V_12 = 0.0f;
float V_13 = 0.0f;
float V_14 = 0.0f;
int32_t V_15 = 0;
bool V_16 = false;
GUILayoutEntry_t3828586629 * V_17 = NULL;
Enumerator_t2732437435 V_18;
memset(&V_18, 0, sizeof(V_18));
float V_19 = 0.0f;
int32_t V_20 = 0;
int32_t V_21 = 0;
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
int32_t G_B43_0 = 0;
{
float L_0 = ___x0;
float L_1 = ___width1;
GUILayoutEntry_SetHorizontal_m1828181654(__this, L_0, L_1, /*hidden argument*/NULL);
bool L_2 = __this->get_resetCoords_12();
if (!L_2)
{
goto IL_001b;
}
}
{
___x0 = (0.0f);
}
IL_001b:
{
GUIStyle_t1799908754 * L_3 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_4 = GUIStyle_get_padding_m4076916754(L_3, /*hidden argument*/NULL);
V_0 = L_4;
bool L_5 = __this->get_isVertical_11();
if (!L_5)
{
goto IL_01cd;
}
}
{
GUIStyle_t1799908754 * L_6 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_7 = GUIStyle_get_none_m4224270950(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((Il2CppObject*)(GUIStyle_t1799908754 *)L_6) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_7)))
{
goto IL_00f4;
}
}
{
List_1_t3197707761 * L_8 = __this->get_entries_10();
Enumerator_t2732437435 L_9 = List_1_GetEnumerator_m529646903(L_8, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_2 = L_9;
}
IL_0051:
try
{ // begin try (depth: 1)
{
goto IL_00cf;
}
IL_0056:
{
GUILayoutEntry_t3828586629 * L_10 = Enumerator_get_Current_m2724498415((&V_2), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_1 = L_10;
GUILayoutEntry_t3828586629 * L_11 = V_1;
RectOffset_t3387826427 * L_12 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_11);
int32_t L_13 = RectOffset_get_left_m439065308(L_12, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_14 = V_0;
int32_t L_15 = RectOffset_get_left_m439065308(L_14, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
int32_t L_16 = Mathf_Max_m1875893177(NULL /*static, unused*/, L_13, L_15, /*hidden argument*/NULL);
V_3 = (((float)((float)L_16)));
float L_17 = ___x0;
float L_18 = V_3;
V_4 = ((float)((float)L_17+(float)L_18));
float L_19 = ___width1;
GUILayoutEntry_t3828586629 * L_20 = V_1;
RectOffset_t3387826427 * L_21 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_20);
int32_t L_22 = RectOffset_get_right_m281378687(L_21, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_23 = V_0;
int32_t L_24 = RectOffset_get_right_m281378687(L_23, /*hidden argument*/NULL);
int32_t L_25 = Mathf_Max_m1875893177(NULL /*static, unused*/, L_22, L_24, /*hidden argument*/NULL);
float L_26 = V_3;
V_5 = ((float)((float)((float)((float)L_19-(float)(((float)((float)L_25)))))-(float)L_26));
GUILayoutEntry_t3828586629 * L_27 = V_1;
int32_t L_28 = L_27->get_stretchWidth_5();
if (!L_28)
{
goto IL_00b3;
}
}
IL_00a4:
{
GUILayoutEntry_t3828586629 * L_29 = V_1;
float L_30 = V_4;
float L_31 = V_5;
VirtActionInvoker2< float, float >::Invoke(7 /* System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single) */, L_29, L_30, L_31);
goto IL_00ce;
}
IL_00b3:
{
GUILayoutEntry_t3828586629 * L_32 = V_1;
float L_33 = V_4;
float L_34 = V_5;
GUILayoutEntry_t3828586629 * L_35 = V_1;
float L_36 = L_35->get_minWidth_0();
GUILayoutEntry_t3828586629 * L_37 = V_1;
float L_38 = L_37->get_maxWidth_1();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_39 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, L_34, L_36, L_38, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(7 /* System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single) */, L_32, L_33, L_39);
}
IL_00ce:
{
}
IL_00cf:
{
bool L_40 = Enumerator_MoveNext_m672443923((&V_2), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_40)
{
goto IL_0056;
}
}
IL_00db:
{
IL2CPP_LEAVE(0xEE, FINALLY_00e0);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_00e0;
}
FINALLY_00e0:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_2), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(224)
} // end finally (depth: 1)
IL2CPP_CLEANUP(224)
{
IL2CPP_JUMP_TBL(0xEE, IL_00ee)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_00ee:
{
goto IL_01c7;
}
IL_00f4:
{
float L_41 = ___x0;
RectOffset_t3387826427 * L_42 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, __this);
int32_t L_43 = RectOffset_get_left_m439065308(L_42, /*hidden argument*/NULL);
V_6 = ((float)((float)L_41-(float)(((float)((float)L_43)))));
float L_44 = ___width1;
RectOffset_t3387826427 * L_45 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, __this);
int32_t L_46 = RectOffset_get_horizontal_m3818523637(L_45, /*hidden argument*/NULL);
V_7 = ((float)((float)L_44+(float)(((float)((float)L_46)))));
List_1_t3197707761 * L_47 = __this->get_entries_10();
Enumerator_t2732437435 L_48 = List_1_GetEnumerator_m529646903(L_47, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_9 = L_48;
}
IL_0123:
try
{ // begin try (depth: 1)
{
goto IL_01a7;
}
IL_0128:
{
GUILayoutEntry_t3828586629 * L_49 = Enumerator_get_Current_m2724498415((&V_9), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_8 = L_49;
GUILayoutEntry_t3828586629 * L_50 = V_8;
int32_t L_51 = L_50->get_stretchWidth_5();
if (!L_51)
{
goto IL_016c;
}
}
IL_013e:
{
GUILayoutEntry_t3828586629 * L_52 = V_8;
float L_53 = V_6;
GUILayoutEntry_t3828586629 * L_54 = V_8;
RectOffset_t3387826427 * L_55 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_54);
int32_t L_56 = RectOffset_get_left_m439065308(L_55, /*hidden argument*/NULL);
float L_57 = V_7;
GUILayoutEntry_t3828586629 * L_58 = V_8;
RectOffset_t3387826427 * L_59 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_58);
int32_t L_60 = RectOffset_get_horizontal_m3818523637(L_59, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(7 /* System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single) */, L_52, ((float)((float)L_53+(float)(((float)((float)L_56))))), ((float)((float)L_57-(float)(((float)((float)L_60))))));
goto IL_01a6;
}
IL_016c:
{
GUILayoutEntry_t3828586629 * L_61 = V_8;
float L_62 = V_6;
GUILayoutEntry_t3828586629 * L_63 = V_8;
RectOffset_t3387826427 * L_64 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_63);
int32_t L_65 = RectOffset_get_left_m439065308(L_64, /*hidden argument*/NULL);
float L_66 = V_7;
GUILayoutEntry_t3828586629 * L_67 = V_8;
RectOffset_t3387826427 * L_68 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_67);
int32_t L_69 = RectOffset_get_horizontal_m3818523637(L_68, /*hidden argument*/NULL);
GUILayoutEntry_t3828586629 * L_70 = V_8;
float L_71 = L_70->get_minWidth_0();
GUILayoutEntry_t3828586629 * L_72 = V_8;
float L_73 = L_72->get_maxWidth_1();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_74 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, ((float)((float)L_66-(float)(((float)((float)L_69))))), L_71, L_73, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(7 /* System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single) */, L_61, ((float)((float)L_62+(float)(((float)((float)L_65))))), L_74);
}
IL_01a6:
{
}
IL_01a7:
{
bool L_75 = Enumerator_MoveNext_m672443923((&V_9), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_75)
{
goto IL_0128;
}
}
IL_01b3:
{
IL2CPP_LEAVE(0x1C6, FINALLY_01b8);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_01b8;
}
FINALLY_01b8:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_9), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(440)
} // end finally (depth: 1)
IL2CPP_CLEANUP(440)
{
IL2CPP_JUMP_TBL(0x1C6, IL_01c6)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_01c6:
{
}
IL_01c7:
{
goto IL_03d4;
}
IL_01cd:
{
GUIStyle_t1799908754 * L_76 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_77 = GUIStyle_get_none_m4224270950(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((Il2CppObject*)(GUIStyle_t1799908754 *)L_76) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_77)))
{
goto IL_025f;
}
}
{
RectOffset_t3387826427 * L_78 = V_0;
int32_t L_79 = RectOffset_get_left_m439065308(L_78, /*hidden argument*/NULL);
V_10 = (((float)((float)L_79)));
RectOffset_t3387826427 * L_80 = V_0;
int32_t L_81 = RectOffset_get_right_m281378687(L_80, /*hidden argument*/NULL);
V_11 = (((float)((float)L_81)));
List_1_t3197707761 * L_82 = __this->get_entries_10();
int32_t L_83 = List_1_get_Count_m3575634194(L_82, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
if (!L_83)
{
goto IL_024f;
}
}
{
float L_84 = V_10;
List_1_t3197707761 * L_85 = __this->get_entries_10();
GUILayoutEntry_t3828586629 * L_86 = List_1_get_Item_m3153062965(L_85, 0, /*hidden argument*/List_1_get_Item_m3153062965_MethodInfo_var);
RectOffset_t3387826427 * L_87 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_86);
int32_t L_88 = RectOffset_get_left_m439065308(L_87, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_89 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_84, (((float)((float)L_88))), /*hidden argument*/NULL);
V_10 = L_89;
float L_90 = V_11;
List_1_t3197707761 * L_91 = __this->get_entries_10();
List_1_t3197707761 * L_92 = __this->get_entries_10();
int32_t L_93 = List_1_get_Count_m3575634194(L_92, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
GUILayoutEntry_t3828586629 * L_94 = List_1_get_Item_m3153062965(L_91, ((int32_t)((int32_t)L_93-(int32_t)1)), /*hidden argument*/List_1_get_Item_m3153062965_MethodInfo_var);
RectOffset_t3387826427 * L_95 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_94);
int32_t L_96 = RectOffset_get_right_m281378687(L_95, /*hidden argument*/NULL);
float L_97 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_90, (((float)((float)L_96))), /*hidden argument*/NULL);
V_11 = L_97;
}
IL_024f:
{
float L_98 = ___x0;
float L_99 = V_10;
___x0 = ((float)((float)L_98+(float)L_99));
float L_100 = ___width1;
float L_101 = V_11;
float L_102 = V_10;
___width1 = ((float)((float)L_100-(float)((float)((float)L_101+(float)L_102))));
}
IL_025f:
{
float L_103 = ___width1;
float L_104 = __this->get_spacing_13();
List_1_t3197707761 * L_105 = __this->get_entries_10();
int32_t L_106 = List_1_get_Count_m3575634194(L_105, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
V_12 = ((float)((float)L_103-(float)((float)((float)L_104*(float)(((float)((float)((int32_t)((int32_t)L_106-(int32_t)1)))))))));
V_13 = (0.0f);
float L_107 = __this->get_m_ChildMinWidth_22();
float L_108 = __this->get_m_ChildMaxWidth_23();
if ((((float)L_107) == ((float)L_108)))
{
goto IL_02b8;
}
}
{
float L_109 = V_12;
float L_110 = __this->get_m_ChildMinWidth_22();
float L_111 = __this->get_m_ChildMaxWidth_23();
float L_112 = __this->get_m_ChildMinWidth_22();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_113 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, ((float)((float)((float)((float)L_109-(float)L_110))/(float)((float)((float)L_111-(float)L_112)))), (0.0f), (1.0f), /*hidden argument*/NULL);
V_13 = L_113;
}
IL_02b8:
{
V_14 = (0.0f);
float L_114 = V_12;
float L_115 = __this->get_m_ChildMaxWidth_23();
if ((!(((float)L_114) > ((float)L_115))))
{
goto IL_02ef;
}
}
{
int32_t L_116 = __this->get_m_StretchableCountX_18();
if ((((int32_t)L_116) <= ((int32_t)0)))
{
goto IL_02ee;
}
}
{
float L_117 = V_12;
float L_118 = __this->get_m_ChildMaxWidth_23();
int32_t L_119 = __this->get_m_StretchableCountX_18();
V_14 = ((float)((float)((float)((float)L_117-(float)L_118))/(float)(((float)((float)L_119)))));
}
IL_02ee:
{
}
IL_02ef:
{
V_15 = 0;
V_16 = (bool)1;
List_1_t3197707761 * L_120 = __this->get_entries_10();
Enumerator_t2732437435 L_121 = List_1_GetEnumerator_m529646903(L_120, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_18 = L_121;
}
IL_0303:
try
{ // begin try (depth: 1)
{
goto IL_03b4;
}
IL_0308:
{
GUILayoutEntry_t3828586629 * L_122 = Enumerator_get_Current_m2724498415((&V_18), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_17 = L_122;
GUILayoutEntry_t3828586629 * L_123 = V_17;
float L_124 = L_123->get_minWidth_0();
GUILayoutEntry_t3828586629 * L_125 = V_17;
float L_126 = L_125->get_maxWidth_1();
float L_127 = V_13;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_128 = Mathf_Lerp_m1686556575(NULL /*static, unused*/, L_124, L_126, L_127, /*hidden argument*/NULL);
V_19 = L_128;
float L_129 = V_19;
float L_130 = V_14;
GUILayoutEntry_t3828586629 * L_131 = V_17;
int32_t L_132 = L_131->get_stretchWidth_5();
V_19 = ((float)((float)L_129+(float)((float)((float)L_130*(float)(((float)((float)L_132)))))));
GUILayoutEntry_t3828586629 * L_133 = V_17;
GUIStyle_t1799908754 * L_134 = GUILayoutEntry_get_style_m998192810(L_133, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_135 = GUILayoutUtility_get_spaceStyle_m1918520192(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((Il2CppObject*)(GUIStyle_t1799908754 *)L_134) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_135)))
{
goto IL_0392;
}
}
IL_034a:
{
GUILayoutEntry_t3828586629 * L_136 = V_17;
RectOffset_t3387826427 * L_137 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_136);
int32_t L_138 = RectOffset_get_left_m439065308(L_137, /*hidden argument*/NULL);
V_20 = L_138;
bool L_139 = V_16;
if (!L_139)
{
goto IL_0368;
}
}
IL_0360:
{
V_20 = 0;
V_16 = (bool)0;
}
IL_0368:
{
int32_t L_140 = V_15;
int32_t L_141 = V_20;
if ((((int32_t)L_140) <= ((int32_t)L_141)))
{
goto IL_0378;
}
}
IL_0371:
{
int32_t L_142 = V_15;
G_B43_0 = L_142;
goto IL_037a;
}
IL_0378:
{
int32_t L_143 = V_20;
G_B43_0 = L_143;
}
IL_037a:
{
V_21 = G_B43_0;
float L_144 = ___x0;
int32_t L_145 = V_21;
___x0 = ((float)((float)L_144+(float)(((float)((float)L_145)))));
GUILayoutEntry_t3828586629 * L_146 = V_17;
RectOffset_t3387826427 * L_147 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_146);
int32_t L_148 = RectOffset_get_right_m281378687(L_147, /*hidden argument*/NULL);
V_15 = L_148;
}
IL_0392:
{
GUILayoutEntry_t3828586629 * L_149 = V_17;
float L_150 = ___x0;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_151 = bankers_roundf(L_150);
float L_152 = V_19;
float L_153 = bankers_roundf(L_152);
VirtActionInvoker2< float, float >::Invoke(7 /* System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single) */, L_149, L_151, L_153);
float L_154 = ___x0;
float L_155 = V_19;
float L_156 = __this->get_spacing_13();
___x0 = ((float)((float)L_154+(float)((float)((float)L_155+(float)L_156))));
}
IL_03b4:
{
bool L_157 = Enumerator_MoveNext_m672443923((&V_18), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_157)
{
goto IL_0308;
}
}
IL_03c0:
{
IL2CPP_LEAVE(0x3D3, FINALLY_03c5);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_03c5;
}
FINALLY_03c5:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_18), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(965)
} // end finally (depth: 1)
IL2CPP_CLEANUP(965)
{
IL2CPP_JUMP_TBL(0x3D3, IL_03d3)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_03d3:
{
}
IL_03d4:
{
return;
}
}
// System.Void UnityEngine.GUILayoutGroup::CalcHeight()
extern "C" void GUILayoutGroup_CalcHeight_m1454440153 (GUILayoutGroup_t3975363388 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutGroup_CalcHeight_m1454440153_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
int32_t V_1 = 0;
int32_t V_2 = 0;
int32_t V_3 = 0;
bool V_4 = false;
GUILayoutEntry_t3828586629 * V_5 = NULL;
Enumerator_t2732437435 V_6;
memset(&V_6, 0, sizeof(V_6));
RectOffset_t3387826427 * V_7 = NULL;
int32_t V_8 = 0;
bool V_9 = false;
GUILayoutEntry_t3828586629 * V_10 = NULL;
Enumerator_t2732437435 V_11;
memset(&V_11, 0, sizeof(V_11));
RectOffset_t3387826427 * V_12 = NULL;
float V_13 = 0.0f;
float V_14 = 0.0f;
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
int32_t G_B38_0 = 0;
int32_t G_B38_1 = 0;
GUILayoutGroup_t3975363388 * G_B38_2 = NULL;
int32_t G_B37_0 = 0;
int32_t G_B37_1 = 0;
GUILayoutGroup_t3975363388 * G_B37_2 = NULL;
int32_t G_B39_0 = 0;
int32_t G_B39_1 = 0;
int32_t G_B39_2 = 0;
GUILayoutGroup_t3975363388 * G_B39_3 = NULL;
{
List_1_t3197707761 * L_0 = __this->get_entries_10();
int32_t L_1 = List_1_get_Count_m3575634194(L_0, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
if (L_1)
{
goto IL_0037;
}
}
{
GUIStyle_t1799908754 * L_2 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_3 = GUIStyle_get_padding_m4076916754(L_2, /*hidden argument*/NULL);
int32_t L_4 = RectOffset_get_vertical_m3856345169(L_3, /*hidden argument*/NULL);
float L_5 = (((float)((float)L_4)));
V_0 = L_5;
((GUILayoutEntry_t3828586629 *)__this)->set_minHeight_2(L_5);
float L_6 = V_0;
((GUILayoutEntry_t3828586629 *)__this)->set_maxHeight_3(L_6);
goto IL_0422;
}
IL_0037:
{
V_1 = 0;
V_2 = 0;
__this->set_m_ChildMinHeight_24((0.0f));
__this->set_m_ChildMaxHeight_25((0.0f));
__this->set_m_StretchableCountY_19(0);
bool L_7 = __this->get_isVertical_11();
if (!L_7)
{
goto IL_01eb;
}
}
{
V_3 = 0;
V_4 = (bool)1;
List_1_t3197707761 * L_8 = __this->get_entries_10();
Enumerator_t2732437435 L_9 = List_1_GetEnumerator_m529646903(L_8, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_6 = L_9;
}
IL_0077:
try
{ // begin try (depth: 1)
{
goto IL_016a;
}
IL_007c:
{
GUILayoutEntry_t3828586629 * L_10 = Enumerator_get_Current_m2724498415((&V_6), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_5 = L_10;
GUILayoutEntry_t3828586629 * L_11 = V_5;
VirtActionInvoker0::Invoke(6 /* System.Void UnityEngine.GUILayoutEntry::CalcHeight() */, L_11);
GUILayoutEntry_t3828586629 * L_12 = V_5;
RectOffset_t3387826427 * L_13 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_12);
V_7 = L_13;
GUILayoutEntry_t3828586629 * L_14 = V_5;
GUIStyle_t1799908754 * L_15 = GUILayoutEntry_get_style_m998192810(L_14, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_16 = GUILayoutUtility_get_spaceStyle_m1918520192(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((Il2CppObject*)(GUIStyle_t1799908754 *)L_15) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_16)))
{
goto IL_012b;
}
}
IL_00a7:
{
bool L_17 = V_4;
if (L_17)
{
goto IL_00c3;
}
}
IL_00af:
{
int32_t L_18 = V_3;
RectOffset_t3387826427 * L_19 = V_7;
int32_t L_20 = RectOffset_get_top_m3629049358(L_19, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
int32_t L_21 = Mathf_Max_m1875893177(NULL /*static, unused*/, L_18, L_20, /*hidden argument*/NULL);
V_8 = L_21;
goto IL_00cb;
}
IL_00c3:
{
V_8 = 0;
V_4 = (bool)0;
}
IL_00cb:
{
float L_22 = __this->get_m_ChildMinHeight_24();
GUILayoutEntry_t3828586629 * L_23 = V_5;
float L_24 = L_23->get_minHeight_2();
float L_25 = __this->get_spacing_13();
int32_t L_26 = V_8;
__this->set_m_ChildMinHeight_24(((float)((float)L_22+(float)((float)((float)((float)((float)L_24+(float)L_25))+(float)(((float)((float)L_26))))))));
float L_27 = __this->get_m_ChildMaxHeight_25();
GUILayoutEntry_t3828586629 * L_28 = V_5;
float L_29 = L_28->get_maxHeight_3();
float L_30 = __this->get_spacing_13();
int32_t L_31 = V_8;
__this->set_m_ChildMaxHeight_25(((float)((float)L_27+(float)((float)((float)((float)((float)L_29+(float)L_30))+(float)(((float)((float)L_31))))))));
RectOffset_t3387826427 * L_32 = V_7;
int32_t L_33 = RectOffset_get_bottom_m4112328858(L_32, /*hidden argument*/NULL);
V_3 = L_33;
int32_t L_34 = __this->get_m_StretchableCountY_19();
GUILayoutEntry_t3828586629 * L_35 = V_5;
int32_t L_36 = L_35->get_stretchHeight_6();
__this->set_m_StretchableCountY_19(((int32_t)((int32_t)L_34+(int32_t)L_36)));
goto IL_0169;
}
IL_012b:
{
float L_37 = __this->get_m_ChildMinHeight_24();
GUILayoutEntry_t3828586629 * L_38 = V_5;
float L_39 = L_38->get_minHeight_2();
__this->set_m_ChildMinHeight_24(((float)((float)L_37+(float)L_39)));
float L_40 = __this->get_m_ChildMaxHeight_25();
GUILayoutEntry_t3828586629 * L_41 = V_5;
float L_42 = L_41->get_maxHeight_3();
__this->set_m_ChildMaxHeight_25(((float)((float)L_40+(float)L_42)));
int32_t L_43 = __this->get_m_StretchableCountY_19();
GUILayoutEntry_t3828586629 * L_44 = V_5;
int32_t L_45 = L_44->get_stretchHeight_6();
__this->set_m_StretchableCountY_19(((int32_t)((int32_t)L_43+(int32_t)L_45)));
}
IL_0169:
{
}
IL_016a:
{
bool L_46 = Enumerator_MoveNext_m672443923((&V_6), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_46)
{
goto IL_007c;
}
}
IL_0176:
{
IL2CPP_LEAVE(0x189, FINALLY_017b);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_017b;
}
FINALLY_017b:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_6), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(379)
} // end finally (depth: 1)
IL2CPP_CLEANUP(379)
{
IL2CPP_JUMP_TBL(0x189, IL_0189)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_0189:
{
float L_47 = __this->get_m_ChildMinHeight_24();
float L_48 = __this->get_spacing_13();
__this->set_m_ChildMinHeight_24(((float)((float)L_47-(float)L_48)));
float L_49 = __this->get_m_ChildMaxHeight_25();
float L_50 = __this->get_spacing_13();
__this->set_m_ChildMaxHeight_25(((float)((float)L_49-(float)L_50)));
List_1_t3197707761 * L_51 = __this->get_entries_10();
int32_t L_52 = List_1_get_Count_m3575634194(L_51, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
if (!L_52)
{
goto IL_01df;
}
}
{
List_1_t3197707761 * L_53 = __this->get_entries_10();
GUILayoutEntry_t3828586629 * L_54 = List_1_get_Item_m3153062965(L_53, 0, /*hidden argument*/List_1_get_Item_m3153062965_MethodInfo_var);
RectOffset_t3387826427 * L_55 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_54);
int32_t L_56 = RectOffset_get_top_m3629049358(L_55, /*hidden argument*/NULL);
V_1 = L_56;
int32_t L_57 = V_3;
V_2 = L_57;
goto IL_01e5;
}
IL_01df:
{
int32_t L_58 = 0;
V_1 = L_58;
V_2 = L_58;
}
IL_01e5:
{
goto IL_02d3;
}
IL_01eb:
{
V_9 = (bool)1;
List_1_t3197707761 * L_59 = __this->get_entries_10();
Enumerator_t2732437435 L_60 = List_1_GetEnumerator_m529646903(L_59, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_11 = L_60;
}
IL_01fd:
try
{ // begin try (depth: 1)
{
goto IL_02b3;
}
IL_0202:
{
GUILayoutEntry_t3828586629 * L_61 = Enumerator_get_Current_m2724498415((&V_11), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_10 = L_61;
GUILayoutEntry_t3828586629 * L_62 = V_10;
VirtActionInvoker0::Invoke(6 /* System.Void UnityEngine.GUILayoutEntry::CalcHeight() */, L_62);
GUILayoutEntry_t3828586629 * L_63 = V_10;
RectOffset_t3387826427 * L_64 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_63);
V_12 = L_64;
GUILayoutEntry_t3828586629 * L_65 = V_10;
GUIStyle_t1799908754 * L_66 = GUILayoutEntry_get_style_m998192810(L_65, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_67 = GUILayoutUtility_get_spaceStyle_m1918520192(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((Il2CppObject*)(GUIStyle_t1799908754 *)L_66) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_67)))
{
goto IL_029e;
}
}
IL_022d:
{
bool L_68 = V_9;
if (L_68)
{
goto IL_0258;
}
}
IL_0235:
{
RectOffset_t3387826427 * L_69 = V_12;
int32_t L_70 = RectOffset_get_top_m3629049358(L_69, /*hidden argument*/NULL);
int32_t L_71 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
int32_t L_72 = Mathf_Min_m2906823867(NULL /*static, unused*/, L_70, L_71, /*hidden argument*/NULL);
V_1 = L_72;
RectOffset_t3387826427 * L_73 = V_12;
int32_t L_74 = RectOffset_get_bottom_m4112328858(L_73, /*hidden argument*/NULL);
int32_t L_75 = V_2;
int32_t L_76 = Mathf_Min_m2906823867(NULL /*static, unused*/, L_74, L_75, /*hidden argument*/NULL);
V_2 = L_76;
goto IL_026d;
}
IL_0258:
{
RectOffset_t3387826427 * L_77 = V_12;
int32_t L_78 = RectOffset_get_top_m3629049358(L_77, /*hidden argument*/NULL);
V_1 = L_78;
RectOffset_t3387826427 * L_79 = V_12;
int32_t L_80 = RectOffset_get_bottom_m4112328858(L_79, /*hidden argument*/NULL);
V_2 = L_80;
V_9 = (bool)0;
}
IL_026d:
{
GUILayoutEntry_t3828586629 * L_81 = V_10;
float L_82 = L_81->get_minHeight_2();
float L_83 = __this->get_m_ChildMinHeight_24();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_84 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_82, L_83, /*hidden argument*/NULL);
__this->set_m_ChildMinHeight_24(L_84);
GUILayoutEntry_t3828586629 * L_85 = V_10;
float L_86 = L_85->get_maxHeight_3();
float L_87 = __this->get_m_ChildMaxHeight_25();
float L_88 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_86, L_87, /*hidden argument*/NULL);
__this->set_m_ChildMaxHeight_25(L_88);
}
IL_029e:
{
int32_t L_89 = __this->get_m_StretchableCountY_19();
GUILayoutEntry_t3828586629 * L_90 = V_10;
int32_t L_91 = L_90->get_stretchHeight_6();
__this->set_m_StretchableCountY_19(((int32_t)((int32_t)L_89+(int32_t)L_91)));
}
IL_02b3:
{
bool L_92 = Enumerator_MoveNext_m672443923((&V_11), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_92)
{
goto IL_0202;
}
}
IL_02bf:
{
IL2CPP_LEAVE(0x2D2, FINALLY_02c4);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_02c4;
}
FINALLY_02c4:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_11), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(708)
} // end finally (depth: 1)
IL2CPP_CLEANUP(708)
{
IL2CPP_JUMP_TBL(0x2D2, IL_02d2)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_02d2:
{
}
IL_02d3:
{
V_13 = (0.0f);
V_14 = (0.0f);
GUIStyle_t1799908754 * L_93 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_94 = GUIStyle_get_none_m4224270950(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((!(((Il2CppObject*)(GUIStyle_t1799908754 *)L_93) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_94))))
{
goto IL_02fc;
}
}
{
bool L_95 = __this->get_m_UserSpecifiedHeight_21();
if (!L_95)
{
goto IL_0335;
}
}
IL_02fc:
{
GUIStyle_t1799908754 * L_96 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_97 = GUIStyle_get_padding_m4076916754(L_96, /*hidden argument*/NULL);
int32_t L_98 = RectOffset_get_top_m3629049358(L_97, /*hidden argument*/NULL);
int32_t L_99 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
int32_t L_100 = Mathf_Max_m1875893177(NULL /*static, unused*/, L_98, L_99, /*hidden argument*/NULL);
V_13 = (((float)((float)L_100)));
GUIStyle_t1799908754 * L_101 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_102 = GUIStyle_get_padding_m4076916754(L_101, /*hidden argument*/NULL);
int32_t L_103 = RectOffset_get_bottom_m4112328858(L_102, /*hidden argument*/NULL);
int32_t L_104 = V_2;
int32_t L_105 = Mathf_Max_m1875893177(NULL /*static, unused*/, L_103, L_104, /*hidden argument*/NULL);
V_14 = (((float)((float)L_105)));
goto IL_0359;
}
IL_0335:
{
RectOffset_t3387826427 * L_106 = __this->get_m_Margin_26();
int32_t L_107 = V_1;
RectOffset_set_top_m3579196427(L_106, L_107, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_108 = __this->get_m_Margin_26();
int32_t L_109 = V_2;
RectOffset_set_bottom_m4065521443(L_108, L_109, /*hidden argument*/NULL);
float L_110 = (0.0f);
V_14 = L_110;
V_13 = L_110;
}
IL_0359:
{
float L_111 = ((GUILayoutEntry_t3828586629 *)__this)->get_minHeight_2();
float L_112 = __this->get_m_ChildMinHeight_24();
float L_113 = V_13;
float L_114 = V_14;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_115 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_111, ((float)((float)((float)((float)L_112+(float)L_113))+(float)L_114)), /*hidden argument*/NULL);
((GUILayoutEntry_t3828586629 *)__this)->set_minHeight_2(L_115);
float L_116 = ((GUILayoutEntry_t3828586629 *)__this)->get_maxHeight_3();
if ((!(((float)L_116) == ((float)(0.0f)))))
{
goto IL_03ca;
}
}
{
int32_t L_117 = ((GUILayoutEntry_t3828586629 *)__this)->get_stretchHeight_6();
int32_t L_118 = __this->get_m_StretchableCountY_19();
GUIStyle_t1799908754 * L_119 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
bool L_120 = GUIStyle_get_stretchHeight_m3396762700(L_119, /*hidden argument*/NULL);
G_B37_0 = L_118;
G_B37_1 = L_117;
G_B37_2 = __this;
if (!L_120)
{
G_B38_0 = L_118;
G_B38_1 = L_117;
G_B38_2 = __this;
goto IL_03aa;
}
}
{
G_B39_0 = 1;
G_B39_1 = G_B37_0;
G_B39_2 = G_B37_1;
G_B39_3 = G_B37_2;
goto IL_03ab;
}
IL_03aa:
{
G_B39_0 = 0;
G_B39_1 = G_B38_0;
G_B39_2 = G_B38_1;
G_B39_3 = G_B38_2;
}
IL_03ab:
{
((GUILayoutEntry_t3828586629 *)G_B39_3)->set_stretchHeight_6(((int32_t)((int32_t)G_B39_2+(int32_t)((int32_t)((int32_t)G_B39_1+(int32_t)G_B39_0)))));
float L_121 = __this->get_m_ChildMaxHeight_25();
float L_122 = V_13;
float L_123 = V_14;
((GUILayoutEntry_t3828586629 *)__this)->set_maxHeight_3(((float)((float)((float)((float)L_121+(float)L_122))+(float)L_123)));
goto IL_03d3;
}
IL_03ca:
{
((GUILayoutEntry_t3828586629 *)__this)->set_stretchHeight_6(0);
}
IL_03d3:
{
float L_124 = ((GUILayoutEntry_t3828586629 *)__this)->get_maxHeight_3();
float L_125 = ((GUILayoutEntry_t3828586629 *)__this)->get_minHeight_2();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_126 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_124, L_125, /*hidden argument*/NULL);
((GUILayoutEntry_t3828586629 *)__this)->set_maxHeight_3(L_126);
GUIStyle_t1799908754 * L_127 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
float L_128 = GUIStyle_get_fixedHeight_m414733479(L_127, /*hidden argument*/NULL);
if ((((float)L_128) == ((float)(0.0f))))
{
goto IL_0422;
}
}
{
GUIStyle_t1799908754 * L_129 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
float L_130 = GUIStyle_get_fixedHeight_m414733479(L_129, /*hidden argument*/NULL);
float L_131 = L_130;
V_0 = L_131;
((GUILayoutEntry_t3828586629 *)__this)->set_minHeight_2(L_131);
float L_132 = V_0;
((GUILayoutEntry_t3828586629 *)__this)->set_maxHeight_3(L_132);
((GUILayoutEntry_t3828586629 *)__this)->set_stretchHeight_6(0);
}
IL_0422:
{
return;
}
}
// System.Void UnityEngine.GUILayoutGroup::SetVertical(System.Single,System.Single)
extern "C" void GUILayoutGroup_SetVertical_m2197915999 (GUILayoutGroup_t3975363388 * __this, float ___y0, float ___height1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutGroup_SetVertical_m2197915999_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RectOffset_t3387826427 * V_0 = NULL;
float V_1 = 0.0f;
float V_2 = 0.0f;
float V_3 = 0.0f;
float V_4 = 0.0f;
float V_5 = 0.0f;
int32_t V_6 = 0;
bool V_7 = false;
GUILayoutEntry_t3828586629 * V_8 = NULL;
Enumerator_t2732437435 V_9;
memset(&V_9, 0, sizeof(V_9));
float V_10 = 0.0f;
int32_t V_11 = 0;
int32_t V_12 = 0;
GUILayoutEntry_t3828586629 * V_13 = NULL;
Enumerator_t2732437435 V_14;
memset(&V_14, 0, sizeof(V_14));
float V_15 = 0.0f;
float V_16 = 0.0f;
float V_17 = 0.0f;
float V_18 = 0.0f;
float V_19 = 0.0f;
GUILayoutEntry_t3828586629 * V_20 = NULL;
Enumerator_t2732437435 V_21;
memset(&V_21, 0, sizeof(V_21));
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
int32_t G_B23_0 = 0;
{
float L_0 = ___y0;
float L_1 = ___height1;
GUILayoutEntry_SetVertical_m2328603448(__this, L_0, L_1, /*hidden argument*/NULL);
List_1_t3197707761 * L_2 = __this->get_entries_10();
int32_t L_3 = List_1_get_Count_m3575634194(L_2, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
if (L_3)
{
goto IL_001e;
}
}
{
goto IL_03e4;
}
IL_001e:
{
GUIStyle_t1799908754 * L_4 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_5 = GUIStyle_get_padding_m4076916754(L_4, /*hidden argument*/NULL);
V_0 = L_5;
bool L_6 = __this->get_resetCoords_12();
if (!L_6)
{
goto IL_003c;
}
}
{
___y0 = (0.0f);
}
IL_003c:
{
bool L_7 = __this->get_isVertical_11();
if (!L_7)
{
goto IL_0244;
}
}
{
GUIStyle_t1799908754 * L_8 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_9 = GUIStyle_get_none_m4224270950(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((Il2CppObject*)(GUIStyle_t1799908754 *)L_8) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_9)))
{
goto IL_00d0;
}
}
{
RectOffset_t3387826427 * L_10 = V_0;
int32_t L_11 = RectOffset_get_top_m3629049358(L_10, /*hidden argument*/NULL);
V_1 = (((float)((float)L_11)));
RectOffset_t3387826427 * L_12 = V_0;
int32_t L_13 = RectOffset_get_bottom_m4112328858(L_12, /*hidden argument*/NULL);
V_2 = (((float)((float)L_13)));
List_1_t3197707761 * L_14 = __this->get_entries_10();
int32_t L_15 = List_1_get_Count_m3575634194(L_14, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
if (!L_15)
{
goto IL_00c3;
}
}
{
float L_16 = V_1;
List_1_t3197707761 * L_17 = __this->get_entries_10();
GUILayoutEntry_t3828586629 * L_18 = List_1_get_Item_m3153062965(L_17, 0, /*hidden argument*/List_1_get_Item_m3153062965_MethodInfo_var);
RectOffset_t3387826427 * L_19 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_18);
int32_t L_20 = RectOffset_get_top_m3629049358(L_19, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_21 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_16, (((float)((float)L_20))), /*hidden argument*/NULL);
V_1 = L_21;
float L_22 = V_2;
List_1_t3197707761 * L_23 = __this->get_entries_10();
List_1_t3197707761 * L_24 = __this->get_entries_10();
int32_t L_25 = List_1_get_Count_m3575634194(L_24, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
GUILayoutEntry_t3828586629 * L_26 = List_1_get_Item_m3153062965(L_23, ((int32_t)((int32_t)L_25-(int32_t)1)), /*hidden argument*/List_1_get_Item_m3153062965_MethodInfo_var);
RectOffset_t3387826427 * L_27 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_26);
int32_t L_28 = RectOffset_get_bottom_m4112328858(L_27, /*hidden argument*/NULL);
float L_29 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_22, (((float)((float)L_28))), /*hidden argument*/NULL);
V_2 = L_29;
}
IL_00c3:
{
float L_30 = ___y0;
float L_31 = V_1;
___y0 = ((float)((float)L_30+(float)L_31));
float L_32 = ___height1;
float L_33 = V_2;
float L_34 = V_1;
___height1 = ((float)((float)L_32-(float)((float)((float)L_33+(float)L_34))));
}
IL_00d0:
{
float L_35 = ___height1;
float L_36 = __this->get_spacing_13();
List_1_t3197707761 * L_37 = __this->get_entries_10();
int32_t L_38 = List_1_get_Count_m3575634194(L_37, /*hidden argument*/List_1_get_Count_m3575634194_MethodInfo_var);
V_3 = ((float)((float)L_35-(float)((float)((float)L_36*(float)(((float)((float)((int32_t)((int32_t)L_38-(int32_t)1)))))))));
V_4 = (0.0f);
float L_39 = __this->get_m_ChildMinHeight_24();
float L_40 = __this->get_m_ChildMaxHeight_25();
if ((((float)L_39) == ((float)L_40)))
{
goto IL_0127;
}
}
{
float L_41 = V_3;
float L_42 = __this->get_m_ChildMinHeight_24();
float L_43 = __this->get_m_ChildMaxHeight_25();
float L_44 = __this->get_m_ChildMinHeight_24();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_45 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, ((float)((float)((float)((float)L_41-(float)L_42))/(float)((float)((float)L_43-(float)L_44)))), (0.0f), (1.0f), /*hidden argument*/NULL);
V_4 = L_45;
}
IL_0127:
{
V_5 = (0.0f);
float L_46 = V_3;
float L_47 = __this->get_m_ChildMaxHeight_25();
if ((!(((float)L_46) > ((float)L_47))))
{
goto IL_015a;
}
}
{
int32_t L_48 = __this->get_m_StretchableCountY_19();
if ((((int32_t)L_48) <= ((int32_t)0)))
{
goto IL_0159;
}
}
{
float L_49 = V_3;
float L_50 = __this->get_m_ChildMaxHeight_25();
int32_t L_51 = __this->get_m_StretchableCountY_19();
V_5 = ((float)((float)((float)((float)L_49-(float)L_50))/(float)(((float)((float)L_51)))));
}
IL_0159:
{
}
IL_015a:
{
V_6 = 0;
V_7 = (bool)1;
List_1_t3197707761 * L_52 = __this->get_entries_10();
Enumerator_t2732437435 L_53 = List_1_GetEnumerator_m529646903(L_52, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_9 = L_53;
}
IL_016e:
try
{ // begin try (depth: 1)
{
goto IL_021f;
}
IL_0173:
{
GUILayoutEntry_t3828586629 * L_54 = Enumerator_get_Current_m2724498415((&V_9), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_8 = L_54;
GUILayoutEntry_t3828586629 * L_55 = V_8;
float L_56 = L_55->get_minHeight_2();
GUILayoutEntry_t3828586629 * L_57 = V_8;
float L_58 = L_57->get_maxHeight_3();
float L_59 = V_4;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_60 = Mathf_Lerp_m1686556575(NULL /*static, unused*/, L_56, L_58, L_59, /*hidden argument*/NULL);
V_10 = L_60;
float L_61 = V_10;
float L_62 = V_5;
GUILayoutEntry_t3828586629 * L_63 = V_8;
int32_t L_64 = L_63->get_stretchHeight_6();
V_10 = ((float)((float)L_61+(float)((float)((float)L_62*(float)(((float)((float)L_64)))))));
GUILayoutEntry_t3828586629 * L_65 = V_8;
GUIStyle_t1799908754 * L_66 = GUILayoutEntry_get_style_m998192810(L_65, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_67 = GUILayoutUtility_get_spaceStyle_m1918520192(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((Il2CppObject*)(GUIStyle_t1799908754 *)L_66) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_67)))
{
goto IL_01fd;
}
}
IL_01b5:
{
GUILayoutEntry_t3828586629 * L_68 = V_8;
RectOffset_t3387826427 * L_69 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_68);
int32_t L_70 = RectOffset_get_top_m3629049358(L_69, /*hidden argument*/NULL);
V_11 = L_70;
bool L_71 = V_7;
if (!L_71)
{
goto IL_01d3;
}
}
IL_01cb:
{
V_11 = 0;
V_7 = (bool)0;
}
IL_01d3:
{
int32_t L_72 = V_6;
int32_t L_73 = V_11;
if ((((int32_t)L_72) <= ((int32_t)L_73)))
{
goto IL_01e3;
}
}
IL_01dc:
{
int32_t L_74 = V_6;
G_B23_0 = L_74;
goto IL_01e5;
}
IL_01e3:
{
int32_t L_75 = V_11;
G_B23_0 = L_75;
}
IL_01e5:
{
V_12 = G_B23_0;
float L_76 = ___y0;
int32_t L_77 = V_12;
___y0 = ((float)((float)L_76+(float)(((float)((float)L_77)))));
GUILayoutEntry_t3828586629 * L_78 = V_8;
RectOffset_t3387826427 * L_79 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_78);
int32_t L_80 = RectOffset_get_bottom_m4112328858(L_79, /*hidden argument*/NULL);
V_6 = L_80;
}
IL_01fd:
{
GUILayoutEntry_t3828586629 * L_81 = V_8;
float L_82 = ___y0;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_83 = bankers_roundf(L_82);
float L_84 = V_10;
float L_85 = bankers_roundf(L_84);
VirtActionInvoker2< float, float >::Invoke(8 /* System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single) */, L_81, L_83, L_85);
float L_86 = ___y0;
float L_87 = V_10;
float L_88 = __this->get_spacing_13();
___y0 = ((float)((float)L_86+(float)((float)((float)L_87+(float)L_88))));
}
IL_021f:
{
bool L_89 = Enumerator_MoveNext_m672443923((&V_9), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_89)
{
goto IL_0173;
}
}
IL_022b:
{
IL2CPP_LEAVE(0x23E, FINALLY_0230);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_0230;
}
FINALLY_0230:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_9), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(560)
} // end finally (depth: 1)
IL2CPP_CLEANUP(560)
{
IL2CPP_JUMP_TBL(0x23E, IL_023e)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_023e:
{
goto IL_03e4;
}
IL_0244:
{
GUIStyle_t1799908754 * L_90 = GUILayoutEntry_get_style_m998192810(__this, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_91 = GUIStyle_get_none_m4224270950(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((Il2CppObject*)(GUIStyle_t1799908754 *)L_90) == ((Il2CppObject*)(GUIStyle_t1799908754 *)L_91)))
{
goto IL_0312;
}
}
{
List_1_t3197707761 * L_92 = __this->get_entries_10();
Enumerator_t2732437435 L_93 = List_1_GetEnumerator_m529646903(L_92, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_14 = L_93;
}
IL_0264:
try
{ // begin try (depth: 1)
{
goto IL_02ed;
}
IL_0269:
{
GUILayoutEntry_t3828586629 * L_94 = Enumerator_get_Current_m2724498415((&V_14), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_13 = L_94;
GUILayoutEntry_t3828586629 * L_95 = V_13;
RectOffset_t3387826427 * L_96 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_95);
int32_t L_97 = RectOffset_get_top_m3629049358(L_96, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_98 = V_0;
int32_t L_99 = RectOffset_get_top_m3629049358(L_98, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
int32_t L_100 = Mathf_Max_m1875893177(NULL /*static, unused*/, L_97, L_99, /*hidden argument*/NULL);
V_15 = (((float)((float)L_100)));
float L_101 = ___y0;
float L_102 = V_15;
V_16 = ((float)((float)L_101+(float)L_102));
float L_103 = ___height1;
GUILayoutEntry_t3828586629 * L_104 = V_13;
RectOffset_t3387826427 * L_105 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_104);
int32_t L_106 = RectOffset_get_bottom_m4112328858(L_105, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_107 = V_0;
int32_t L_108 = RectOffset_get_bottom_m4112328858(L_107, /*hidden argument*/NULL);
int32_t L_109 = Mathf_Max_m1875893177(NULL /*static, unused*/, L_106, L_108, /*hidden argument*/NULL);
float L_110 = V_15;
V_17 = ((float)((float)((float)((float)L_103-(float)(((float)((float)L_109)))))-(float)L_110));
GUILayoutEntry_t3828586629 * L_111 = V_13;
int32_t L_112 = L_111->get_stretchHeight_6();
if (!L_112)
{
goto IL_02ce;
}
}
IL_02be:
{
GUILayoutEntry_t3828586629 * L_113 = V_13;
float L_114 = V_16;
float L_115 = V_17;
VirtActionInvoker2< float, float >::Invoke(8 /* System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single) */, L_113, L_114, L_115);
goto IL_02ec;
}
IL_02ce:
{
GUILayoutEntry_t3828586629 * L_116 = V_13;
float L_117 = V_16;
float L_118 = V_17;
GUILayoutEntry_t3828586629 * L_119 = V_13;
float L_120 = L_119->get_minHeight_2();
GUILayoutEntry_t3828586629 * L_121 = V_13;
float L_122 = L_121->get_maxHeight_3();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_123 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, L_118, L_120, L_122, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(8 /* System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single) */, L_116, L_117, L_123);
}
IL_02ec:
{
}
IL_02ed:
{
bool L_124 = Enumerator_MoveNext_m672443923((&V_14), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_124)
{
goto IL_0269;
}
}
IL_02f9:
{
IL2CPP_LEAVE(0x30C, FINALLY_02fe);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_02fe;
}
FINALLY_02fe:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_14), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(766)
} // end finally (depth: 1)
IL2CPP_CLEANUP(766)
{
IL2CPP_JUMP_TBL(0x30C, IL_030c)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_030c:
{
goto IL_03e3;
}
IL_0312:
{
float L_125 = ___y0;
RectOffset_t3387826427 * L_126 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, __this);
int32_t L_127 = RectOffset_get_top_m3629049358(L_126, /*hidden argument*/NULL);
V_18 = ((float)((float)L_125-(float)(((float)((float)L_127)))));
float L_128 = ___height1;
RectOffset_t3387826427 * L_129 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, __this);
int32_t L_130 = RectOffset_get_vertical_m3856345169(L_129, /*hidden argument*/NULL);
V_19 = ((float)((float)L_128+(float)(((float)((float)L_130)))));
List_1_t3197707761 * L_131 = __this->get_entries_10();
Enumerator_t2732437435 L_132 = List_1_GetEnumerator_m529646903(L_131, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_21 = L_132;
}
IL_0341:
try
{ // begin try (depth: 1)
{
goto IL_03c3;
}
IL_0346:
{
GUILayoutEntry_t3828586629 * L_133 = Enumerator_get_Current_m2724498415((&V_21), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_20 = L_133;
GUILayoutEntry_t3828586629 * L_134 = V_20;
int32_t L_135 = L_134->get_stretchHeight_6();
if (!L_135)
{
goto IL_0388;
}
}
IL_035c:
{
GUILayoutEntry_t3828586629 * L_136 = V_20;
float L_137 = V_18;
GUILayoutEntry_t3828586629 * L_138 = V_20;
RectOffset_t3387826427 * L_139 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_138);
int32_t L_140 = RectOffset_get_top_m3629049358(L_139, /*hidden argument*/NULL);
float L_141 = V_19;
GUILayoutEntry_t3828586629 * L_142 = V_20;
RectOffset_t3387826427 * L_143 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_142);
int32_t L_144 = RectOffset_get_vertical_m3856345169(L_143, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(8 /* System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single) */, L_136, ((float)((float)L_137+(float)(((float)((float)L_140))))), ((float)((float)L_141-(float)(((float)((float)L_144))))));
goto IL_03c2;
}
IL_0388:
{
GUILayoutEntry_t3828586629 * L_145 = V_20;
float L_146 = V_18;
GUILayoutEntry_t3828586629 * L_147 = V_20;
RectOffset_t3387826427 * L_148 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_147);
int32_t L_149 = RectOffset_get_top_m3629049358(L_148, /*hidden argument*/NULL);
float L_150 = V_19;
GUILayoutEntry_t3828586629 * L_151 = V_20;
RectOffset_t3387826427 * L_152 = VirtFuncInvoker0< RectOffset_t3387826427 * >::Invoke(4 /* UnityEngine.RectOffset UnityEngine.GUILayoutEntry::get_margin() */, L_151);
int32_t L_153 = RectOffset_get_vertical_m3856345169(L_152, /*hidden argument*/NULL);
GUILayoutEntry_t3828586629 * L_154 = V_20;
float L_155 = L_154->get_minHeight_2();
GUILayoutEntry_t3828586629 * L_156 = V_20;
float L_157 = L_156->get_maxHeight_3();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_158 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, ((float)((float)L_150-(float)(((float)((float)L_153))))), L_155, L_157, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(8 /* System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single) */, L_145, ((float)((float)L_146+(float)(((float)((float)L_149))))), L_158);
}
IL_03c2:
{
}
IL_03c3:
{
bool L_159 = Enumerator_MoveNext_m672443923((&V_21), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_159)
{
goto IL_0346;
}
}
IL_03cf:
{
IL2CPP_LEAVE(0x3E2, FINALLY_03d4);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_03d4;
}
FINALLY_03d4:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_21), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(980)
} // end finally (depth: 1)
IL2CPP_CLEANUP(980)
{
IL2CPP_JUMP_TBL(0x3E2, IL_03e2)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_03e2:
{
}
IL_03e3:
{
}
IL_03e4:
{
return;
}
}
// System.String UnityEngine.GUILayoutGroup::ToString()
extern "C" String_t* GUILayoutGroup_ToString_m2654218848 (GUILayoutGroup_t3975363388 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutGroup_ToString_m2654218848_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* V_1 = NULL;
int32_t V_2 = 0;
String_t* V_3 = NULL;
GUILayoutEntry_t3828586629 * V_4 = NULL;
Enumerator_t2732437435 V_5;
memset(&V_5, 0, sizeof(V_5));
String_t* V_6 = NULL;
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
{
V_0 = _stringLiteral371857150;
V_1 = _stringLiteral371857150;
V_2 = 0;
goto IL_0024;
}
IL_0014:
{
String_t* L_0 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_1 = String_Concat_m2596409543(NULL /*static, unused*/, L_0, _stringLiteral372029310, /*hidden argument*/NULL);
V_1 = L_1;
int32_t L_2 = V_2;
V_2 = ((int32_t)((int32_t)L_2+(int32_t)1));
}
IL_0024:
{
int32_t L_3 = V_2;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var);
int32_t L_4 = ((GUILayoutEntry_t3828586629_StaticFields*)GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var->static_fields)->get_indent_9();
if ((((int32_t)L_3) < ((int32_t)L_4)))
{
goto IL_0014;
}
}
{
String_t* L_5 = V_0;
V_3 = L_5;
ObjectU5BU5D_t3614634134* L_6 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)5));
String_t* L_7 = V_3;
ArrayElementTypeCheck (L_6, L_7);
(L_6)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)L_7);
ObjectU5BU5D_t3614634134* L_8 = L_6;
String_t* L_9 = GUILayoutEntry_ToString_m1331406279(__this, /*hidden argument*/NULL);
ArrayElementTypeCheck (L_8, L_9);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (Il2CppObject *)L_9);
ObjectU5BU5D_t3614634134* L_10 = L_8;
ArrayElementTypeCheck (L_10, _stringLiteral1159361143);
(L_10)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(2), (Il2CppObject *)_stringLiteral1159361143);
ObjectU5BU5D_t3614634134* L_11 = L_10;
float L_12 = __this->get_m_ChildMinHeight_24();
float L_13 = L_12;
Il2CppObject * L_14 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_13);
ArrayElementTypeCheck (L_11, L_14);
(L_11)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(3), (Il2CppObject *)L_14);
ObjectU5BU5D_t3614634134* L_15 = L_11;
ArrayElementTypeCheck (L_15, _stringLiteral2759504069);
(L_15)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(4), (Il2CppObject *)_stringLiteral2759504069);
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_16 = String_Concat_m3881798623(NULL /*static, unused*/, L_15, /*hidden argument*/NULL);
V_0 = L_16;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var);
int32_t L_17 = ((GUILayoutEntry_t3828586629_StaticFields*)GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var->static_fields)->get_indent_9();
((GUILayoutEntry_t3828586629_StaticFields*)GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var->static_fields)->set_indent_9(((int32_t)((int32_t)L_17+(int32_t)4)));
List_1_t3197707761 * L_18 = __this->get_entries_10();
Enumerator_t2732437435 L_19 = List_1_GetEnumerator_m529646903(L_18, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_5 = L_19;
}
IL_0082:
try
{ // begin try (depth: 1)
{
goto IL_00a5;
}
IL_0087:
{
GUILayoutEntry_t3828586629 * L_20 = Enumerator_get_Current_m2724498415((&V_5), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_4 = L_20;
String_t* L_21 = V_0;
GUILayoutEntry_t3828586629 * L_22 = V_4;
String_t* L_23 = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, L_22);
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_24 = String_Concat_m612901809(NULL /*static, unused*/, L_21, L_23, _stringLiteral372029352, /*hidden argument*/NULL);
V_0 = L_24;
}
IL_00a5:
{
bool L_25 = Enumerator_MoveNext_m672443923((&V_5), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_25)
{
goto IL_0087;
}
}
IL_00b1:
{
IL2CPP_LEAVE(0xC4, FINALLY_00b6);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_00b6;
}
FINALLY_00b6:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_5), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(182)
} // end finally (depth: 1)
IL2CPP_CLEANUP(182)
{
IL2CPP_JUMP_TBL(0xC4, IL_00c4)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_00c4:
{
String_t* L_26 = V_0;
String_t* L_27 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_28 = String_Concat_m612901809(NULL /*static, unused*/, L_26, L_27, _stringLiteral372029393, /*hidden argument*/NULL);
V_0 = L_28;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var);
int32_t L_29 = ((GUILayoutEntry_t3828586629_StaticFields*)GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var->static_fields)->get_indent_9();
((GUILayoutEntry_t3828586629_StaticFields*)GUILayoutEntry_t3828586629_il2cpp_TypeInfo_var->static_fields)->set_indent_9(((int32_t)((int32_t)L_29-(int32_t)4)));
String_t* L_30 = V_0;
V_6 = L_30;
goto IL_00e5;
}
IL_00e5:
{
String_t* L_31 = V_6;
return L_31;
}
}
// System.Void UnityEngine.GUILayoutOption::.ctor(UnityEngine.GUILayoutOption/Type,System.Object)
extern "C" void GUILayoutOption__ctor_m1607805343 (GUILayoutOption_t4183744904 * __this, int32_t ___type0, Il2CppObject * ___value1, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
int32_t L_0 = ___type0;
__this->set_type_0(L_0);
Il2CppObject * L_1 = ___value1;
__this->set_value_1(L_1);
return;
}
}
// UnityEngine.GUILayoutUtility/LayoutCache UnityEngine.GUILayoutUtility::SelectIDList(System.Int32,System.Boolean)
extern "C" LayoutCache_t3120781045 * GUILayoutUtility_SelectIDList_m756828237 (Il2CppObject * __this /* static, unused */, int32_t ___instanceID0, bool ___isWindow1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility_SelectIDList_m756828237_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Dictionary_2_t2128606680 * V_0 = NULL;
LayoutCache_t3120781045 * V_1 = NULL;
LayoutCache_t3120781045 * V_2 = NULL;
Dictionary_2_t2128606680 * G_B3_0 = NULL;
{
bool L_0 = ___isWindow1;
if (!L_0)
{
goto IL_0011;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
Dictionary_2_t2128606680 * L_1 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_s_StoredWindows_1();
G_B3_0 = L_1;
goto IL_0016;
}
IL_0011:
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
Dictionary_2_t2128606680 * L_2 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_s_StoredLayouts_0();
G_B3_0 = L_2;
}
IL_0016:
{
V_0 = G_B3_0;
Dictionary_2_t2128606680 * L_3 = V_0;
int32_t L_4 = ___instanceID0;
bool L_5 = Dictionary_2_TryGetValue_m1480015700(L_3, L_4, (&V_1), /*hidden argument*/Dictionary_2_TryGetValue_m1480015700_MethodInfo_var);
if (L_5)
{
goto IL_003a;
}
}
{
LayoutCache_t3120781045 * L_6 = (LayoutCache_t3120781045 *)il2cpp_codegen_object_new(LayoutCache_t3120781045_il2cpp_TypeInfo_var);
LayoutCache__ctor_m2805543017(L_6, /*hidden argument*/NULL);
V_1 = L_6;
Dictionary_2_t2128606680 * L_7 = V_0;
int32_t L_8 = ___instanceID0;
LayoutCache_t3120781045 * L_9 = V_1;
Dictionary_2_set_Item_m1800215906(L_7, L_8, L_9, /*hidden argument*/Dictionary_2_set_Item_m1800215906_MethodInfo_var);
goto IL_003c;
}
IL_003a:
{
}
IL_003c:
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_10 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_11 = V_1;
GUILayoutGroup_t3975363388 * L_12 = L_11->get_topLevel_0();
L_10->set_topLevel_0(L_12);
LayoutCache_t3120781045 * L_13 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_14 = V_1;
GenericStack_t3718539591 * L_15 = L_14->get_layoutGroups_1();
L_13->set_layoutGroups_1(L_15);
LayoutCache_t3120781045 * L_16 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_17 = V_1;
GUILayoutGroup_t3975363388 * L_18 = L_17->get_windows_2();
L_16->set_windows_2(L_18);
LayoutCache_t3120781045 * L_19 = V_1;
V_2 = L_19;
goto IL_0073;
}
IL_0073:
{
LayoutCache_t3120781045 * L_20 = V_2;
return L_20;
}
}
// System.Void UnityEngine.GUILayoutUtility::Begin(System.Int32)
extern "C" void GUILayoutUtility_Begin_m2360858304 (Il2CppObject * __this /* static, unused */, int32_t ___instanceID0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility_Begin_m2360858304_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
LayoutCache_t3120781045 * V_0 = NULL;
GUILayoutGroup_t3975363388 * V_1 = NULL;
{
int32_t L_0 = ___instanceID0;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_1 = GUILayoutUtility_SelectIDList_m756828237(NULL /*static, unused*/, L_0, (bool)0, /*hidden argument*/NULL);
V_0 = L_1;
Event_t3028476042 * L_2 = Event_get_current_m2901774193(NULL /*static, unused*/, /*hidden argument*/NULL);
int32_t L_3 = Event_get_type_m2426033198(L_2, /*hidden argument*/NULL);
if ((!(((uint32_t)L_3) == ((uint32_t)8))))
{
goto IL_0078;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_4 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_5 = V_0;
GUILayoutGroup_t3975363388 * L_6 = (GUILayoutGroup_t3975363388 *)il2cpp_codegen_object_new(GUILayoutGroup_t3975363388_il2cpp_TypeInfo_var);
GUILayoutGroup__ctor_m992523271(L_6, /*hidden argument*/NULL);
GUILayoutGroup_t3975363388 * L_7 = L_6;
V_1 = L_7;
L_5->set_topLevel_0(L_7);
GUILayoutGroup_t3975363388 * L_8 = V_1;
L_4->set_topLevel_0(L_8);
LayoutCache_t3120781045 * L_9 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GenericStack_t3718539591 * L_10 = L_9->get_layoutGroups_1();
VirtActionInvoker0::Invoke(13 /* System.Void System.Collections.Stack::Clear() */, L_10);
LayoutCache_t3120781045 * L_11 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GenericStack_t3718539591 * L_12 = L_11->get_layoutGroups_1();
LayoutCache_t3120781045 * L_13 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_14 = L_13->get_topLevel_0();
VirtActionInvoker1< Il2CppObject * >::Invoke(19 /* System.Void System.Collections.Stack::Push(System.Object) */, L_12, L_14);
LayoutCache_t3120781045 * L_15 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_16 = V_0;
GUILayoutGroup_t3975363388 * L_17 = (GUILayoutGroup_t3975363388 *)il2cpp_codegen_object_new(GUILayoutGroup_t3975363388_il2cpp_TypeInfo_var);
GUILayoutGroup__ctor_m992523271(L_17, /*hidden argument*/NULL);
GUILayoutGroup_t3975363388 * L_18 = L_17;
V_1 = L_18;
L_16->set_windows_2(L_18);
GUILayoutGroup_t3975363388 * L_19 = V_1;
L_15->set_windows_2(L_19);
goto IL_00aa;
}
IL_0078:
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_20 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_21 = V_0;
GUILayoutGroup_t3975363388 * L_22 = L_21->get_topLevel_0();
L_20->set_topLevel_0(L_22);
LayoutCache_t3120781045 * L_23 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_24 = V_0;
GenericStack_t3718539591 * L_25 = L_24->get_layoutGroups_1();
L_23->set_layoutGroups_1(L_25);
LayoutCache_t3120781045 * L_26 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_27 = V_0;
GUILayoutGroup_t3975363388 * L_28 = L_27->get_windows_2();
L_26->set_windows_2(L_28);
}
IL_00aa:
{
return;
}
}
// System.Void UnityEngine.GUILayoutUtility::BeginWindow(System.Int32,UnityEngine.GUIStyle,UnityEngine.GUILayoutOption[])
extern "C" void GUILayoutUtility_BeginWindow_m488834212 (Il2CppObject * __this /* static, unused */, int32_t ___windowID0, GUIStyle_t1799908754 * ___style1, GUILayoutOptionU5BU5D_t2108882777* ___options2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility_BeginWindow_m488834212_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
LayoutCache_t3120781045 * V_0 = NULL;
GUILayoutGroup_t3975363388 * V_1 = NULL;
{
int32_t L_0 = ___windowID0;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_1 = GUILayoutUtility_SelectIDList_m756828237(NULL /*static, unused*/, L_0, (bool)1, /*hidden argument*/NULL);
V_0 = L_1;
Event_t3028476042 * L_2 = Event_get_current_m2901774193(NULL /*static, unused*/, /*hidden argument*/NULL);
int32_t L_3 = Event_get_type_m2426033198(L_2, /*hidden argument*/NULL);
if ((!(((uint32_t)L_3) == ((uint32_t)8))))
{
goto IL_00ae;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_4 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_5 = V_0;
GUILayoutGroup_t3975363388 * L_6 = (GUILayoutGroup_t3975363388 *)il2cpp_codegen_object_new(GUILayoutGroup_t3975363388_il2cpp_TypeInfo_var);
GUILayoutGroup__ctor_m992523271(L_6, /*hidden argument*/NULL);
GUILayoutGroup_t3975363388 * L_7 = L_6;
V_1 = L_7;
L_5->set_topLevel_0(L_7);
GUILayoutGroup_t3975363388 * L_8 = V_1;
L_4->set_topLevel_0(L_8);
LayoutCache_t3120781045 * L_9 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_10 = L_9->get_topLevel_0();
GUIStyle_t1799908754 * L_11 = ___style1;
GUILayoutEntry_set_style_m70917293(L_10, L_11, /*hidden argument*/NULL);
LayoutCache_t3120781045 * L_12 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_13 = L_12->get_topLevel_0();
int32_t L_14 = ___windowID0;
L_13->set_windowID_16(L_14);
GUILayoutOptionU5BU5D_t2108882777* L_15 = ___options2;
if (!L_15)
{
goto IL_0068;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_16 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_17 = L_16->get_topLevel_0();
GUILayoutOptionU5BU5D_t2108882777* L_18 = ___options2;
VirtActionInvoker1< GUILayoutOptionU5BU5D_t2108882777* >::Invoke(10 /* System.Void UnityEngine.GUILayoutEntry::ApplyOptions(UnityEngine.GUILayoutOption[]) */, L_17, L_18);
}
IL_0068:
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_19 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GenericStack_t3718539591 * L_20 = L_19->get_layoutGroups_1();
VirtActionInvoker0::Invoke(13 /* System.Void System.Collections.Stack::Clear() */, L_20);
LayoutCache_t3120781045 * L_21 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GenericStack_t3718539591 * L_22 = L_21->get_layoutGroups_1();
LayoutCache_t3120781045 * L_23 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_24 = L_23->get_topLevel_0();
VirtActionInvoker1< Il2CppObject * >::Invoke(19 /* System.Void System.Collections.Stack::Push(System.Object) */, L_22, L_24);
LayoutCache_t3120781045 * L_25 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_26 = V_0;
GUILayoutGroup_t3975363388 * L_27 = (GUILayoutGroup_t3975363388 *)il2cpp_codegen_object_new(GUILayoutGroup_t3975363388_il2cpp_TypeInfo_var);
GUILayoutGroup__ctor_m992523271(L_27, /*hidden argument*/NULL);
GUILayoutGroup_t3975363388 * L_28 = L_27;
V_1 = L_28;
L_26->set_windows_2(L_28);
GUILayoutGroup_t3975363388 * L_29 = V_1;
L_25->set_windows_2(L_29);
goto IL_00e0;
}
IL_00ae:
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_30 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_31 = V_0;
GUILayoutGroup_t3975363388 * L_32 = L_31->get_topLevel_0();
L_30->set_topLevel_0(L_32);
LayoutCache_t3120781045 * L_33 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_34 = V_0;
GenericStack_t3718539591 * L_35 = L_34->get_layoutGroups_1();
L_33->set_layoutGroups_1(L_35);
LayoutCache_t3120781045 * L_36 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
LayoutCache_t3120781045 * L_37 = V_0;
GUILayoutGroup_t3975363388 * L_38 = L_37->get_windows_2();
L_36->set_windows_2(L_38);
}
IL_00e0:
{
return;
}
}
// System.Void UnityEngine.GUILayoutUtility::Layout()
extern "C" void GUILayoutUtility_Layout_m3812180708 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility_Layout_m3812180708_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_0 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_1 = L_0->get_topLevel_0();
int32_t L_2 = L_1->get_windowID_16();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_00b2;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_3 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_4 = L_3->get_topLevel_0();
VirtActionInvoker0::Invoke(5 /* System.Void UnityEngine.GUILayoutEntry::CalcWidth() */, L_4);
LayoutCache_t3120781045 * L_5 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_6 = L_5->get_topLevel_0();
int32_t L_7 = Screen_get_width_m41137238(NULL /*static, unused*/, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
float L_8 = GUIUtility_get_pixelsPerPoint_m2667928361(NULL /*static, unused*/, /*hidden argument*/NULL);
LayoutCache_t3120781045 * L_9 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_10 = L_9->get_topLevel_0();
float L_11 = ((GUILayoutEntry_t3828586629 *)L_10)->get_maxWidth_1();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_12 = Mathf_Min_m1648492575(NULL /*static, unused*/, ((float)((float)(((float)((float)L_7)))/(float)L_8)), L_11, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(7 /* System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single) */, L_6, (0.0f), L_12);
LayoutCache_t3120781045 * L_13 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_14 = L_13->get_topLevel_0();
VirtActionInvoker0::Invoke(6 /* System.Void UnityEngine.GUILayoutEntry::CalcHeight() */, L_14);
LayoutCache_t3120781045 * L_15 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_16 = L_15->get_topLevel_0();
int32_t L_17 = Screen_get_height_m1051800773(NULL /*static, unused*/, /*hidden argument*/NULL);
float L_18 = GUIUtility_get_pixelsPerPoint_m2667928361(NULL /*static, unused*/, /*hidden argument*/NULL);
LayoutCache_t3120781045 * L_19 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_20 = L_19->get_topLevel_0();
float L_21 = ((GUILayoutEntry_t3828586629 *)L_20)->get_maxHeight_3();
float L_22 = Mathf_Min_m1648492575(NULL /*static, unused*/, ((float)((float)(((float)((float)L_17)))/(float)L_18)), L_21, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(8 /* System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single) */, L_16, (0.0f), L_22);
LayoutCache_t3120781045 * L_23 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_24 = L_23->get_windows_2();
GUILayoutUtility_LayoutFreeGroup_m1173219546(NULL /*static, unused*/, L_24, /*hidden argument*/NULL);
goto IL_00d2;
}
IL_00b2:
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_25 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_26 = L_25->get_topLevel_0();
GUILayoutUtility_LayoutSingleGroup_m3547078816(NULL /*static, unused*/, L_26, /*hidden argument*/NULL);
LayoutCache_t3120781045 * L_27 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_28 = L_27->get_windows_2();
GUILayoutUtility_LayoutFreeGroup_m1173219546(NULL /*static, unused*/, L_28, /*hidden argument*/NULL);
}
IL_00d2:
{
return;
}
}
// System.Void UnityEngine.GUILayoutUtility::LayoutFromEditorWindow()
extern "C" void GUILayoutUtility_LayoutFromEditorWindow_m1847418289 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility_LayoutFromEditorWindow_m1847418289_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
LayoutCache_t3120781045 * L_0 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_1 = L_0->get_topLevel_0();
VirtActionInvoker0::Invoke(5 /* System.Void UnityEngine.GUILayoutEntry::CalcWidth() */, L_1);
LayoutCache_t3120781045 * L_2 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_3 = L_2->get_topLevel_0();
int32_t L_4 = Screen_get_width_m41137238(NULL /*static, unused*/, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
float L_5 = GUIUtility_get_pixelsPerPoint_m2667928361(NULL /*static, unused*/, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(7 /* System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single) */, L_3, (0.0f), ((float)((float)(((float)((float)L_4)))/(float)L_5)));
LayoutCache_t3120781045 * L_6 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_7 = L_6->get_topLevel_0();
VirtActionInvoker0::Invoke(6 /* System.Void UnityEngine.GUILayoutEntry::CalcHeight() */, L_7);
LayoutCache_t3120781045 * L_8 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_9 = L_8->get_topLevel_0();
int32_t L_10 = Screen_get_height_m1051800773(NULL /*static, unused*/, /*hidden argument*/NULL);
float L_11 = GUIUtility_get_pixelsPerPoint_m2667928361(NULL /*static, unused*/, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(8 /* System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single) */, L_9, (0.0f), ((float)((float)(((float)((float)L_10)))/(float)L_11)));
LayoutCache_t3120781045 * L_12 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_current_2();
GUILayoutGroup_t3975363388 * L_13 = L_12->get_windows_2();
GUILayoutUtility_LayoutFreeGroup_m1173219546(NULL /*static, unused*/, L_13, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUILayoutUtility::LayoutFreeGroup(UnityEngine.GUILayoutGroup)
extern "C" void GUILayoutUtility_LayoutFreeGroup_m1173219546 (Il2CppObject * __this /* static, unused */, GUILayoutGroup_t3975363388 * ___toplevel0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility_LayoutFreeGroup_m1173219546_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUILayoutGroup_t3975363388 * V_0 = NULL;
Enumerator_t2732437435 V_1;
memset(&V_1, 0, sizeof(V_1));
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
{
GUILayoutGroup_t3975363388 * L_0 = ___toplevel0;
List_1_t3197707761 * L_1 = L_0->get_entries_10();
Enumerator_t2732437435 L_2 = List_1_GetEnumerator_m529646903(L_1, /*hidden argument*/List_1_GetEnumerator_m529646903_MethodInfo_var);
V_1 = L_2;
}
IL_000e:
try
{ // begin try (depth: 1)
{
goto IL_0028;
}
IL_0013:
{
GUILayoutEntry_t3828586629 * L_3 = Enumerator_get_Current_m2724498415((&V_1), /*hidden argument*/Enumerator_get_Current_m2724498415_MethodInfo_var);
V_0 = ((GUILayoutGroup_t3975363388 *)CastclassClass(L_3, GUILayoutGroup_t3975363388_il2cpp_TypeInfo_var));
GUILayoutGroup_t3975363388 * L_4 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_LayoutSingleGroup_m3547078816(NULL /*static, unused*/, L_4, /*hidden argument*/NULL);
}
IL_0028:
{
bool L_5 = Enumerator_MoveNext_m672443923((&V_1), /*hidden argument*/Enumerator_MoveNext_m672443923_MethodInfo_var);
if (L_5)
{
goto IL_0013;
}
}
IL_0034:
{
IL2CPP_LEAVE(0x47, FINALLY_0039);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_0039;
}
FINALLY_0039:
{ // begin finally (depth: 1)
Enumerator_Dispose_m4028763464((&V_1), /*hidden argument*/Enumerator_Dispose_m4028763464_MethodInfo_var);
IL2CPP_END_FINALLY(57)
} // end finally (depth: 1)
IL2CPP_CLEANUP(57)
{
IL2CPP_JUMP_TBL(0x47, IL_0047)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_0047:
{
GUILayoutGroup_t3975363388 * L_6 = ___toplevel0;
GUILayoutGroup_ResetCursor_m3160916532(L_6, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUILayoutUtility::LayoutSingleGroup(UnityEngine.GUILayoutGroup)
extern "C" void GUILayoutUtility_LayoutSingleGroup_m3547078816 (Il2CppObject * __this /* static, unused */, GUILayoutGroup_t3975363388 * ___i0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility_LayoutSingleGroup_m3547078816_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
float V_1 = 0.0f;
float V_2 = 0.0f;
float V_3 = 0.0f;
Rect_t3681755626 V_4;
memset(&V_4, 0, sizeof(V_4));
{
GUILayoutGroup_t3975363388 * L_0 = ___i0;
bool L_1 = L_0->get_isWindow_15();
if (L_1)
{
goto IL_0077;
}
}
{
GUILayoutGroup_t3975363388 * L_2 = ___i0;
float L_3 = ((GUILayoutEntry_t3828586629 *)L_2)->get_minWidth_0();
V_0 = L_3;
GUILayoutGroup_t3975363388 * L_4 = ___i0;
float L_5 = ((GUILayoutEntry_t3828586629 *)L_4)->get_maxWidth_1();
V_1 = L_5;
GUILayoutGroup_t3975363388 * L_6 = ___i0;
VirtActionInvoker0::Invoke(5 /* System.Void UnityEngine.GUILayoutEntry::CalcWidth() */, L_6);
GUILayoutGroup_t3975363388 * L_7 = ___i0;
GUILayoutGroup_t3975363388 * L_8 = ___i0;
Rect_t3681755626 * L_9 = ((GUILayoutEntry_t3828586629 *)L_8)->get_address_of_rect_4();
float L_10 = Rect_get_x_m1393582490(L_9, /*hidden argument*/NULL);
GUILayoutGroup_t3975363388 * L_11 = ___i0;
float L_12 = ((GUILayoutEntry_t3828586629 *)L_11)->get_maxWidth_1();
float L_13 = V_0;
float L_14 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_15 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, L_12, L_13, L_14, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(7 /* System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single) */, L_7, L_10, L_15);
GUILayoutGroup_t3975363388 * L_16 = ___i0;
float L_17 = ((GUILayoutEntry_t3828586629 *)L_16)->get_minHeight_2();
V_2 = L_17;
GUILayoutGroup_t3975363388 * L_18 = ___i0;
float L_19 = ((GUILayoutEntry_t3828586629 *)L_18)->get_maxHeight_3();
V_3 = L_19;
GUILayoutGroup_t3975363388 * L_20 = ___i0;
VirtActionInvoker0::Invoke(6 /* System.Void UnityEngine.GUILayoutEntry::CalcHeight() */, L_20);
GUILayoutGroup_t3975363388 * L_21 = ___i0;
GUILayoutGroup_t3975363388 * L_22 = ___i0;
Rect_t3681755626 * L_23 = ((GUILayoutEntry_t3828586629 *)L_22)->get_address_of_rect_4();
float L_24 = Rect_get_y_m1393582395(L_23, /*hidden argument*/NULL);
GUILayoutGroup_t3975363388 * L_25 = ___i0;
float L_26 = ((GUILayoutEntry_t3828586629 *)L_25)->get_maxHeight_3();
float L_27 = V_2;
float L_28 = V_3;
float L_29 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, L_26, L_27, L_28, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(8 /* System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single) */, L_21, L_24, L_29);
goto IL_00ed;
}
IL_0077:
{
GUILayoutGroup_t3975363388 * L_30 = ___i0;
VirtActionInvoker0::Invoke(5 /* System.Void UnityEngine.GUILayoutEntry::CalcWidth() */, L_30);
GUILayoutGroup_t3975363388 * L_31 = ___i0;
int32_t L_32 = L_31->get_windowID_16();
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
Rect_t3681755626 L_33 = GUILayoutUtility_Internal_GetWindowRect_m1287880151(NULL /*static, unused*/, L_32, /*hidden argument*/NULL);
V_4 = L_33;
GUILayoutGroup_t3975363388 * L_34 = ___i0;
float L_35 = Rect_get_x_m1393582490((&V_4), /*hidden argument*/NULL);
float L_36 = Rect_get_width_m1138015702((&V_4), /*hidden argument*/NULL);
GUILayoutGroup_t3975363388 * L_37 = ___i0;
float L_38 = ((GUILayoutEntry_t3828586629 *)L_37)->get_minWidth_0();
GUILayoutGroup_t3975363388 * L_39 = ___i0;
float L_40 = ((GUILayoutEntry_t3828586629 *)L_39)->get_maxWidth_1();
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_41 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, L_36, L_38, L_40, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(7 /* System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single) */, L_34, L_35, L_41);
GUILayoutGroup_t3975363388 * L_42 = ___i0;
VirtActionInvoker0::Invoke(6 /* System.Void UnityEngine.GUILayoutEntry::CalcHeight() */, L_42);
GUILayoutGroup_t3975363388 * L_43 = ___i0;
float L_44 = Rect_get_y_m1393582395((&V_4), /*hidden argument*/NULL);
float L_45 = Rect_get_height_m3128694305((&V_4), /*hidden argument*/NULL);
GUILayoutGroup_t3975363388 * L_46 = ___i0;
float L_47 = ((GUILayoutEntry_t3828586629 *)L_46)->get_minHeight_2();
GUILayoutGroup_t3975363388 * L_48 = ___i0;
float L_49 = ((GUILayoutEntry_t3828586629 *)L_48)->get_maxHeight_3();
float L_50 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, L_45, L_47, L_49, /*hidden argument*/NULL);
VirtActionInvoker2< float, float >::Invoke(8 /* System.Void UnityEngine.GUILayoutEntry::SetVertical(System.Single,System.Single) */, L_43, L_44, L_50);
GUILayoutGroup_t3975363388 * L_51 = ___i0;
int32_t L_52 = L_51->get_windowID_16();
GUILayoutGroup_t3975363388 * L_53 = ___i0;
Rect_t3681755626 L_54 = ((GUILayoutEntry_t3828586629 *)L_53)->get_rect_4();
GUILayoutUtility_Internal_MoveWindow_m3217449419(NULL /*static, unused*/, L_52, L_54, /*hidden argument*/NULL);
}
IL_00ed:
{
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUILayoutUtility::get_spaceStyle()
extern "C" GUIStyle_t1799908754 * GUILayoutUtility_get_spaceStyle_m1918520192 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility_get_spaceStyle_m1918520192_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUIStyle_t1799908754 * V_0 = NULL;
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_0 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_s_SpaceStyle_4();
if (L_0)
{
goto IL_0015;
}
}
{
GUIStyle_t1799908754 * L_1 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_1, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->set_s_SpaceStyle_4(L_1);
}
IL_0015:
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_2 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_s_SpaceStyle_4();
GUIStyle_set_stretchWidth_m1198647818(L_2, (bool)0, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_3 = ((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->get_s_SpaceStyle_4();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
GUIStyle_t1799908754 * L_4 = V_0;
return L_4;
}
}
// UnityEngine.Rect UnityEngine.GUILayoutUtility::Internal_GetWindowRect(System.Int32)
extern "C" Rect_t3681755626 GUILayoutUtility_Internal_GetWindowRect_m1287880151 (Il2CppObject * __this /* static, unused */, int32_t ___windowID0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility_Internal_GetWindowRect_m1287880151_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Rect_t3681755626 V_0;
memset(&V_0, 0, sizeof(V_0));
Rect_t3681755626 V_1;
memset(&V_1, 0, sizeof(V_1));
{
int32_t L_0 = ___windowID0;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_INTERNAL_CALL_Internal_GetWindowRect_m3236664463(NULL /*static, unused*/, L_0, (&V_0), /*hidden argument*/NULL);
Rect_t3681755626 L_1 = V_0;
V_1 = L_1;
goto IL_0010;
}
IL_0010:
{
Rect_t3681755626 L_2 = V_1;
return L_2;
}
}
// System.Void UnityEngine.GUILayoutUtility::INTERNAL_CALL_Internal_GetWindowRect(System.Int32,UnityEngine.Rect&)
extern "C" void GUILayoutUtility_INTERNAL_CALL_Internal_GetWindowRect_m3236664463 (Il2CppObject * __this /* static, unused */, int32_t ___windowID0, Rect_t3681755626 * ___value1, const MethodInfo* method)
{
typedef void (*GUILayoutUtility_INTERNAL_CALL_Internal_GetWindowRect_m3236664463_ftn) (int32_t, Rect_t3681755626 *);
static GUILayoutUtility_INTERNAL_CALL_Internal_GetWindowRect_m3236664463_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUILayoutUtility_INTERNAL_CALL_Internal_GetWindowRect_m3236664463_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUILayoutUtility::INTERNAL_CALL_Internal_GetWindowRect(System.Int32,UnityEngine.Rect&)");
_il2cpp_icall_func(___windowID0, ___value1);
}
// System.Void UnityEngine.GUILayoutUtility::Internal_MoveWindow(System.Int32,UnityEngine.Rect)
extern "C" void GUILayoutUtility_Internal_MoveWindow_m3217449419 (Il2CppObject * __this /* static, unused */, int32_t ___windowID0, Rect_t3681755626 ___r1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility_Internal_MoveWindow_m3217449419_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___windowID0;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_INTERNAL_CALL_Internal_MoveWindow_m1347894376(NULL /*static, unused*/, L_0, (&___r1), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUILayoutUtility::INTERNAL_CALL_Internal_MoveWindow(System.Int32,UnityEngine.Rect&)
extern "C" void GUILayoutUtility_INTERNAL_CALL_Internal_MoveWindow_m1347894376 (Il2CppObject * __this /* static, unused */, int32_t ___windowID0, Rect_t3681755626 * ___r1, const MethodInfo* method)
{
typedef void (*GUILayoutUtility_INTERNAL_CALL_Internal_MoveWindow_m1347894376_ftn) (int32_t, Rect_t3681755626 *);
static GUILayoutUtility_INTERNAL_CALL_Internal_MoveWindow_m1347894376_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUILayoutUtility_INTERNAL_CALL_Internal_MoveWindow_m1347894376_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUILayoutUtility::INTERNAL_CALL_Internal_MoveWindow(System.Int32,UnityEngine.Rect&)");
_il2cpp_icall_func(___windowID0, ___r1);
}
// System.Void UnityEngine.GUILayoutUtility::.cctor()
extern "C" void GUILayoutUtility__cctor_m2957755459 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUILayoutUtility__cctor_m2957755459_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Dictionary_2_t2128606680 * L_0 = (Dictionary_2_t2128606680 *)il2cpp_codegen_object_new(Dictionary_2_t2128606680_il2cpp_TypeInfo_var);
Dictionary_2__ctor_m853591007(L_0, /*hidden argument*/Dictionary_2__ctor_m853591007_MethodInfo_var);
((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->set_s_StoredLayouts_0(L_0);
Dictionary_2_t2128606680 * L_1 = (Dictionary_2_t2128606680 *)il2cpp_codegen_object_new(Dictionary_2_t2128606680_il2cpp_TypeInfo_var);
Dictionary_2__ctor_m853591007(L_1, /*hidden argument*/Dictionary_2__ctor_m853591007_MethodInfo_var);
((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->set_s_StoredWindows_1(L_1);
LayoutCache_t3120781045 * L_2 = (LayoutCache_t3120781045 *)il2cpp_codegen_object_new(LayoutCache_t3120781045_il2cpp_TypeInfo_var);
LayoutCache__ctor_m2805543017(L_2, /*hidden argument*/NULL);
((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->set_current_2(L_2);
Rect_t3681755626 L_3;
memset(&L_3, 0, sizeof(L_3));
Rect__ctor_m1220545469(&L_3, (0.0f), (0.0f), (1.0f), (1.0f), /*hidden argument*/NULL);
((GUILayoutUtility_t996096873_StaticFields*)GUILayoutUtility_t996096873_il2cpp_TypeInfo_var->static_fields)->set_kDummyRect_3(L_3);
return;
}
}
// System.Void UnityEngine.GUILayoutUtility/LayoutCache::.ctor()
extern "C" void LayoutCache__ctor_m2805543017 (LayoutCache_t3120781045 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (LayoutCache__ctor_m2805543017_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
GUILayoutGroup_t3975363388 * L_0 = (GUILayoutGroup_t3975363388 *)il2cpp_codegen_object_new(GUILayoutGroup_t3975363388_il2cpp_TypeInfo_var);
GUILayoutGroup__ctor_m992523271(L_0, /*hidden argument*/NULL);
__this->set_topLevel_0(L_0);
GenericStack_t3718539591 * L_1 = (GenericStack_t3718539591 *)il2cpp_codegen_object_new(GenericStack_t3718539591_il2cpp_TypeInfo_var);
GenericStack__ctor_m1256224477(L_1, /*hidden argument*/NULL);
__this->set_layoutGroups_1(L_1);
GUILayoutGroup_t3975363388 * L_2 = (GUILayoutGroup_t3975363388 *)il2cpp_codegen_object_new(GUILayoutGroup_t3975363388_il2cpp_TypeInfo_var);
GUILayoutGroup__ctor_m992523271(L_2, /*hidden argument*/NULL);
__this->set_windows_2(L_2);
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
GenericStack_t3718539591 * L_3 = __this->get_layoutGroups_1();
GUILayoutGroup_t3975363388 * L_4 = __this->get_topLevel_0();
VirtActionInvoker1< Il2CppObject * >::Invoke(19 /* System.Void System.Collections.Stack::Push(System.Object) */, L_3, L_4);
return;
}
}
// System.Void UnityEngine.GUIScrollGroup::.ctor()
extern "C" void GUIScrollGroup__ctor_m3551718706 (GUIScrollGroup_t755788567 * __this, const MethodInfo* method)
{
{
__this->set_allowHorizontalScroll_33((bool)1);
__this->set_allowVerticalScroll_34((bool)1);
GUILayoutGroup__ctor_m992523271(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIScrollGroup::CalcWidth()
extern "C" void GUIScrollGroup_CalcWidth_m1820616279 (GUIScrollGroup_t755788567 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
float V_1 = 0.0f;
{
float L_0 = ((GUILayoutEntry_t3828586629 *)__this)->get_minWidth_0();
V_0 = L_0;
float L_1 = ((GUILayoutEntry_t3828586629 *)__this)->get_maxWidth_1();
V_1 = L_1;
bool L_2 = __this->get_allowHorizontalScroll_33();
if (!L_2)
{
goto IL_0032;
}
}
{
((GUILayoutEntry_t3828586629 *)__this)->set_minWidth_0((0.0f));
((GUILayoutEntry_t3828586629 *)__this)->set_maxWidth_1((0.0f));
}
IL_0032:
{
GUILayoutGroup_CalcWidth_m4107152934(__this, /*hidden argument*/NULL);
float L_3 = ((GUILayoutEntry_t3828586629 *)__this)->get_minWidth_0();
__this->set_calcMinWidth_27(L_3);
float L_4 = ((GUILayoutEntry_t3828586629 *)__this)->get_maxWidth_1();
__this->set_calcMaxWidth_28(L_4);
bool L_5 = __this->get_allowHorizontalScroll_33();
if (!L_5)
{
goto IL_00a5;
}
}
{
float L_6 = ((GUILayoutEntry_t3828586629 *)__this)->get_minWidth_0();
if ((!(((float)L_6) > ((float)(32.0f)))))
{
goto IL_0077;
}
}
{
((GUILayoutEntry_t3828586629 *)__this)->set_minWidth_0((32.0f));
}
IL_0077:
{
float L_7 = V_0;
if ((((float)L_7) == ((float)(0.0f))))
{
goto IL_0089;
}
}
{
float L_8 = V_0;
((GUILayoutEntry_t3828586629 *)__this)->set_minWidth_0(L_8);
}
IL_0089:
{
float L_9 = V_1;
if ((((float)L_9) == ((float)(0.0f))))
{
goto IL_00a4;
}
}
{
float L_10 = V_1;
((GUILayoutEntry_t3828586629 *)__this)->set_maxWidth_1(L_10);
((GUILayoutEntry_t3828586629 *)__this)->set_stretchWidth_5(0);
}
IL_00a4:
{
}
IL_00a5:
{
return;
}
}
// System.Void UnityEngine.GUIScrollGroup::SetHorizontal(System.Single,System.Single)
extern "C" void GUIScrollGroup_SetHorizontal_m2124180940 (GUIScrollGroup_t755788567 * __this, float ___x0, float ___width1, const MethodInfo* method)
{
float V_0 = 0.0f;
float G_B3_0 = 0.0f;
{
bool L_0 = __this->get_needsVerticalScrollbar_36();
if (!L_0)
{
goto IL_0030;
}
}
{
float L_1 = ___width1;
GUIStyle_t1799908754 * L_2 = __this->get_verticalScrollbar_38();
float L_3 = GUIStyle_get_fixedWidth_m97997484(L_2, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_4 = __this->get_verticalScrollbar_38();
RectOffset_t3387826427 * L_5 = GUIStyle_get_margin_m1012250163(L_4, /*hidden argument*/NULL);
int32_t L_6 = RectOffset_get_left_m439065308(L_5, /*hidden argument*/NULL);
G_B3_0 = ((float)((float)((float)((float)L_1-(float)L_3))-(float)(((float)((float)L_6)))));
goto IL_0031;
}
IL_0030:
{
float L_7 = ___width1;
G_B3_0 = L_7;
}
IL_0031:
{
V_0 = G_B3_0;
bool L_8 = __this->get_allowHorizontalScroll_33();
if (!L_8)
{
goto IL_0094;
}
}
{
float L_9 = V_0;
float L_10 = __this->get_calcMinWidth_27();
if ((!(((float)L_9) < ((float)L_10))))
{
goto IL_0094;
}
}
{
__this->set_needsHorizontalScrollbar_35((bool)1);
float L_11 = __this->get_calcMinWidth_27();
((GUILayoutEntry_t3828586629 *)__this)->set_minWidth_0(L_11);
float L_12 = __this->get_calcMaxWidth_28();
((GUILayoutEntry_t3828586629 *)__this)->set_maxWidth_1(L_12);
float L_13 = ___x0;
float L_14 = __this->get_calcMinWidth_27();
GUILayoutGroup_SetHorizontal_m15325071(__this, L_13, L_14, /*hidden argument*/NULL);
Rect_t3681755626 * L_15 = ((GUILayoutEntry_t3828586629 *)__this)->get_address_of_rect_4();
float L_16 = ___width1;
Rect_set_width_m1921257731(L_15, L_16, /*hidden argument*/NULL);
float L_17 = __this->get_calcMinWidth_27();
__this->set_clientWidth_31(L_17);
goto IL_00dd;
}
IL_0094:
{
__this->set_needsHorizontalScrollbar_35((bool)0);
bool L_18 = __this->get_allowHorizontalScroll_33();
if (!L_18)
{
goto IL_00c1;
}
}
{
float L_19 = __this->get_calcMinWidth_27();
((GUILayoutEntry_t3828586629 *)__this)->set_minWidth_0(L_19);
float L_20 = __this->get_calcMaxWidth_28();
((GUILayoutEntry_t3828586629 *)__this)->set_maxWidth_1(L_20);
}
IL_00c1:
{
float L_21 = ___x0;
float L_22 = V_0;
GUILayoutGroup_SetHorizontal_m15325071(__this, L_21, L_22, /*hidden argument*/NULL);
Rect_t3681755626 * L_23 = ((GUILayoutEntry_t3828586629 *)__this)->get_address_of_rect_4();
float L_24 = ___width1;
Rect_set_width_m1921257731(L_23, L_24, /*hidden argument*/NULL);
float L_25 = V_0;
__this->set_clientWidth_31(L_25);
}
IL_00dd:
{
return;
}
}
// System.Void UnityEngine.GUIScrollGroup::CalcHeight()
extern "C" void GUIScrollGroup_CalcHeight_m35746966 (GUIScrollGroup_t755788567 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
float V_1 = 0.0f;
float V_2 = 0.0f;
{
float L_0 = ((GUILayoutEntry_t3828586629 *)__this)->get_minHeight_2();
V_0 = L_0;
float L_1 = ((GUILayoutEntry_t3828586629 *)__this)->get_maxHeight_3();
V_1 = L_1;
bool L_2 = __this->get_allowVerticalScroll_34();
if (!L_2)
{
goto IL_0032;
}
}
{
((GUILayoutEntry_t3828586629 *)__this)->set_minHeight_2((0.0f));
((GUILayoutEntry_t3828586629 *)__this)->set_maxHeight_3((0.0f));
}
IL_0032:
{
GUILayoutGroup_CalcHeight_m1454440153(__this, /*hidden argument*/NULL);
float L_3 = ((GUILayoutEntry_t3828586629 *)__this)->get_minHeight_2();
__this->set_calcMinHeight_29(L_3);
float L_4 = ((GUILayoutEntry_t3828586629 *)__this)->get_maxHeight_3();
__this->set_calcMaxHeight_30(L_4);
bool L_5 = __this->get_needsHorizontalScrollbar_35();
if (!L_5)
{
goto IL_0097;
}
}
{
GUIStyle_t1799908754 * L_6 = __this->get_horizontalScrollbar_37();
float L_7 = GUIStyle_get_fixedHeight_m414733479(L_6, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_8 = __this->get_horizontalScrollbar_37();
RectOffset_t3387826427 * L_9 = GUIStyle_get_margin_m1012250163(L_8, /*hidden argument*/NULL);
int32_t L_10 = RectOffset_get_top_m3629049358(L_9, /*hidden argument*/NULL);
V_2 = ((float)((float)L_7+(float)(((float)((float)L_10)))));
float L_11 = ((GUILayoutEntry_t3828586629 *)__this)->get_minHeight_2();
float L_12 = V_2;
((GUILayoutEntry_t3828586629 *)__this)->set_minHeight_2(((float)((float)L_11+(float)L_12)));
float L_13 = ((GUILayoutEntry_t3828586629 *)__this)->get_maxHeight_3();
float L_14 = V_2;
((GUILayoutEntry_t3828586629 *)__this)->set_maxHeight_3(((float)((float)L_13+(float)L_14)));
}
IL_0097:
{
bool L_15 = __this->get_allowVerticalScroll_34();
if (!L_15)
{
goto IL_00ec;
}
}
{
float L_16 = ((GUILayoutEntry_t3828586629 *)__this)->get_minHeight_2();
if ((!(((float)L_16) > ((float)(32.0f)))))
{
goto IL_00be;
}
}
{
((GUILayoutEntry_t3828586629 *)__this)->set_minHeight_2((32.0f));
}
IL_00be:
{
float L_17 = V_0;
if ((((float)L_17) == ((float)(0.0f))))
{
goto IL_00d0;
}
}
{
float L_18 = V_0;
((GUILayoutEntry_t3828586629 *)__this)->set_minHeight_2(L_18);
}
IL_00d0:
{
float L_19 = V_1;
if ((((float)L_19) == ((float)(0.0f))))
{
goto IL_00eb;
}
}
{
float L_20 = V_1;
((GUILayoutEntry_t3828586629 *)__this)->set_maxHeight_3(L_20);
((GUILayoutEntry_t3828586629 *)__this)->set_stretchHeight_6(0);
}
IL_00eb:
{
}
IL_00ec:
{
return;
}
}
// System.Void UnityEngine.GUIScrollGroup::SetVertical(System.Single,System.Single)
extern "C" void GUIScrollGroup_SetVertical_m3540700730 (GUIScrollGroup_t755788567 * __this, float ___y0, float ___height1, const MethodInfo* method)
{
float V_0 = 0.0f;
float V_1 = 0.0f;
float V_2 = 0.0f;
float V_3 = 0.0f;
{
float L_0 = ___height1;
V_0 = L_0;
bool L_1 = __this->get_needsHorizontalScrollbar_35();
if (!L_1)
{
goto IL_002e;
}
}
{
float L_2 = V_0;
GUIStyle_t1799908754 * L_3 = __this->get_horizontalScrollbar_37();
float L_4 = GUIStyle_get_fixedHeight_m414733479(L_3, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_5 = __this->get_horizontalScrollbar_37();
RectOffset_t3387826427 * L_6 = GUIStyle_get_margin_m1012250163(L_5, /*hidden argument*/NULL);
int32_t L_7 = RectOffset_get_top_m3629049358(L_6, /*hidden argument*/NULL);
V_0 = ((float)((float)L_2-(float)((float)((float)L_4+(float)(((float)((float)L_7)))))));
}
IL_002e:
{
bool L_8 = __this->get_allowVerticalScroll_34();
if (!L_8)
{
goto IL_013e;
}
}
{
float L_9 = V_0;
float L_10 = __this->get_calcMinHeight_29();
if ((!(((float)L_9) < ((float)L_10))))
{
goto IL_013e;
}
}
{
bool L_11 = __this->get_needsHorizontalScrollbar_35();
if (L_11)
{
goto IL_00df;
}
}
{
bool L_12 = __this->get_needsVerticalScrollbar_36();
if (L_12)
{
goto IL_00df;
}
}
{
Rect_t3681755626 * L_13 = ((GUILayoutEntry_t3828586629 *)__this)->get_address_of_rect_4();
float L_14 = Rect_get_width_m1138015702(L_13, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_15 = __this->get_verticalScrollbar_38();
float L_16 = GUIStyle_get_fixedWidth_m97997484(L_15, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_17 = __this->get_verticalScrollbar_38();
RectOffset_t3387826427 * L_18 = GUIStyle_get_margin_m1012250163(L_17, /*hidden argument*/NULL);
int32_t L_19 = RectOffset_get_left_m439065308(L_18, /*hidden argument*/NULL);
__this->set_clientWidth_31(((float)((float)((float)((float)L_14-(float)L_16))-(float)(((float)((float)L_19))))));
float L_20 = __this->get_clientWidth_31();
float L_21 = __this->get_calcMinWidth_27();
if ((!(((float)L_20) < ((float)L_21))))
{
goto IL_00a9;
}
}
{
float L_22 = __this->get_calcMinWidth_27();
__this->set_clientWidth_31(L_22);
}
IL_00a9:
{
Rect_t3681755626 * L_23 = ((GUILayoutEntry_t3828586629 *)__this)->get_address_of_rect_4();
float L_24 = Rect_get_width_m1138015702(L_23, /*hidden argument*/NULL);
V_1 = L_24;
Rect_t3681755626 * L_25 = ((GUILayoutEntry_t3828586629 *)__this)->get_address_of_rect_4();
float L_26 = Rect_get_x_m1393582490(L_25, /*hidden argument*/NULL);
float L_27 = __this->get_clientWidth_31();
VirtActionInvoker2< float, float >::Invoke(7 /* System.Void UnityEngine.GUILayoutEntry::SetHorizontal(System.Single,System.Single) */, __this, L_26, L_27);
VirtActionInvoker0::Invoke(6 /* System.Void UnityEngine.GUILayoutEntry::CalcHeight() */, __this);
Rect_t3681755626 * L_28 = ((GUILayoutEntry_t3828586629 *)__this)->get_address_of_rect_4();
float L_29 = V_1;
Rect_set_width_m1921257731(L_28, L_29, /*hidden argument*/NULL);
}
IL_00df:
{
float L_30 = ((GUILayoutEntry_t3828586629 *)__this)->get_minHeight_2();
V_2 = L_30;
float L_31 = ((GUILayoutEntry_t3828586629 *)__this)->get_maxHeight_3();
V_3 = L_31;
float L_32 = __this->get_calcMinHeight_29();
((GUILayoutEntry_t3828586629 *)__this)->set_minHeight_2(L_32);
float L_33 = __this->get_calcMaxHeight_30();
((GUILayoutEntry_t3828586629 *)__this)->set_maxHeight_3(L_33);
float L_34 = ___y0;
float L_35 = __this->get_calcMinHeight_29();
GUILayoutGroup_SetVertical_m2197915999(__this, L_34, L_35, /*hidden argument*/NULL);
float L_36 = V_2;
((GUILayoutEntry_t3828586629 *)__this)->set_minHeight_2(L_36);
float L_37 = V_3;
((GUILayoutEntry_t3828586629 *)__this)->set_maxHeight_3(L_37);
Rect_t3681755626 * L_38 = ((GUILayoutEntry_t3828586629 *)__this)->get_address_of_rect_4();
float L_39 = ___height1;
Rect_set_height_m2019122814(L_38, L_39, /*hidden argument*/NULL);
float L_40 = __this->get_calcMinHeight_29();
__this->set_clientHeight_32(L_40);
goto IL_0180;
}
IL_013e:
{
bool L_41 = __this->get_allowVerticalScroll_34();
if (!L_41)
{
goto IL_0164;
}
}
{
float L_42 = __this->get_calcMinHeight_29();
((GUILayoutEntry_t3828586629 *)__this)->set_minHeight_2(L_42);
float L_43 = __this->get_calcMaxHeight_30();
((GUILayoutEntry_t3828586629 *)__this)->set_maxHeight_3(L_43);
}
IL_0164:
{
float L_44 = ___y0;
float L_45 = V_0;
GUILayoutGroup_SetVertical_m2197915999(__this, L_44, L_45, /*hidden argument*/NULL);
Rect_t3681755626 * L_46 = ((GUILayoutEntry_t3828586629 *)__this)->get_address_of_rect_4();
float L_47 = ___height1;
Rect_set_height_m2019122814(L_46, L_47, /*hidden argument*/NULL);
float L_48 = V_0;
__this->set_clientHeight_32(L_48);
}
IL_0180:
{
return;
}
}
// System.Void UnityEngine.GUISettings::.ctor()
extern "C" void GUISettings__ctor_m2453724887 (GUISettings_t622856320 * __this, const MethodInfo* method)
{
{
__this->set_m_DoubleClickSelectsWord_0((bool)1);
__this->set_m_TripleClickSelectsLine_1((bool)1);
Color_t2020392075 L_0 = Color_get_white_m3987539815(NULL /*static, unused*/, /*hidden argument*/NULL);
__this->set_m_CursorColor_2(L_0);
__this->set_m_CursorFlashSpeed_3((-1.0f));
Color_t2020392075 L_1;
memset(&L_1, 0, sizeof(L_1));
Color__ctor_m3811852957(&L_1, (0.5f), (0.5f), (1.0f), /*hidden argument*/NULL);
__this->set_m_SelectionColor_4(L_1);
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Color UnityEngine.GUISettings::get_cursorColor()
extern "C" Color_t2020392075 GUISettings_get_cursorColor_m3884075294 (GUISettings_t622856320 * __this, const MethodInfo* method)
{
Color_t2020392075 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Color_t2020392075 L_0 = __this->get_m_CursorColor_2();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Color_t2020392075 L_1 = V_0;
return L_1;
}
}
// System.Single UnityEngine.GUISettings::get_cursorFlashSpeed()
extern "C" float GUISettings_get_cursorFlashSpeed_m3722011925 (GUISettings_t622856320 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_CursorFlashSpeed_3();
if ((!(((float)L_0) >= ((float)(0.0f)))))
{
goto IL_001d;
}
}
{
float L_1 = __this->get_m_CursorFlashSpeed_3();
V_0 = L_1;
goto IL_0029;
}
IL_001d:
{
float L_2 = GUISettings_Internal_GetCursorFlashSpeed_m3799968572(NULL /*static, unused*/, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0029;
}
IL_0029:
{
float L_3 = V_0;
return L_3;
}
}
// UnityEngine.Color UnityEngine.GUISettings::get_selectionColor()
extern "C" Color_t2020392075 GUISettings_get_selectionColor_m1824063266 (GUISettings_t622856320 * __this, const MethodInfo* method)
{
Color_t2020392075 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Color_t2020392075 L_0 = __this->get_m_SelectionColor_4();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Color_t2020392075 L_1 = V_0;
return L_1;
}
}
// System.Single UnityEngine.GUISettings::Internal_GetCursorFlashSpeed()
extern "C" float GUISettings_Internal_GetCursorFlashSpeed_m3799968572 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef float (*GUISettings_Internal_GetCursorFlashSpeed_m3799968572_ftn) ();
static GUISettings_Internal_GetCursorFlashSpeed_m3799968572_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUISettings_Internal_GetCursorFlashSpeed_m3799968572_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUISettings::Internal_GetCursorFlashSpeed()");
return _il2cpp_icall_func();
}
// System.Void UnityEngine.GUISkin::.ctor()
extern "C" void GUISkin__ctor_m1526071177 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUISkin__ctor_m1526071177_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
GUISettings_t622856320 * L_0 = (GUISettings_t622856320 *)il2cpp_codegen_object_new(GUISettings_t622856320_il2cpp_TypeInfo_var);
GUISettings__ctor_m2453724887(L_0, /*hidden argument*/NULL);
__this->set_m_Settings_24(L_0);
__this->set_m_Styles_26((Dictionary_2_t3714688016 *)NULL);
ScriptableObject__ctor_m2671490429(__this, /*hidden argument*/NULL);
__this->set_m_CustomStyles_23(((GUIStyleU5BU5D_t2497716199*)SZArrayNew(GUIStyleU5BU5D_t2497716199_il2cpp_TypeInfo_var, (uint32_t)1)));
return;
}
}
// System.Void UnityEngine.GUISkin::OnEnable()
extern "C" void GUISkin_OnEnable_m668906001 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
{
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUISkin::CleanupRoots()
extern "C" void GUISkin_CleanupRoots_m1306395062 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUISkin_CleanupRoots_m1306395062_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->set_current_28((GUISkin_t1436893342 *)NULL);
((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->set_ms_Error_25((GUIStyle_t1799908754 *)NULL);
return;
}
}
// UnityEngine.Font UnityEngine.GUISkin::get_font()
extern "C" Font_t4239498691 * GUISkin_get_font_m3373823514 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
Font_t4239498691 * V_0 = NULL;
{
Font_t4239498691 * L_0 = __this->get_m_Font_2();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Font_t4239498691 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_font(UnityEngine.Font)
extern "C" void GUISkin_set_font_m4009958323 (GUISkin_t1436893342 * __this, Font_t4239498691 * ___value0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUISkin_set_font_m4009958323_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Font_t4239498691 * L_0 = ___value0;
__this->set_m_Font_2(L_0);
GUISkin_t1436893342 * L_1 = ((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->get_current_28();
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_2 = Object_op_Equality_m3764089466(NULL /*static, unused*/, L_1, __this, /*hidden argument*/NULL);
if (!L_2)
{
goto IL_0023;
}
}
{
Font_t4239498691 * L_3 = __this->get_m_Font_2();
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_SetDefaultFont_m2095841351(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
}
IL_0023:
{
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_box()
extern "C" GUIStyle_t1799908754 * GUISkin_get_box_m533626169 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_box_3();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_box(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_box_m877476512 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_box_3(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_label()
extern "C" GUIStyle_t1799908754 * GUISkin_get_label_m2703078986 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_label_6();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_label(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_label_m3497795469 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_label_6(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_textField()
extern "C" GUIStyle_t1799908754 * GUISkin_get_textField_m757680403 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_textField_7();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_textField(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_textField_m1154803040 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_textField_7(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_textArea()
extern "C" GUIStyle_t1799908754 * GUISkin_get_textArea_m2761984156 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_textArea_8();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_textArea(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_textArea_m1764644057 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_textArea_8(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_button()
extern "C" GUIStyle_t1799908754 * GUISkin_get_button_m797402546 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_button_4();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_button(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_button_m412653849 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_button_4(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_toggle()
extern "C" GUIStyle_t1799908754 * GUISkin_get_toggle_m4153935270 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_toggle_5();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_toggle(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_toggle_m1758777401 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_toggle_5(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_window()
extern "C" GUIStyle_t1799908754 * GUISkin_get_window_m304699482 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_window_9();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_window(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_window_m3629811303 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_window_9(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_horizontalSlider()
extern "C" GUIStyle_t1799908754 * GUISkin_get_horizontalSlider_m2127949063 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_horizontalSlider_10();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_horizontalSlider(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_horizontalSlider_m1661016058 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_horizontalSlider_10(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_horizontalSliderThumb()
extern "C" GUIStyle_t1799908754 * GUISkin_get_horizontalSliderThumb_m3625135389 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_horizontalSliderThumb_11();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_horizontalSliderThumb(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_horizontalSliderThumb_m2630442322 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_horizontalSliderThumb_11(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_verticalSlider()
extern "C" GUIStyle_t1799908754 * GUISkin_get_verticalSlider_m466249663 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_verticalSlider_12();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_verticalSlider(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_verticalSlider_m2804454404 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_verticalSlider_12(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_verticalSliderThumb()
extern "C" GUIStyle_t1799908754 * GUISkin_get_verticalSliderThumb_m4023737417 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_verticalSliderThumb_13();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_verticalSliderThumb(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_verticalSliderThumb_m2120268044 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_verticalSliderThumb_13(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_horizontalScrollbar()
extern "C" GUIStyle_t1799908754 * GUISkin_get_horizontalScrollbar_m1466427350 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_horizontalScrollbar_14();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_horizontalScrollbar(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_horizontalScrollbar_m3905379441 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_horizontalScrollbar_14(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_horizontalScrollbarThumb()
extern "C" GUIStyle_t1799908754 * GUISkin_get_horizontalScrollbarThumb_m4062590908 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_horizontalScrollbarThumb_15();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_horizontalScrollbarThumb(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_horizontalScrollbarThumb_m2119687595 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_horizontalScrollbarThumb_15(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_horizontalScrollbarLeftButton()
extern "C" GUIStyle_t1799908754 * GUISkin_get_horizontalScrollbarLeftButton_m3291286167 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_horizontalScrollbarLeftButton_16();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_horizontalScrollbarLeftButton(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_horizontalScrollbarLeftButton_m3732867738 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_horizontalScrollbarLeftButton_16(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_horizontalScrollbarRightButton()
extern "C" GUIStyle_t1799908754 * GUISkin_get_horizontalScrollbarRightButton_m3712291674 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_horizontalScrollbarRightButton_17();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_horizontalScrollbarRightButton(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_horizontalScrollbarRightButton_m3490630791 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_horizontalScrollbarRightButton_17(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_verticalScrollbar()
extern "C" GUIStyle_t1799908754 * GUISkin_get_verticalScrollbar_m851893488 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_verticalScrollbar_18();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_verticalScrollbar(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_verticalScrollbar_m1889864653 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_verticalScrollbar_18(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_verticalScrollbarThumb()
extern "C" GUIStyle_t1799908754 * GUISkin_get_verticalScrollbarThumb_m649633186 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_verticalScrollbarThumb_19();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_verticalScrollbarThumb(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_verticalScrollbarThumb_m2647835739 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_verticalScrollbarThumb_19(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_verticalScrollbarUpButton()
extern "C" GUIStyle_t1799908754 * GUISkin_get_verticalScrollbarUpButton_m3589224297 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_verticalScrollbarUpButton_20();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_verticalScrollbarUpButton(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_verticalScrollbarUpButton_m2965376352 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_verticalScrollbarUpButton_20(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_verticalScrollbarDownButton()
extern "C" GUIStyle_t1799908754 * GUISkin_get_verticalScrollbarDownButton_m1190388548 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_verticalScrollbarDownButton_21();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_verticalScrollbarDownButton(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_verticalScrollbarDownButton_m2438949637 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_verticalScrollbarDownButton_21(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_scrollView()
extern "C" GUIStyle_t1799908754 * GUISkin_get_scrollView_m2941173958 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_ScrollView_22();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyle_t1799908754 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_scrollView(UnityEngine.GUIStyle)
extern "C" void GUISkin_set_scrollView_m979648939 (GUISkin_t1436893342 * __this, GUIStyle_t1799908754 * ___value0, const MethodInfo* method)
{
{
GUIStyle_t1799908754 * L_0 = ___value0;
__this->set_m_ScrollView_22(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle[] UnityEngine.GUISkin::get_customStyles()
extern "C" GUIStyleU5BU5D_t2497716199* GUISkin_get_customStyles_m3624283365 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUIStyleU5BU5D_t2497716199* V_0 = NULL;
{
GUIStyleU5BU5D_t2497716199* L_0 = __this->get_m_CustomStyles_23();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUIStyleU5BU5D_t2497716199* L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUISkin::set_customStyles(UnityEngine.GUIStyle[])
extern "C" void GUISkin_set_customStyles_m4770734 (GUISkin_t1436893342 * __this, GUIStyleU5BU5D_t2497716199* ___value0, const MethodInfo* method)
{
{
GUIStyleU5BU5D_t2497716199* L_0 = ___value0;
__this->set_m_CustomStyles_23(L_0);
GUISkin_Apply_m3789936953(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUISettings UnityEngine.GUISkin::get_settings()
extern "C" GUISettings_t622856320 * GUISkin_get_settings_m626844463 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
GUISettings_t622856320 * V_0 = NULL;
{
GUISettings_t622856320 * L_0 = __this->get_m_Settings_24();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
GUISettings_t622856320 * L_1 = V_0;
return L_1;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::get_error()
extern "C" GUIStyle_t1799908754 * GUISkin_get_error_m1687921970 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUISkin_get_error_m1687921970_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUIStyle_t1799908754 * V_0 = NULL;
{
GUIStyle_t1799908754 * L_0 = ((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->get_ms_Error_25();
if (L_0)
{
goto IL_0015;
}
}
{
GUIStyle_t1799908754 * L_1 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_1, /*hidden argument*/NULL);
((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->set_ms_Error_25(L_1);
}
IL_0015:
{
GUIStyle_t1799908754 * L_2 = ((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->get_ms_Error_25();
V_0 = L_2;
goto IL_0020;
}
IL_0020:
{
GUIStyle_t1799908754 * L_3 = V_0;
return L_3;
}
}
// System.Void UnityEngine.GUISkin::Apply()
extern "C" void GUISkin_Apply_m3789936953 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUISkin_Apply_m3789936953_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
GUIStyleU5BU5D_t2497716199* L_0 = __this->get_m_CustomStyles_23();
if (L_0)
{
goto IL_0016;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Debug_t1368543263_il2cpp_TypeInfo_var);
Debug_Log_m920475918(NULL /*static, unused*/, _stringLiteral2300850132, /*hidden argument*/NULL);
}
IL_0016:
{
GUISkin_BuildStyleCache_m3553586894(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUISkin::BuildStyleCache()
extern "C" void GUISkin_BuildStyleCache_m3553586894 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUISkin_BuildStyleCache_m3553586894_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
GUIStyle_t1799908754 * L_0 = __this->get_m_box_3();
if (L_0)
{
goto IL_0017;
}
}
{
GUIStyle_t1799908754 * L_1 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_1, /*hidden argument*/NULL);
__this->set_m_box_3(L_1);
}
IL_0017:
{
GUIStyle_t1799908754 * L_2 = __this->get_m_button_4();
if (L_2)
{
goto IL_002d;
}
}
{
GUIStyle_t1799908754 * L_3 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_3, /*hidden argument*/NULL);
__this->set_m_button_4(L_3);
}
IL_002d:
{
GUIStyle_t1799908754 * L_4 = __this->get_m_toggle_5();
if (L_4)
{
goto IL_0043;
}
}
{
GUIStyle_t1799908754 * L_5 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_5, /*hidden argument*/NULL);
__this->set_m_toggle_5(L_5);
}
IL_0043:
{
GUIStyle_t1799908754 * L_6 = __this->get_m_label_6();
if (L_6)
{
goto IL_0059;
}
}
{
GUIStyle_t1799908754 * L_7 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_7, /*hidden argument*/NULL);
__this->set_m_label_6(L_7);
}
IL_0059:
{
GUIStyle_t1799908754 * L_8 = __this->get_m_window_9();
if (L_8)
{
goto IL_006f;
}
}
{
GUIStyle_t1799908754 * L_9 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_9, /*hidden argument*/NULL);
__this->set_m_window_9(L_9);
}
IL_006f:
{
GUIStyle_t1799908754 * L_10 = __this->get_m_textField_7();
if (L_10)
{
goto IL_0085;
}
}
{
GUIStyle_t1799908754 * L_11 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_11, /*hidden argument*/NULL);
__this->set_m_textField_7(L_11);
}
IL_0085:
{
GUIStyle_t1799908754 * L_12 = __this->get_m_textArea_8();
if (L_12)
{
goto IL_009b;
}
}
{
GUIStyle_t1799908754 * L_13 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_13, /*hidden argument*/NULL);
__this->set_m_textArea_8(L_13);
}
IL_009b:
{
GUIStyle_t1799908754 * L_14 = __this->get_m_horizontalSlider_10();
if (L_14)
{
goto IL_00b1;
}
}
{
GUIStyle_t1799908754 * L_15 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_15, /*hidden argument*/NULL);
__this->set_m_horizontalSlider_10(L_15);
}
IL_00b1:
{
GUIStyle_t1799908754 * L_16 = __this->get_m_horizontalSliderThumb_11();
if (L_16)
{
goto IL_00c7;
}
}
{
GUIStyle_t1799908754 * L_17 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_17, /*hidden argument*/NULL);
__this->set_m_horizontalSliderThumb_11(L_17);
}
IL_00c7:
{
GUIStyle_t1799908754 * L_18 = __this->get_m_verticalSlider_12();
if (L_18)
{
goto IL_00dd;
}
}
{
GUIStyle_t1799908754 * L_19 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_19, /*hidden argument*/NULL);
__this->set_m_verticalSlider_12(L_19);
}
IL_00dd:
{
GUIStyle_t1799908754 * L_20 = __this->get_m_verticalSliderThumb_13();
if (L_20)
{
goto IL_00f3;
}
}
{
GUIStyle_t1799908754 * L_21 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_21, /*hidden argument*/NULL);
__this->set_m_verticalSliderThumb_13(L_21);
}
IL_00f3:
{
GUIStyle_t1799908754 * L_22 = __this->get_m_horizontalScrollbar_14();
if (L_22)
{
goto IL_0109;
}
}
{
GUIStyle_t1799908754 * L_23 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_23, /*hidden argument*/NULL);
__this->set_m_horizontalScrollbar_14(L_23);
}
IL_0109:
{
GUIStyle_t1799908754 * L_24 = __this->get_m_horizontalScrollbarThumb_15();
if (L_24)
{
goto IL_011f;
}
}
{
GUIStyle_t1799908754 * L_25 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_25, /*hidden argument*/NULL);
__this->set_m_horizontalScrollbarThumb_15(L_25);
}
IL_011f:
{
GUIStyle_t1799908754 * L_26 = __this->get_m_horizontalScrollbarLeftButton_16();
if (L_26)
{
goto IL_0135;
}
}
{
GUIStyle_t1799908754 * L_27 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_27, /*hidden argument*/NULL);
__this->set_m_horizontalScrollbarLeftButton_16(L_27);
}
IL_0135:
{
GUIStyle_t1799908754 * L_28 = __this->get_m_horizontalScrollbarRightButton_17();
if (L_28)
{
goto IL_014b;
}
}
{
GUIStyle_t1799908754 * L_29 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_29, /*hidden argument*/NULL);
__this->set_m_horizontalScrollbarRightButton_17(L_29);
}
IL_014b:
{
GUIStyle_t1799908754 * L_30 = __this->get_m_verticalScrollbar_18();
if (L_30)
{
goto IL_0161;
}
}
{
GUIStyle_t1799908754 * L_31 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_31, /*hidden argument*/NULL);
__this->set_m_verticalScrollbar_18(L_31);
}
IL_0161:
{
GUIStyle_t1799908754 * L_32 = __this->get_m_verticalScrollbarThumb_19();
if (L_32)
{
goto IL_0177;
}
}
{
GUIStyle_t1799908754 * L_33 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_33, /*hidden argument*/NULL);
__this->set_m_verticalScrollbarThumb_19(L_33);
}
IL_0177:
{
GUIStyle_t1799908754 * L_34 = __this->get_m_verticalScrollbarUpButton_20();
if (L_34)
{
goto IL_018d;
}
}
{
GUIStyle_t1799908754 * L_35 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_35, /*hidden argument*/NULL);
__this->set_m_verticalScrollbarUpButton_20(L_35);
}
IL_018d:
{
GUIStyle_t1799908754 * L_36 = __this->get_m_verticalScrollbarDownButton_21();
if (L_36)
{
goto IL_01a3;
}
}
{
GUIStyle_t1799908754 * L_37 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_37, /*hidden argument*/NULL);
__this->set_m_verticalScrollbarDownButton_21(L_37);
}
IL_01a3:
{
GUIStyle_t1799908754 * L_38 = __this->get_m_ScrollView_22();
if (L_38)
{
goto IL_01b9;
}
}
{
GUIStyle_t1799908754 * L_39 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_39, /*hidden argument*/NULL);
__this->set_m_ScrollView_22(L_39);
}
IL_01b9:
{
IL2CPP_RUNTIME_CLASS_INIT(StringComparer_t1574862926_il2cpp_TypeInfo_var);
StringComparer_t1574862926 * L_40 = StringComparer_get_OrdinalIgnoreCase_m3428639861(NULL /*static, unused*/, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_41 = (Dictionary_2_t3714688016 *)il2cpp_codegen_object_new(Dictionary_2_t3714688016_il2cpp_TypeInfo_var);
Dictionary_2__ctor_m2582671449(L_41, L_40, /*hidden argument*/Dictionary_2__ctor_m2582671449_MethodInfo_var);
__this->set_m_Styles_26(L_41);
Dictionary_2_t3714688016 * L_42 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_43 = __this->get_m_box_3();
Dictionary_2_set_Item_m1398559205(L_42, _stringLiteral1502598545, L_43, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_44 = __this->get_m_box_3();
GUIStyle_set_name_m1034188361(L_44, _stringLiteral1502598545, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_45 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_46 = __this->get_m_button_4();
Dictionary_2_set_Item_m1398559205(L_45, _stringLiteral1993738382, L_46, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_47 = __this->get_m_button_4();
GUIStyle_set_name_m1034188361(L_47, _stringLiteral1993738382, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_48 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_49 = __this->get_m_toggle_5();
Dictionary_2_set_Item_m1398559205(L_48, _stringLiteral4217812034, L_49, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_50 = __this->get_m_toggle_5();
GUIStyle_set_name_m1034188361(L_50, _stringLiteral4217812034, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_51 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_52 = __this->get_m_label_6();
Dictionary_2_set_Item_m1398559205(L_51, _stringLiteral2515770764, L_52, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_53 = __this->get_m_label_6();
GUIStyle_set_name_m1034188361(L_53, _stringLiteral2515770764, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_54 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_55 = __this->get_m_window_9();
Dictionary_2_set_Item_m1398559205(L_54, _stringLiteral2523094542, L_55, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_56 = __this->get_m_window_9();
GUIStyle_set_name_m1034188361(L_56, _stringLiteral2523094542, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_57 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_58 = __this->get_m_textField_7();
Dictionary_2_set_Item_m1398559205(L_57, _stringLiteral2693452707, L_58, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_59 = __this->get_m_textField_7();
GUIStyle_set_name_m1034188361(L_59, _stringLiteral2693452707, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_60 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_61 = __this->get_m_textArea_8();
Dictionary_2_set_Item_m1398559205(L_60, _stringLiteral276680784, L_61, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_62 = __this->get_m_textArea_8();
GUIStyle_set_name_m1034188361(L_62, _stringLiteral276680784, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_63 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_64 = __this->get_m_horizontalSlider_10();
Dictionary_2_set_Item_m1398559205(L_63, _stringLiteral3942610267, L_64, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_65 = __this->get_m_horizontalSlider_10();
GUIStyle_set_name_m1034188361(L_65, _stringLiteral3942610267, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_66 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_67 = __this->get_m_horizontalSliderThumb_11();
Dictionary_2_set_Item_m1398559205(L_66, _stringLiteral4223230861, L_67, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_68 = __this->get_m_horizontalSliderThumb_11();
GUIStyle_set_name_m1034188361(L_68, _stringLiteral4223230861, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_69 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_70 = __this->get_m_verticalSlider_12();
Dictionary_2_set_Item_m1398559205(L_69, _stringLiteral641410427, L_70, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_71 = __this->get_m_verticalSlider_12();
GUIStyle_set_name_m1034188361(L_71, _stringLiteral641410427, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_72 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_73 = __this->get_m_verticalSliderThumb_13();
Dictionary_2_set_Item_m1398559205(L_72, _stringLiteral31520553, L_73, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_74 = __this->get_m_verticalSliderThumb_13();
GUIStyle_set_name_m1034188361(L_74, _stringLiteral31520553, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_75 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_76 = __this->get_m_horizontalScrollbar_14();
Dictionary_2_set_Item_m1398559205(L_75, _stringLiteral2511075584, L_76, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_77 = __this->get_m_horizontalScrollbar_14();
GUIStyle_set_name_m1034188361(L_77, _stringLiteral2511075584, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_78 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_79 = __this->get_m_horizontalScrollbarThumb_15();
Dictionary_2_set_Item_m1398559205(L_78, _stringLiteral1174722496, L_79, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_80 = __this->get_m_horizontalScrollbarThumb_15();
GUIStyle_set_name_m1034188361(L_80, _stringLiteral1174722496, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_81 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_82 = __this->get_m_horizontalScrollbarLeftButton_16();
Dictionary_2_set_Item_m1398559205(L_81, _stringLiteral876328135, L_82, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_83 = __this->get_m_horizontalScrollbarLeftButton_16();
GUIStyle_set_name_m1034188361(L_83, _stringLiteral876328135, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_84 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_85 = __this->get_m_horizontalScrollbarRightButton_17();
Dictionary_2_set_Item_m1398559205(L_84, _stringLiteral597299030, L_85, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_86 = __this->get_m_horizontalScrollbarRightButton_17();
GUIStyle_set_name_m1034188361(L_86, _stringLiteral597299030, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_87 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_88 = __this->get_m_verticalScrollbar_18();
Dictionary_2_set_Item_m1398559205(L_87, _stringLiteral4042931670, L_88, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_89 = __this->get_m_verticalScrollbar_18();
GUIStyle_set_name_m1034188361(L_89, _stringLiteral4042931670, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_90 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_91 = __this->get_m_verticalScrollbarThumb_19();
Dictionary_2_set_Item_m1398559205(L_90, _stringLiteral2359823790, L_91, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_92 = __this->get_m_verticalScrollbarThumb_19();
GUIStyle_set_name_m1034188361(L_92, _stringLiteral2359823790, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_93 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_94 = __this->get_m_verticalScrollbarUpButton_20();
Dictionary_2_set_Item_m1398559205(L_93, _stringLiteral2304878361, L_94, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_95 = __this->get_m_verticalScrollbarUpButton_20();
GUIStyle_set_name_m1034188361(L_95, _stringLiteral2304878361, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_96 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_97 = __this->get_m_verticalScrollbarDownButton_21();
Dictionary_2_set_Item_m1398559205(L_96, _stringLiteral530814794, L_97, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_98 = __this->get_m_verticalScrollbarDownButton_21();
GUIStyle_set_name_m1034188361(L_98, _stringLiteral530814794, /*hidden argument*/NULL);
Dictionary_2_t3714688016 * L_99 = __this->get_m_Styles_26();
GUIStyle_t1799908754 * L_100 = __this->get_m_ScrollView_22();
Dictionary_2_set_Item_m1398559205(L_99, _stringLiteral3501965954, L_100, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
GUIStyle_t1799908754 * L_101 = __this->get_m_ScrollView_22();
GUIStyle_set_name_m1034188361(L_101, _stringLiteral3501965954, /*hidden argument*/NULL);
GUIStyleU5BU5D_t2497716199* L_102 = __this->get_m_CustomStyles_23();
if (!L_102)
{
goto IL_051b;
}
}
{
V_0 = 0;
goto IL_050c;
}
IL_04d4:
{
GUIStyleU5BU5D_t2497716199* L_103 = __this->get_m_CustomStyles_23();
int32_t L_104 = V_0;
int32_t L_105 = L_104;
GUIStyle_t1799908754 * L_106 = (L_103)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_105));
if (L_106)
{
goto IL_04e7;
}
}
{
goto IL_0508;
}
IL_04e7:
{
Dictionary_2_t3714688016 * L_107 = __this->get_m_Styles_26();
GUIStyleU5BU5D_t2497716199* L_108 = __this->get_m_CustomStyles_23();
int32_t L_109 = V_0;
int32_t L_110 = L_109;
GUIStyle_t1799908754 * L_111 = (L_108)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_110));
String_t* L_112 = GUIStyle_get_name_m753291950(L_111, /*hidden argument*/NULL);
GUIStyleU5BU5D_t2497716199* L_113 = __this->get_m_CustomStyles_23();
int32_t L_114 = V_0;
int32_t L_115 = L_114;
GUIStyle_t1799908754 * L_116 = (L_113)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_115));
Dictionary_2_set_Item_m1398559205(L_107, L_112, L_116, /*hidden argument*/Dictionary_2_set_Item_m1398559205_MethodInfo_var);
}
IL_0508:
{
int32_t L_117 = V_0;
V_0 = ((int32_t)((int32_t)L_117+(int32_t)1));
}
IL_050c:
{
int32_t L_118 = V_0;
GUIStyleU5BU5D_t2497716199* L_119 = __this->get_m_CustomStyles_23();
if ((((int32_t)L_118) < ((int32_t)(((int32_t)((int32_t)(((Il2CppArray *)L_119)->max_length)))))))
{
goto IL_04d4;
}
}
{
}
IL_051b:
{
GUIStyle_t1799908754 * L_120 = GUISkin_get_error_m1687921970(NULL /*static, unused*/, /*hidden argument*/NULL);
GUIStyle_set_stretchHeight_m421727883(L_120, (bool)1, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_121 = GUISkin_get_error_m1687921970(NULL /*static, unused*/, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_122 = GUIStyle_get_normal_m2789468942(L_121, /*hidden argument*/NULL);
Color_t2020392075 L_123 = Color_get_red_m2410286591(NULL /*static, unused*/, /*hidden argument*/NULL);
GUIStyleState_set_textColor_m3970174237(L_122, L_123, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::GetStyle(System.String)
extern "C" GUIStyle_t1799908754 * GUISkin_GetStyle_m3594137272 (GUISkin_t1436893342 * __this, String_t* ___styleName0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUISkin_GetStyle_m3594137272_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUIStyle_t1799908754 * V_0 = NULL;
GUIStyle_t1799908754 * V_1 = NULL;
{
String_t* L_0 = ___styleName0;
GUIStyle_t1799908754 * L_1 = GUISkin_FindStyle_m4277712965(__this, L_0, /*hidden argument*/NULL);
V_0 = L_1;
GUIStyle_t1799908754 * L_2 = V_0;
if (!L_2)
{
goto IL_0016;
}
}
{
GUIStyle_t1799908754 * L_3 = V_0;
V_1 = L_3;
goto IL_0068;
}
IL_0016:
{
ObjectU5BU5D_t3614634134* L_4 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)6));
ArrayElementTypeCheck (L_4, _stringLiteral3073647763);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)_stringLiteral3073647763);
ObjectU5BU5D_t3614634134* L_5 = L_4;
String_t* L_6 = ___styleName0;
ArrayElementTypeCheck (L_5, L_6);
(L_5)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (Il2CppObject *)L_6);
ObjectU5BU5D_t3614634134* L_7 = L_5;
ArrayElementTypeCheck (L_7, _stringLiteral2704271486);
(L_7)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(2), (Il2CppObject *)_stringLiteral2704271486);
ObjectU5BU5D_t3614634134* L_8 = L_7;
String_t* L_9 = Object_get_name_m2079638459(__this, /*hidden argument*/NULL);
ArrayElementTypeCheck (L_8, L_9);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(3), (Il2CppObject *)L_9);
ObjectU5BU5D_t3614634134* L_10 = L_8;
ArrayElementTypeCheck (L_10, _stringLiteral811305467);
(L_10)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(4), (Il2CppObject *)_stringLiteral811305467);
ObjectU5BU5D_t3614634134* L_11 = L_10;
Event_t3028476042 * L_12 = Event_get_current_m2901774193(NULL /*static, unused*/, /*hidden argument*/NULL);
int32_t L_13 = Event_get_type_m2426033198(L_12, /*hidden argument*/NULL);
int32_t L_14 = L_13;
Il2CppObject * L_15 = Box(EventType_t3919834026_il2cpp_TypeInfo_var, &L_14);
ArrayElementTypeCheck (L_11, L_15);
(L_11)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(5), (Il2CppObject *)L_15);
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_16 = String_Concat_m3881798623(NULL /*static, unused*/, L_11, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Debug_t1368543263_il2cpp_TypeInfo_var);
Debug_LogWarning_m2503577968(NULL /*static, unused*/, L_16, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_17 = GUISkin_get_error_m1687921970(NULL /*static, unused*/, /*hidden argument*/NULL);
V_1 = L_17;
goto IL_0068;
}
IL_0068:
{
GUIStyle_t1799908754 * L_18 = V_1;
return L_18;
}
}
// UnityEngine.GUIStyle UnityEngine.GUISkin::FindStyle(System.String)
extern "C" GUIStyle_t1799908754 * GUISkin_FindStyle_m4277712965 (GUISkin_t1436893342 * __this, String_t* ___styleName0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUISkin_FindStyle_m4277712965_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUIStyle_t1799908754 * V_0 = NULL;
GUIStyle_t1799908754 * V_1 = NULL;
{
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_0 = Object_op_Equality_m3764089466(NULL /*static, unused*/, __this, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_0)
{
goto IL_001f;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Debug_t1368543263_il2cpp_TypeInfo_var);
Debug_LogError_m3715728798(NULL /*static, unused*/, _stringLiteral3853863397, /*hidden argument*/NULL);
V_0 = (GUIStyle_t1799908754 *)NULL;
goto IL_0051;
}
IL_001f:
{
Dictionary_2_t3714688016 * L_1 = __this->get_m_Styles_26();
if (L_1)
{
goto IL_0030;
}
}
{
GUISkin_BuildStyleCache_m3553586894(__this, /*hidden argument*/NULL);
}
IL_0030:
{
Dictionary_2_t3714688016 * L_2 = __this->get_m_Styles_26();
String_t* L_3 = ___styleName0;
bool L_4 = Dictionary_2_TryGetValue_m595022037(L_2, L_3, (&V_1), /*hidden argument*/Dictionary_2_TryGetValue_m595022037_MethodInfo_var);
if (!L_4)
{
goto IL_004a;
}
}
{
GUIStyle_t1799908754 * L_5 = V_1;
V_0 = L_5;
goto IL_0051;
}
IL_004a:
{
V_0 = (GUIStyle_t1799908754 *)NULL;
goto IL_0051;
}
IL_0051:
{
GUIStyle_t1799908754 * L_6 = V_0;
return L_6;
}
}
// System.Void UnityEngine.GUISkin::MakeCurrent()
extern "C" void GUISkin_MakeCurrent_m126414424 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUISkin_MakeCurrent_m126414424_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->set_current_28(__this);
Font_t4239498691 * L_0 = GUISkin_get_font_m3373823514(__this, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_SetDefaultFont_m2095841351(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
SkinChangedDelegate_t3594822336 * L_1 = ((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->get_m_SkinChanged_27();
if (!L_1)
{
goto IL_0026;
}
}
{
SkinChangedDelegate_t3594822336 * L_2 = ((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->get_m_SkinChanged_27();
SkinChangedDelegate_Invoke_m2801964040(L_2, /*hidden argument*/NULL);
}
IL_0026:
{
return;
}
}
// System.Collections.IEnumerator UnityEngine.GUISkin::GetEnumerator()
extern "C" Il2CppObject * GUISkin_GetEnumerator_m3501317101 (GUISkin_t1436893342 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUISkin_GetEnumerator_m3501317101_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Il2CppObject * V_0 = NULL;
{
Dictionary_2_t3714688016 * L_0 = __this->get_m_Styles_26();
if (L_0)
{
goto IL_0012;
}
}
{
GUISkin_BuildStyleCache_m3553586894(__this, /*hidden argument*/NULL);
}
IL_0012:
{
Dictionary_2_t3714688016 * L_1 = __this->get_m_Styles_26();
ValueCollection_t2417747859 * L_2 = Dictionary_2_get_Values_m2837248370(L_1, /*hidden argument*/Dictionary_2_get_Values_m2837248370_MethodInfo_var);
Enumerator_t1106253484 L_3 = ValueCollection_GetEnumerator_m1549252400(L_2, /*hidden argument*/ValueCollection_GetEnumerator_m1549252400_MethodInfo_var);
Enumerator_t1106253484 L_4 = L_3;
Il2CppObject * L_5 = Box(Enumerator_t1106253484_il2cpp_TypeInfo_var, &L_4);
V_0 = (Il2CppObject *)L_5;
goto IL_002d;
}
IL_002d:
{
Il2CppObject * L_6 = V_0;
return L_6;
}
}
extern "C" void DelegatePInvokeWrapper_SkinChangedDelegate_t3594822336 (SkinChangedDelegate_t3594822336 * __this, const MethodInfo* method)
{
typedef void (STDCALL *PInvokeFunc)();
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(((Il2CppDelegate*)__this)->method->methodPointer);
// Native function invocation
il2cppPInvokeFunc();
}
// System.Void UnityEngine.GUISkin/SkinChangedDelegate::.ctor(System.Object,System.IntPtr)
extern "C" void SkinChangedDelegate__ctor_m3905328298 (SkinChangedDelegate_t3594822336 * __this, Il2CppObject * ___object0, IntPtr_t ___method1, const MethodInfo* method)
{
__this->set_method_ptr_0((Il2CppMethodPointer)((MethodInfo*)___method1.get_m_value_0())->methodPointer);
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.GUISkin/SkinChangedDelegate::Invoke()
extern "C" void SkinChangedDelegate_Invoke_m2801964040 (SkinChangedDelegate_t3594822336 * __this, const MethodInfo* method)
{
if(__this->get_prev_9() != NULL)
{
SkinChangedDelegate_Invoke_m2801964040((SkinChangedDelegate_t3594822336 *)__this->get_prev_9(), method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->get_method_3().get_m_value_0()));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->get_method_3().get_m_value_0()));
if ((__this->get_m_target_2() != NULL || MethodHasParameters((MethodInfo*)(__this->get_method_3().get_m_value_0()))) && ___methodIsStatic)
{
typedef void (*FunctionPointerType) (Il2CppObject *, void* __this, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(NULL,__this->get_m_target_2(),(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
else
{
typedef void (*FunctionPointerType) (void* __this, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(__this->get_m_target_2(),(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
}
// System.IAsyncResult UnityEngine.GUISkin/SkinChangedDelegate::BeginInvoke(System.AsyncCallback,System.Object)
extern "C" Il2CppObject * SkinChangedDelegate_BeginInvoke_m4259161711 (SkinChangedDelegate_t3594822336 * __this, AsyncCallback_t163412349 * ___callback0, Il2CppObject * ___object1, const MethodInfo* method)
{
void *__d_args[1] = {0};
return (Il2CppObject *)il2cpp_codegen_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback0, (Il2CppObject*)___object1);
}
// System.Void UnityEngine.GUISkin/SkinChangedDelegate::EndInvoke(System.IAsyncResult)
extern "C" void SkinChangedDelegate_EndInvoke_m2989252188 (SkinChangedDelegate_t3594822336 * __this, Il2CppObject * ___result0, const MethodInfo* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
// Conversion methods for marshalling of: UnityEngine.GUIStyle
extern "C" void GUIStyle_t1799908754_marshal_pinvoke(const GUIStyle_t1799908754& unmarshaled, GUIStyle_t1799908754_marshaled_pinvoke& marshaled)
{
Il2CppCodeGenException* ___m_Normal_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Normal' of type 'GUIStyle': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Normal_1Exception);
}
extern "C" void GUIStyle_t1799908754_marshal_pinvoke_back(const GUIStyle_t1799908754_marshaled_pinvoke& marshaled, GUIStyle_t1799908754& unmarshaled)
{
Il2CppCodeGenException* ___m_Normal_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Normal' of type 'GUIStyle': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Normal_1Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.GUIStyle
extern "C" void GUIStyle_t1799908754_marshal_pinvoke_cleanup(GUIStyle_t1799908754_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.GUIStyle
extern "C" void GUIStyle_t1799908754_marshal_com(const GUIStyle_t1799908754& unmarshaled, GUIStyle_t1799908754_marshaled_com& marshaled)
{
Il2CppCodeGenException* ___m_Normal_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Normal' of type 'GUIStyle': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Normal_1Exception);
}
extern "C" void GUIStyle_t1799908754_marshal_com_back(const GUIStyle_t1799908754_marshaled_com& marshaled, GUIStyle_t1799908754& unmarshaled)
{
Il2CppCodeGenException* ___m_Normal_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Normal' of type 'GUIStyle': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Normal_1Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.GUIStyle
extern "C" void GUIStyle_t1799908754_marshal_com_cleanup(GUIStyle_t1799908754_marshaled_com& marshaled)
{
}
// System.Void UnityEngine.GUIStyle::.ctor()
extern "C" void GUIStyle__ctor_m3665892801 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
GUIStyle_Init_m3872198731(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::.ctor(UnityEngine.GUIStyle)
extern "C" void GUIStyle__ctor_m2210993436 (GUIStyle_t1799908754 * __this, GUIStyle_t1799908754 * ___other0, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_0 = ___other0;
GUIStyle_InitCopy_m3676786505(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::Finalize()
extern "C" void GUIStyle_Finalize_m1258476043 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
{
}
IL_0001:
try
{ // begin try (depth: 1)
GUIStyle_Cleanup_m1915255373(__this, /*hidden argument*/NULL);
IL2CPP_LEAVE(0x13, FINALLY_000c);
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_000c;
}
FINALLY_000c:
{ // begin finally (depth: 1)
Object_Finalize_m4087144328(__this, /*hidden argument*/NULL);
IL2CPP_END_FINALLY(12)
} // end finally (depth: 1)
IL2CPP_CLEANUP(12)
{
IL2CPP_JUMP_TBL(0x13, IL_0013)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_0013:
{
return;
}
}
// System.Void UnityEngine.GUIStyle::CleanupRoots()
extern "C" void GUIStyle_CleanupRoots_m1437637400 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_CleanupRoots_m1437637400_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
((GUIStyle_t1799908754_StaticFields*)GUIStyle_t1799908754_il2cpp_TypeInfo_var->static_fields)->set_s_None_15((GUIStyle_t1799908754 *)NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::InternalOnAfterDeserialize()
extern "C" void GUIStyle_InternalOnAfterDeserialize_m1316894156 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
{
Font_t4239498691 * L_0 = GUIStyle_GetFontInternalDuringLoadingThread_m229734483(__this, /*hidden argument*/NULL);
__this->set_m_FontInternal_13(L_0);
IntPtr_t L_1 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 0, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_2 = GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976(NULL /*static, unused*/, __this, L_1, /*hidden argument*/NULL);
__this->set_m_Normal_1(L_2);
IntPtr_t L_3 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 1, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_4 = GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976(NULL /*static, unused*/, __this, L_3, /*hidden argument*/NULL);
__this->set_m_Hover_2(L_4);
IntPtr_t L_5 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 2, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_6 = GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976(NULL /*static, unused*/, __this, L_5, /*hidden argument*/NULL);
__this->set_m_Active_3(L_6);
IntPtr_t L_7 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 3, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_8 = GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976(NULL /*static, unused*/, __this, L_7, /*hidden argument*/NULL);
__this->set_m_Focused_4(L_8);
IntPtr_t L_9 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 4, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_10 = GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976(NULL /*static, unused*/, __this, L_9, /*hidden argument*/NULL);
__this->set_m_OnNormal_5(L_10);
IntPtr_t L_11 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 5, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_12 = GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976(NULL /*static, unused*/, __this, L_11, /*hidden argument*/NULL);
__this->set_m_OnHover_6(L_12);
IntPtr_t L_13 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 6, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_14 = GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976(NULL /*static, unused*/, __this, L_13, /*hidden argument*/NULL);
__this->set_m_OnActive_7(L_14);
IntPtr_t L_15 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 7, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_16 = GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976(NULL /*static, unused*/, __this, L_15, /*hidden argument*/NULL);
__this->set_m_OnFocused_8(L_16);
return;
}
}
// UnityEngine.GUIStyleState UnityEngine.GUIStyle::get_normal()
extern "C" GUIStyleState_t3801000545 * GUIStyle_get_normal_m2789468942 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
GUIStyleState_t3801000545 * V_0 = NULL;
{
GUIStyleState_t3801000545 * L_0 = __this->get_m_Normal_1();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 0, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_2 = GUIStyleState_GetGUIStyleState_m2816150617(NULL /*static, unused*/, __this, L_1, /*hidden argument*/NULL);
__this->set_m_Normal_1(L_2);
}
IL_001f:
{
GUIStyleState_t3801000545 * L_3 = __this->get_m_Normal_1();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
GUIStyleState_t3801000545 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_normal(UnityEngine.GUIStyleState)
extern "C" void GUIStyle_set_normal_m3961052767 (GUIStyle_t1799908754 * __this, GUIStyleState_t3801000545 * ___value0, const MethodInfo* method)
{
{
GUIStyleState_t3801000545 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignStyleState_m2665274947(__this, 0, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyleState UnityEngine.GUIStyle::get_hover()
extern "C" GUIStyleState_t3801000545 * GUIStyle_get_hover_m2852629197 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
GUIStyleState_t3801000545 * V_0 = NULL;
{
GUIStyleState_t3801000545 * L_0 = __this->get_m_Hover_2();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 1, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_2 = GUIStyleState_GetGUIStyleState_m2816150617(NULL /*static, unused*/, __this, L_1, /*hidden argument*/NULL);
__this->set_m_Hover_2(L_2);
}
IL_001f:
{
GUIStyleState_t3801000545 * L_3 = __this->get_m_Hover_2();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
GUIStyleState_t3801000545 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_hover(UnityEngine.GUIStyleState)
extern "C" void GUIStyle_set_hover_m3804756686 (GUIStyle_t1799908754 * __this, GUIStyleState_t3801000545 * ___value0, const MethodInfo* method)
{
{
GUIStyleState_t3801000545 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignStyleState_m2665274947(__this, 1, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyleState UnityEngine.GUIStyle::get_active()
extern "C" GUIStyleState_t3801000545 * GUIStyle_get_active_m1570427943 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
GUIStyleState_t3801000545 * V_0 = NULL;
{
GUIStyleState_t3801000545 * L_0 = __this->get_m_Active_3();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 2, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_2 = GUIStyleState_GetGUIStyleState_m2816150617(NULL /*static, unused*/, __this, L_1, /*hidden argument*/NULL);
__this->set_m_Active_3(L_2);
}
IL_001f:
{
GUIStyleState_t3801000545 * L_3 = __this->get_m_Active_3();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
GUIStyleState_t3801000545 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_active(UnityEngine.GUIStyleState)
extern "C" void GUIStyle_set_active_m2896743432 (GUIStyle_t1799908754 * __this, GUIStyleState_t3801000545 * ___value0, const MethodInfo* method)
{
{
GUIStyleState_t3801000545 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignStyleState_m2665274947(__this, 2, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyleState UnityEngine.GUIStyle::get_onNormal()
extern "C" GUIStyleState_t3801000545 * GUIStyle_get_onNormal_m1675201777 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
GUIStyleState_t3801000545 * V_0 = NULL;
{
GUIStyleState_t3801000545 * L_0 = __this->get_m_OnNormal_5();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 4, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_2 = GUIStyleState_GetGUIStyleState_m2816150617(NULL /*static, unused*/, __this, L_1, /*hidden argument*/NULL);
__this->set_m_OnNormal_5(L_2);
}
IL_001f:
{
GUIStyleState_t3801000545 * L_3 = __this->get_m_OnNormal_5();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
GUIStyleState_t3801000545 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_onNormal(UnityEngine.GUIStyleState)
extern "C" void GUIStyle_set_onNormal_m1461827296 (GUIStyle_t1799908754 * __this, GUIStyleState_t3801000545 * ___value0, const MethodInfo* method)
{
{
GUIStyleState_t3801000545 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignStyleState_m2665274947(__this, 4, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyleState UnityEngine.GUIStyle::get_onHover()
extern "C" GUIStyleState_t3801000545 * GUIStyle_get_onHover_m2772546760 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
GUIStyleState_t3801000545 * V_0 = NULL;
{
GUIStyleState_t3801000545 * L_0 = __this->get_m_OnHover_6();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 5, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_2 = GUIStyleState_GetGUIStyleState_m2816150617(NULL /*static, unused*/, __this, L_1, /*hidden argument*/NULL);
__this->set_m_OnHover_6(L_2);
}
IL_001f:
{
GUIStyleState_t3801000545 * L_3 = __this->get_m_OnHover_6();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
GUIStyleState_t3801000545 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_onHover(UnityEngine.GUIStyleState)
extern "C" void GUIStyle_set_onHover_m3908151335 (GUIStyle_t1799908754 * __this, GUIStyleState_t3801000545 * ___value0, const MethodInfo* method)
{
{
GUIStyleState_t3801000545 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignStyleState_m2665274947(__this, 5, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyleState UnityEngine.GUIStyle::get_onActive()
extern "C" GUIStyleState_t3801000545 * GUIStyle_get_onActive_m1207191918 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
GUIStyleState_t3801000545 * V_0 = NULL;
{
GUIStyleState_t3801000545 * L_0 = __this->get_m_OnActive_7();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 6, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_2 = GUIStyleState_GetGUIStyleState_m2816150617(NULL /*static, unused*/, __this, L_1, /*hidden argument*/NULL);
__this->set_m_OnActive_7(L_2);
}
IL_001f:
{
GUIStyleState_t3801000545 * L_3 = __this->get_m_OnActive_7();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
GUIStyleState_t3801000545 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_onActive(UnityEngine.GUIStyleState)
extern "C" void GUIStyle_set_onActive_m504713485 (GUIStyle_t1799908754 * __this, GUIStyleState_t3801000545 * ___value0, const MethodInfo* method)
{
{
GUIStyleState_t3801000545 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignStyleState_m2665274947(__this, 6, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyleState UnityEngine.GUIStyle::get_focused()
extern "C" GUIStyleState_t3801000545 * GUIStyle_get_focused_m2556379628 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
GUIStyleState_t3801000545 * V_0 = NULL;
{
GUIStyleState_t3801000545 * L_0 = __this->get_m_Focused_4();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 3, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_2 = GUIStyleState_GetGUIStyleState_m2816150617(NULL /*static, unused*/, __this, L_1, /*hidden argument*/NULL);
__this->set_m_Focused_4(L_2);
}
IL_001f:
{
GUIStyleState_t3801000545 * L_3 = __this->get_m_Focused_4();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
GUIStyleState_t3801000545 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_focused(UnityEngine.GUIStyleState)
extern "C" void GUIStyle_set_focused_m1547304893 (GUIStyle_t1799908754 * __this, GUIStyleState_t3801000545 * ___value0, const MethodInfo* method)
{
{
GUIStyleState_t3801000545 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignStyleState_m2665274947(__this, 3, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyleState UnityEngine.GUIStyle::get_onFocused()
extern "C" GUIStyleState_t3801000545 * GUIStyle_get_onFocused_m2592399571 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
GUIStyleState_t3801000545 * V_0 = NULL;
{
GUIStyleState_t3801000545 * L_0 = __this->get_m_OnFocused_8();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetStyleStatePtr_m1972527409(__this, 7, /*hidden argument*/NULL);
GUIStyleState_t3801000545 * L_2 = GUIStyleState_GetGUIStyleState_m2816150617(NULL /*static, unused*/, __this, L_1, /*hidden argument*/NULL);
__this->set_m_OnFocused_8(L_2);
}
IL_001f:
{
GUIStyleState_t3801000545 * L_3 = __this->get_m_OnFocused_8();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
GUIStyleState_t3801000545 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_onFocused(UnityEngine.GUIStyleState)
extern "C" void GUIStyle_set_onFocused_m3237213858 (GUIStyle_t1799908754 * __this, GUIStyleState_t3801000545 * ___value0, const MethodInfo* method)
{
{
GUIStyleState_t3801000545 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignStyleState_m2665274947(__this, 7, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.RectOffset UnityEngine.GUIStyle::get_border()
extern "C" RectOffset_t3387826427 * GUIStyle_get_border_m2676279601 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_get_border_m2676279601_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RectOffset_t3387826427 * V_0 = NULL;
{
RectOffset_t3387826427 * L_0 = __this->get_m_Border_9();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetRectOffsetPtr_m4223228888(__this, 0, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_2 = (RectOffset_t3387826427 *)il2cpp_codegen_object_new(RectOffset_t3387826427_il2cpp_TypeInfo_var);
RectOffset__ctor_m1265077918(L_2, __this, L_1, /*hidden argument*/NULL);
__this->set_m_Border_9(L_2);
}
IL_001f:
{
RectOffset_t3387826427 * L_3 = __this->get_m_Border_9();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
RectOffset_t3387826427 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_border(UnityEngine.RectOffset)
extern "C" void GUIStyle_set_border_m1243171088 (GUIStyle_t1799908754 * __this, RectOffset_t3387826427 * ___value0, const MethodInfo* method)
{
{
RectOffset_t3387826427 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignRectOffset_m2998103580(__this, 0, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.RectOffset UnityEngine.GUIStyle::get_margin()
extern "C" RectOffset_t3387826427 * GUIStyle_get_margin_m1012250163 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_get_margin_m1012250163_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RectOffset_t3387826427 * V_0 = NULL;
{
RectOffset_t3387826427 * L_0 = __this->get_m_Margin_11();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetRectOffsetPtr_m4223228888(__this, 1, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_2 = (RectOffset_t3387826427 *)il2cpp_codegen_object_new(RectOffset_t3387826427_il2cpp_TypeInfo_var);
RectOffset__ctor_m1265077918(L_2, __this, L_1, /*hidden argument*/NULL);
__this->set_m_Margin_11(L_2);
}
IL_001f:
{
RectOffset_t3387826427 * L_3 = __this->get_m_Margin_11();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
RectOffset_t3387826427 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_margin(UnityEngine.RectOffset)
extern "C" void GUIStyle_set_margin_m2529965880 (GUIStyle_t1799908754 * __this, RectOffset_t3387826427 * ___value0, const MethodInfo* method)
{
{
RectOffset_t3387826427 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignRectOffset_m2998103580(__this, 1, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.RectOffset UnityEngine.GUIStyle::get_padding()
extern "C" RectOffset_t3387826427 * GUIStyle_get_padding_m4076916754 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_get_padding_m4076916754_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RectOffset_t3387826427 * V_0 = NULL;
{
RectOffset_t3387826427 * L_0 = __this->get_m_Padding_10();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetRectOffsetPtr_m4223228888(__this, 2, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_2 = (RectOffset_t3387826427 *)il2cpp_codegen_object_new(RectOffset_t3387826427_il2cpp_TypeInfo_var);
RectOffset__ctor_m1265077918(L_2, __this, L_1, /*hidden argument*/NULL);
__this->set_m_Padding_10(L_2);
}
IL_001f:
{
RectOffset_t3387826427 * L_3 = __this->get_m_Padding_10();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
RectOffset_t3387826427 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_padding(UnityEngine.RectOffset)
extern "C" void GUIStyle_set_padding_m3722809255 (GUIStyle_t1799908754 * __this, RectOffset_t3387826427 * ___value0, const MethodInfo* method)
{
{
RectOffset_t3387826427 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignRectOffset_m2998103580(__this, 2, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.RectOffset UnityEngine.GUIStyle::get_overflow()
extern "C" RectOffset_t3387826427 * GUIStyle_get_overflow_m1125058093 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_get_overflow_m1125058093_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RectOffset_t3387826427 * V_0 = NULL;
{
RectOffset_t3387826427 * L_0 = __this->get_m_Overflow_12();
if (L_0)
{
goto IL_001f;
}
}
{
IntPtr_t L_1 = GUIStyle_GetRectOffsetPtr_m4223228888(__this, 3, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_2 = (RectOffset_t3387826427 *)il2cpp_codegen_object_new(RectOffset_t3387826427_il2cpp_TypeInfo_var);
RectOffset__ctor_m1265077918(L_2, __this, L_1, /*hidden argument*/NULL);
__this->set_m_Overflow_12(L_2);
}
IL_001f:
{
RectOffset_t3387826427 * L_3 = __this->get_m_Overflow_12();
V_0 = L_3;
goto IL_002b;
}
IL_002b:
{
RectOffset_t3387826427 * L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.GUIStyle::set_overflow(UnityEngine.RectOffset)
extern "C" void GUIStyle_set_overflow_m3735423712 (GUIStyle_t1799908754 * __this, RectOffset_t3387826427 * ___value0, const MethodInfo* method)
{
{
RectOffset_t3387826427 * L_0 = ___value0;
IntPtr_t L_1 = L_0->get_m_Ptr_0();
GUIStyle_AssignRectOffset_m2998103580(__this, 3, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Vector2 UnityEngine.GUIStyle::get_clipOffset()
extern "C" Vector2_t2243707579 GUIStyle_get_clipOffset_m2888582498 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector2_t2243707579 L_0 = GUIStyle_get_Internal_clipOffset_m4237737448(__this, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Vector2_t2243707579 L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUIStyle::set_clipOffset(UnityEngine.Vector2)
extern "C" void GUIStyle_set_clipOffset_m3871613343 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
{
Vector2_t2243707579 L_0 = ___value0;
GUIStyle_set_Internal_clipOffset_m118330819(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Font UnityEngine.GUIStyle::get_font()
extern "C" Font_t4239498691 * GUIStyle_get_font_m1489712926 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
Font_t4239498691 * V_0 = NULL;
{
Font_t4239498691 * L_0 = GUIStyle_GetFontInternal_m3509743324(__this, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Font_t4239498691 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUIStyle::set_font(UnityEngine.Font)
extern "C" void GUIStyle_set_font_m312124587 (GUIStyle_t1799908754 * __this, Font_t4239498691 * ___value0, const MethodInfo* method)
{
{
Font_t4239498691 * L_0 = ___value0;
GUIStyle_SetFontInternal_m4135062999(__this, L_0, /*hidden argument*/NULL);
Font_t4239498691 * L_1 = ___value0;
__this->set_m_FontInternal_13(L_1);
return;
}
}
// System.Single UnityEngine.GUIStyle::get_lineHeight()
extern "C" float GUIStyle_get_lineHeight_m2132859383 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_get_lineHeight_m2132859383_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
float L_1 = GUIStyle_Internal_GetLineHeight_m2503294326(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_2 = bankers_roundf(L_1);
V_0 = L_2;
goto IL_0017;
}
IL_0017:
{
float L_3 = V_0;
return L_3;
}
}
// System.Void UnityEngine.GUIStyle::Internal_Draw(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,System.Boolean,System.Boolean,System.Boolean,System.Boolean)
extern "C" void GUIStyle_Internal_Draw_m3610093213 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, bool ___isHover3, bool ___isActive4, bool ___on5, bool ___hasKeyboardFocus6, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Internal_Draw_m3610093213_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Internal_DrawArguments_t2834709342 V_0;
memset(&V_0, 0, sizeof(V_0));
Internal_DrawArguments_t2834709342 * G_B2_0 = NULL;
Internal_DrawArguments_t2834709342 * G_B1_0 = NULL;
int32_t G_B3_0 = 0;
Internal_DrawArguments_t2834709342 * G_B3_1 = NULL;
Internal_DrawArguments_t2834709342 * G_B5_0 = NULL;
Internal_DrawArguments_t2834709342 * G_B4_0 = NULL;
int32_t G_B6_0 = 0;
Internal_DrawArguments_t2834709342 * G_B6_1 = NULL;
Internal_DrawArguments_t2834709342 * G_B8_0 = NULL;
Internal_DrawArguments_t2834709342 * G_B7_0 = NULL;
int32_t G_B9_0 = 0;
Internal_DrawArguments_t2834709342 * G_B9_1 = NULL;
Internal_DrawArguments_t2834709342 * G_B11_0 = NULL;
Internal_DrawArguments_t2834709342 * G_B10_0 = NULL;
int32_t G_B12_0 = 0;
Internal_DrawArguments_t2834709342 * G_B12_1 = NULL;
{
Initobj (Internal_DrawArguments_t2834709342_il2cpp_TypeInfo_var, (&V_0));
IntPtr_t L_0 = ___target0;
(&V_0)->set_target_0(L_0);
Rect_t3681755626 L_1 = ___position1;
(&V_0)->set_position_1(L_1);
bool L_2 = ___isHover3;
G_B1_0 = (&V_0);
if (!L_2)
{
G_B2_0 = (&V_0);
goto IL_0027;
}
}
{
G_B3_0 = 1;
G_B3_1 = G_B1_0;
goto IL_0028;
}
IL_0027:
{
G_B3_0 = 0;
G_B3_1 = G_B2_0;
}
IL_0028:
{
G_B3_1->set_isHover_2(G_B3_0);
bool L_3 = ___isActive4;
G_B4_0 = (&V_0);
if (!L_3)
{
G_B5_0 = (&V_0);
goto IL_003c;
}
}
{
G_B6_0 = 1;
G_B6_1 = G_B4_0;
goto IL_003d;
}
IL_003c:
{
G_B6_0 = 0;
G_B6_1 = G_B5_0;
}
IL_003d:
{
G_B6_1->set_isActive_3(G_B6_0);
bool L_4 = ___on5;
G_B7_0 = (&V_0);
if (!L_4)
{
G_B8_0 = (&V_0);
goto IL_0051;
}
}
{
G_B9_0 = 1;
G_B9_1 = G_B7_0;
goto IL_0052;
}
IL_0051:
{
G_B9_0 = 0;
G_B9_1 = G_B8_0;
}
IL_0052:
{
G_B9_1->set_on_4(G_B9_0);
bool L_5 = ___hasKeyboardFocus6;
G_B10_0 = (&V_0);
if (!L_5)
{
G_B11_0 = (&V_0);
goto IL_0066;
}
}
{
G_B12_0 = 1;
G_B12_1 = G_B10_0;
goto IL_0067;
}
IL_0066:
{
G_B12_0 = 0;
G_B12_1 = G_B11_0;
}
IL_0067:
{
G_B12_1->set_hasKeyboardFocus_5(G_B12_0);
GUIContent_t4210063000 * L_6 = ___content2;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_Draw_m694122665(NULL /*static, unused*/, L_6, (&V_0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::Draw(UnityEngine.Rect,System.Boolean,System.Boolean,System.Boolean,System.Boolean)
extern "C" void GUIStyle_Draw_m4006459684 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, bool ___isHover1, bool ___isActive2, bool ___on3, bool ___hasKeyboardFocus4, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Draw_m4006459684_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
Rect_t3681755626 L_1 = ___position0;
IL2CPP_RUNTIME_CLASS_INIT(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent_t4210063000 * L_2 = ((GUIContent_t4210063000_StaticFields*)GUIContent_t4210063000_il2cpp_TypeInfo_var->static_fields)->get_none_6();
bool L_3 = ___isHover1;
bool L_4 = ___isActive2;
bool L_5 = ___on3;
bool L_6 = ___hasKeyboardFocus4;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_Draw_m3610093213(NULL /*static, unused*/, L_0, L_1, L_2, L_3, L_4, L_5, L_6, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::Draw(UnityEngine.Rect,System.String,System.Boolean,System.Boolean,System.Boolean,System.Boolean)
extern "C" void GUIStyle_Draw_m3134455812 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, String_t* ___text1, bool ___isHover2, bool ___isActive3, bool ___on4, bool ___hasKeyboardFocus5, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Draw_m3134455812_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
Rect_t3681755626 L_1 = ___position0;
String_t* L_2 = ___text1;
IL2CPP_RUNTIME_CLASS_INIT(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent_t4210063000 * L_3 = GUIContent_Temp_m1650198655(NULL /*static, unused*/, L_2, /*hidden argument*/NULL);
bool L_4 = ___isHover2;
bool L_5 = ___isActive3;
bool L_6 = ___on4;
bool L_7 = ___hasKeyboardFocus5;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_Draw_m3610093213(NULL /*static, unused*/, L_0, L_1, L_3, L_4, L_5, L_6, L_7, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::Draw(UnityEngine.Rect,UnityEngine.Texture,System.Boolean,System.Boolean,System.Boolean,System.Boolean)
extern "C" void GUIStyle_Draw_m3521010226 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, Texture_t2243626319 * ___image1, bool ___isHover2, bool ___isActive3, bool ___on4, bool ___hasKeyboardFocus5, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Draw_m3521010226_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
Rect_t3681755626 L_1 = ___position0;
Texture_t2243626319 * L_2 = ___image1;
IL2CPP_RUNTIME_CLASS_INIT(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent_t4210063000 * L_3 = GUIContent_Temp_m1937454133(NULL /*static, unused*/, L_2, /*hidden argument*/NULL);
bool L_4 = ___isHover2;
bool L_5 = ___isActive3;
bool L_6 = ___on4;
bool L_7 = ___hasKeyboardFocus5;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_Draw_m3610093213(NULL /*static, unused*/, L_0, L_1, L_3, L_4, L_5, L_6, L_7, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::Draw(UnityEngine.Rect,UnityEngine.GUIContent,System.Boolean,System.Boolean,System.Boolean,System.Boolean)
extern "C" void GUIStyle_Draw_m2284294803 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, GUIContent_t4210063000 * ___content1, bool ___isHover2, bool ___isActive3, bool ___on4, bool ___hasKeyboardFocus5, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Draw_m2284294803_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
Rect_t3681755626 L_1 = ___position0;
GUIContent_t4210063000 * L_2 = ___content1;
bool L_3 = ___isHover2;
bool L_4 = ___isActive3;
bool L_5 = ___on4;
bool L_6 = ___hasKeyboardFocus5;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_Draw_m3610093213(NULL /*static, unused*/, L_0, L_1, L_2, L_3, L_4, L_5, L_6, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::Draw(UnityEngine.Rect,UnityEngine.GUIContent,System.Int32)
extern "C" void GUIStyle_Draw_m2055025106 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, GUIContent_t4210063000 * ___content1, int32_t ___controlID2, const MethodInfo* method)
{
{
Rect_t3681755626 L_0 = ___position0;
GUIContent_t4210063000 * L_1 = ___content1;
int32_t L_2 = ___controlID2;
GUIStyle_Draw_m1435796321(__this, L_0, L_1, L_2, (bool)0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::Draw(UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,System.Boolean)
extern "C" void GUIStyle_Draw_m1435796321 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, GUIContent_t4210063000 * ___content1, int32_t ___controlID2, bool ___on3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Draw_m1435796321_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
GUIContent_t4210063000 * L_0 = ___content1;
if (!L_0)
{
goto IL_001c;
}
}
{
IntPtr_t L_1 = __this->get_m_Ptr_0();
Rect_t3681755626 L_2 = ___position0;
GUIContent_t4210063000 * L_3 = ___content1;
int32_t L_4 = ___controlID2;
bool L_5 = ___on3;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_Draw2_m878252945(NULL /*static, unused*/, L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
goto IL_0026;
}
IL_001c:
{
IL2CPP_RUNTIME_CLASS_INIT(Debug_t1368543263_il2cpp_TypeInfo_var);
Debug_LogError_m3715728798(NULL /*static, unused*/, _stringLiteral3255618103, /*hidden argument*/NULL);
}
IL_0026:
{
return;
}
}
// System.Void UnityEngine.GUIStyle::DrawCursor(UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,System.Int32)
extern "C" void GUIStyle_DrawCursor_m3727336857 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, GUIContent_t4210063000 * ___content1, int32_t ___controlID2, int32_t ___Character3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_DrawCursor_m3727336857_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Event_t3028476042 * V_0 = NULL;
Color_t2020392075 V_1;
memset(&V_1, 0, sizeof(V_1));
float V_2 = 0.0f;
float V_3 = 0.0f;
{
Event_t3028476042 * L_0 = Event_get_current_m2901774193(NULL /*static, unused*/, /*hidden argument*/NULL);
V_0 = L_0;
Event_t3028476042 * L_1 = V_0;
int32_t L_2 = Event_get_type_m2426033198(L_1, /*hidden argument*/NULL);
if ((!(((uint32_t)L_2) == ((uint32_t)7))))
{
goto IL_0088;
}
}
{
Color__ctor_m1909920690((&V_1), (0.0f), (0.0f), (0.0f), (0.0f), /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUISkin_t1436893342 * L_3 = GUI_get_skin_m2309570990(NULL /*static, unused*/, /*hidden argument*/NULL);
GUISettings_t622856320 * L_4 = GUISkin_get_settings_m626844463(L_3, /*hidden argument*/NULL);
float L_5 = GUISettings_get_cursorFlashSpeed_m3722011925(L_4, /*hidden argument*/NULL);
V_2 = L_5;
float L_6 = Time_get_realtimeSinceStartup_m357614587(NULL /*static, unused*/, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
float L_7 = GUIStyle_Internal_GetCursorFlashOffset_m3177259302(NULL /*static, unused*/, /*hidden argument*/NULL);
float L_8 = V_2;
float L_9 = V_2;
V_3 = ((float)((float)(fmodf(((float)((float)L_6-(float)L_7)), L_8))/(float)L_9));
float L_10 = V_2;
if ((((float)L_10) == ((float)(0.0f))))
{
goto IL_0065;
}
}
{
float L_11 = V_3;
if ((!(((float)L_11) < ((float)(0.5f)))))
{
goto IL_0077;
}
}
IL_0065:
{
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUISkin_t1436893342 * L_12 = GUI_get_skin_m2309570990(NULL /*static, unused*/, /*hidden argument*/NULL);
GUISettings_t622856320 * L_13 = GUISkin_get_settings_m626844463(L_12, /*hidden argument*/NULL);
Color_t2020392075 L_14 = GUISettings_get_cursorColor_m3884075294(L_13, /*hidden argument*/NULL);
V_1 = L_14;
}
IL_0077:
{
IntPtr_t L_15 = __this->get_m_Ptr_0();
Rect_t3681755626 L_16 = ___position0;
GUIContent_t4210063000 * L_17 = ___content1;
int32_t L_18 = ___Character3;
Color_t2020392075 L_19 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_DrawCursor_m1394927592(NULL /*static, unused*/, L_15, L_16, L_17, L_18, L_19, /*hidden argument*/NULL);
}
IL_0088:
{
return;
}
}
// System.Void UnityEngine.GUIStyle::DrawWithTextSelection(UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,System.Int32,System.Int32,System.Boolean)
extern "C" void GUIStyle_DrawWithTextSelection_m2215181902 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, GUIContent_t4210063000 * ___content1, int32_t ___controlID2, int32_t ___firstSelectedCharacter3, int32_t ___lastSelectedCharacter4, bool ___drawSelectionAsComposition5, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_DrawWithTextSelection_m2215181902_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Event_t3028476042 * V_0 = NULL;
Color_t2020392075 V_1;
memset(&V_1, 0, sizeof(V_1));
float V_2 = 0.0f;
float V_3 = 0.0f;
Internal_DrawWithTextSelectionArguments_t1327795077 V_4;
memset(&V_4, 0, sizeof(V_4));
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B5_0 = NULL;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B4_0 = NULL;
int32_t G_B6_0 = 0;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B6_1 = NULL;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B8_0 = NULL;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B7_0 = NULL;
int32_t G_B9_0 = 0;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B9_1 = NULL;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B12_0 = NULL;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B10_0 = NULL;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B11_0 = NULL;
int32_t G_B13_0 = 0;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B13_1 = NULL;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B15_0 = NULL;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B14_0 = NULL;
int32_t G_B16_0 = 0;
Internal_DrawWithTextSelectionArguments_t1327795077 * G_B16_1 = NULL;
{
Event_t3028476042 * L_0 = Event_get_current_m2901774193(NULL /*static, unused*/, /*hidden argument*/NULL);
V_0 = L_0;
Color__ctor_m1909920690((&V_1), (0.0f), (0.0f), (0.0f), (0.0f), /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUISkin_t1436893342 * L_1 = GUI_get_skin_m2309570990(NULL /*static, unused*/, /*hidden argument*/NULL);
GUISettings_t622856320 * L_2 = GUISkin_get_settings_m626844463(L_1, /*hidden argument*/NULL);
float L_3 = GUISettings_get_cursorFlashSpeed_m3722011925(L_2, /*hidden argument*/NULL);
V_2 = L_3;
float L_4 = Time_get_realtimeSinceStartup_m357614587(NULL /*static, unused*/, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
float L_5 = GUIStyle_Internal_GetCursorFlashOffset_m3177259302(NULL /*static, unused*/, /*hidden argument*/NULL);
float L_6 = V_2;
float L_7 = V_2;
V_3 = ((float)((float)(fmodf(((float)((float)L_4-(float)L_5)), L_6))/(float)L_7));
float L_8 = V_2;
if ((((float)L_8) == ((float)(0.0f))))
{
goto IL_0058;
}
}
{
float L_9 = V_3;
if ((!(((float)L_9) < ((float)(0.5f)))))
{
goto IL_0068;
}
}
IL_0058:
{
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUISkin_t1436893342 * L_10 = GUI_get_skin_m2309570990(NULL /*static, unused*/, /*hidden argument*/NULL);
GUISettings_t622856320 * L_11 = GUISkin_get_settings_m626844463(L_10, /*hidden argument*/NULL);
Color_t2020392075 L_12 = GUISettings_get_cursorColor_m3884075294(L_11, /*hidden argument*/NULL);
V_1 = L_12;
}
IL_0068:
{
Initobj (Internal_DrawWithTextSelectionArguments_t1327795077_il2cpp_TypeInfo_var, (&V_4));
IntPtr_t L_13 = __this->get_m_Ptr_0();
(&V_4)->set_target_0(L_13);
Rect_t3681755626 L_14 = ___position0;
(&V_4)->set_position_1(L_14);
int32_t L_15 = ___firstSelectedCharacter3;
(&V_4)->set_firstPos_2(L_15);
int32_t L_16 = ___lastSelectedCharacter4;
(&V_4)->set_lastPos_3(L_16);
Color_t2020392075 L_17 = V_1;
(&V_4)->set_cursorColor_4(L_17);
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUISkin_t1436893342 * L_18 = GUI_get_skin_m2309570990(NULL /*static, unused*/, /*hidden argument*/NULL);
GUISettings_t622856320 * L_19 = GUISkin_get_settings_m626844463(L_18, /*hidden argument*/NULL);
Color_t2020392075 L_20 = GUISettings_get_selectionColor_m1824063266(L_19, /*hidden argument*/NULL);
(&V_4)->set_selectionColor_5(L_20);
Event_t3028476042 * L_21 = V_0;
Vector2_t2243707579 L_22 = Event_get_mousePosition_m3789571399(L_21, /*hidden argument*/NULL);
bool L_23 = Rect_Contains_m1334685290((&___position0), L_22, /*hidden argument*/NULL);
G_B4_0 = (&V_4);
if (!L_23)
{
G_B5_0 = (&V_4);
goto IL_00cf;
}
}
{
G_B6_0 = 1;
G_B6_1 = G_B4_0;
goto IL_00d0;
}
IL_00cf:
{
G_B6_0 = 0;
G_B6_1 = G_B5_0;
}
IL_00d0:
{
G_B6_1->set_isHover_6(G_B6_0);
int32_t L_24 = ___controlID2;
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
int32_t L_25 = GUIUtility_get_hotControl_m466901769(NULL /*static, unused*/, /*hidden argument*/NULL);
G_B7_0 = (&V_4);
if ((!(((uint32_t)L_24) == ((uint32_t)L_25))))
{
G_B8_0 = (&V_4);
goto IL_00e8;
}
}
{
G_B9_0 = 1;
G_B9_1 = G_B7_0;
goto IL_00e9;
}
IL_00e8:
{
G_B9_0 = 0;
G_B9_1 = G_B8_0;
}
IL_00e9:
{
G_B9_1->set_isActive_7(G_B9_0);
(&V_4)->set_on_8(0);
int32_t L_26 = ___controlID2;
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
int32_t L_27 = GUIUtility_get_keyboardControl_m2418463643(NULL /*static, unused*/, /*hidden argument*/NULL);
G_B10_0 = (&V_4);
if ((!(((uint32_t)L_26) == ((uint32_t)L_27))))
{
G_B12_0 = (&V_4);
goto IL_0113;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
bool L_28 = ((GUIStyle_t1799908754_StaticFields*)GUIStyle_t1799908754_il2cpp_TypeInfo_var->static_fields)->get_showKeyboardFocus_14();
G_B11_0 = G_B10_0;
if (!L_28)
{
G_B12_0 = G_B10_0;
goto IL_0113;
}
}
{
G_B13_0 = 1;
G_B13_1 = G_B11_0;
goto IL_0114;
}
IL_0113:
{
G_B13_0 = 0;
G_B13_1 = G_B12_0;
}
IL_0114:
{
G_B13_1->set_hasKeyboardFocus_9(G_B13_0);
bool L_29 = ___drawSelectionAsComposition5;
G_B14_0 = (&V_4);
if (!L_29)
{
G_B15_0 = (&V_4);
goto IL_0128;
}
}
{
G_B16_0 = 1;
G_B16_1 = G_B14_0;
goto IL_0129;
}
IL_0128:
{
G_B16_0 = 0;
G_B16_1 = G_B15_0;
}
IL_0129:
{
G_B16_1->set_drawSelectionAsComposition_10(G_B16_0);
GUIContent_t4210063000 * L_30 = ___content1;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_DrawWithTextSelection_m2258778613(NULL /*static, unused*/, L_30, (&V_4), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::DrawWithTextSelection(UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,System.Int32,System.Int32)
extern "C" void GUIStyle_DrawWithTextSelection_m3191662157 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, GUIContent_t4210063000 * ___content1, int32_t ___controlID2, int32_t ___firstSelectedCharacter3, int32_t ___lastSelectedCharacter4, const MethodInfo* method)
{
{
Rect_t3681755626 L_0 = ___position0;
GUIContent_t4210063000 * L_1 = ___content1;
int32_t L_2 = ___controlID2;
int32_t L_3 = ___firstSelectedCharacter3;
int32_t L_4 = ___lastSelectedCharacter4;
GUIStyle_DrawWithTextSelection_m2215181902(__this, L_0, L_1, L_2, L_3, L_4, (bool)0, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.GUIStyle UnityEngine.GUIStyle::op_Implicit(System.String)
extern "C" GUIStyle_t1799908754 * GUIStyle_op_Implicit_m781448948 (Il2CppObject * __this /* static, unused */, String_t* ___str0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_op_Implicit_m781448948_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUIStyle_t1799908754 * V_0 = NULL;
{
GUISkin_t1436893342 * L_0 = ((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->get_current_28();
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_1 = Object_op_Equality_m3764089466(NULL /*static, unused*/, L_0, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0027;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Debug_t1368543263_il2cpp_TypeInfo_var);
Debug_LogError_m3715728798(NULL /*static, unused*/, _stringLiteral763681067, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_2 = GUISkin_get_error_m1687921970(NULL /*static, unused*/, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0038;
}
IL_0027:
{
GUISkin_t1436893342 * L_3 = ((GUISkin_t1436893342_StaticFields*)GUISkin_t1436893342_il2cpp_TypeInfo_var->static_fields)->get_current_28();
String_t* L_4 = ___str0;
GUIStyle_t1799908754 * L_5 = GUISkin_GetStyle_m3594137272(L_3, L_4, /*hidden argument*/NULL);
V_0 = L_5;
goto IL_0038;
}
IL_0038:
{
GUIStyle_t1799908754 * L_6 = V_0;
return L_6;
}
}
// UnityEngine.GUIStyle UnityEngine.GUIStyle::get_none()
extern "C" GUIStyle_t1799908754 * GUIStyle_get_none_m4224270950 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_get_none_m4224270950_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUIStyle_t1799908754 * V_0 = NULL;
{
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_0 = ((GUIStyle_t1799908754_StaticFields*)GUIStyle_t1799908754_il2cpp_TypeInfo_var->static_fields)->get_s_None_15();
if (L_0)
{
goto IL_0015;
}
}
{
GUIStyle_t1799908754 * L_1 = (GUIStyle_t1799908754 *)il2cpp_codegen_object_new(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle__ctor_m3665892801(L_1, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
((GUIStyle_t1799908754_StaticFields*)GUIStyle_t1799908754_il2cpp_TypeInfo_var->static_fields)->set_s_None_15(L_1);
}
IL_0015:
{
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_t1799908754 * L_2 = ((GUIStyle_t1799908754_StaticFields*)GUIStyle_t1799908754_il2cpp_TypeInfo_var->static_fields)->get_s_None_15();
V_0 = L_2;
goto IL_0020;
}
IL_0020:
{
GUIStyle_t1799908754 * L_3 = V_0;
return L_3;
}
}
// UnityEngine.Vector2 UnityEngine.GUIStyle::GetCursorPixelPosition(UnityEngine.Rect,UnityEngine.GUIContent,System.Int32)
extern "C" Vector2_t2243707579 GUIStyle_GetCursorPixelPosition_m2488570694 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, GUIContent_t4210063000 * ___content1, int32_t ___cursorStringIndex2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_GetCursorPixelPosition_m2488570694_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
Rect_t3681755626 L_1 = ___position0;
GUIContent_t4210063000 * L_2 = ___content1;
int32_t L_3 = ___cursorStringIndex2;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_GetCursorPixelPosition_m823797035(NULL /*static, unused*/, L_0, L_1, L_2, L_3, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_4 = V_0;
V_1 = L_4;
goto IL_0018;
}
IL_0018:
{
Vector2_t2243707579 L_5 = V_1;
return L_5;
}
}
// System.Int32 UnityEngine.GUIStyle::GetCursorStringIndex(UnityEngine.Rect,UnityEngine.GUIContent,UnityEngine.Vector2)
extern "C" int32_t GUIStyle_GetCursorStringIndex_m326283516 (GUIStyle_t1799908754 * __this, Rect_t3681755626 ___position0, GUIContent_t4210063000 * ___content1, Vector2_t2243707579 ___cursorPixelPosition2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_GetCursorStringIndex_m326283516_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
Rect_t3681755626 L_1 = ___position0;
GUIContent_t4210063000 * L_2 = ___content1;
Vector2_t2243707579 L_3 = ___cursorPixelPosition2;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
int32_t L_4 = GUIStyle_Internal_GetCursorStringIndex_m1491806746(NULL /*static, unused*/, L_0, L_1, L_2, L_3, /*hidden argument*/NULL);
V_0 = L_4;
goto IL_0015;
}
IL_0015:
{
int32_t L_5 = V_0;
return L_5;
}
}
// System.Int32 UnityEngine.GUIStyle::GetNumCharactersThatFitWithinWidth(System.String,System.Single)
extern "C" int32_t GUIStyle_GetNumCharactersThatFitWithinWidth_m3760066083 (GUIStyle_t1799908754 * __this, String_t* ___text0, float ___width1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_GetNumCharactersThatFitWithinWidth_m3760066083_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
String_t* L_1 = ___text0;
float L_2 = ___width1;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
int32_t L_3 = GUIStyle_Internal_GetNumCharactersThatFitWithinWidth_m2132182605(NULL /*static, unused*/, L_0, L_1, L_2, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_0014;
}
IL_0014:
{
int32_t L_4 = V_0;
return L_4;
}
}
// UnityEngine.Vector2 UnityEngine.GUIStyle::CalcSize(UnityEngine.GUIContent)
extern "C" Vector2_t2243707579 GUIStyle_CalcSize_m4254746879 (GUIStyle_t1799908754 * __this, GUIContent_t4210063000 * ___content0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_CalcSize_m4254746879_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
GUIContent_t4210063000 * L_1 = ___content0;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_CalcSize_m1309259680(NULL /*static, unused*/, L_0, L_1, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_2 = V_0;
V_1 = L_2;
goto IL_0016;
}
IL_0016:
{
Vector2_t2243707579 L_3 = V_1;
return L_3;
}
}
// UnityEngine.Vector2 UnityEngine.GUIStyle::CalcSizeWithConstraints(UnityEngine.GUIContent,UnityEngine.Vector2)
extern "C" Vector2_t2243707579 GUIStyle_CalcSizeWithConstraints_m4117833199 (GUIStyle_t1799908754 * __this, GUIContent_t4210063000 * ___content0, Vector2_t2243707579 ___constraints1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_CalcSizeWithConstraints_m4117833199_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
GUIContent_t4210063000 * L_1 = ___content0;
Vector2_t2243707579 L_2 = ___constraints1;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_CalcSizeWithConstraints_m3375255978(NULL /*static, unused*/, L_0, L_1, L_2, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_3 = V_0;
V_1 = L_3;
goto IL_0017;
}
IL_0017:
{
Vector2_t2243707579 L_4 = V_1;
return L_4;
}
}
// UnityEngine.Vector2 UnityEngine.GUIStyle::CalcScreenSize(UnityEngine.Vector2)
extern "C" Vector2_t2243707579 GUIStyle_CalcScreenSize_m1349129130 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 ___contentSize0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_CalcScreenSize_m1349129130_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
float G_B3_0 = 0.0f;
float G_B5_0 = 0.0f;
float G_B4_0 = 0.0f;
float G_B6_0 = 0.0f;
float G_B6_1 = 0.0f;
{
float L_0 = GUIStyle_get_fixedWidth_m97997484(__this, /*hidden argument*/NULL);
if ((((float)L_0) == ((float)(0.0f))))
{
goto IL_001c;
}
}
{
float L_1 = GUIStyle_get_fixedWidth_m97997484(__this, /*hidden argument*/NULL);
G_B3_0 = L_1;
goto IL_0042;
}
IL_001c:
{
float L_2 = (&___contentSize0)->get_x_0();
RectOffset_t3387826427 * L_3 = GUIStyle_get_padding_m4076916754(__this, /*hidden argument*/NULL);
int32_t L_4 = RectOffset_get_left_m439065308(L_3, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_5 = GUIStyle_get_padding_m4076916754(__this, /*hidden argument*/NULL);
int32_t L_6 = RectOffset_get_right_m281378687(L_5, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_7 = ceilf(((float)((float)((float)((float)L_2+(float)(((float)((float)L_4)))))+(float)(((float)((float)L_6))))));
G_B3_0 = L_7;
}
IL_0042:
{
float L_8 = GUIStyle_get_fixedHeight_m414733479(__this, /*hidden argument*/NULL);
G_B4_0 = G_B3_0;
if ((((float)L_8) == ((float)(0.0f))))
{
G_B5_0 = G_B3_0;
goto IL_005d;
}
}
{
float L_9 = GUIStyle_get_fixedHeight_m414733479(__this, /*hidden argument*/NULL);
G_B6_0 = L_9;
G_B6_1 = G_B4_0;
goto IL_0083;
}
IL_005d:
{
float L_10 = (&___contentSize0)->get_y_1();
RectOffset_t3387826427 * L_11 = GUIStyle_get_padding_m4076916754(__this, /*hidden argument*/NULL);
int32_t L_12 = RectOffset_get_top_m3629049358(L_11, /*hidden argument*/NULL);
RectOffset_t3387826427 * L_13 = GUIStyle_get_padding_m4076916754(__this, /*hidden argument*/NULL);
int32_t L_14 = RectOffset_get_bottom_m4112328858(L_13, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_15 = ceilf(((float)((float)((float)((float)L_10+(float)(((float)((float)L_12)))))+(float)(((float)((float)L_14))))));
G_B6_0 = L_15;
G_B6_1 = G_B5_0;
}
IL_0083:
{
Vector2_t2243707579 L_16;
memset(&L_16, 0, sizeof(L_16));
Vector2__ctor_m3067419446(&L_16, G_B6_1, G_B6_0, /*hidden argument*/NULL);
V_0 = L_16;
goto IL_008e;
}
IL_008e:
{
Vector2_t2243707579 L_17 = V_0;
return L_17;
}
}
// System.Single UnityEngine.GUIStyle::CalcHeight(UnityEngine.GUIContent,System.Single)
extern "C" float GUIStyle_CalcHeight_m1685124037 (GUIStyle_t1799908754 * __this, GUIContent_t4210063000 * ___content0, float ___width1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_CalcHeight_m1685124037_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
GUIContent_t4210063000 * L_1 = ___content0;
float L_2 = ___width1;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
float L_3 = GUIStyle_Internal_CalcHeight_m350880591(NULL /*static, unused*/, L_0, L_1, L_2, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_0014;
}
IL_0014:
{
float L_4 = V_0;
return L_4;
}
}
// System.Boolean UnityEngine.GUIStyle::get_isHeightDependantOnWidth()
extern "C" bool GUIStyle_get_isHeightDependantOnWidth_m1706997031 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
bool V_0 = false;
int32_t G_B4_0 = 0;
int32_t G_B6_0 = 0;
{
float L_0 = GUIStyle_get_fixedHeight_m414733479(__this, /*hidden argument*/NULL);
if ((!(((float)L_0) == ((float)(0.0f)))))
{
goto IL_002d;
}
}
{
bool L_1 = GUIStyle_get_wordWrap_m3655049112(__this, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_002a;
}
}
{
int32_t L_2 = GUIStyle_get_imagePosition_m1104201320(__this, /*hidden argument*/NULL);
G_B4_0 = ((((int32_t)((((int32_t)L_2) == ((int32_t)2))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_002b;
}
IL_002a:
{
G_B4_0 = 0;
}
IL_002b:
{
G_B6_0 = G_B4_0;
goto IL_002e;
}
IL_002d:
{
G_B6_0 = 0;
}
IL_002e:
{
V_0 = (bool)G_B6_0;
goto IL_0034;
}
IL_0034:
{
bool L_3 = V_0;
return L_3;
}
}
// System.Void UnityEngine.GUIStyle::CalcMinMaxWidth(UnityEngine.GUIContent,System.Single&,System.Single&)
extern "C" void GUIStyle_CalcMinMaxWidth_m2027503105 (GUIStyle_t1799908754 * __this, GUIContent_t4210063000 * ___content0, float* ___minWidth1, float* ___maxWidth2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_CalcMinMaxWidth_m2027503105_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IntPtr_t L_0 = __this->get_m_Ptr_0();
GUIContent_t4210063000 * L_1 = ___content0;
float* L_2 = ___minWidth1;
float* L_3 = ___maxWidth2;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_Internal_CalcMinMaxWidth_m3660306863(NULL /*static, unused*/, L_0, L_1, L_2, L_3, /*hidden argument*/NULL);
return;
}
}
// System.String UnityEngine.GUIStyle::ToString()
extern "C" String_t* GUIStyle_ToString_m3046670236 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_ToString_m3046670236_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
ObjectU5BU5D_t3614634134* L_0 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)1));
String_t* L_1 = GUIStyle_get_name_m753291950(__this, /*hidden argument*/NULL);
ArrayElementTypeCheck (L_0, L_1);
(L_0)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)L_1);
String_t* L_2 = UnityString_Format_m2949645127(NULL /*static, unused*/, _stringLiteral232734272, L_0, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0020;
}
IL_0020:
{
String_t* L_3 = V_0;
return L_3;
}
}
// System.Void UnityEngine.GUIStyle::Init()
extern "C" void GUIStyle_Init_m3872198731 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef void (*GUIStyle_Init_m3872198731_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_Init_m3872198731_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_Init_m3872198731_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::Init()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::InitCopy(UnityEngine.GUIStyle)
extern "C" void GUIStyle_InitCopy_m3676786505 (GUIStyle_t1799908754 * __this, GUIStyle_t1799908754 * ___other0, const MethodInfo* method)
{
typedef void (*GUIStyle_InitCopy_m3676786505_ftn) (GUIStyle_t1799908754 *, GUIStyle_t1799908754 *);
static GUIStyle_InitCopy_m3676786505_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_InitCopy_m3676786505_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::InitCopy(UnityEngine.GUIStyle)");
_il2cpp_icall_func(__this, ___other0);
}
// System.Void UnityEngine.GUIStyle::Cleanup()
extern "C" void GUIStyle_Cleanup_m1915255373 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef void (*GUIStyle_Cleanup_m1915255373_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_Cleanup_m1915255373_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_Cleanup_m1915255373_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::Cleanup()");
_il2cpp_icall_func(__this);
}
// System.String UnityEngine.GUIStyle::get_name()
extern "C" String_t* GUIStyle_get_name_m753291950 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef String_t* (*GUIStyle_get_name_m753291950_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_name_m753291950_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_name_m753291950_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_name()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_name(System.String)
extern "C" void GUIStyle_set_name_m1034188361 (GUIStyle_t1799908754 * __this, String_t* ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_name_m1034188361_ftn) (GUIStyle_t1799908754 *, String_t*);
static GUIStyle_set_name_m1034188361_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_name_m1034188361_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_name(System.String)");
_il2cpp_icall_func(__this, ___value0);
}
// System.IntPtr UnityEngine.GUIStyle::GetStyleStatePtr(System.Int32)
extern "C" IntPtr_t GUIStyle_GetStyleStatePtr_m1972527409 (GUIStyle_t1799908754 * __this, int32_t ___idx0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_GetStyleStatePtr_m1972527409_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
IntPtr_t V_0;
memset(&V_0, 0, sizeof(V_0));
IntPtr_t V_1;
memset(&V_1, 0, sizeof(V_1));
{
int32_t L_0 = ___idx0;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_INTERNAL_CALL_GetStyleStatePtr_m976729086(NULL /*static, unused*/, __this, L_0, (&V_0), /*hidden argument*/NULL);
IntPtr_t L_1 = V_0;
V_1 = L_1;
goto IL_0011;
}
IL_0011:
{
IntPtr_t L_2 = V_1;
return L_2;
}
}
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_GetStyleStatePtr(UnityEngine.GUIStyle,System.Int32,System.IntPtr&)
extern "C" void GUIStyle_INTERNAL_CALL_GetStyleStatePtr_m976729086 (Il2CppObject * __this /* static, unused */, GUIStyle_t1799908754 * ___self0, int32_t ___idx1, IntPtr_t* ___value2, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_CALL_GetStyleStatePtr_m976729086_ftn) (GUIStyle_t1799908754 *, int32_t, IntPtr_t*);
static GUIStyle_INTERNAL_CALL_GetStyleStatePtr_m976729086_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_CALL_GetStyleStatePtr_m976729086_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_CALL_GetStyleStatePtr(UnityEngine.GUIStyle,System.Int32,System.IntPtr&)");
_il2cpp_icall_func(___self0, ___idx1, ___value2);
}
// System.Void UnityEngine.GUIStyle::AssignStyleState(System.Int32,System.IntPtr)
extern "C" void GUIStyle_AssignStyleState_m2665274947 (GUIStyle_t1799908754 * __this, int32_t ___idx0, IntPtr_t ___srcStyleState1, const MethodInfo* method)
{
typedef void (*GUIStyle_AssignStyleState_m2665274947_ftn) (GUIStyle_t1799908754 *, int32_t, IntPtr_t);
static GUIStyle_AssignStyleState_m2665274947_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_AssignStyleState_m2665274947_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::AssignStyleState(System.Int32,System.IntPtr)");
_il2cpp_icall_func(__this, ___idx0, ___srcStyleState1);
}
// System.IntPtr UnityEngine.GUIStyle::GetRectOffsetPtr(System.Int32)
extern "C" IntPtr_t GUIStyle_GetRectOffsetPtr_m4223228888 (GUIStyle_t1799908754 * __this, int32_t ___idx0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_GetRectOffsetPtr_m4223228888_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
IntPtr_t V_0;
memset(&V_0, 0, sizeof(V_0));
IntPtr_t V_1;
memset(&V_1, 0, sizeof(V_1));
{
int32_t L_0 = ___idx0;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_INTERNAL_CALL_GetRectOffsetPtr_m1971938403(NULL /*static, unused*/, __this, L_0, (&V_0), /*hidden argument*/NULL);
IntPtr_t L_1 = V_0;
V_1 = L_1;
goto IL_0011;
}
IL_0011:
{
IntPtr_t L_2 = V_1;
return L_2;
}
}
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_GetRectOffsetPtr(UnityEngine.GUIStyle,System.Int32,System.IntPtr&)
extern "C" void GUIStyle_INTERNAL_CALL_GetRectOffsetPtr_m1971938403 (Il2CppObject * __this /* static, unused */, GUIStyle_t1799908754 * ___self0, int32_t ___idx1, IntPtr_t* ___value2, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_CALL_GetRectOffsetPtr_m1971938403_ftn) (GUIStyle_t1799908754 *, int32_t, IntPtr_t*);
static GUIStyle_INTERNAL_CALL_GetRectOffsetPtr_m1971938403_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_CALL_GetRectOffsetPtr_m1971938403_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_CALL_GetRectOffsetPtr(UnityEngine.GUIStyle,System.Int32,System.IntPtr&)");
_il2cpp_icall_func(___self0, ___idx1, ___value2);
}
// System.Void UnityEngine.GUIStyle::AssignRectOffset(System.Int32,System.IntPtr)
extern "C" void GUIStyle_AssignRectOffset_m2998103580 (GUIStyle_t1799908754 * __this, int32_t ___idx0, IntPtr_t ___srcRectOffset1, const MethodInfo* method)
{
typedef void (*GUIStyle_AssignRectOffset_m2998103580_ftn) (GUIStyle_t1799908754 *, int32_t, IntPtr_t);
static GUIStyle_AssignRectOffset_m2998103580_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_AssignRectOffset_m2998103580_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::AssignRectOffset(System.Int32,System.IntPtr)");
_il2cpp_icall_func(__this, ___idx0, ___srcRectOffset1);
}
// UnityEngine.ImagePosition UnityEngine.GUIStyle::get_imagePosition()
extern "C" int32_t GUIStyle_get_imagePosition_m1104201320 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef int32_t (*GUIStyle_get_imagePosition_m1104201320_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_imagePosition_m1104201320_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_imagePosition_m1104201320_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_imagePosition()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_imagePosition(UnityEngine.ImagePosition)
extern "C" void GUIStyle_set_imagePosition_m327170707 (GUIStyle_t1799908754 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_imagePosition_m327170707_ftn) (GUIStyle_t1799908754 *, int32_t);
static GUIStyle_set_imagePosition_m327170707_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_imagePosition_m327170707_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_imagePosition(UnityEngine.ImagePosition)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.TextAnchor UnityEngine.GUIStyle::get_alignment()
extern "C" int32_t GUIStyle_get_alignment_m3513439031 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef int32_t (*GUIStyle_get_alignment_m3513439031_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_alignment_m3513439031_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_alignment_m3513439031_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_alignment()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_alignment(UnityEngine.TextAnchor)
extern "C" void GUIStyle_set_alignment_m1024943876 (GUIStyle_t1799908754 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_alignment_m1024943876_ftn) (GUIStyle_t1799908754 *, int32_t);
static GUIStyle_set_alignment_m1024943876_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_alignment_m1024943876_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_alignment(UnityEngine.TextAnchor)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Boolean UnityEngine.GUIStyle::get_wordWrap()
extern "C" bool GUIStyle_get_wordWrap_m3655049112 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef bool (*GUIStyle_get_wordWrap_m3655049112_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_wordWrap_m3655049112_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_wordWrap_m3655049112_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_wordWrap()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_wordWrap(System.Boolean)
extern "C" void GUIStyle_set_wordWrap_m2043927261 (GUIStyle_t1799908754 * __this, bool ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_wordWrap_m2043927261_ftn) (GUIStyle_t1799908754 *, bool);
static GUIStyle_set_wordWrap_m2043927261_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_wordWrap_m2043927261_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_wordWrap(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.TextClipping UnityEngine.GUIStyle::get_clipping()
extern "C" int32_t GUIStyle_get_clipping_m2754700641 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef int32_t (*GUIStyle_get_clipping_m2754700641_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_clipping_m2754700641_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_clipping_m2754700641_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_clipping()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_clipping(UnityEngine.TextClipping)
extern "C" void GUIStyle_set_clipping_m2858420820 (GUIStyle_t1799908754 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_clipping_m2858420820_ftn) (GUIStyle_t1799908754 *, int32_t);
static GUIStyle_set_clipping_m2858420820_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_clipping_m2858420820_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_clipping(UnityEngine.TextClipping)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Vector2 UnityEngine.GUIStyle::get_contentOffset()
extern "C" Vector2_t2243707579 GUIStyle_get_contentOffset_m1904924583 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
GUIStyle_INTERNAL_get_contentOffset_m2667265678(__this, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_0 = V_0;
V_1 = L_0;
goto IL_0010;
}
IL_0010:
{
Vector2_t2243707579 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.GUIStyle::set_contentOffset(UnityEngine.Vector2)
extern "C" void GUIStyle_set_contentOffset_m2138084868 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
{
GUIStyle_INTERNAL_set_contentOffset_m1314037746(__this, (&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::INTERNAL_get_contentOffset(UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_get_contentOffset_m2667265678 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_get_contentOffset_m2667265678_ftn) (GUIStyle_t1799908754 *, Vector2_t2243707579 *);
static GUIStyle_INTERNAL_get_contentOffset_m2667265678_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_get_contentOffset_m2667265678_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_get_contentOffset(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.GUIStyle::INTERNAL_set_contentOffset(UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_set_contentOffset_m1314037746 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_set_contentOffset_m1314037746_ftn) (GUIStyle_t1799908754 *, Vector2_t2243707579 *);
static GUIStyle_INTERNAL_set_contentOffset_m1314037746_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_set_contentOffset_m1314037746_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_set_contentOffset(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Vector2 UnityEngine.GUIStyle::get_Internal_clipOffset()
extern "C" Vector2_t2243707579 GUIStyle_get_Internal_clipOffset_m4237737448 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
GUIStyle_INTERNAL_get_Internal_clipOffset_m3336627565(__this, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_0 = V_0;
V_1 = L_0;
goto IL_0010;
}
IL_0010:
{
Vector2_t2243707579 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.GUIStyle::set_Internal_clipOffset(UnityEngine.Vector2)
extern "C" void GUIStyle_set_Internal_clipOffset_m118330819 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
{
GUIStyle_INTERNAL_set_Internal_clipOffset_m2024478897(__this, (&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::INTERNAL_get_Internal_clipOffset(UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_get_Internal_clipOffset_m3336627565 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_get_Internal_clipOffset_m3336627565_ftn) (GUIStyle_t1799908754 *, Vector2_t2243707579 *);
static GUIStyle_INTERNAL_get_Internal_clipOffset_m3336627565_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_get_Internal_clipOffset_m3336627565_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_get_Internal_clipOffset(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.GUIStyle::INTERNAL_set_Internal_clipOffset(UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_set_Internal_clipOffset_m2024478897 (GUIStyle_t1799908754 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_set_Internal_clipOffset_m2024478897_ftn) (GUIStyle_t1799908754 *, Vector2_t2243707579 *);
static GUIStyle_INTERNAL_set_Internal_clipOffset_m2024478897_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_set_Internal_clipOffset_m2024478897_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_set_Internal_clipOffset(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Single UnityEngine.GUIStyle::get_fixedWidth()
extern "C" float GUIStyle_get_fixedWidth_m97997484 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef float (*GUIStyle_get_fixedWidth_m97997484_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_fixedWidth_m97997484_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_fixedWidth_m97997484_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_fixedWidth()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_fixedWidth(System.Single)
extern "C" void GUIStyle_set_fixedWidth_m2562018757 (GUIStyle_t1799908754 * __this, float ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_fixedWidth_m2562018757_ftn) (GUIStyle_t1799908754 *, float);
static GUIStyle_set_fixedWidth_m2562018757_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_fixedWidth_m2562018757_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_fixedWidth(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Single UnityEngine.GUIStyle::get_fixedHeight()
extern "C" float GUIStyle_get_fixedHeight_m414733479 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef float (*GUIStyle_get_fixedHeight_m414733479_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_fixedHeight_m414733479_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_fixedHeight_m414733479_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_fixedHeight()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_fixedHeight(System.Single)
extern "C" void GUIStyle_set_fixedHeight_m1517737608 (GUIStyle_t1799908754 * __this, float ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_fixedHeight_m1517737608_ftn) (GUIStyle_t1799908754 *, float);
static GUIStyle_set_fixedHeight_m1517737608_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_fixedHeight_m1517737608_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_fixedHeight(System.Single)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Boolean UnityEngine.GUIStyle::get_stretchWidth()
extern "C" bool GUIStyle_get_stretchWidth_m1223411161 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef bool (*GUIStyle_get_stretchWidth_m1223411161_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_stretchWidth_m1223411161_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_stretchWidth_m1223411161_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_stretchWidth()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_stretchWidth(System.Boolean)
extern "C" void GUIStyle_set_stretchWidth_m1198647818 (GUIStyle_t1799908754 * __this, bool ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_stretchWidth_m1198647818_ftn) (GUIStyle_t1799908754 *, bool);
static GUIStyle_set_stretchWidth_m1198647818_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_stretchWidth_m1198647818_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_stretchWidth(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Boolean UnityEngine.GUIStyle::get_stretchHeight()
extern "C" bool GUIStyle_get_stretchHeight_m3396762700 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef bool (*GUIStyle_get_stretchHeight_m3396762700_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_stretchHeight_m3396762700_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_stretchHeight_m3396762700_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_stretchHeight()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_stretchHeight(System.Boolean)
extern "C" void GUIStyle_set_stretchHeight_m421727883 (GUIStyle_t1799908754 * __this, bool ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_stretchHeight_m421727883_ftn) (GUIStyle_t1799908754 *, bool);
static GUIStyle_set_stretchHeight_m421727883_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_stretchHeight_m421727883_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_stretchHeight(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Single UnityEngine.GUIStyle::Internal_GetLineHeight(System.IntPtr)
extern "C" float GUIStyle_Internal_GetLineHeight_m2503294326 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, const MethodInfo* method)
{
typedef float (*GUIStyle_Internal_GetLineHeight_m2503294326_ftn) (IntPtr_t);
static GUIStyle_Internal_GetLineHeight_m2503294326_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_Internal_GetLineHeight_m2503294326_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::Internal_GetLineHeight(System.IntPtr)");
return _il2cpp_icall_func(___target0);
}
// System.Void UnityEngine.GUIStyle::SetFontInternal(UnityEngine.Font)
extern "C" void GUIStyle_SetFontInternal_m4135062999 (GUIStyle_t1799908754 * __this, Font_t4239498691 * ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_SetFontInternal_m4135062999_ftn) (GUIStyle_t1799908754 *, Font_t4239498691 *);
static GUIStyle_SetFontInternal_m4135062999_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_SetFontInternal_m4135062999_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::SetFontInternal(UnityEngine.Font)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Font UnityEngine.GUIStyle::GetFontInternalDuringLoadingThread()
extern "C" Font_t4239498691 * GUIStyle_GetFontInternalDuringLoadingThread_m229734483 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef Font_t4239498691 * (*GUIStyle_GetFontInternalDuringLoadingThread_m229734483_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_GetFontInternalDuringLoadingThread_m229734483_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_GetFontInternalDuringLoadingThread_m229734483_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::GetFontInternalDuringLoadingThread()");
return _il2cpp_icall_func(__this);
}
// UnityEngine.Font UnityEngine.GUIStyle::GetFontInternal()
extern "C" Font_t4239498691 * GUIStyle_GetFontInternal_m3509743324 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef Font_t4239498691 * (*GUIStyle_GetFontInternal_m3509743324_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_GetFontInternal_m3509743324_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_GetFontInternal_m3509743324_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::GetFontInternal()");
return _il2cpp_icall_func(__this);
}
// System.Int32 UnityEngine.GUIStyle::get_fontSize()
extern "C" int32_t GUIStyle_get_fontSize_m3568562864 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef int32_t (*GUIStyle_get_fontSize_m3568562864_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_fontSize_m3568562864_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_fontSize_m3568562864_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_fontSize()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_fontSize(System.Int32)
extern "C" void GUIStyle_set_fontSize_m4015341543 (GUIStyle_t1799908754 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_fontSize_m4015341543_ftn) (GUIStyle_t1799908754 *, int32_t);
static GUIStyle_set_fontSize_m4015341543_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_fontSize_m4015341543_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_fontSize(System.Int32)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.FontStyle UnityEngine.GUIStyle::get_fontStyle()
extern "C" int32_t GUIStyle_get_fontStyle_m3124364840 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef int32_t (*GUIStyle_get_fontStyle_m3124364840_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_fontStyle_m3124364840_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_fontStyle_m3124364840_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_fontStyle()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_fontStyle(UnityEngine.FontStyle)
extern "C" void GUIStyle_set_fontStyle_m3960530579 (GUIStyle_t1799908754 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_fontStyle_m3960530579_ftn) (GUIStyle_t1799908754 *, int32_t);
static GUIStyle_set_fontStyle_m3960530579_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_fontStyle_m3960530579_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_fontStyle(UnityEngine.FontStyle)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Boolean UnityEngine.GUIStyle::get_richText()
extern "C" bool GUIStyle_get_richText_m1518013201 (GUIStyle_t1799908754 * __this, const MethodInfo* method)
{
typedef bool (*GUIStyle_get_richText_m1518013201_ftn) (GUIStyle_t1799908754 *);
static GUIStyle_get_richText_m1518013201_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_get_richText_m1518013201_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::get_richText()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyle::set_richText(System.Boolean)
extern "C" void GUIStyle_set_richText_m1853532836 (GUIStyle_t1799908754 * __this, bool ___value0, const MethodInfo* method)
{
typedef void (*GUIStyle_set_richText_m1853532836_ftn) (GUIStyle_t1799908754 *, bool);
static GUIStyle_set_richText_m1853532836_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_set_richText_m1853532836_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::set_richText(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.GUIStyle::Internal_Draw(UnityEngine.GUIContent,UnityEngine.Internal_DrawArguments&)
extern "C" void GUIStyle_Internal_Draw_m694122665 (Il2CppObject * __this /* static, unused */, GUIContent_t4210063000 * ___content0, Internal_DrawArguments_t2834709342 * ___arguments1, const MethodInfo* method)
{
typedef void (*GUIStyle_Internal_Draw_m694122665_ftn) (GUIContent_t4210063000 *, Internal_DrawArguments_t2834709342 *);
static GUIStyle_Internal_Draw_m694122665_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_Internal_Draw_m694122665_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::Internal_Draw(UnityEngine.GUIContent,UnityEngine.Internal_DrawArguments&)");
_il2cpp_icall_func(___content0, ___arguments1);
}
// System.Void UnityEngine.GUIStyle::Internal_Draw2(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,System.Boolean)
extern "C" void GUIStyle_Internal_Draw2_m878252945 (Il2CppObject * __this /* static, unused */, IntPtr_t ___style0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, int32_t ___controlID3, bool ___on4, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Internal_Draw2_m878252945_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IntPtr_t L_0 = ___style0;
GUIContent_t4210063000 * L_1 = ___content2;
int32_t L_2 = ___controlID3;
bool L_3 = ___on4;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_INTERNAL_CALL_Internal_Draw2_m2973483786(NULL /*static, unused*/, L_0, (&___position1), L_1, L_2, L_3, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_Internal_Draw2(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,System.Boolean)
extern "C" void GUIStyle_INTERNAL_CALL_Internal_Draw2_m2973483786 (Il2CppObject * __this /* static, unused */, IntPtr_t ___style0, Rect_t3681755626 * ___position1, GUIContent_t4210063000 * ___content2, int32_t ___controlID3, bool ___on4, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_CALL_Internal_Draw2_m2973483786_ftn) (IntPtr_t, Rect_t3681755626 *, GUIContent_t4210063000 *, int32_t, bool);
static GUIStyle_INTERNAL_CALL_Internal_Draw2_m2973483786_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_CALL_Internal_Draw2_m2973483786_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_CALL_Internal_Draw2(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,System.Boolean)");
_il2cpp_icall_func(___style0, ___position1, ___content2, ___controlID3, ___on4);
}
// System.Void UnityEngine.GUIStyle::SetMouseTooltip(System.String,UnityEngine.Rect)
extern "C" void GUIStyle_SetMouseTooltip_m2239589192 (GUIStyle_t1799908754 * __this, String_t* ___tooltip0, Rect_t3681755626 ___screenRect1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_SetMouseTooltip_m2239589192_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = ___tooltip0;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_INTERNAL_CALL_SetMouseTooltip_m1802284884(NULL /*static, unused*/, __this, L_0, (&___screenRect1), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_SetMouseTooltip(UnityEngine.GUIStyle,System.String,UnityEngine.Rect&)
extern "C" void GUIStyle_INTERNAL_CALL_SetMouseTooltip_m1802284884 (Il2CppObject * __this /* static, unused */, GUIStyle_t1799908754 * ___self0, String_t* ___tooltip1, Rect_t3681755626 * ___screenRect2, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_CALL_SetMouseTooltip_m1802284884_ftn) (GUIStyle_t1799908754 *, String_t*, Rect_t3681755626 *);
static GUIStyle_INTERNAL_CALL_SetMouseTooltip_m1802284884_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_CALL_SetMouseTooltip_m1802284884_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_CALL_SetMouseTooltip(UnityEngine.GUIStyle,System.String,UnityEngine.Rect&)");
_il2cpp_icall_func(___self0, ___tooltip1, ___screenRect2);
}
// System.Void UnityEngine.GUIStyle::Internal_DrawPrefixLabel(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,System.Boolean)
extern "C" void GUIStyle_Internal_DrawPrefixLabel_m1693575069 (Il2CppObject * __this /* static, unused */, IntPtr_t ___style0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, int32_t ___controlID3, bool ___on4, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Internal_DrawPrefixLabel_m1693575069_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IntPtr_t L_0 = ___style0;
GUIContent_t4210063000 * L_1 = ___content2;
int32_t L_2 = ___controlID3;
bool L_3 = ___on4;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_INTERNAL_CALL_Internal_DrawPrefixLabel_m557487542(NULL /*static, unused*/, L_0, (&___position1), L_1, L_2, L_3, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_Internal_DrawPrefixLabel(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,System.Boolean)
extern "C" void GUIStyle_INTERNAL_CALL_Internal_DrawPrefixLabel_m557487542 (Il2CppObject * __this /* static, unused */, IntPtr_t ___style0, Rect_t3681755626 * ___position1, GUIContent_t4210063000 * ___content2, int32_t ___controlID3, bool ___on4, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_CALL_Internal_DrawPrefixLabel_m557487542_ftn) (IntPtr_t, Rect_t3681755626 *, GUIContent_t4210063000 *, int32_t, bool);
static GUIStyle_INTERNAL_CALL_Internal_DrawPrefixLabel_m557487542_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_CALL_Internal_DrawPrefixLabel_m557487542_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_CALL_Internal_DrawPrefixLabel(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,System.Boolean)");
_il2cpp_icall_func(___style0, ___position1, ___content2, ___controlID3, ___on4);
}
// System.Single UnityEngine.GUIStyle::Internal_GetCursorFlashOffset()
extern "C" float GUIStyle_Internal_GetCursorFlashOffset_m3177259302 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef float (*GUIStyle_Internal_GetCursorFlashOffset_m3177259302_ftn) ();
static GUIStyle_Internal_GetCursorFlashOffset_m3177259302_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_Internal_GetCursorFlashOffset_m3177259302_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::Internal_GetCursorFlashOffset()");
return _il2cpp_icall_func();
}
// System.Void UnityEngine.GUIStyle::Internal_DrawCursor(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,UnityEngine.Color)
extern "C" void GUIStyle_Internal_DrawCursor_m1394927592 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, int32_t ___pos3, Color_t2020392075 ___cursorColor4, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Internal_DrawCursor_m1394927592_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IntPtr_t L_0 = ___target0;
GUIContent_t4210063000 * L_1 = ___content2;
int32_t L_2 = ___pos3;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_INTERNAL_CALL_Internal_DrawCursor_m512401185(NULL /*static, unused*/, L_0, (&___position1), L_1, L_2, (&___cursorColor4), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_Internal_DrawCursor(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,UnityEngine.Color&)
extern "C" void GUIStyle_INTERNAL_CALL_Internal_DrawCursor_m512401185 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 * ___position1, GUIContent_t4210063000 * ___content2, int32_t ___pos3, Color_t2020392075 * ___cursorColor4, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_CALL_Internal_DrawCursor_m512401185_ftn) (IntPtr_t, Rect_t3681755626 *, GUIContent_t4210063000 *, int32_t, Color_t2020392075 *);
static GUIStyle_INTERNAL_CALL_Internal_DrawCursor_m512401185_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_CALL_Internal_DrawCursor_m512401185_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_CALL_Internal_DrawCursor(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,UnityEngine.Color&)");
_il2cpp_icall_func(___target0, ___position1, ___content2, ___pos3, ___cursorColor4);
}
// System.Void UnityEngine.GUIStyle::Internal_DrawWithTextSelection(UnityEngine.GUIContent,UnityEngine.Internal_DrawWithTextSelectionArguments&)
extern "C" void GUIStyle_Internal_DrawWithTextSelection_m2258778613 (Il2CppObject * __this /* static, unused */, GUIContent_t4210063000 * ___content0, Internal_DrawWithTextSelectionArguments_t1327795077 * ___arguments1, const MethodInfo* method)
{
typedef void (*GUIStyle_Internal_DrawWithTextSelection_m2258778613_ftn) (GUIContent_t4210063000 *, Internal_DrawWithTextSelectionArguments_t1327795077 *);
static GUIStyle_Internal_DrawWithTextSelection_m2258778613_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_Internal_DrawWithTextSelection_m2258778613_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::Internal_DrawWithTextSelection(UnityEngine.GUIContent,UnityEngine.Internal_DrawWithTextSelectionArguments&)");
_il2cpp_icall_func(___content0, ___arguments1);
}
// System.Void UnityEngine.GUIStyle::SetDefaultFont(UnityEngine.Font)
extern "C" void GUIStyle_SetDefaultFont_m2095841351 (Il2CppObject * __this /* static, unused */, Font_t4239498691 * ___font0, const MethodInfo* method)
{
typedef void (*GUIStyle_SetDefaultFont_m2095841351_ftn) (Font_t4239498691 *);
static GUIStyle_SetDefaultFont_m2095841351_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_SetDefaultFont_m2095841351_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::SetDefaultFont(UnityEngine.Font)");
_il2cpp_icall_func(___font0);
}
// System.Void UnityEngine.GUIStyle::Internal_GetCursorPixelPosition(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,System.Int32,UnityEngine.Vector2&)
extern "C" void GUIStyle_Internal_GetCursorPixelPosition_m823797035 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, int32_t ___cursorStringIndex3, Vector2_t2243707579 * ___ret4, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Internal_GetCursorPixelPosition_m823797035_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IntPtr_t L_0 = ___target0;
GUIContent_t4210063000 * L_1 = ___content2;
int32_t L_2 = ___cursorStringIndex3;
Vector2_t2243707579 * L_3 = ___ret4;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_INTERNAL_CALL_Internal_GetCursorPixelPosition_m562482816(NULL /*static, unused*/, L_0, (&___position1), L_1, L_2, L_3, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_Internal_GetCursorPixelPosition(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_CALL_Internal_GetCursorPixelPosition_m562482816 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 * ___position1, GUIContent_t4210063000 * ___content2, int32_t ___cursorStringIndex3, Vector2_t2243707579 * ___ret4, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_CALL_Internal_GetCursorPixelPosition_m562482816_ftn) (IntPtr_t, Rect_t3681755626 *, GUIContent_t4210063000 *, int32_t, Vector2_t2243707579 *);
static GUIStyle_INTERNAL_CALL_Internal_GetCursorPixelPosition_m562482816_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_CALL_Internal_GetCursorPixelPosition_m562482816_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_CALL_Internal_GetCursorPixelPosition(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,System.Int32,UnityEngine.Vector2&)");
_il2cpp_icall_func(___target0, ___position1, ___content2, ___cursorStringIndex3, ___ret4);
}
// System.Int32 UnityEngine.GUIStyle::Internal_GetCursorStringIndex(System.IntPtr,UnityEngine.Rect,UnityEngine.GUIContent,UnityEngine.Vector2)
extern "C" int32_t GUIStyle_Internal_GetCursorStringIndex_m1491806746 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 ___position1, GUIContent_t4210063000 * ___content2, Vector2_t2243707579 ___cursorPixelPosition3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Internal_GetCursorStringIndex_m1491806746_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
IntPtr_t L_0 = ___target0;
GUIContent_t4210063000 * L_1 = ___content2;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
int32_t L_2 = GUIStyle_INTERNAL_CALL_Internal_GetCursorStringIndex_m3074318281(NULL /*static, unused*/, L_0, (&___position1), L_1, (&___cursorPixelPosition3), /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0012;
}
IL_0012:
{
int32_t L_3 = V_0;
return L_3;
}
}
// System.Int32 UnityEngine.GUIStyle::INTERNAL_CALL_Internal_GetCursorStringIndex(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,UnityEngine.Vector2&)
extern "C" int32_t GUIStyle_INTERNAL_CALL_Internal_GetCursorStringIndex_m3074318281 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, Rect_t3681755626 * ___position1, GUIContent_t4210063000 * ___content2, Vector2_t2243707579 * ___cursorPixelPosition3, const MethodInfo* method)
{
typedef int32_t (*GUIStyle_INTERNAL_CALL_Internal_GetCursorStringIndex_m3074318281_ftn) (IntPtr_t, Rect_t3681755626 *, GUIContent_t4210063000 *, Vector2_t2243707579 *);
static GUIStyle_INTERNAL_CALL_Internal_GetCursorStringIndex_m3074318281_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_CALL_Internal_GetCursorStringIndex_m3074318281_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_CALL_Internal_GetCursorStringIndex(System.IntPtr,UnityEngine.Rect&,UnityEngine.GUIContent,UnityEngine.Vector2&)");
return _il2cpp_icall_func(___target0, ___position1, ___content2, ___cursorPixelPosition3);
}
// System.Int32 UnityEngine.GUIStyle::Internal_GetNumCharactersThatFitWithinWidth(System.IntPtr,System.String,System.Single)
extern "C" int32_t GUIStyle_Internal_GetNumCharactersThatFitWithinWidth_m2132182605 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, String_t* ___text1, float ___width2, const MethodInfo* method)
{
typedef int32_t (*GUIStyle_Internal_GetNumCharactersThatFitWithinWidth_m2132182605_ftn) (IntPtr_t, String_t*, float);
static GUIStyle_Internal_GetNumCharactersThatFitWithinWidth_m2132182605_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_Internal_GetNumCharactersThatFitWithinWidth_m2132182605_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::Internal_GetNumCharactersThatFitWithinWidth(System.IntPtr,System.String,System.Single)");
return _il2cpp_icall_func(___target0, ___text1, ___width2);
}
// System.Void UnityEngine.GUIStyle::Internal_CalcSize(System.IntPtr,UnityEngine.GUIContent,UnityEngine.Vector2&)
extern "C" void GUIStyle_Internal_CalcSize_m1309259680 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, GUIContent_t4210063000 * ___content1, Vector2_t2243707579 * ___ret2, const MethodInfo* method)
{
typedef void (*GUIStyle_Internal_CalcSize_m1309259680_ftn) (IntPtr_t, GUIContent_t4210063000 *, Vector2_t2243707579 *);
static GUIStyle_Internal_CalcSize_m1309259680_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_Internal_CalcSize_m1309259680_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::Internal_CalcSize(System.IntPtr,UnityEngine.GUIContent,UnityEngine.Vector2&)");
_il2cpp_icall_func(___target0, ___content1, ___ret2);
}
// System.Void UnityEngine.GUIStyle::Internal_CalcSizeWithConstraints(System.IntPtr,UnityEngine.GUIContent,UnityEngine.Vector2,UnityEngine.Vector2&)
extern "C" void GUIStyle_Internal_CalcSizeWithConstraints_m3375255978 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, GUIContent_t4210063000 * ___content1, Vector2_t2243707579 ___maxSize2, Vector2_t2243707579 * ___ret3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle_Internal_CalcSizeWithConstraints_m3375255978_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IntPtr_t L_0 = ___target0;
GUIContent_t4210063000 * L_1 = ___content1;
Vector2_t2243707579 * L_2 = ___ret3;
IL2CPP_RUNTIME_CLASS_INIT(GUIStyle_t1799908754_il2cpp_TypeInfo_var);
GUIStyle_INTERNAL_CALL_Internal_CalcSizeWithConstraints_m1203344891(NULL /*static, unused*/, L_0, L_1, (&___maxSize2), L_2, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyle::INTERNAL_CALL_Internal_CalcSizeWithConstraints(System.IntPtr,UnityEngine.GUIContent,UnityEngine.Vector2&,UnityEngine.Vector2&)
extern "C" void GUIStyle_INTERNAL_CALL_Internal_CalcSizeWithConstraints_m1203344891 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, GUIContent_t4210063000 * ___content1, Vector2_t2243707579 * ___maxSize2, Vector2_t2243707579 * ___ret3, const MethodInfo* method)
{
typedef void (*GUIStyle_INTERNAL_CALL_Internal_CalcSizeWithConstraints_m1203344891_ftn) (IntPtr_t, GUIContent_t4210063000 *, Vector2_t2243707579 *, Vector2_t2243707579 *);
static GUIStyle_INTERNAL_CALL_Internal_CalcSizeWithConstraints_m1203344891_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_INTERNAL_CALL_Internal_CalcSizeWithConstraints_m1203344891_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::INTERNAL_CALL_Internal_CalcSizeWithConstraints(System.IntPtr,UnityEngine.GUIContent,UnityEngine.Vector2&,UnityEngine.Vector2&)");
_il2cpp_icall_func(___target0, ___content1, ___maxSize2, ___ret3);
}
// System.Single UnityEngine.GUIStyle::Internal_CalcHeight(System.IntPtr,UnityEngine.GUIContent,System.Single)
extern "C" float GUIStyle_Internal_CalcHeight_m350880591 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, GUIContent_t4210063000 * ___content1, float ___width2, const MethodInfo* method)
{
typedef float (*GUIStyle_Internal_CalcHeight_m350880591_ftn) (IntPtr_t, GUIContent_t4210063000 *, float);
static GUIStyle_Internal_CalcHeight_m350880591_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_Internal_CalcHeight_m350880591_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::Internal_CalcHeight(System.IntPtr,UnityEngine.GUIContent,System.Single)");
return _il2cpp_icall_func(___target0, ___content1, ___width2);
}
// System.Void UnityEngine.GUIStyle::Internal_CalcMinMaxWidth(System.IntPtr,UnityEngine.GUIContent,System.Single&,System.Single&)
extern "C" void GUIStyle_Internal_CalcMinMaxWidth_m3660306863 (Il2CppObject * __this /* static, unused */, IntPtr_t ___target0, GUIContent_t4210063000 * ___content1, float* ___minWidth2, float* ___maxWidth3, const MethodInfo* method)
{
typedef void (*GUIStyle_Internal_CalcMinMaxWidth_m3660306863_ftn) (IntPtr_t, GUIContent_t4210063000 *, float*, float*);
static GUIStyle_Internal_CalcMinMaxWidth_m3660306863_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyle_Internal_CalcMinMaxWidth_m3660306863_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyle::Internal_CalcMinMaxWidth(System.IntPtr,UnityEngine.GUIContent,System.Single&,System.Single&)");
_il2cpp_icall_func(___target0, ___content1, ___minWidth2, ___maxWidth3);
}
// System.Void UnityEngine.GUIStyle::.cctor()
extern "C" void GUIStyle__cctor_m1781956100 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyle__cctor_m1781956100_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
((GUIStyle_t1799908754_StaticFields*)GUIStyle_t1799908754_il2cpp_TypeInfo_var->static_fields)->set_showKeyboardFocus_14((bool)1);
return;
}
}
// Conversion methods for marshalling of: UnityEngine.GUIStyleState
extern "C" void GUIStyleState_t3801000545_marshal_pinvoke(const GUIStyleState_t3801000545& unmarshaled, GUIStyleState_t3801000545_marshaled_pinvoke& marshaled)
{
Il2CppCodeGenException* ___m_SourceStyle_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_SourceStyle' of type 'GUIStyleState': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_SourceStyle_1Exception);
}
extern "C" void GUIStyleState_t3801000545_marshal_pinvoke_back(const GUIStyleState_t3801000545_marshaled_pinvoke& marshaled, GUIStyleState_t3801000545& unmarshaled)
{
Il2CppCodeGenException* ___m_SourceStyle_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_SourceStyle' of type 'GUIStyleState': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_SourceStyle_1Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.GUIStyleState
extern "C" void GUIStyleState_t3801000545_marshal_pinvoke_cleanup(GUIStyleState_t3801000545_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.GUIStyleState
extern "C" void GUIStyleState_t3801000545_marshal_com(const GUIStyleState_t3801000545& unmarshaled, GUIStyleState_t3801000545_marshaled_com& marshaled)
{
Il2CppCodeGenException* ___m_SourceStyle_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_SourceStyle' of type 'GUIStyleState': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_SourceStyle_1Exception);
}
extern "C" void GUIStyleState_t3801000545_marshal_com_back(const GUIStyleState_t3801000545_marshaled_com& marshaled, GUIStyleState_t3801000545& unmarshaled)
{
Il2CppCodeGenException* ___m_SourceStyle_1Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_SourceStyle' of type 'GUIStyleState': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_SourceStyle_1Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.GUIStyleState
extern "C" void GUIStyleState_t3801000545_marshal_com_cleanup(GUIStyleState_t3801000545_marshaled_com& marshaled)
{
}
// System.Void UnityEngine.GUIStyleState::.ctor()
extern "C" void GUIStyleState__ctor_m3611888666 (GUIStyleState_t3801000545 * __this, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
GUIStyleState_Init_m2434147050(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyleState::.ctor(UnityEngine.GUIStyle,System.IntPtr)
extern "C" void GUIStyleState__ctor_m2708667747 (GUIStyleState_t3801000545 * __this, GUIStyle_t1799908754 * ___sourceStyle0, IntPtr_t ___source1, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
GUIStyle_t1799908754 * L_0 = ___sourceStyle0;
__this->set_m_SourceStyle_1(L_0);
IntPtr_t L_1 = ___source1;
__this->set_m_Ptr_0(L_1);
return;
}
}
// UnityEngine.GUIStyleState UnityEngine.GUIStyleState::ProduceGUIStyleStateFromDeserialization(UnityEngine.GUIStyle,System.IntPtr)
extern "C" GUIStyleState_t3801000545 * GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976 (Il2CppObject * __this /* static, unused */, GUIStyle_t1799908754 * ___sourceStyle0, IntPtr_t ___source1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyleState_ProduceGUIStyleStateFromDeserialization_m1887139976_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUIStyleState_t3801000545 * V_0 = NULL;
GUIStyleState_t3801000545 * V_1 = NULL;
{
GUIStyle_t1799908754 * L_0 = ___sourceStyle0;
IntPtr_t L_1 = ___source1;
GUIStyleState_t3801000545 * L_2 = (GUIStyleState_t3801000545 *)il2cpp_codegen_object_new(GUIStyleState_t3801000545_il2cpp_TypeInfo_var);
GUIStyleState__ctor_m2708667747(L_2, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
GUIStyleState_t3801000545 * L_3 = V_0;
GUIStyleState_t3801000545 * L_4 = V_0;
Texture2D_t3542995729 * L_5 = GUIStyleState_GetBackgroundInternalFromDeserialization_m1892089769(L_4, /*hidden argument*/NULL);
L_3->set_m_Background_2(L_5);
GUIStyleState_t3801000545 * L_6 = V_0;
V_1 = L_6;
goto IL_001c;
}
IL_001c:
{
GUIStyleState_t3801000545 * L_7 = V_1;
return L_7;
}
}
// UnityEngine.GUIStyleState UnityEngine.GUIStyleState::GetGUIStyleState(UnityEngine.GUIStyle,System.IntPtr)
extern "C" GUIStyleState_t3801000545 * GUIStyleState_GetGUIStyleState_m2816150617 (Il2CppObject * __this /* static, unused */, GUIStyle_t1799908754 * ___sourceStyle0, IntPtr_t ___source1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIStyleState_GetGUIStyleState_m2816150617_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUIStyleState_t3801000545 * V_0 = NULL;
GUIStyleState_t3801000545 * V_1 = NULL;
{
GUIStyle_t1799908754 * L_0 = ___sourceStyle0;
IntPtr_t L_1 = ___source1;
GUIStyleState_t3801000545 * L_2 = (GUIStyleState_t3801000545 *)il2cpp_codegen_object_new(GUIStyleState_t3801000545_il2cpp_TypeInfo_var);
GUIStyleState__ctor_m2708667747(L_2, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
GUIStyleState_t3801000545 * L_3 = V_0;
GUIStyleState_t3801000545 * L_4 = V_0;
Texture2D_t3542995729 * L_5 = GUIStyleState_GetBackgroundInternal_m439046630(L_4, /*hidden argument*/NULL);
L_3->set_m_Background_2(L_5);
GUIStyleState_t3801000545 * L_6 = V_0;
V_1 = L_6;
goto IL_001c;
}
IL_001c:
{
GUIStyleState_t3801000545 * L_7 = V_1;
return L_7;
}
}
// System.Void UnityEngine.GUIStyleState::Finalize()
extern "C" void GUIStyleState_Finalize_m401465910 (GUIStyleState_t3801000545 * __this, const MethodInfo* method)
{
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
{
}
IL_0001:
try
{ // begin try (depth: 1)
{
GUIStyle_t1799908754 * L_0 = __this->get_m_SourceStyle_1();
if (L_0)
{
goto IL_0012;
}
}
IL_000c:
{
GUIStyleState_Cleanup_m705006206(__this, /*hidden argument*/NULL);
}
IL_0012:
{
IL2CPP_LEAVE(0x1E, FINALLY_0017);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_0017;
}
FINALLY_0017:
{ // begin finally (depth: 1)
Object_Finalize_m4087144328(__this, /*hidden argument*/NULL);
IL2CPP_END_FINALLY(23)
} // end finally (depth: 1)
IL2CPP_CLEANUP(23)
{
IL2CPP_JUMP_TBL(0x1E, IL_001e)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_001e:
{
return;
}
}
// System.Void UnityEngine.GUIStyleState::Init()
extern "C" void GUIStyleState_Init_m2434147050 (GUIStyleState_t3801000545 * __this, const MethodInfo* method)
{
typedef void (*GUIStyleState_Init_m2434147050_ftn) (GUIStyleState_t3801000545 *);
static GUIStyleState_Init_m2434147050_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyleState_Init_m2434147050_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyleState::Init()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyleState::Cleanup()
extern "C" void GUIStyleState_Cleanup_m705006206 (GUIStyleState_t3801000545 * __this, const MethodInfo* method)
{
typedef void (*GUIStyleState_Cleanup_m705006206_ftn) (GUIStyleState_t3801000545 *);
static GUIStyleState_Cleanup_m705006206_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyleState_Cleanup_m705006206_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyleState::Cleanup()");
_il2cpp_icall_func(__this);
}
// UnityEngine.Texture2D UnityEngine.GUIStyleState::GetBackgroundInternalFromDeserialization()
extern "C" Texture2D_t3542995729 * GUIStyleState_GetBackgroundInternalFromDeserialization_m1892089769 (GUIStyleState_t3801000545 * __this, const MethodInfo* method)
{
typedef Texture2D_t3542995729 * (*GUIStyleState_GetBackgroundInternalFromDeserialization_m1892089769_ftn) (GUIStyleState_t3801000545 *);
static GUIStyleState_GetBackgroundInternalFromDeserialization_m1892089769_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyleState_GetBackgroundInternalFromDeserialization_m1892089769_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyleState::GetBackgroundInternalFromDeserialization()");
return _il2cpp_icall_func(__this);
}
// UnityEngine.Texture2D UnityEngine.GUIStyleState::GetBackgroundInternal()
extern "C" Texture2D_t3542995729 * GUIStyleState_GetBackgroundInternal_m439046630 (GUIStyleState_t3801000545 * __this, const MethodInfo* method)
{
typedef Texture2D_t3542995729 * (*GUIStyleState_GetBackgroundInternal_m439046630_ftn) (GUIStyleState_t3801000545 *);
static GUIStyleState_GetBackgroundInternal_m439046630_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyleState_GetBackgroundInternal_m439046630_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyleState::GetBackgroundInternal()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.GUIStyleState::set_textColor(UnityEngine.Color)
extern "C" void GUIStyleState_set_textColor_m3970174237 (GUIStyleState_t3801000545 * __this, Color_t2020392075 ___value0, const MethodInfo* method)
{
{
GUIStyleState_INTERNAL_set_textColor_m3876928435(__this, (&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIStyleState::INTERNAL_set_textColor(UnityEngine.Color&)
extern "C" void GUIStyleState_INTERNAL_set_textColor_m3876928435 (GUIStyleState_t3801000545 * __this, Color_t2020392075 * ___value0, const MethodInfo* method)
{
typedef void (*GUIStyleState_INTERNAL_set_textColor_m3876928435_ftn) (GUIStyleState_t3801000545 *, Color_t2020392075 *);
static GUIStyleState_INTERNAL_set_textColor_m3876928435_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIStyleState_INTERNAL_set_textColor_m3876928435_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIStyleState::INTERNAL_set_textColor(UnityEngine.Color&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Int32 UnityEngine.GUITargetAttribute::GetGUITargetAttrValue(System.Type,System.String)
extern "C" int32_t GUITargetAttribute_GetGUITargetAttrValue_m3740620102 (Il2CppObject * __this /* static, unused */, Type_t * ___klass0, String_t* ___methodName1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUITargetAttribute_GetGUITargetAttrValue_m3740620102_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
MethodInfo_t * V_0 = NULL;
ObjectU5BU5D_t3614634134* V_1 = NULL;
int32_t V_2 = 0;
GUITargetAttribute_t863467180 * V_3 = NULL;
int32_t V_4 = 0;
{
Type_t * L_0 = ___klass0;
String_t* L_1 = ___methodName1;
MethodInfo_t * L_2 = Type_GetMethod_m475234662(L_0, L_1, ((int32_t)52), /*hidden argument*/NULL);
V_0 = L_2;
MethodInfo_t * L_3 = V_0;
if (!L_3)
{
goto IL_006a;
}
}
{
MethodInfo_t * L_4 = V_0;
ObjectU5BU5D_t3614634134* L_5 = VirtFuncInvoker1< ObjectU5BU5D_t3614634134*, bool >::Invoke(12 /* System.Object[] System.Reflection.MemberInfo::GetCustomAttributes(System.Boolean) */, L_4, (bool)1);
V_1 = L_5;
ObjectU5BU5D_t3614634134* L_6 = V_1;
if (!L_6)
{
goto IL_0069;
}
}
{
V_2 = 0;
goto IL_005f;
}
IL_0028:
{
ObjectU5BU5D_t3614634134* L_7 = V_1;
int32_t L_8 = V_2;
int32_t L_9 = L_8;
Il2CppObject * L_10 = (L_7)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_9));
Type_t * L_11 = Object_GetType_m191970594(L_10, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_12 = Type_GetTypeFromHandle_m432505302(NULL /*static, unused*/, LoadTypeToken(GUITargetAttribute_t863467180_0_0_0_var), /*hidden argument*/NULL);
if ((((Il2CppObject*)(Type_t *)L_11) == ((Il2CppObject*)(Type_t *)L_12)))
{
goto IL_0045;
}
}
{
goto IL_005b;
}
IL_0045:
{
ObjectU5BU5D_t3614634134* L_13 = V_1;
int32_t L_14 = V_2;
int32_t L_15 = L_14;
Il2CppObject * L_16 = (L_13)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_15));
V_3 = ((GUITargetAttribute_t863467180 *)IsInstClass(L_16, GUITargetAttribute_t863467180_il2cpp_TypeInfo_var));
GUITargetAttribute_t863467180 * L_17 = V_3;
int32_t L_18 = L_17->get_displayMask_0();
V_4 = L_18;
goto IL_0072;
}
IL_005b:
{
int32_t L_19 = V_2;
V_2 = ((int32_t)((int32_t)L_19+(int32_t)1));
}
IL_005f:
{
int32_t L_20 = V_2;
ObjectU5BU5D_t3614634134* L_21 = V_1;
if ((((int32_t)L_20) < ((int32_t)(((int32_t)((int32_t)(((Il2CppArray *)L_21)->max_length)))))))
{
goto IL_0028;
}
}
{
}
IL_0069:
{
}
IL_006a:
{
V_4 = (-1);
goto IL_0072;
}
IL_0072:
{
int32_t L_22 = V_4;
return L_22;
}
}
// System.Single UnityEngine.GUIUtility::get_pixelsPerPoint()
extern "C" float GUIUtility_get_pixelsPerPoint_m2667928361 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_get_pixelsPerPoint_m2667928361_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
{
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
float L_0 = GUIUtility_Internal_GetPixelsPerPoint_m1770975086(NULL /*static, unused*/, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000c;
}
IL_000c:
{
float L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.GUIUtility::set_guiIsExiting(System.Boolean)
extern "C" void GUIUtility_set_guiIsExiting_m2362636745 (Il2CppObject * __this /* static, unused */, bool ___value0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_set_guiIsExiting_m2362636745_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
bool L_0 = ___value0;
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
((GUIUtility_t3275770671_StaticFields*)GUIUtility_t3275770671_il2cpp_TypeInfo_var->static_fields)->set_U3CguiIsExitingU3Ek__BackingField_2(L_0);
return;
}
}
// System.Int32 UnityEngine.GUIUtility::get_hotControl()
extern "C" int32_t GUIUtility_get_hotControl_m466901769 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_get_hotControl_m466901769_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
int32_t L_0 = GUIUtility_Internal_GetHotControl_m2510727642(NULL /*static, unused*/, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000c;
}
IL_000c:
{
int32_t L_1 = V_0;
return L_1;
}
}
// System.Int32 UnityEngine.GUIUtility::get_keyboardControl()
extern "C" int32_t GUIUtility_get_keyboardControl_m2418463643 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_get_keyboardControl_m2418463643_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
int32_t L_0 = GUIUtility_Internal_GetKeyboardControl_m973220286(NULL /*static, unused*/, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000c;
}
IL_000c:
{
int32_t L_1 = V_0;
return L_1;
}
}
// UnityEngine.GUISkin UnityEngine.GUIUtility::GetDefaultSkin()
extern "C" GUISkin_t1436893342 * GUIUtility_GetDefaultSkin_m2022075576 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_GetDefaultSkin_m2022075576_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
GUISkin_t1436893342 * V_0 = NULL;
{
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
int32_t L_0 = ((GUIUtility_t3275770671_StaticFields*)GUIUtility_t3275770671_il2cpp_TypeInfo_var->static_fields)->get_s_SkinMode_0();
GUISkin_t1436893342 * L_1 = GUIUtility_Internal_GetDefaultSkin_m2135852437(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_0011;
}
IL_0011:
{
GUISkin_t1436893342 * L_2 = V_0;
return L_2;
}
}
// System.Boolean UnityEngine.GUIUtility::ProcessEvent(System.Int32,System.IntPtr)
extern "C" bool GUIUtility_ProcessEvent_m142250930 (Il2CppObject * __this /* static, unused */, int32_t ___instanceID0, IntPtr_t ___nativeEventPtr1, const MethodInfo* method)
{
bool V_0 = false;
{
V_0 = (bool)0;
goto IL_0008;
}
IL_0008:
{
bool L_0 = V_0;
return L_0;
}
}
// System.Void UnityEngine.GUIUtility::BeginGUI(System.Int32,System.Int32,System.Int32)
extern "C" void GUIUtility_BeginGUI_m2907220931 (Il2CppObject * __this /* static, unused */, int32_t ___skinMode0, int32_t ___instanceID1, int32_t ___useGUILayout2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_BeginGUI_m2907220931_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___skinMode0;
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
((GUIUtility_t3275770671_StaticFields*)GUIUtility_t3275770671_il2cpp_TypeInfo_var->static_fields)->set_s_SkinMode_0(L_0);
int32_t L_1 = ___instanceID1;
((GUIUtility_t3275770671_StaticFields*)GUIUtility_t3275770671_il2cpp_TypeInfo_var->static_fields)->set_s_OriginalID_1(L_1);
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUI_set_skin_m3391676555(NULL /*static, unused*/, (GUISkin_t1436893342 *)NULL, /*hidden argument*/NULL);
GUIUtility_set_guiIsExiting_m2362636745(NULL /*static, unused*/, (bool)0, /*hidden argument*/NULL);
int32_t L_2 = ___useGUILayout2;
if (!L_2)
{
goto IL_0027;
}
}
{
int32_t L_3 = ___instanceID1;
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_Begin_m2360858304(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
}
IL_0027:
{
IL2CPP_RUNTIME_CLASS_INIT(GUI_t4082743951_il2cpp_TypeInfo_var);
GUI_set_changed_m470833806(NULL /*static, unused*/, (bool)0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.GUIUtility::EndGUI(System.Int32)
extern "C" void GUIUtility_EndGUI_m3538781391 (Il2CppObject * __this /* static, unused */, int32_t ___layoutType0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_EndGUI_m3538781391_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
{
}
IL_0001:
try
{ // begin try (depth: 1)
{
Event_t3028476042 * L_0 = Event_get_current_m2901774193(NULL /*static, unused*/, /*hidden argument*/NULL);
int32_t L_1 = Event_get_type_m2426033198(L_0, /*hidden argument*/NULL);
if ((!(((uint32_t)L_1) == ((uint32_t)8))))
{
goto IL_0046;
}
}
IL_0012:
{
int32_t L_2 = ___layoutType0;
if (!L_2)
{
goto IL_002c;
}
}
IL_0019:
{
int32_t L_3 = ___layoutType0;
if ((((int32_t)L_3) == ((int32_t)1)))
{
goto IL_0031;
}
}
IL_0020:
{
int32_t L_4 = ___layoutType0;
if ((((int32_t)L_4) == ((int32_t)2)))
{
goto IL_003b;
}
}
IL_0027:
{
goto IL_0045;
}
IL_002c:
{
goto IL_0045;
}
IL_0031:
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_Layout_m3812180708(NULL /*static, unused*/, /*hidden argument*/NULL);
goto IL_0045;
}
IL_003b:
{
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_LayoutFromEditorWindow_m1847418289(NULL /*static, unused*/, /*hidden argument*/NULL);
goto IL_0045;
}
IL_0045:
{
}
IL_0046:
{
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
int32_t L_5 = ((GUIUtility_t3275770671_StaticFields*)GUIUtility_t3275770671_il2cpp_TypeInfo_var->static_fields)->get_s_OriginalID_1();
IL2CPP_RUNTIME_CLASS_INIT(GUILayoutUtility_t996096873_il2cpp_TypeInfo_var);
GUILayoutUtility_SelectIDList_m756828237(NULL /*static, unused*/, L_5, (bool)0, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(GUIContent_t4210063000_il2cpp_TypeInfo_var);
GUIContent_ClearStaticCache_m3271816250(NULL /*static, unused*/, /*hidden argument*/NULL);
IL2CPP_LEAVE(0x65, FINALLY_005d);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_005d;
}
FINALLY_005d:
{ // begin finally (depth: 1)
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
GUIUtility_Internal_ExitGUI_m2271097629(NULL /*static, unused*/, /*hidden argument*/NULL);
IL2CPP_END_FINALLY(93)
} // end finally (depth: 1)
IL2CPP_CLEANUP(93)
{
IL2CPP_JUMP_TBL(0x65, IL_0065)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_0065:
{
return;
}
}
// System.Boolean UnityEngine.GUIUtility::EndGUIFromException(System.Exception)
extern "C" bool GUIUtility_EndGUIFromException_m2091524531 (Il2CppObject * __this /* static, unused */, Exception_t1927440687 * ___exception0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_EndGUIFromException_m2091524531_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
GUIUtility_Internal_ExitGUI_m2271097629(NULL /*static, unused*/, /*hidden argument*/NULL);
Exception_t1927440687 * L_0 = ___exception0;
bool L_1 = GUIUtility_ShouldRethrowException_m1990329277(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_0012;
}
IL_0012:
{
bool L_2 = V_0;
return L_2;
}
}
// System.Boolean UnityEngine.GUIUtility::EndContainerGUIFromException(System.Exception)
extern "C" bool GUIUtility_EndContainerGUIFromException_m8097082 (Il2CppObject * __this /* static, unused */, Exception_t1927440687 * ___exception0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_EndContainerGUIFromException_m8097082_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
Exception_t1927440687 * L_0 = ___exception0;
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
bool L_1 = GUIUtility_ShouldRethrowException_m1990329277(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000d;
}
IL_000d:
{
bool L_2 = V_0;
return L_2;
}
}
// System.Boolean UnityEngine.GUIUtility::ShouldRethrowException(System.Exception)
extern "C" bool GUIUtility_ShouldRethrowException_m1990329277 (Il2CppObject * __this /* static, unused */, Exception_t1927440687 * ___exception0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_ShouldRethrowException_m1990329277_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
goto IL_000e;
}
IL_0006:
{
Exception_t1927440687 * L_0 = ___exception0;
Exception_t1927440687 * L_1 = Exception_get_InnerException_m3722561235(L_0, /*hidden argument*/NULL);
___exception0 = L_1;
}
IL_000e:
{
Exception_t1927440687 * L_2 = ___exception0;
if (!((TargetInvocationException_t4098620458 *)IsInstSealed(L_2, TargetInvocationException_t4098620458_il2cpp_TypeInfo_var)))
{
goto IL_0024;
}
}
{
Exception_t1927440687 * L_3 = ___exception0;
Exception_t1927440687 * L_4 = Exception_get_InnerException_m3722561235(L_3, /*hidden argument*/NULL);
if (L_4)
{
goto IL_0006;
}
}
IL_0024:
{
Exception_t1927440687 * L_5 = ___exception0;
V_0 = (bool)((!(((Il2CppObject*)(ExitGUIException_t1618397098 *)((ExitGUIException_t1618397098 *)IsInstSealed(L_5, ExitGUIException_t1618397098_il2cpp_TypeInfo_var))) <= ((Il2CppObject*)(Il2CppObject *)NULL)))? 1 : 0);
goto IL_0033;
}
IL_0033:
{
bool L_6 = V_0;
return L_6;
}
}
// System.Void UnityEngine.GUIUtility::CheckOnGUI()
extern "C" void GUIUtility_CheckOnGUI_m4284398968 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility_CheckOnGUI_m4284398968_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(GUIUtility_t3275770671_il2cpp_TypeInfo_var);
int32_t L_0 = GUIUtility_Internal_GetGUIDepth_m1699616910(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((int32_t)L_0) > ((int32_t)0)))
{
goto IL_0017;
}
}
{
ArgumentException_t3259014390 * L_1 = (ArgumentException_t3259014390 *)il2cpp_codegen_object_new(ArgumentException_t3259014390_il2cpp_TypeInfo_var);
ArgumentException__ctor_m3739475201(L_1, _stringLiteral4248023613, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1);
}
IL_0017:
{
return;
}
}
// System.Single UnityEngine.GUIUtility::Internal_GetPixelsPerPoint()
extern "C" float GUIUtility_Internal_GetPixelsPerPoint_m1770975086 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef float (*GUIUtility_Internal_GetPixelsPerPoint_m1770975086_ftn) ();
static GUIUtility_Internal_GetPixelsPerPoint_m1770975086_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIUtility_Internal_GetPixelsPerPoint_m1770975086_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIUtility::Internal_GetPixelsPerPoint()");
return _il2cpp_icall_func();
}
// System.Int32 UnityEngine.GUIUtility::Internal_GetHotControl()
extern "C" int32_t GUIUtility_Internal_GetHotControl_m2510727642 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef int32_t (*GUIUtility_Internal_GetHotControl_m2510727642_ftn) ();
static GUIUtility_Internal_GetHotControl_m2510727642_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIUtility_Internal_GetHotControl_m2510727642_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIUtility::Internal_GetHotControl()");
return _il2cpp_icall_func();
}
// System.Int32 UnityEngine.GUIUtility::Internal_GetKeyboardControl()
extern "C" int32_t GUIUtility_Internal_GetKeyboardControl_m973220286 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef int32_t (*GUIUtility_Internal_GetKeyboardControl_m973220286_ftn) ();
static GUIUtility_Internal_GetKeyboardControl_m973220286_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIUtility_Internal_GetKeyboardControl_m973220286_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIUtility::Internal_GetKeyboardControl()");
return _il2cpp_icall_func();
}
// System.String UnityEngine.GUIUtility::get_systemCopyBuffer()
extern "C" String_t* GUIUtility_get_systemCopyBuffer_m396434174 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef String_t* (*GUIUtility_get_systemCopyBuffer_m396434174_ftn) ();
static GUIUtility_get_systemCopyBuffer_m396434174_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIUtility_get_systemCopyBuffer_m396434174_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIUtility::get_systemCopyBuffer()");
return _il2cpp_icall_func();
}
// System.Void UnityEngine.GUIUtility::set_systemCopyBuffer(System.String)
extern "C" void GUIUtility_set_systemCopyBuffer_m2040945785 (Il2CppObject * __this /* static, unused */, String_t* ___value0, const MethodInfo* method)
{
typedef void (*GUIUtility_set_systemCopyBuffer_m2040945785_ftn) (String_t*);
static GUIUtility_set_systemCopyBuffer_m2040945785_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIUtility_set_systemCopyBuffer_m2040945785_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIUtility::set_systemCopyBuffer(System.String)");
_il2cpp_icall_func(___value0);
}
// UnityEngine.GUISkin UnityEngine.GUIUtility::Internal_GetDefaultSkin(System.Int32)
extern "C" GUISkin_t1436893342 * GUIUtility_Internal_GetDefaultSkin_m2135852437 (Il2CppObject * __this /* static, unused */, int32_t ___skinMode0, const MethodInfo* method)
{
typedef GUISkin_t1436893342 * (*GUIUtility_Internal_GetDefaultSkin_m2135852437_ftn) (int32_t);
static GUIUtility_Internal_GetDefaultSkin_m2135852437_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIUtility_Internal_GetDefaultSkin_m2135852437_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIUtility::Internal_GetDefaultSkin(System.Int32)");
return _il2cpp_icall_func(___skinMode0);
}
// System.Void UnityEngine.GUIUtility::Internal_ExitGUI()
extern "C" void GUIUtility_Internal_ExitGUI_m2271097629 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef void (*GUIUtility_Internal_ExitGUI_m2271097629_ftn) ();
static GUIUtility_Internal_ExitGUI_m2271097629_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIUtility_Internal_ExitGUI_m2271097629_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIUtility::Internal_ExitGUI()");
_il2cpp_icall_func();
}
// System.Int32 UnityEngine.GUIUtility::Internal_GetGUIDepth()
extern "C" int32_t GUIUtility_Internal_GetGUIDepth_m1699616910 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef int32_t (*GUIUtility_Internal_GetGUIDepth_m1699616910_ftn) ();
static GUIUtility_Internal_GetGUIDepth_m1699616910_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (GUIUtility_Internal_GetGUIDepth_m1699616910_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.GUIUtility::Internal_GetGUIDepth()");
return _il2cpp_icall_func();
}
// System.Void UnityEngine.GUIUtility::.cctor()
extern "C" void GUIUtility__cctor_m46116445 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (GUIUtility__cctor_m46116445_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Vector2_t2243707579 L_0 = Vector2_get_zero_m3966848876(NULL /*static, unused*/, /*hidden argument*/NULL);
((GUIUtility_t3275770671_StaticFields*)GUIUtility_t3275770671_il2cpp_TypeInfo_var->static_fields)->set_s_EditorScreenPointOffset_3(L_0);
return;
}
}
// Conversion methods for marshalling of: UnityEngine.HumanBone
extern "C" void HumanBone_t1529896151_marshal_pinvoke(const HumanBone_t1529896151& unmarshaled, HumanBone_t1529896151_marshaled_pinvoke& marshaled)
{
marshaled.___m_BoneName_0 = il2cpp_codegen_marshal_string(unmarshaled.get_m_BoneName_0());
marshaled.___m_HumanName_1 = il2cpp_codegen_marshal_string(unmarshaled.get_m_HumanName_1());
marshaled.___limit_2 = unmarshaled.get_limit_2();
}
extern "C" void HumanBone_t1529896151_marshal_pinvoke_back(const HumanBone_t1529896151_marshaled_pinvoke& marshaled, HumanBone_t1529896151& unmarshaled)
{
unmarshaled.set_m_BoneName_0(il2cpp_codegen_marshal_string_result(marshaled.___m_BoneName_0));
unmarshaled.set_m_HumanName_1(il2cpp_codegen_marshal_string_result(marshaled.___m_HumanName_1));
HumanLimit_t250797648 unmarshaled_limit_temp_2;
memset(&unmarshaled_limit_temp_2, 0, sizeof(unmarshaled_limit_temp_2));
unmarshaled_limit_temp_2 = marshaled.___limit_2;
unmarshaled.set_limit_2(unmarshaled_limit_temp_2);
}
// Conversion method for clean up from marshalling of: UnityEngine.HumanBone
extern "C" void HumanBone_t1529896151_marshal_pinvoke_cleanup(HumanBone_t1529896151_marshaled_pinvoke& marshaled)
{
il2cpp_codegen_marshal_free(marshaled.___m_BoneName_0);
marshaled.___m_BoneName_0 = NULL;
il2cpp_codegen_marshal_free(marshaled.___m_HumanName_1);
marshaled.___m_HumanName_1 = NULL;
}
// Conversion methods for marshalling of: UnityEngine.HumanBone
extern "C" void HumanBone_t1529896151_marshal_com(const HumanBone_t1529896151& unmarshaled, HumanBone_t1529896151_marshaled_com& marshaled)
{
marshaled.___m_BoneName_0 = il2cpp_codegen_marshal_bstring(unmarshaled.get_m_BoneName_0());
marshaled.___m_HumanName_1 = il2cpp_codegen_marshal_bstring(unmarshaled.get_m_HumanName_1());
marshaled.___limit_2 = unmarshaled.get_limit_2();
}
extern "C" void HumanBone_t1529896151_marshal_com_back(const HumanBone_t1529896151_marshaled_com& marshaled, HumanBone_t1529896151& unmarshaled)
{
unmarshaled.set_m_BoneName_0(il2cpp_codegen_marshal_bstring_result(marshaled.___m_BoneName_0));
unmarshaled.set_m_HumanName_1(il2cpp_codegen_marshal_bstring_result(marshaled.___m_HumanName_1));
HumanLimit_t250797648 unmarshaled_limit_temp_2;
memset(&unmarshaled_limit_temp_2, 0, sizeof(unmarshaled_limit_temp_2));
unmarshaled_limit_temp_2 = marshaled.___limit_2;
unmarshaled.set_limit_2(unmarshaled_limit_temp_2);
}
// Conversion method for clean up from marshalling of: UnityEngine.HumanBone
extern "C" void HumanBone_t1529896151_marshal_com_cleanup(HumanBone_t1529896151_marshaled_com& marshaled)
{
il2cpp_codegen_marshal_free_bstring(marshaled.___m_BoneName_0);
marshaled.___m_BoneName_0 = NULL;
il2cpp_codegen_marshal_free_bstring(marshaled.___m_HumanName_1);
marshaled.___m_HumanName_1 = NULL;
}
// System.String UnityEngine.HumanBone::get_boneName()
extern "C" String_t* HumanBone_get_boneName_m1281040133 (HumanBone_t1529896151 * __this, const MethodInfo* method)
{
String_t* V_0 = NULL;
{
String_t* L_0 = __this->get_m_BoneName_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
String_t* L_1 = V_0;
return L_1;
}
}
extern "C" String_t* HumanBone_get_boneName_m1281040133_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
HumanBone_t1529896151 * _thisAdjusted = reinterpret_cast<HumanBone_t1529896151 *>(__this + 1);
return HumanBone_get_boneName_m1281040133(_thisAdjusted, method);
}
// System.Void UnityEngine.HumanBone::set_boneName(System.String)
extern "C" void HumanBone_set_boneName_m2410239828 (HumanBone_t1529896151 * __this, String_t* ___value0, const MethodInfo* method)
{
{
String_t* L_0 = ___value0;
__this->set_m_BoneName_0(L_0);
return;
}
}
extern "C" void HumanBone_set_boneName_m2410239828_AdjustorThunk (Il2CppObject * __this, String_t* ___value0, const MethodInfo* method)
{
HumanBone_t1529896151 * _thisAdjusted = reinterpret_cast<HumanBone_t1529896151 *>(__this + 1);
HumanBone_set_boneName_m2410239828(_thisAdjusted, ___value0, method);
}
// System.String UnityEngine.HumanBone::get_humanName()
extern "C" String_t* HumanBone_get_humanName_m2091758568 (HumanBone_t1529896151 * __this, const MethodInfo* method)
{
String_t* V_0 = NULL;
{
String_t* L_0 = __this->get_m_HumanName_1();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
String_t* L_1 = V_0;
return L_1;
}
}
extern "C" String_t* HumanBone_get_humanName_m2091758568_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
HumanBone_t1529896151 * _thisAdjusted = reinterpret_cast<HumanBone_t1529896151 *>(__this + 1);
return HumanBone_get_humanName_m2091758568(_thisAdjusted, method);
}
// System.Void UnityEngine.HumanBone::set_humanName(System.String)
extern "C" void HumanBone_set_humanName_m1385708911 (HumanBone_t1529896151 * __this, String_t* ___value0, const MethodInfo* method)
{
{
String_t* L_0 = ___value0;
__this->set_m_HumanName_1(L_0);
return;
}
}
extern "C" void HumanBone_set_humanName_m1385708911_AdjustorThunk (Il2CppObject * __this, String_t* ___value0, const MethodInfo* method)
{
HumanBone_t1529896151 * _thisAdjusted = reinterpret_cast<HumanBone_t1529896151 *>(__this + 1);
HumanBone_set_humanName_m1385708911(_thisAdjusted, ___value0, method);
}
// System.Void UnityEngine.IL2CPPStructAlignmentAttribute::.ctor()
extern "C" void IL2CPPStructAlignmentAttribute__ctor_m2555798229 (IL2CPPStructAlignmentAttribute_t130316838 * __this, const MethodInfo* method)
{
{
Attribute__ctor_m1730479323(__this, /*hidden argument*/NULL);
__this->set_Align_0(1);
return;
}
}
// System.Boolean UnityEngine.Input::GetKeyUpInt(System.Int32)
extern "C" bool Input_GetKeyUpInt_m2486491081 (Il2CppObject * __this /* static, unused */, int32_t ___key0, const MethodInfo* method)
{
typedef bool (*Input_GetKeyUpInt_m2486491081_ftn) (int32_t);
static Input_GetKeyUpInt_m2486491081_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_GetKeyUpInt_m2486491081_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::GetKeyUpInt(System.Int32)");
return _il2cpp_icall_func(___key0);
}
// System.Boolean UnityEngine.Input::GetKeyDownInt(System.Int32)
extern "C" bool Input_GetKeyDownInt_m2930607648 (Il2CppObject * __this /* static, unused */, int32_t ___key0, const MethodInfo* method)
{
typedef bool (*Input_GetKeyDownInt_m2930607648_ftn) (int32_t);
static Input_GetKeyDownInt_m2930607648_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_GetKeyDownInt_m2930607648_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::GetKeyDownInt(System.Int32)");
return _il2cpp_icall_func(___key0);
}
// System.Single UnityEngine.Input::GetAxisRaw(System.String)
extern "C" float Input_GetAxisRaw_m4133353720 (Il2CppObject * __this /* static, unused */, String_t* ___axisName0, const MethodInfo* method)
{
typedef float (*Input_GetAxisRaw_m4133353720_ftn) (String_t*);
static Input_GetAxisRaw_m4133353720_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_GetAxisRaw_m4133353720_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::GetAxisRaw(System.String)");
return _il2cpp_icall_func(___axisName0);
}
// System.Boolean UnityEngine.Input::GetButtonDown(System.String)
extern "C" bool Input_GetButtonDown_m2792523731 (Il2CppObject * __this /* static, unused */, String_t* ___buttonName0, const MethodInfo* method)
{
typedef bool (*Input_GetButtonDown_m2792523731_ftn) (String_t*);
static Input_GetButtonDown_m2792523731_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_GetButtonDown_m2792523731_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::GetButtonDown(System.String)");
return _il2cpp_icall_func(___buttonName0);
}
// System.Boolean UnityEngine.Input::GetKeyDown(UnityEngine.KeyCode)
extern "C" bool Input_GetKeyDown_m1771960377 (Il2CppObject * __this /* static, unused */, int32_t ___key0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Input_GetKeyDown_m1771960377_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
int32_t L_0 = ___key0;
IL2CPP_RUNTIME_CLASS_INIT(Input_t1785128008_il2cpp_TypeInfo_var);
bool L_1 = Input_GetKeyDownInt_m2930607648(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000d;
}
IL_000d:
{
bool L_2 = V_0;
return L_2;
}
}
// System.Boolean UnityEngine.Input::GetKeyUp(UnityEngine.KeyCode)
extern "C" bool Input_GetKeyUp_m1008512962 (Il2CppObject * __this /* static, unused */, int32_t ___key0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Input_GetKeyUp_m1008512962_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
int32_t L_0 = ___key0;
IL2CPP_RUNTIME_CLASS_INIT(Input_t1785128008_il2cpp_TypeInfo_var);
bool L_1 = Input_GetKeyUpInt_m2486491081(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000d;
}
IL_000d:
{
bool L_2 = V_0;
return L_2;
}
}
// System.Boolean UnityEngine.Input::GetMouseButton(System.Int32)
extern "C" bool Input_GetMouseButton_m464100923 (Il2CppObject * __this /* static, unused */, int32_t ___button0, const MethodInfo* method)
{
typedef bool (*Input_GetMouseButton_m464100923_ftn) (int32_t);
static Input_GetMouseButton_m464100923_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_GetMouseButton_m464100923_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::GetMouseButton(System.Int32)");
return _il2cpp_icall_func(___button0);
}
// System.Boolean UnityEngine.Input::GetMouseButtonDown(System.Int32)
extern "C" bool Input_GetMouseButtonDown_m47917805 (Il2CppObject * __this /* static, unused */, int32_t ___button0, const MethodInfo* method)
{
typedef bool (*Input_GetMouseButtonDown_m47917805_ftn) (int32_t);
static Input_GetMouseButtonDown_m47917805_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_GetMouseButtonDown_m47917805_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::GetMouseButtonDown(System.Int32)");
return _il2cpp_icall_func(___button0);
}
// System.Boolean UnityEngine.Input::GetMouseButtonUp(System.Int32)
extern "C" bool Input_GetMouseButtonUp_m1275967966 (Il2CppObject * __this /* static, unused */, int32_t ___button0, const MethodInfo* method)
{
typedef bool (*Input_GetMouseButtonUp_m1275967966_ftn) (int32_t);
static Input_GetMouseButtonUp_m1275967966_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_GetMouseButtonUp_m1275967966_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::GetMouseButtonUp(System.Int32)");
return _il2cpp_icall_func(___button0);
}
// UnityEngine.Vector3 UnityEngine.Input::get_mousePosition()
extern "C" Vector3_t2243707580 Input_get_mousePosition_m146923508 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Input_get_mousePosition_m146923508_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector3_t2243707580 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector3_t2243707580 V_1;
memset(&V_1, 0, sizeof(V_1));
{
IL2CPP_RUNTIME_CLASS_INIT(Input_t1785128008_il2cpp_TypeInfo_var);
Input_INTERNAL_get_mousePosition_m2302165941(NULL /*static, unused*/, (&V_0), /*hidden argument*/NULL);
Vector3_t2243707580 L_0 = V_0;
V_1 = L_0;
goto IL_000f;
}
IL_000f:
{
Vector3_t2243707580 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.Input::INTERNAL_get_mousePosition(UnityEngine.Vector3&)
extern "C" void Input_INTERNAL_get_mousePosition_m2302165941 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 * ___value0, const MethodInfo* method)
{
typedef void (*Input_INTERNAL_get_mousePosition_m2302165941_ftn) (Vector3_t2243707580 *);
static Input_INTERNAL_get_mousePosition_m2302165941_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_INTERNAL_get_mousePosition_m2302165941_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::INTERNAL_get_mousePosition(UnityEngine.Vector3&)");
_il2cpp_icall_func(___value0);
}
// UnityEngine.Vector2 UnityEngine.Input::get_mouseScrollDelta()
extern "C" Vector2_t2243707579 Input_get_mouseScrollDelta_m3430638853 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Input_get_mouseScrollDelta_m3430638853_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
IL2CPP_RUNTIME_CLASS_INIT(Input_t1785128008_il2cpp_TypeInfo_var);
Input_INTERNAL_get_mouseScrollDelta_m1140491498(NULL /*static, unused*/, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_0 = V_0;
V_1 = L_0;
goto IL_000f;
}
IL_000f:
{
Vector2_t2243707579 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.Input::INTERNAL_get_mouseScrollDelta(UnityEngine.Vector2&)
extern "C" void Input_INTERNAL_get_mouseScrollDelta_m1140491498 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*Input_INTERNAL_get_mouseScrollDelta_m1140491498_ftn) (Vector2_t2243707579 *);
static Input_INTERNAL_get_mouseScrollDelta_m1140491498_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_INTERNAL_get_mouseScrollDelta_m1140491498_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::INTERNAL_get_mouseScrollDelta(UnityEngine.Vector2&)");
_il2cpp_icall_func(___value0);
}
// System.Boolean UnityEngine.Input::get_mousePresent()
extern "C" bool Input_get_mousePresent_m1434891730 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef bool (*Input_get_mousePresent_m1434891730_ftn) ();
static Input_get_mousePresent_m1434891730_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_get_mousePresent_m1434891730_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::get_mousePresent()");
return _il2cpp_icall_func();
}
// UnityEngine.Touch UnityEngine.Input::GetTouch(System.Int32)
extern "C" Touch_t407273883 Input_GetTouch_m1463942798 (Il2CppObject * __this /* static, unused */, int32_t ___index0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Input_GetTouch_m1463942798_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Touch_t407273883 V_0;
memset(&V_0, 0, sizeof(V_0));
Touch_t407273883 V_1;
memset(&V_1, 0, sizeof(V_1));
{
int32_t L_0 = ___index0;
IL2CPP_RUNTIME_CLASS_INIT(Input_t1785128008_il2cpp_TypeInfo_var);
Input_INTERNAL_CALL_GetTouch_m1737132542(NULL /*static, unused*/, L_0, (&V_0), /*hidden argument*/NULL);
Touch_t407273883 L_1 = V_0;
V_1 = L_1;
goto IL_0010;
}
IL_0010:
{
Touch_t407273883 L_2 = V_1;
return L_2;
}
}
// System.Void UnityEngine.Input::INTERNAL_CALL_GetTouch(System.Int32,UnityEngine.Touch&)
extern "C" void Input_INTERNAL_CALL_GetTouch_m1737132542 (Il2CppObject * __this /* static, unused */, int32_t ___index0, Touch_t407273883 * ___value1, const MethodInfo* method)
{
typedef void (*Input_INTERNAL_CALL_GetTouch_m1737132542_ftn) (int32_t, Touch_t407273883 *);
static Input_INTERNAL_CALL_GetTouch_m1737132542_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_INTERNAL_CALL_GetTouch_m1737132542_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::INTERNAL_CALL_GetTouch(System.Int32,UnityEngine.Touch&)");
_il2cpp_icall_func(___index0, ___value1);
}
// System.Int32 UnityEngine.Input::get_touchCount()
extern "C" int32_t Input_get_touchCount_m2050827666 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef int32_t (*Input_get_touchCount_m2050827666_ftn) ();
static Input_get_touchCount_m2050827666_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_get_touchCount_m2050827666_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::get_touchCount()");
return _il2cpp_icall_func();
}
// System.Boolean UnityEngine.Input::get_touchSupported()
extern "C" bool Input_get_touchSupported_m3352846145 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef bool (*Input_get_touchSupported_m3352846145_ftn) ();
static Input_get_touchSupported_m3352846145_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_get_touchSupported_m3352846145_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::get_touchSupported()");
return _il2cpp_icall_func();
}
// UnityEngine.IMECompositionMode UnityEngine.Input::get_imeCompositionMode()
extern "C" int32_t Input_get_imeCompositionMode_m4250689464 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef int32_t (*Input_get_imeCompositionMode_m4250689464_ftn) ();
static Input_get_imeCompositionMode_m4250689464_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_get_imeCompositionMode_m4250689464_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::get_imeCompositionMode()");
return _il2cpp_icall_func();
}
// System.Void UnityEngine.Input::set_imeCompositionMode(UnityEngine.IMECompositionMode)
extern "C" void Input_set_imeCompositionMode_m2881085485 (Il2CppObject * __this /* static, unused */, int32_t ___value0, const MethodInfo* method)
{
typedef void (*Input_set_imeCompositionMode_m2881085485_ftn) (int32_t);
static Input_set_imeCompositionMode_m2881085485_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_set_imeCompositionMode_m2881085485_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::set_imeCompositionMode(UnityEngine.IMECompositionMode)");
_il2cpp_icall_func(___value0);
}
// System.String UnityEngine.Input::get_compositionString()
extern "C" String_t* Input_get_compositionString_m636835668 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef String_t* (*Input_get_compositionString_m636835668_ftn) ();
static Input_get_compositionString_m636835668_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_get_compositionString_m636835668_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::get_compositionString()");
return _il2cpp_icall_func();
}
// UnityEngine.Vector2 UnityEngine.Input::get_compositionCursorPos()
extern "C" Vector2_t2243707579 Input_get_compositionCursorPos_m1262302043 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Input_get_compositionCursorPos_m1262302043_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
IL2CPP_RUNTIME_CLASS_INIT(Input_t1785128008_il2cpp_TypeInfo_var);
Input_INTERNAL_get_compositionCursorPos_m2426914348(NULL /*static, unused*/, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_0 = V_0;
V_1 = L_0;
goto IL_000f;
}
IL_000f:
{
Vector2_t2243707579 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.Input::set_compositionCursorPos(UnityEngine.Vector2)
extern "C" void Input_set_compositionCursorPos_m1615567306 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Input_set_compositionCursorPos_m1615567306_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Input_t1785128008_il2cpp_TypeInfo_var);
Input_INTERNAL_set_compositionCursorPos_m1501857600(NULL /*static, unused*/, (&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Input::INTERNAL_get_compositionCursorPos(UnityEngine.Vector2&)
extern "C" void Input_INTERNAL_get_compositionCursorPos_m2426914348 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*Input_INTERNAL_get_compositionCursorPos_m2426914348_ftn) (Vector2_t2243707579 *);
static Input_INTERNAL_get_compositionCursorPos_m2426914348_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_INTERNAL_get_compositionCursorPos_m2426914348_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::INTERNAL_get_compositionCursorPos(UnityEngine.Vector2&)");
_il2cpp_icall_func(___value0);
}
// System.Void UnityEngine.Input::INTERNAL_set_compositionCursorPos(UnityEngine.Vector2&)
extern "C" void Input_INTERNAL_set_compositionCursorPos_m1501857600 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*Input_INTERNAL_set_compositionCursorPos_m1501857600_ftn) (Vector2_t2243707579 *);
static Input_INTERNAL_set_compositionCursorPos_m1501857600_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Input_INTERNAL_set_compositionCursorPos_m1501857600_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Input::INTERNAL_set_compositionCursorPos(UnityEngine.Vector2&)");
_il2cpp_icall_func(___value0);
}
// System.Void UnityEngine.Input::.cctor()
extern "C" void Input__cctor_m829848544 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Input__cctor_m829848544_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
((Input_t1785128008_StaticFields*)Input_t1785128008_il2cpp_TypeInfo_var->static_fields)->set_m_MainGyro_0((Gyroscope_t1705362817 *)NULL);
return;
}
}
// System.Void UnityEngine.Internal.DefaultValueAttribute::.ctor(System.String)
extern "C" void DefaultValueAttribute__ctor_m4191464344 (DefaultValueAttribute_t1027170048 * __this, String_t* ___value0, const MethodInfo* method)
{
{
Attribute__ctor_m1730479323(__this, /*hidden argument*/NULL);
String_t* L_0 = ___value0;
__this->set_DefaultValue_0(L_0);
return;
}
}
// System.Object UnityEngine.Internal.DefaultValueAttribute::get_Value()
extern "C" Il2CppObject * DefaultValueAttribute_get_Value_m397428899 (DefaultValueAttribute_t1027170048 * __this, const MethodInfo* method)
{
Il2CppObject * V_0 = NULL;
{
Il2CppObject * L_0 = __this->get_DefaultValue_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Il2CppObject * L_1 = V_0;
return L_1;
}
}
// System.Boolean UnityEngine.Internal.DefaultValueAttribute::Equals(System.Object)
extern "C" bool DefaultValueAttribute_Equals_m3216982933 (DefaultValueAttribute_t1027170048 * __this, Il2CppObject * ___obj0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (DefaultValueAttribute_Equals_m3216982933_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
DefaultValueAttribute_t1027170048 * V_0 = NULL;
bool V_1 = false;
{
Il2CppObject * L_0 = ___obj0;
V_0 = ((DefaultValueAttribute_t1027170048 *)IsInstClass(L_0, DefaultValueAttribute_t1027170048_il2cpp_TypeInfo_var));
DefaultValueAttribute_t1027170048 * L_1 = V_0;
if (L_1)
{
goto IL_0015;
}
}
{
V_1 = (bool)0;
goto IL_0046;
}
IL_0015:
{
Il2CppObject * L_2 = __this->get_DefaultValue_0();
if (L_2)
{
goto IL_002f;
}
}
{
DefaultValueAttribute_t1027170048 * L_3 = V_0;
Il2CppObject * L_4 = DefaultValueAttribute_get_Value_m397428899(L_3, /*hidden argument*/NULL);
V_1 = (bool)((((Il2CppObject*)(Il2CppObject *)L_4) == ((Il2CppObject*)(Il2CppObject *)NULL))? 1 : 0);
goto IL_0046;
}
IL_002f:
{
Il2CppObject * L_5 = __this->get_DefaultValue_0();
DefaultValueAttribute_t1027170048 * L_6 = V_0;
Il2CppObject * L_7 = DefaultValueAttribute_get_Value_m397428899(L_6, /*hidden argument*/NULL);
bool L_8 = VirtFuncInvoker1< bool, Il2CppObject * >::Invoke(0 /* System.Boolean System.Object::Equals(System.Object) */, L_5, L_7);
V_1 = L_8;
goto IL_0046;
}
IL_0046:
{
bool L_9 = V_1;
return L_9;
}
}
// System.Int32 UnityEngine.Internal.DefaultValueAttribute::GetHashCode()
extern "C" int32_t DefaultValueAttribute_GetHashCode_m1495299559 (DefaultValueAttribute_t1027170048 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
Il2CppObject * L_0 = __this->get_DefaultValue_0();
if (L_0)
{
goto IL_0018;
}
}
{
int32_t L_1 = Attribute_GetHashCode_m2653962112(__this, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_0029;
}
IL_0018:
{
Il2CppObject * L_2 = __this->get_DefaultValue_0();
int32_t L_3 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, L_2);
V_0 = L_3;
goto IL_0029;
}
IL_0029:
{
int32_t L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.Internal.ExcludeFromDocsAttribute::.ctor()
extern "C" void ExcludeFromDocsAttribute__ctor_m1684225175 (ExcludeFromDocsAttribute_t665825653 * __this, const MethodInfo* method)
{
{
Attribute__ctor_m1730479323(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Keyframe::.ctor(System.Single,System.Single)
extern "C" void Keyframe__ctor_m2042404667 (Keyframe_t1449471340 * __this, float ___time0, float ___value1, const MethodInfo* method)
{
{
float L_0 = ___time0;
__this->set_m_Time_0(L_0);
float L_1 = ___value1;
__this->set_m_Value_1(L_1);
__this->set_m_InTangent_2((0.0f));
__this->set_m_OutTangent_3((0.0f));
return;
}
}
extern "C" void Keyframe__ctor_m2042404667_AdjustorThunk (Il2CppObject * __this, float ___time0, float ___value1, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
Keyframe__ctor_m2042404667(_thisAdjusted, ___time0, ___value1, method);
}
// System.Void UnityEngine.Keyframe::.ctor(System.Single,System.Single,System.Single,System.Single)
extern "C" void Keyframe__ctor_m140082843 (Keyframe_t1449471340 * __this, float ___time0, float ___value1, float ___inTangent2, float ___outTangent3, const MethodInfo* method)
{
{
float L_0 = ___time0;
__this->set_m_Time_0(L_0);
float L_1 = ___value1;
__this->set_m_Value_1(L_1);
float L_2 = ___inTangent2;
__this->set_m_InTangent_2(L_2);
float L_3 = ___outTangent3;
__this->set_m_OutTangent_3(L_3);
return;
}
}
extern "C" void Keyframe__ctor_m140082843_AdjustorThunk (Il2CppObject * __this, float ___time0, float ___value1, float ___inTangent2, float ___outTangent3, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
Keyframe__ctor_m140082843(_thisAdjusted, ___time0, ___value1, ___inTangent2, ___outTangent3, method);
}
// System.Single UnityEngine.Keyframe::get_time()
extern "C" float Keyframe_get_time_m2226372497 (Keyframe_t1449471340 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_Time_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Keyframe_get_time_m2226372497_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
return Keyframe_get_time_m2226372497(_thisAdjusted, method);
}
// System.Void UnityEngine.Keyframe::set_time(System.Single)
extern "C" void Keyframe_set_time_m848496062 (Keyframe_t1449471340 * __this, float ___value0, const MethodInfo* method)
{
{
float L_0 = ___value0;
__this->set_m_Time_0(L_0);
return;
}
}
extern "C" void Keyframe_set_time_m848496062_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
Keyframe_set_time_m848496062(_thisAdjusted, ___value0, method);
}
// System.Single UnityEngine.Keyframe::get_value()
extern "C" float Keyframe_get_value_m979894315 (Keyframe_t1449471340 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_Value_1();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Keyframe_get_value_m979894315_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
return Keyframe_get_value_m979894315(_thisAdjusted, method);
}
// System.Void UnityEngine.Keyframe::set_value(System.Single)
extern "C" void Keyframe_set_value_m2184486356 (Keyframe_t1449471340 * __this, float ___value0, const MethodInfo* method)
{
{
float L_0 = ___value0;
__this->set_m_Value_1(L_0);
return;
}
}
extern "C" void Keyframe_set_value_m2184486356_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
Keyframe_set_value_m2184486356(_thisAdjusted, ___value0, method);
}
// System.Single UnityEngine.Keyframe::get_inTangent()
extern "C" float Keyframe_get_inTangent_m3256944616 (Keyframe_t1449471340 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_InTangent_2();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Keyframe_get_inTangent_m3256944616_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
return Keyframe_get_inTangent_m3256944616(_thisAdjusted, method);
}
// System.Void UnityEngine.Keyframe::set_inTangent(System.Single)
extern "C" void Keyframe_set_inTangent_m4280114775 (Keyframe_t1449471340 * __this, float ___value0, const MethodInfo* method)
{
{
float L_0 = ___value0;
__this->set_m_InTangent_2(L_0);
return;
}
}
extern "C" void Keyframe_set_inTangent_m4280114775_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
Keyframe_set_inTangent_m4280114775(_thisAdjusted, ___value0, method);
}
// System.Single UnityEngine.Keyframe::get_outTangent()
extern "C" float Keyframe_get_outTangent_m1894374085 (Keyframe_t1449471340 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_OutTangent_3();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Keyframe_get_outTangent_m1894374085_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
return Keyframe_get_outTangent_m1894374085(_thisAdjusted, method);
}
// System.Void UnityEngine.Keyframe::set_outTangent(System.Single)
extern "C" void Keyframe_set_outTangent_m1054927214 (Keyframe_t1449471340 * __this, float ___value0, const MethodInfo* method)
{
{
float L_0 = ___value0;
__this->set_m_OutTangent_3(L_0);
return;
}
}
extern "C" void Keyframe_set_outTangent_m1054927214_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
Keyframe_set_outTangent_m1054927214(_thisAdjusted, ___value0, method);
}
// System.Int32 UnityEngine.Keyframe::get_tangentMode()
extern "C" int32_t Keyframe_get_tangentMode_m1869200796 (Keyframe_t1449471340 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
V_0 = 0;
goto IL_0008;
}
IL_0008:
{
int32_t L_0 = V_0;
return L_0;
}
}
extern "C" int32_t Keyframe_get_tangentMode_m1869200796_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
return Keyframe_get_tangentMode_m1869200796(_thisAdjusted, method);
}
// System.Void UnityEngine.Keyframe::set_tangentMode(System.Int32)
extern "C" void Keyframe_set_tangentMode_m1073266123 (Keyframe_t1449471340 * __this, int32_t ___value0, const MethodInfo* method)
{
{
return;
}
}
extern "C" void Keyframe_set_tangentMode_m1073266123_AdjustorThunk (Il2CppObject * __this, int32_t ___value0, const MethodInfo* method)
{
Keyframe_t1449471340 * _thisAdjusted = reinterpret_cast<Keyframe_t1449471340 *>(__this + 1);
Keyframe_set_tangentMode_m1073266123(_thisAdjusted, ___value0, method);
}
// System.Int32 UnityEngine.LayerMask::op_Implicit(UnityEngine.LayerMask)
extern "C" int32_t LayerMask_op_Implicit_m2135076047 (Il2CppObject * __this /* static, unused */, LayerMask_t3188175821 ___mask0, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (&___mask0)->get_m_Mask_0();
V_0 = L_0;
goto IL_000e;
}
IL_000e:
{
int32_t L_1 = V_0;
return L_1;
}
}
// UnityEngine.LayerMask UnityEngine.LayerMask::op_Implicit(System.Int32)
extern "C" LayerMask_t3188175821 LayerMask_op_Implicit_m3804506591 (Il2CppObject * __this /* static, unused */, int32_t ___intVal0, const MethodInfo* method)
{
LayerMask_t3188175821 V_0;
memset(&V_0, 0, sizeof(V_0));
LayerMask_t3188175821 V_1;
memset(&V_1, 0, sizeof(V_1));
{
int32_t L_0 = ___intVal0;
(&V_0)->set_m_Mask_0(L_0);
LayerMask_t3188175821 L_1 = V_0;
V_1 = L_1;
goto IL_0010;
}
IL_0010:
{
LayerMask_t3188175821 L_2 = V_1;
return L_2;
}
}
// System.Void UnityEngine.Logger::.ctor(UnityEngine.ILogHandler)
extern "C" void Logger__ctor_m3834134587 (Logger_t3328995178 * __this, Il2CppObject * ___logHandler0, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
Il2CppObject * L_0 = ___logHandler0;
Logger_set_logHandler_m2851576632(__this, L_0, /*hidden argument*/NULL);
Logger_set_logEnabled_m3852234466(__this, (bool)1, /*hidden argument*/NULL);
Logger_set_filterLogType_m1452353615(__this, 3, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.ILogHandler UnityEngine.Logger::get_logHandler()
extern "C" Il2CppObject * Logger_get_logHandler_m4190583509 (Logger_t3328995178 * __this, const MethodInfo* method)
{
Il2CppObject * V_0 = NULL;
{
Il2CppObject * L_0 = __this->get_U3ClogHandlerU3Ek__BackingField_0();
V_0 = L_0;
goto IL_000c;
}
IL_000c:
{
Il2CppObject * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.Logger::set_logHandler(UnityEngine.ILogHandler)
extern "C" void Logger_set_logHandler_m2851576632 (Logger_t3328995178 * __this, Il2CppObject * ___value0, const MethodInfo* method)
{
{
Il2CppObject * L_0 = ___value0;
__this->set_U3ClogHandlerU3Ek__BackingField_0(L_0);
return;
}
}
// System.Boolean UnityEngine.Logger::get_logEnabled()
extern "C" bool Logger_get_logEnabled_m3807759477 (Logger_t3328995178 * __this, const MethodInfo* method)
{
bool V_0 = false;
{
bool L_0 = __this->get_U3ClogEnabledU3Ek__BackingField_1();
V_0 = L_0;
goto IL_000c;
}
IL_000c:
{
bool L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.Logger::set_logEnabled(System.Boolean)
extern "C" void Logger_set_logEnabled_m3852234466 (Logger_t3328995178 * __this, bool ___value0, const MethodInfo* method)
{
{
bool L_0 = ___value0;
__this->set_U3ClogEnabledU3Ek__BackingField_1(L_0);
return;
}
}
// UnityEngine.LogType UnityEngine.Logger::get_filterLogType()
extern "C" int32_t Logger_get_filterLogType_m3672438698 (Logger_t3328995178 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_U3CfilterLogTypeU3Ek__BackingField_2();
V_0 = L_0;
goto IL_000c;
}
IL_000c:
{
int32_t L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.Logger::set_filterLogType(UnityEngine.LogType)
extern "C" void Logger_set_filterLogType_m1452353615 (Logger_t3328995178 * __this, int32_t ___value0, const MethodInfo* method)
{
{
int32_t L_0 = ___value0;
__this->set_U3CfilterLogTypeU3Ek__BackingField_2(L_0);
return;
}
}
// System.Boolean UnityEngine.Logger::IsLogTypeAllowed(UnityEngine.LogType)
extern "C" bool Logger_IsLogTypeAllowed_m1750132386 (Logger_t3328995178 * __this, int32_t ___logType0, const MethodInfo* method)
{
bool V_0 = false;
int32_t G_B4_0 = 0;
{
bool L_0 = Logger_get_logEnabled_m3807759477(__this, /*hidden argument*/NULL);
if (!L_0)
{
goto IL_0025;
}
}
{
int32_t L_1 = ___logType0;
int32_t L_2 = Logger_get_filterLogType_m3672438698(__this, /*hidden argument*/NULL);
if ((((int32_t)L_1) <= ((int32_t)L_2)))
{
goto IL_001e;
}
}
{
int32_t L_3 = ___logType0;
G_B4_0 = ((((int32_t)L_3) == ((int32_t)4))? 1 : 0);
goto IL_001f;
}
IL_001e:
{
G_B4_0 = 1;
}
IL_001f:
{
V_0 = (bool)G_B4_0;
goto IL_002c;
}
IL_0025:
{
V_0 = (bool)0;
goto IL_002c;
}
IL_002c:
{
bool L_4 = V_0;
return L_4;
}
}
// System.String UnityEngine.Logger::GetString(System.Object)
extern "C" String_t* Logger_GetString_m4086587133 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___message0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Logger_GetString_m4086587133_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
Il2CppObject * L_0 = ___message0;
if (!L_0)
{
goto IL_0012;
}
}
{
Il2CppObject * L_1 = ___message0;
String_t* L_2 = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, L_1);
G_B3_0 = L_2;
goto IL_0017;
}
IL_0012:
{
G_B3_0 = _stringLiteral1743625299;
}
IL_0017:
{
V_0 = G_B3_0;
goto IL_001d;
}
IL_001d:
{
String_t* L_3 = V_0;
return L_3;
}
}
// System.Void UnityEngine.Logger::Log(UnityEngine.LogType,System.Object)
extern "C" void Logger_Log_m3587255568 (Logger_t3328995178 * __this, int32_t ___logType0, Il2CppObject * ___message1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Logger_Log_m3587255568_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___logType0;
bool L_1 = Logger_IsLogTypeAllowed_m1750132386(__this, L_0, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_002e;
}
}
{
Il2CppObject * L_2 = Logger_get_logHandler_m4190583509(__this, /*hidden argument*/NULL);
int32_t L_3 = ___logType0;
ObjectU5BU5D_t3614634134* L_4 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)1));
Il2CppObject * L_5 = ___message1;
String_t* L_6 = Logger_GetString_m4086587133(NULL /*static, unused*/, L_5, /*hidden argument*/NULL);
ArrayElementTypeCheck (L_4, L_6);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)L_6);
InterfaceActionInvoker4< int32_t, Object_t1021602117 *, String_t*, ObjectU5BU5D_t3614634134* >::Invoke(0 /* System.Void UnityEngine.ILogHandler::LogFormat(UnityEngine.LogType,UnityEngine.Object,System.String,System.Object[]) */, ILogHandler_t264057413_il2cpp_TypeInfo_var, L_2, L_3, (Object_t1021602117 *)NULL, _stringLiteral104529068, L_4);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.Logger::Log(UnityEngine.LogType,System.Object,UnityEngine.Object)
extern "C" void Logger_Log_m4012064130 (Logger_t3328995178 * __this, int32_t ___logType0, Il2CppObject * ___message1, Object_t1021602117 * ___context2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Logger_Log_m4012064130_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___logType0;
bool L_1 = Logger_IsLogTypeAllowed_m1750132386(__this, L_0, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_002e;
}
}
{
Il2CppObject * L_2 = Logger_get_logHandler_m4190583509(__this, /*hidden argument*/NULL);
int32_t L_3 = ___logType0;
Object_t1021602117 * L_4 = ___context2;
ObjectU5BU5D_t3614634134* L_5 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)1));
Il2CppObject * L_6 = ___message1;
String_t* L_7 = Logger_GetString_m4086587133(NULL /*static, unused*/, L_6, /*hidden argument*/NULL);
ArrayElementTypeCheck (L_5, L_7);
(L_5)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)L_7);
InterfaceActionInvoker4< int32_t, Object_t1021602117 *, String_t*, ObjectU5BU5D_t3614634134* >::Invoke(0 /* System.Void UnityEngine.ILogHandler::LogFormat(UnityEngine.LogType,UnityEngine.Object,System.String,System.Object[]) */, ILogHandler_t264057413_il2cpp_TypeInfo_var, L_2, L_3, L_4, _stringLiteral104529068, L_5);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.Logger::LogFormat(UnityEngine.LogType,UnityEngine.Object,System.String,System.Object[])
extern "C" void Logger_LogFormat_m193464629 (Logger_t3328995178 * __this, int32_t ___logType0, Object_t1021602117 * ___context1, String_t* ___format2, ObjectU5BU5D_t3614634134* ___args3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Logger_LogFormat_m193464629_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___logType0;
bool L_1 = Logger_IsLogTypeAllowed_m1750132386(__this, L_0, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_001d;
}
}
{
Il2CppObject * L_2 = Logger_get_logHandler_m4190583509(__this, /*hidden argument*/NULL);
int32_t L_3 = ___logType0;
Object_t1021602117 * L_4 = ___context1;
String_t* L_5 = ___format2;
ObjectU5BU5D_t3614634134* L_6 = ___args3;
InterfaceActionInvoker4< int32_t, Object_t1021602117 *, String_t*, ObjectU5BU5D_t3614634134* >::Invoke(0 /* System.Void UnityEngine.ILogHandler::LogFormat(UnityEngine.LogType,UnityEngine.Object,System.String,System.Object[]) */, ILogHandler_t264057413_il2cpp_TypeInfo_var, L_2, L_3, L_4, L_5, L_6);
}
IL_001d:
{
return;
}
}
// System.Void UnityEngine.Logger::LogException(System.Exception,UnityEngine.Object)
extern "C" void Logger_LogException_m206035446 (Logger_t3328995178 * __this, Exception_t1927440687 * ___exception0, Object_t1021602117 * ___context1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Logger_LogException_m206035446_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
bool L_0 = Logger_get_logEnabled_m3807759477(__this, /*hidden argument*/NULL);
if (!L_0)
{
goto IL_0019;
}
}
{
Il2CppObject * L_1 = Logger_get_logHandler_m4190583509(__this, /*hidden argument*/NULL);
Exception_t1927440687 * L_2 = ___exception0;
Object_t1021602117 * L_3 = ___context1;
InterfaceActionInvoker2< Exception_t1927440687 *, Object_t1021602117 * >::Invoke(1 /* System.Void UnityEngine.ILogHandler::LogException(System.Exception,UnityEngine.Object) */, ILogHandler_t264057413_il2cpp_TypeInfo_var, L_1, L_2, L_3);
}
IL_0019:
{
return;
}
}
// System.Void UnityEngine.Material::.ctor(UnityEngine.Material)
extern "C" void Material__ctor_m1440882780 (Material_t193706927 * __this, Material_t193706927 * ___source0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Material__ctor_m1440882780_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object__ctor_m197157284(__this, /*hidden argument*/NULL);
Material_t193706927 * L_0 = ___source0;
Material_Internal_CreateWithMaterial_m2907597451(NULL /*static, unused*/, __this, L_0, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Texture UnityEngine.Material::get_mainTexture()
extern "C" Texture_t2243626319 * Material_get_mainTexture_m432794412 (Material_t193706927 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Material_get_mainTexture_m432794412_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Texture_t2243626319 * V_0 = NULL;
{
Texture_t2243626319 * L_0 = Material_GetTexture_m1257877102(__this, _stringLiteral4026354833, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_0012;
}
IL_0012:
{
Texture_t2243626319 * L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.Material::SetFloatImpl(System.Int32,System.Single)
extern "C" void Material_SetFloatImpl_m2784769558 (Material_t193706927 * __this, int32_t ___nameID0, float ___value1, const MethodInfo* method)
{
typedef void (*Material_SetFloatImpl_m2784769558_ftn) (Material_t193706927 *, int32_t, float);
static Material_SetFloatImpl_m2784769558_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Material_SetFloatImpl_m2784769558_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Material::SetFloatImpl(System.Int32,System.Single)");
_il2cpp_icall_func(__this, ___nameID0, ___value1);
}
// System.Void UnityEngine.Material::SetIntImpl(System.Int32,System.Int32)
extern "C" void Material_SetIntImpl_m4157631275 (Material_t193706927 * __this, int32_t ___nameID0, int32_t ___value1, const MethodInfo* method)
{
typedef void (*Material_SetIntImpl_m4157631275_ftn) (Material_t193706927 *, int32_t, int32_t);
static Material_SetIntImpl_m4157631275_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Material_SetIntImpl_m4157631275_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Material::SetIntImpl(System.Int32,System.Int32)");
_il2cpp_icall_func(__this, ___nameID0, ___value1);
}
// UnityEngine.Texture UnityEngine.Material::GetTextureImpl(System.Int32)
extern "C" Texture_t2243626319 * Material_GetTextureImpl_m623159197 (Material_t193706927 * __this, int32_t ___nameID0, const MethodInfo* method)
{
typedef Texture_t2243626319 * (*Material_GetTextureImpl_m623159197_ftn) (Material_t193706927 *, int32_t);
static Material_GetTextureImpl_m623159197_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Material_GetTextureImpl_m623159197_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Material::GetTextureImpl(System.Int32)");
return _il2cpp_icall_func(__this, ___nameID0);
}
// System.Boolean UnityEngine.Material::HasProperty(System.String)
extern "C" bool Material_HasProperty_m3511389613 (Material_t193706927 * __this, String_t* ___propertyName0, const MethodInfo* method)
{
bool V_0 = false;
{
String_t* L_0 = ___propertyName0;
int32_t L_1 = Shader_PropertyToID_m678579425(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
bool L_2 = Material_HasProperty_m3175512802(__this, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0013;
}
IL_0013:
{
bool L_3 = V_0;
return L_3;
}
}
// System.Boolean UnityEngine.Material::HasProperty(System.Int32)
extern "C" bool Material_HasProperty_m3175512802 (Material_t193706927 * __this, int32_t ___nameID0, const MethodInfo* method)
{
typedef bool (*Material_HasProperty_m3175512802_ftn) (Material_t193706927 *, int32_t);
static Material_HasProperty_m3175512802_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Material_HasProperty_m3175512802_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Material::HasProperty(System.Int32)");
return _il2cpp_icall_func(__this, ___nameID0);
}
// System.Void UnityEngine.Material::Internal_CreateWithMaterial(UnityEngine.Material,UnityEngine.Material)
extern "C" void Material_Internal_CreateWithMaterial_m2907597451 (Il2CppObject * __this /* static, unused */, Material_t193706927 * ___mono0, Material_t193706927 * ___source1, const MethodInfo* method)
{
typedef void (*Material_Internal_CreateWithMaterial_m2907597451_ftn) (Material_t193706927 *, Material_t193706927 *);
static Material_Internal_CreateWithMaterial_m2907597451_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Material_Internal_CreateWithMaterial_m2907597451_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Material::Internal_CreateWithMaterial(UnityEngine.Material,UnityEngine.Material)");
_il2cpp_icall_func(___mono0, ___source1);
}
// System.Void UnityEngine.Material::EnableKeyword(System.String)
extern "C" void Material_EnableKeyword_m3724752646 (Material_t193706927 * __this, String_t* ___keyword0, const MethodInfo* method)
{
typedef void (*Material_EnableKeyword_m3724752646_ftn) (Material_t193706927 *, String_t*);
static Material_EnableKeyword_m3724752646_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Material_EnableKeyword_m3724752646_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Material::EnableKeyword(System.String)");
_il2cpp_icall_func(__this, ___keyword0);
}
// System.Void UnityEngine.Material::DisableKeyword(System.String)
extern "C" void Material_DisableKeyword_m1204728089 (Material_t193706927 * __this, String_t* ___keyword0, const MethodInfo* method)
{
typedef void (*Material_DisableKeyword_m1204728089_ftn) (Material_t193706927 *, String_t*);
static Material_DisableKeyword_m1204728089_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Material_DisableKeyword_m1204728089_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Material::DisableKeyword(System.String)");
_il2cpp_icall_func(__this, ___keyword0);
}
// System.Void UnityEngine.Material::SetFloat(System.Int32,System.Single)
extern "C" void Material_SetFloat_m953675160 (Material_t193706927 * __this, int32_t ___nameID0, float ___value1, const MethodInfo* method)
{
{
int32_t L_0 = ___nameID0;
float L_1 = ___value1;
Material_SetFloatImpl_m2784769558(__this, L_0, L_1, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Material::SetInt(System.String,System.Int32)
extern "C" void Material_SetInt_m522302436 (Material_t193706927 * __this, String_t* ___name0, int32_t ___value1, const MethodInfo* method)
{
{
String_t* L_0 = ___name0;
int32_t L_1 = Shader_PropertyToID_m678579425(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
int32_t L_2 = ___value1;
Material_SetInt_m977568583(__this, L_1, L_2, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Material::SetInt(System.Int32,System.Int32)
extern "C" void Material_SetInt_m977568583 (Material_t193706927 * __this, int32_t ___nameID0, int32_t ___value1, const MethodInfo* method)
{
{
int32_t L_0 = ___nameID0;
int32_t L_1 = ___value1;
Material_SetIntImpl_m4157631275(__this, L_0, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Texture UnityEngine.Material::GetTexture(System.String)
extern "C" Texture_t2243626319 * Material_GetTexture_m1257877102 (Material_t193706927 * __this, String_t* ___name0, const MethodInfo* method)
{
Texture_t2243626319 * V_0 = NULL;
{
String_t* L_0 = ___name0;
int32_t L_1 = Shader_PropertyToID_m678579425(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
Texture_t2243626319 * L_2 = Material_GetTexture_m648312929(__this, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0013;
}
IL_0013:
{
Texture_t2243626319 * L_3 = V_0;
return L_3;
}
}
// UnityEngine.Texture UnityEngine.Material::GetTexture(System.Int32)
extern "C" Texture_t2243626319 * Material_GetTexture_m648312929 (Material_t193706927 * __this, int32_t ___nameID0, const MethodInfo* method)
{
Texture_t2243626319 * V_0 = NULL;
{
int32_t L_0 = ___nameID0;
Texture_t2243626319 * L_1 = Material_GetTextureImpl_m623159197(__this, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000e;
}
IL_000e:
{
Texture_t2243626319 * L_2 = V_0;
return L_2;
}
}
// System.Single UnityEngine.Mathf::Sin(System.Single)
extern "C" float Mathf_Sin_m831310046 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___f0;
double L_1 = sin((((double)((double)L_0))));
V_0 = (((float)((float)L_1)));
goto IL_000f;
}
IL_000f:
{
float L_2 = V_0;
return L_2;
}
}
// System.Single UnityEngine.Mathf::Cos(System.Single)
extern "C" float Mathf_Cos_m238853451 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___f0;
double L_1 = cos((((double)((double)L_0))));
V_0 = (((float)((float)L_1)));
goto IL_000f;
}
IL_000f:
{
float L_2 = V_0;
return L_2;
}
}
// System.Single UnityEngine.Mathf::Sqrt(System.Single)
extern "C" float Mathf_Sqrt_m2213915910 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___f0;
double L_1 = sqrt((((double)((double)L_0))));
V_0 = (((float)((float)L_1)));
goto IL_000f;
}
IL_000f:
{
float L_2 = V_0;
return L_2;
}
}
// System.Single UnityEngine.Mathf::Abs(System.Single)
extern "C" float Mathf_Abs_m1942863256 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___f0;
float L_1 = fabsf(L_0);
V_0 = (((float)((float)L_1)));
goto IL_000e;
}
IL_000e:
{
float L_2 = V_0;
return L_2;
}
}
// System.Single UnityEngine.Mathf::Min(System.Single,System.Single)
extern "C" float Mathf_Min_m1648492575 (Il2CppObject * __this /* static, unused */, float ___a0, float ___b1, const MethodInfo* method)
{
float V_0 = 0.0f;
float G_B3_0 = 0.0f;
{
float L_0 = ___a0;
float L_1 = ___b1;
if ((!(((float)L_0) < ((float)L_1))))
{
goto IL_000e;
}
}
{
float L_2 = ___a0;
G_B3_0 = L_2;
goto IL_000f;
}
IL_000e:
{
float L_3 = ___b1;
G_B3_0 = L_3;
}
IL_000f:
{
V_0 = G_B3_0;
goto IL_0015;
}
IL_0015:
{
float L_4 = V_0;
return L_4;
}
}
// System.Int32 UnityEngine.Mathf::Min(System.Int32,System.Int32)
extern "C" int32_t Mathf_Min_m2906823867 (Il2CppObject * __this /* static, unused */, int32_t ___a0, int32_t ___b1, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B3_0 = 0;
{
int32_t L_0 = ___a0;
int32_t L_1 = ___b1;
if ((((int32_t)L_0) >= ((int32_t)L_1)))
{
goto IL_000e;
}
}
{
int32_t L_2 = ___a0;
G_B3_0 = L_2;
goto IL_000f;
}
IL_000e:
{
int32_t L_3 = ___b1;
G_B3_0 = L_3;
}
IL_000f:
{
V_0 = G_B3_0;
goto IL_0015;
}
IL_0015:
{
int32_t L_4 = V_0;
return L_4;
}
}
// System.Single UnityEngine.Mathf::Max(System.Single,System.Single)
extern "C" float Mathf_Max_m2564622569 (Il2CppObject * __this /* static, unused */, float ___a0, float ___b1, const MethodInfo* method)
{
float V_0 = 0.0f;
float G_B3_0 = 0.0f;
{
float L_0 = ___a0;
float L_1 = ___b1;
if ((!(((float)L_0) > ((float)L_1))))
{
goto IL_000e;
}
}
{
float L_2 = ___a0;
G_B3_0 = L_2;
goto IL_000f;
}
IL_000e:
{
float L_3 = ___b1;
G_B3_0 = L_3;
}
IL_000f:
{
V_0 = G_B3_0;
goto IL_0015;
}
IL_0015:
{
float L_4 = V_0;
return L_4;
}
}
// System.Int32 UnityEngine.Mathf::Max(System.Int32,System.Int32)
extern "C" int32_t Mathf_Max_m1875893177 (Il2CppObject * __this /* static, unused */, int32_t ___a0, int32_t ___b1, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B3_0 = 0;
{
int32_t L_0 = ___a0;
int32_t L_1 = ___b1;
if ((((int32_t)L_0) <= ((int32_t)L_1)))
{
goto IL_000e;
}
}
{
int32_t L_2 = ___a0;
G_B3_0 = L_2;
goto IL_000f;
}
IL_000e:
{
int32_t L_3 = ___b1;
G_B3_0 = L_3;
}
IL_000f:
{
V_0 = G_B3_0;
goto IL_0015;
}
IL_0015:
{
int32_t L_4 = V_0;
return L_4;
}
}
// System.Single UnityEngine.Mathf::Pow(System.Single,System.Single)
extern "C" float Mathf_Pow_m3865188073 (Il2CppObject * __this /* static, unused */, float ___f0, float ___p1, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___f0;
float L_1 = ___p1;
double L_2 = pow((((double)((double)L_0))), (((double)((double)L_1))));
V_0 = (((float)((float)L_2)));
goto IL_0011;
}
IL_0011:
{
float L_3 = V_0;
return L_3;
}
}
// System.Single UnityEngine.Mathf::Log(System.Single,System.Single)
extern "C" float Mathf_Log_m3878563109 (Il2CppObject * __this /* static, unused */, float ___f0, float ___p1, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___f0;
float L_1 = ___p1;
double L_2 = Math_Log_m3325929366(NULL /*static, unused*/, (((double)((double)L_0))), (((double)((double)L_1))), /*hidden argument*/NULL);
V_0 = (((float)((float)L_2)));
goto IL_0011;
}
IL_0011:
{
float L_3 = V_0;
return L_3;
}
}
// System.Single UnityEngine.Mathf::Ceil(System.Single)
extern "C" float Mathf_Ceil_m3621406599 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___f0;
double L_1 = ceil((((double)((double)L_0))));
V_0 = (((float)((float)L_1)));
goto IL_000f;
}
IL_000f:
{
float L_2 = V_0;
return L_2;
}
}
// System.Single UnityEngine.Mathf::Floor(System.Single)
extern "C" float Mathf_Floor_m3472740614 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___f0;
double L_1 = floor((((double)((double)L_0))));
V_0 = (((float)((float)L_1)));
goto IL_000f;
}
IL_000f:
{
float L_2 = V_0;
return L_2;
}
}
// System.Single UnityEngine.Mathf::Round(System.Single)
extern "C" float Mathf_Round_m227387340 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___f0;
double L_1 = bankers_round((((double)((double)L_0))));
V_0 = (((float)((float)L_1)));
goto IL_000f;
}
IL_000f:
{
float L_2 = V_0;
return L_2;
}
}
// System.Int32 UnityEngine.Mathf::CeilToInt(System.Single)
extern "C" int32_t Mathf_CeilToInt_m2672598779 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
int32_t V_0 = 0;
{
float L_0 = ___f0;
double L_1 = ceil((((double)((double)L_0))));
V_0 = (((int32_t)((int32_t)L_1)));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 UnityEngine.Mathf::FloorToInt(System.Single)
extern "C" int32_t Mathf_FloorToInt_m4005035722 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
int32_t V_0 = 0;
{
float L_0 = ___f0;
double L_1 = floor((((double)((double)L_0))));
V_0 = (((int32_t)((int32_t)L_1)));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 UnityEngine.Mathf::RoundToInt(System.Single)
extern "C" int32_t Mathf_RoundToInt_m2927198556 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
int32_t V_0 = 0;
{
float L_0 = ___f0;
double L_1 = bankers_round((((double)((double)L_0))));
V_0 = (((int32_t)((int32_t)L_1)));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Single UnityEngine.Mathf::Sign(System.Single)
extern "C" float Mathf_Sign_m2039143327 (Il2CppObject * __this /* static, unused */, float ___f0, const MethodInfo* method)
{
float V_0 = 0.0f;
float G_B3_0 = 0.0f;
{
float L_0 = ___f0;
if ((!(((float)L_0) >= ((float)(0.0f)))))
{
goto IL_0016;
}
}
{
G_B3_0 = (1.0f);
goto IL_001b;
}
IL_0016:
{
G_B3_0 = (-1.0f);
}
IL_001b:
{
V_0 = G_B3_0;
goto IL_0021;
}
IL_0021:
{
float L_1 = V_0;
return L_1;
}
}
// System.Single UnityEngine.Mathf::Clamp(System.Single,System.Single,System.Single)
extern "C" float Mathf_Clamp_m2354025655 (Il2CppObject * __this /* static, unused */, float ___value0, float ___min1, float ___max2, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___value0;
float L_1 = ___min1;
if ((!(((float)L_0) < ((float)L_1))))
{
goto IL_0010;
}
}
{
float L_2 = ___min1;
___value0 = L_2;
goto IL_001a;
}
IL_0010:
{
float L_3 = ___value0;
float L_4 = ___max2;
if ((!(((float)L_3) > ((float)L_4))))
{
goto IL_001a;
}
}
{
float L_5 = ___max2;
___value0 = L_5;
}
IL_001a:
{
float L_6 = ___value0;
V_0 = L_6;
goto IL_0021;
}
IL_0021:
{
float L_7 = V_0;
return L_7;
}
}
// System.Int32 UnityEngine.Mathf::Clamp(System.Int32,System.Int32,System.Int32)
extern "C" int32_t Mathf_Clamp_m3542052159 (Il2CppObject * __this /* static, unused */, int32_t ___value0, int32_t ___min1, int32_t ___max2, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = ___value0;
int32_t L_1 = ___min1;
if ((((int32_t)L_0) >= ((int32_t)L_1)))
{
goto IL_0010;
}
}
{
int32_t L_2 = ___min1;
___value0 = L_2;
goto IL_001a;
}
IL_0010:
{
int32_t L_3 = ___value0;
int32_t L_4 = ___max2;
if ((((int32_t)L_3) <= ((int32_t)L_4)))
{
goto IL_001a;
}
}
{
int32_t L_5 = ___max2;
___value0 = L_5;
}
IL_001a:
{
int32_t L_6 = ___value0;
V_0 = L_6;
goto IL_0021;
}
IL_0021:
{
int32_t L_7 = V_0;
return L_7;
}
}
// System.Single UnityEngine.Mathf::Clamp01(System.Single)
extern "C" float Mathf_Clamp01_m3888954684 (Il2CppObject * __this /* static, unused */, float ___value0, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = ___value0;
if ((!(((float)L_0) < ((float)(0.0f)))))
{
goto IL_0017;
}
}
{
V_0 = (0.0f);
goto IL_0034;
}
IL_0017:
{
float L_1 = ___value0;
if ((!(((float)L_1) > ((float)(1.0f)))))
{
goto IL_002d;
}
}
{
V_0 = (1.0f);
goto IL_0034;
}
IL_002d:
{
float L_2 = ___value0;
V_0 = L_2;
goto IL_0034;
}
IL_0034:
{
float L_3 = V_0;
return L_3;
}
}
// System.Single UnityEngine.Mathf::Lerp(System.Single,System.Single,System.Single)
extern "C" float Mathf_Lerp_m1686556575 (Il2CppObject * __this /* static, unused */, float ___a0, float ___b1, float ___t2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mathf_Lerp_m1686556575_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
{
float L_0 = ___a0;
float L_1 = ___b1;
float L_2 = ___a0;
float L_3 = ___t2;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_4 = Mathf_Clamp01_m3888954684(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
V_0 = ((float)((float)L_0+(float)((float)((float)((float)((float)L_1-(float)L_2))*(float)L_4))));
goto IL_0013;
}
IL_0013:
{
float L_5 = V_0;
return L_5;
}
}
// System.Boolean UnityEngine.Mathf::Approximately(System.Single,System.Single)
extern "C" bool Mathf_Approximately_m1064446634 (Il2CppObject * __this /* static, unused */, float ___a0, float ___b1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mathf_Approximately_m1064446634_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
float L_0 = ___b1;
float L_1 = ___a0;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_2 = fabsf(((float)((float)L_0-(float)L_1)));
float L_3 = ___a0;
float L_4 = fabsf(L_3);
float L_5 = ___b1;
float L_6 = fabsf(L_5);
float L_7 = Mathf_Max_m2564622569(NULL /*static, unused*/, L_4, L_6, /*hidden argument*/NULL);
float L_8 = ((Mathf_t2336485820_StaticFields*)Mathf_t2336485820_il2cpp_TypeInfo_var->static_fields)->get_Epsilon_0();
float L_9 = Mathf_Max_m2564622569(NULL /*static, unused*/, ((float)((float)(1.0E-06f)*(float)L_7)), ((float)((float)L_8*(float)(8.0f))), /*hidden argument*/NULL);
V_0 = (bool)((((float)L_2) < ((float)L_9))? 1 : 0);
goto IL_0038;
}
IL_0038:
{
bool L_10 = V_0;
return L_10;
}
}
// System.Single UnityEngine.Mathf::SmoothDamp(System.Single,System.Single,System.Single&,System.Single,System.Single,System.Single)
extern "C" float Mathf_SmoothDamp_m1604773625 (Il2CppObject * __this /* static, unused */, float ___current0, float ___target1, float* ___currentVelocity2, float ___smoothTime3, float ___maxSpeed4, float ___deltaTime5, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mathf_SmoothDamp_m1604773625_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
float V_1 = 0.0f;
float V_2 = 0.0f;
float V_3 = 0.0f;
float V_4 = 0.0f;
float V_5 = 0.0f;
float V_6 = 0.0f;
float V_7 = 0.0f;
float V_8 = 0.0f;
{
float L_0 = ___smoothTime3;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_1 = Mathf_Max_m2564622569(NULL /*static, unused*/, (0.0001f), L_0, /*hidden argument*/NULL);
___smoothTime3 = L_1;
float L_2 = ___smoothTime3;
V_0 = ((float)((float)(2.0f)/(float)L_2));
float L_3 = V_0;
float L_4 = ___deltaTime5;
V_1 = ((float)((float)L_3*(float)L_4));
float L_5 = V_1;
float L_6 = V_1;
float L_7 = V_1;
float L_8 = V_1;
float L_9 = V_1;
float L_10 = V_1;
V_2 = ((float)((float)(1.0f)/(float)((float)((float)((float)((float)((float)((float)(1.0f)+(float)L_5))+(float)((float)((float)((float)((float)(0.48f)*(float)L_6))*(float)L_7))))+(float)((float)((float)((float)((float)((float)((float)(0.235f)*(float)L_8))*(float)L_9))*(float)L_10))))));
float L_11 = ___current0;
float L_12 = ___target1;
V_3 = ((float)((float)L_11-(float)L_12));
float L_13 = ___target1;
V_4 = L_13;
float L_14 = ___maxSpeed4;
float L_15 = ___smoothTime3;
V_5 = ((float)((float)L_14*(float)L_15));
float L_16 = V_3;
float L_17 = V_5;
float L_18 = V_5;
float L_19 = Mathf_Clamp_m2354025655(NULL /*static, unused*/, L_16, ((-L_17)), L_18, /*hidden argument*/NULL);
V_3 = L_19;
float L_20 = ___current0;
float L_21 = V_3;
___target1 = ((float)((float)L_20-(float)L_21));
float* L_22 = ___currentVelocity2;
float L_23 = V_0;
float L_24 = V_3;
float L_25 = ___deltaTime5;
V_6 = ((float)((float)((float)((float)(*((float*)L_22))+(float)((float)((float)L_23*(float)L_24))))*(float)L_25));
float* L_26 = ___currentVelocity2;
float* L_27 = ___currentVelocity2;
float L_28 = V_0;
float L_29 = V_6;
float L_30 = V_2;
*((float*)(L_26)) = (float)((float)((float)((float)((float)(*((float*)L_27))-(float)((float)((float)L_28*(float)L_29))))*(float)L_30));
float L_31 = ___target1;
float L_32 = V_3;
float L_33 = V_6;
float L_34 = V_2;
V_7 = ((float)((float)L_31+(float)((float)((float)((float)((float)L_32+(float)L_33))*(float)L_34))));
float L_35 = V_4;
float L_36 = ___current0;
float L_37 = V_7;
float L_38 = V_4;
if ((!(((uint32_t)((((float)((float)((float)L_35-(float)L_36))) > ((float)(0.0f)))? 1 : 0)) == ((uint32_t)((((float)L_37) > ((float)L_38))? 1 : 0)))))
{
goto IL_00a3;
}
}
{
float L_39 = V_4;
V_7 = L_39;
float* L_40 = ___currentVelocity2;
float L_41 = V_7;
float L_42 = V_4;
float L_43 = ___deltaTime5;
*((float*)(L_40)) = (float)((float)((float)((float)((float)L_41-(float)L_42))/(float)L_43));
}
IL_00a3:
{
float L_44 = V_7;
V_8 = L_44;
goto IL_00ac;
}
IL_00ac:
{
float L_45 = V_8;
return L_45;
}
}
// System.Single UnityEngine.Mathf::Repeat(System.Single,System.Single)
extern "C" float Mathf_Repeat_m943844734 (Il2CppObject * __this /* static, unused */, float ___t0, float ___length1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mathf_Repeat_m943844734_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
{
float L_0 = ___t0;
float L_1 = ___t0;
float L_2 = ___length1;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_3 = floorf(((float)((float)L_1/(float)L_2)));
float L_4 = ___length1;
V_0 = ((float)((float)L_0-(float)((float)((float)L_3*(float)L_4))));
goto IL_0013;
}
IL_0013:
{
float L_5 = V_0;
return L_5;
}
}
// System.Single UnityEngine.Mathf::InverseLerp(System.Single,System.Single,System.Single)
extern "C" float Mathf_InverseLerp_m55890283 (Il2CppObject * __this /* static, unused */, float ___a0, float ___b1, float ___value2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mathf_InverseLerp_m55890283_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
{
float L_0 = ___a0;
float L_1 = ___b1;
if ((((float)L_0) == ((float)L_1)))
{
goto IL_001a;
}
}
{
float L_2 = ___value2;
float L_3 = ___a0;
float L_4 = ___b1;
float L_5 = ___a0;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
float L_6 = Mathf_Clamp01_m3888954684(NULL /*static, unused*/, ((float)((float)((float)((float)L_2-(float)L_3))/(float)((float)((float)L_4-(float)L_5)))), /*hidden argument*/NULL);
V_0 = L_6;
goto IL_0025;
}
IL_001a:
{
V_0 = (0.0f);
goto IL_0025;
}
IL_0025:
{
float L_7 = V_0;
return L_7;
}
}
// System.Void UnityEngine.Mathf::.cctor()
extern "C" void Mathf__cctor_m326403828 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mathf__cctor_m326403828_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float G_B3_0;
memset(&G_B3_0, 0, sizeof(G_B3_0));
{
IL2CPP_RUNTIME_CLASS_INIT(MathfInternal_t715669973_il2cpp_TypeInfo_var);
bool L_0 = ((MathfInternal_t715669973_StaticFields*)MathfInternal_t715669973_il2cpp_TypeInfo_var->static_fields)->get_IsFlushToZeroEnabled_2();
if (!L_0)
{
goto IL_0016;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(MathfInternal_t715669973_il2cpp_TypeInfo_var);
float L_1 = ((MathfInternal_t715669973_StaticFields*)MathfInternal_t715669973_il2cpp_TypeInfo_var->static_fields)->get_FloatMinNormal_0();
il2cpp_codegen_memory_barrier();
G_B3_0 = L_1;
goto IL_001d;
}
IL_0016:
{
IL2CPP_RUNTIME_CLASS_INIT(MathfInternal_t715669973_il2cpp_TypeInfo_var);
float L_2 = ((MathfInternal_t715669973_StaticFields*)MathfInternal_t715669973_il2cpp_TypeInfo_var->static_fields)->get_FloatMinDenormal_1();
il2cpp_codegen_memory_barrier();
G_B3_0 = L_2;
}
IL_001d:
{
((Mathf_t2336485820_StaticFields*)Mathf_t2336485820_il2cpp_TypeInfo_var->static_fields)->set_Epsilon_0(G_B3_0);
return;
}
}
// System.Single UnityEngine.Matrix4x4::get_Item(System.Int32,System.Int32)
extern "C" float Matrix4x4_get_Item_m312280350 (Matrix4x4_t2933234003 * __this, int32_t ___row0, int32_t ___column1, const MethodInfo* method)
{
float V_0 = 0.0f;
{
int32_t L_0 = ___row0;
int32_t L_1 = ___column1;
float L_2 = Matrix4x4_get_Item_m3317262185(__this, ((int32_t)((int32_t)L_0+(int32_t)((int32_t)((int32_t)L_1*(int32_t)4)))), /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0012;
}
IL_0012:
{
float L_3 = V_0;
return L_3;
}
}
extern "C" float Matrix4x4_get_Item_m312280350_AdjustorThunk (Il2CppObject * __this, int32_t ___row0, int32_t ___column1, const MethodInfo* method)
{
Matrix4x4_t2933234003 * _thisAdjusted = reinterpret_cast<Matrix4x4_t2933234003 *>(__this + 1);
return Matrix4x4_get_Item_m312280350(_thisAdjusted, ___row0, ___column1, method);
}
// System.Single UnityEngine.Matrix4x4::get_Item(System.Int32)
extern "C" float Matrix4x4_get_Item_m3317262185 (Matrix4x4_t2933234003 * __this, int32_t ___index0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Matrix4x4_get_Item_m3317262185_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
{
int32_t L_0 = ___index0;
switch (L_0)
{
case 0:
{
goto IL_004c;
}
case 1:
{
goto IL_0058;
}
case 2:
{
goto IL_0064;
}
case 3:
{
goto IL_0070;
}
case 4:
{
goto IL_007c;
}
case 5:
{
goto IL_0088;
}
case 6:
{
goto IL_0094;
}
case 7:
{
goto IL_00a0;
}
case 8:
{
goto IL_00ac;
}
case 9:
{
goto IL_00b8;
}
case 10:
{
goto IL_00c4;
}
case 11:
{
goto IL_00d0;
}
case 12:
{
goto IL_00dc;
}
case 13:
{
goto IL_00e8;
}
case 14:
{
goto IL_00f4;
}
case 15:
{
goto IL_0100;
}
}
}
{
goto IL_010c;
}
IL_004c:
{
float L_1 = __this->get_m00_0();
V_0 = L_1;
goto IL_0117;
}
IL_0058:
{
float L_2 = __this->get_m10_1();
V_0 = L_2;
goto IL_0117;
}
IL_0064:
{
float L_3 = __this->get_m20_2();
V_0 = L_3;
goto IL_0117;
}
IL_0070:
{
float L_4 = __this->get_m30_3();
V_0 = L_4;
goto IL_0117;
}
IL_007c:
{
float L_5 = __this->get_m01_4();
V_0 = L_5;
goto IL_0117;
}
IL_0088:
{
float L_6 = __this->get_m11_5();
V_0 = L_6;
goto IL_0117;
}
IL_0094:
{
float L_7 = __this->get_m21_6();
V_0 = L_7;
goto IL_0117;
}
IL_00a0:
{
float L_8 = __this->get_m31_7();
V_0 = L_8;
goto IL_0117;
}
IL_00ac:
{
float L_9 = __this->get_m02_8();
V_0 = L_9;
goto IL_0117;
}
IL_00b8:
{
float L_10 = __this->get_m12_9();
V_0 = L_10;
goto IL_0117;
}
IL_00c4:
{
float L_11 = __this->get_m22_10();
V_0 = L_11;
goto IL_0117;
}
IL_00d0:
{
float L_12 = __this->get_m32_11();
V_0 = L_12;
goto IL_0117;
}
IL_00dc:
{
float L_13 = __this->get_m03_12();
V_0 = L_13;
goto IL_0117;
}
IL_00e8:
{
float L_14 = __this->get_m13_13();
V_0 = L_14;
goto IL_0117;
}
IL_00f4:
{
float L_15 = __this->get_m23_14();
V_0 = L_15;
goto IL_0117;
}
IL_0100:
{
float L_16 = __this->get_m33_15();
V_0 = L_16;
goto IL_0117;
}
IL_010c:
{
IndexOutOfRangeException_t3527622107 * L_17 = (IndexOutOfRangeException_t3527622107 *)il2cpp_codegen_object_new(IndexOutOfRangeException_t3527622107_il2cpp_TypeInfo_var);
IndexOutOfRangeException__ctor_m1847153122(L_17, _stringLiteral1338169977, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_17);
}
IL_0117:
{
float L_18 = V_0;
return L_18;
}
}
extern "C" float Matrix4x4_get_Item_m3317262185_AdjustorThunk (Il2CppObject * __this, int32_t ___index0, const MethodInfo* method)
{
Matrix4x4_t2933234003 * _thisAdjusted = reinterpret_cast<Matrix4x4_t2933234003 *>(__this + 1);
return Matrix4x4_get_Item_m3317262185(_thisAdjusted, ___index0, method);
}
// System.Int32 UnityEngine.Matrix4x4::GetHashCode()
extern "C" int32_t Matrix4x4_GetHashCode_m3649708037 (Matrix4x4_t2933234003 * __this, const MethodInfo* method)
{
Vector4_t2243707581 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector4_t2243707581 V_1;
memset(&V_1, 0, sizeof(V_1));
Vector4_t2243707581 V_2;
memset(&V_2, 0, sizeof(V_2));
Vector4_t2243707581 V_3;
memset(&V_3, 0, sizeof(V_3));
int32_t V_4 = 0;
{
Vector4_t2243707581 L_0 = Matrix4x4_GetColumn_m1367096730(__this, 0, /*hidden argument*/NULL);
V_0 = L_0;
int32_t L_1 = Vector4_GetHashCode_m1576457715((&V_0), /*hidden argument*/NULL);
Vector4_t2243707581 L_2 = Matrix4x4_GetColumn_m1367096730(__this, 1, /*hidden argument*/NULL);
V_1 = L_2;
int32_t L_3 = Vector4_GetHashCode_m1576457715((&V_1), /*hidden argument*/NULL);
Vector4_t2243707581 L_4 = Matrix4x4_GetColumn_m1367096730(__this, 2, /*hidden argument*/NULL);
V_2 = L_4;
int32_t L_5 = Vector4_GetHashCode_m1576457715((&V_2), /*hidden argument*/NULL);
Vector4_t2243707581 L_6 = Matrix4x4_GetColumn_m1367096730(__this, 3, /*hidden argument*/NULL);
V_3 = L_6;
int32_t L_7 = Vector4_GetHashCode_m1576457715((&V_3), /*hidden argument*/NULL);
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_1^(int32_t)((int32_t)((int32_t)L_3<<(int32_t)2))))^(int32_t)((int32_t)((int32_t)L_5>>(int32_t)2))))^(int32_t)((int32_t)((int32_t)L_7>>(int32_t)1))));
goto IL_0065;
}
IL_0065:
{
int32_t L_8 = V_4;
return L_8;
}
}
extern "C" int32_t Matrix4x4_GetHashCode_m3649708037_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Matrix4x4_t2933234003 * _thisAdjusted = reinterpret_cast<Matrix4x4_t2933234003 *>(__this + 1);
return Matrix4x4_GetHashCode_m3649708037(_thisAdjusted, method);
}
// System.Boolean UnityEngine.Matrix4x4::Equals(System.Object)
extern "C" bool Matrix4x4_Equals_m1321236479 (Matrix4x4_t2933234003 * __this, Il2CppObject * ___other0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Matrix4x4_Equals_m1321236479_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
Matrix4x4_t2933234003 V_1;
memset(&V_1, 0, sizeof(V_1));
Vector4_t2243707581 V_2;
memset(&V_2, 0, sizeof(V_2));
Vector4_t2243707581 V_3;
memset(&V_3, 0, sizeof(V_3));
Vector4_t2243707581 V_4;
memset(&V_4, 0, sizeof(V_4));
Vector4_t2243707581 V_5;
memset(&V_5, 0, sizeof(V_5));
int32_t G_B7_0 = 0;
{
Il2CppObject * L_0 = ___other0;
if (((Il2CppObject *)IsInstSealed(L_0, Matrix4x4_t2933234003_il2cpp_TypeInfo_var)))
{
goto IL_0013;
}
}
{
V_0 = (bool)0;
goto IL_00bc;
}
IL_0013:
{
Il2CppObject * L_1 = ___other0;
V_1 = ((*(Matrix4x4_t2933234003 *)((Matrix4x4_t2933234003 *)UnBox(L_1, Matrix4x4_t2933234003_il2cpp_TypeInfo_var))));
Vector4_t2243707581 L_2 = Matrix4x4_GetColumn_m1367096730(__this, 0, /*hidden argument*/NULL);
V_2 = L_2;
Vector4_t2243707581 L_3 = Matrix4x4_GetColumn_m1367096730((&V_1), 0, /*hidden argument*/NULL);
Vector4_t2243707581 L_4 = L_3;
Il2CppObject * L_5 = Box(Vector4_t2243707581_il2cpp_TypeInfo_var, &L_4);
bool L_6 = Vector4_Equals_m3783731577((&V_2), L_5, /*hidden argument*/NULL);
if (!L_6)
{
goto IL_00b5;
}
}
{
Vector4_t2243707581 L_7 = Matrix4x4_GetColumn_m1367096730(__this, 1, /*hidden argument*/NULL);
V_3 = L_7;
Vector4_t2243707581 L_8 = Matrix4x4_GetColumn_m1367096730((&V_1), 1, /*hidden argument*/NULL);
Vector4_t2243707581 L_9 = L_8;
Il2CppObject * L_10 = Box(Vector4_t2243707581_il2cpp_TypeInfo_var, &L_9);
bool L_11 = Vector4_Equals_m3783731577((&V_3), L_10, /*hidden argument*/NULL);
if (!L_11)
{
goto IL_00b5;
}
}
{
Vector4_t2243707581 L_12 = Matrix4x4_GetColumn_m1367096730(__this, 2, /*hidden argument*/NULL);
V_4 = L_12;
Vector4_t2243707581 L_13 = Matrix4x4_GetColumn_m1367096730((&V_1), 2, /*hidden argument*/NULL);
Vector4_t2243707581 L_14 = L_13;
Il2CppObject * L_15 = Box(Vector4_t2243707581_il2cpp_TypeInfo_var, &L_14);
bool L_16 = Vector4_Equals_m3783731577((&V_4), L_15, /*hidden argument*/NULL);
if (!L_16)
{
goto IL_00b5;
}
}
{
Vector4_t2243707581 L_17 = Matrix4x4_GetColumn_m1367096730(__this, 3, /*hidden argument*/NULL);
V_5 = L_17;
Vector4_t2243707581 L_18 = Matrix4x4_GetColumn_m1367096730((&V_1), 3, /*hidden argument*/NULL);
Vector4_t2243707581 L_19 = L_18;
Il2CppObject * L_20 = Box(Vector4_t2243707581_il2cpp_TypeInfo_var, &L_19);
bool L_21 = Vector4_Equals_m3783731577((&V_5), L_20, /*hidden argument*/NULL);
G_B7_0 = ((int32_t)(L_21));
goto IL_00b6;
}
IL_00b5:
{
G_B7_0 = 0;
}
IL_00b6:
{
V_0 = (bool)G_B7_0;
goto IL_00bc;
}
IL_00bc:
{
bool L_22 = V_0;
return L_22;
}
}
extern "C" bool Matrix4x4_Equals_m1321236479_AdjustorThunk (Il2CppObject * __this, Il2CppObject * ___other0, const MethodInfo* method)
{
Matrix4x4_t2933234003 * _thisAdjusted = reinterpret_cast<Matrix4x4_t2933234003 *>(__this + 1);
return Matrix4x4_Equals_m1321236479(_thisAdjusted, ___other0, method);
}
// UnityEngine.Vector4 UnityEngine.Matrix4x4::GetColumn(System.Int32)
extern "C" Vector4_t2243707581 Matrix4x4_GetColumn_m1367096730 (Matrix4x4_t2933234003 * __this, int32_t ___i0, const MethodInfo* method)
{
Vector4_t2243707581 V_0;
memset(&V_0, 0, sizeof(V_0));
{
int32_t L_0 = ___i0;
float L_1 = Matrix4x4_get_Item_m312280350(__this, 0, L_0, /*hidden argument*/NULL);
int32_t L_2 = ___i0;
float L_3 = Matrix4x4_get_Item_m312280350(__this, 1, L_2, /*hidden argument*/NULL);
int32_t L_4 = ___i0;
float L_5 = Matrix4x4_get_Item_m312280350(__this, 2, L_4, /*hidden argument*/NULL);
int32_t L_6 = ___i0;
float L_7 = Matrix4x4_get_Item_m312280350(__this, 3, L_6, /*hidden argument*/NULL);
Vector4_t2243707581 L_8;
memset(&L_8, 0, sizeof(L_8));
Vector4__ctor_m1222289168(&L_8, L_1, L_3, L_5, L_7, /*hidden argument*/NULL);
V_0 = L_8;
goto IL_002c;
}
IL_002c:
{
Vector4_t2243707581 L_9 = V_0;
return L_9;
}
}
extern "C" Vector4_t2243707581 Matrix4x4_GetColumn_m1367096730_AdjustorThunk (Il2CppObject * __this, int32_t ___i0, const MethodInfo* method)
{
Matrix4x4_t2933234003 * _thisAdjusted = reinterpret_cast<Matrix4x4_t2933234003 *>(__this + 1);
return Matrix4x4_GetColumn_m1367096730(_thisAdjusted, ___i0, method);
}
// UnityEngine.Vector3 UnityEngine.Matrix4x4::MultiplyPoint3x4(UnityEngine.Vector3)
extern "C" Vector3_t2243707580 Matrix4x4_MultiplyPoint3x4_m1007952212 (Matrix4x4_t2933234003 * __this, Vector3_t2243707580 ___v0, const MethodInfo* method)
{
Vector3_t2243707580 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector3_t2243707580 V_1;
memset(&V_1, 0, sizeof(V_1));
{
float L_0 = __this->get_m00_0();
float L_1 = (&___v0)->get_x_1();
float L_2 = __this->get_m01_4();
float L_3 = (&___v0)->get_y_2();
float L_4 = __this->get_m02_8();
float L_5 = (&___v0)->get_z_3();
float L_6 = __this->get_m03_12();
(&V_0)->set_x_1(((float)((float)((float)((float)((float)((float)((float)((float)L_0*(float)L_1))+(float)((float)((float)L_2*(float)L_3))))+(float)((float)((float)L_4*(float)L_5))))+(float)L_6)));
float L_7 = __this->get_m10_1();
float L_8 = (&___v0)->get_x_1();
float L_9 = __this->get_m11_5();
float L_10 = (&___v0)->get_y_2();
float L_11 = __this->get_m12_9();
float L_12 = (&___v0)->get_z_3();
float L_13 = __this->get_m13_13();
(&V_0)->set_y_2(((float)((float)((float)((float)((float)((float)((float)((float)L_7*(float)L_8))+(float)((float)((float)L_9*(float)L_10))))+(float)((float)((float)L_11*(float)L_12))))+(float)L_13)));
float L_14 = __this->get_m20_2();
float L_15 = (&___v0)->get_x_1();
float L_16 = __this->get_m21_6();
float L_17 = (&___v0)->get_y_2();
float L_18 = __this->get_m22_10();
float L_19 = (&___v0)->get_z_3();
float L_20 = __this->get_m23_14();
(&V_0)->set_z_3(((float)((float)((float)((float)((float)((float)((float)((float)L_14*(float)L_15))+(float)((float)((float)L_16*(float)L_17))))+(float)((float)((float)L_18*(float)L_19))))+(float)L_20)));
Vector3_t2243707580 L_21 = V_0;
V_1 = L_21;
goto IL_00b6;
}
IL_00b6:
{
Vector3_t2243707580 L_22 = V_1;
return L_22;
}
}
extern "C" Vector3_t2243707580 Matrix4x4_MultiplyPoint3x4_m1007952212_AdjustorThunk (Il2CppObject * __this, Vector3_t2243707580 ___v0, const MethodInfo* method)
{
Matrix4x4_t2933234003 * _thisAdjusted = reinterpret_cast<Matrix4x4_t2933234003 *>(__this + 1);
return Matrix4x4_MultiplyPoint3x4_m1007952212(_thisAdjusted, ___v0, method);
}
// System.String UnityEngine.Matrix4x4::ToString()
extern "C" String_t* Matrix4x4_ToString_m1982554457 (Matrix4x4_t2933234003 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Matrix4x4_ToString_m1982554457_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
ObjectU5BU5D_t3614634134* L_0 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)((int32_t)16)));
float L_1 = __this->get_m00_0();
float L_2 = L_1;
Il2CppObject * L_3 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_2);
ArrayElementTypeCheck (L_0, L_3);
(L_0)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)L_3);
ObjectU5BU5D_t3614634134* L_4 = L_0;
float L_5 = __this->get_m01_4();
float L_6 = L_5;
Il2CppObject * L_7 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_6);
ArrayElementTypeCheck (L_4, L_7);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (Il2CppObject *)L_7);
ObjectU5BU5D_t3614634134* L_8 = L_4;
float L_9 = __this->get_m02_8();
float L_10 = L_9;
Il2CppObject * L_11 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_10);
ArrayElementTypeCheck (L_8, L_11);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(2), (Il2CppObject *)L_11);
ObjectU5BU5D_t3614634134* L_12 = L_8;
float L_13 = __this->get_m03_12();
float L_14 = L_13;
Il2CppObject * L_15 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_14);
ArrayElementTypeCheck (L_12, L_15);
(L_12)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(3), (Il2CppObject *)L_15);
ObjectU5BU5D_t3614634134* L_16 = L_12;
float L_17 = __this->get_m10_1();
float L_18 = L_17;
Il2CppObject * L_19 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_18);
ArrayElementTypeCheck (L_16, L_19);
(L_16)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(4), (Il2CppObject *)L_19);
ObjectU5BU5D_t3614634134* L_20 = L_16;
float L_21 = __this->get_m11_5();
float L_22 = L_21;
Il2CppObject * L_23 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_22);
ArrayElementTypeCheck (L_20, L_23);
(L_20)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(5), (Il2CppObject *)L_23);
ObjectU5BU5D_t3614634134* L_24 = L_20;
float L_25 = __this->get_m12_9();
float L_26 = L_25;
Il2CppObject * L_27 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_26);
ArrayElementTypeCheck (L_24, L_27);
(L_24)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(6), (Il2CppObject *)L_27);
ObjectU5BU5D_t3614634134* L_28 = L_24;
float L_29 = __this->get_m13_13();
float L_30 = L_29;
Il2CppObject * L_31 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_30);
ArrayElementTypeCheck (L_28, L_31);
(L_28)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(7), (Il2CppObject *)L_31);
ObjectU5BU5D_t3614634134* L_32 = L_28;
float L_33 = __this->get_m20_2();
float L_34 = L_33;
Il2CppObject * L_35 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_34);
ArrayElementTypeCheck (L_32, L_35);
(L_32)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(8), (Il2CppObject *)L_35);
ObjectU5BU5D_t3614634134* L_36 = L_32;
float L_37 = __this->get_m21_6();
float L_38 = L_37;
Il2CppObject * L_39 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_38);
ArrayElementTypeCheck (L_36, L_39);
(L_36)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(((int32_t)9)), (Il2CppObject *)L_39);
ObjectU5BU5D_t3614634134* L_40 = L_36;
float L_41 = __this->get_m22_10();
float L_42 = L_41;
Il2CppObject * L_43 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_42);
ArrayElementTypeCheck (L_40, L_43);
(L_40)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(((int32_t)10)), (Il2CppObject *)L_43);
ObjectU5BU5D_t3614634134* L_44 = L_40;
float L_45 = __this->get_m23_14();
float L_46 = L_45;
Il2CppObject * L_47 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_46);
ArrayElementTypeCheck (L_44, L_47);
(L_44)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(((int32_t)11)), (Il2CppObject *)L_47);
ObjectU5BU5D_t3614634134* L_48 = L_44;
float L_49 = __this->get_m30_3();
float L_50 = L_49;
Il2CppObject * L_51 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_50);
ArrayElementTypeCheck (L_48, L_51);
(L_48)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(((int32_t)12)), (Il2CppObject *)L_51);
ObjectU5BU5D_t3614634134* L_52 = L_48;
float L_53 = __this->get_m31_7();
float L_54 = L_53;
Il2CppObject * L_55 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_54);
ArrayElementTypeCheck (L_52, L_55);
(L_52)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(((int32_t)13)), (Il2CppObject *)L_55);
ObjectU5BU5D_t3614634134* L_56 = L_52;
float L_57 = __this->get_m32_11();
float L_58 = L_57;
Il2CppObject * L_59 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_58);
ArrayElementTypeCheck (L_56, L_59);
(L_56)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(((int32_t)14)), (Il2CppObject *)L_59);
ObjectU5BU5D_t3614634134* L_60 = L_56;
float L_61 = __this->get_m33_15();
float L_62 = L_61;
Il2CppObject * L_63 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_62);
ArrayElementTypeCheck (L_60, L_63);
(L_60)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(((int32_t)15)), (Il2CppObject *)L_63);
String_t* L_64 = UnityString_Format_m2949645127(NULL /*static, unused*/, _stringLiteral3991437666, L_60, /*hidden argument*/NULL);
V_0 = L_64;
goto IL_00ff;
}
IL_00ff:
{
String_t* L_65 = V_0;
return L_65;
}
}
extern "C" String_t* Matrix4x4_ToString_m1982554457_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Matrix4x4_t2933234003 * _thisAdjusted = reinterpret_cast<Matrix4x4_t2933234003 *>(__this + 1);
return Matrix4x4_ToString_m1982554457(_thisAdjusted, method);
}
// System.Void UnityEngine.Mesh::.ctor()
extern "C" void Mesh__ctor_m2975981674 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh__ctor_m2975981674_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object__ctor_m197157284(__this, /*hidden argument*/NULL);
Mesh_Internal_Create_m1486058998(NULL /*static, unused*/, __this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Mesh::Internal_Create(UnityEngine.Mesh)
extern "C" void Mesh_Internal_Create_m1486058998 (Il2CppObject * __this /* static, unused */, Mesh_t1356156583 * ___mono0, const MethodInfo* method)
{
typedef void (*Mesh_Internal_Create_m1486058998_ftn) (Mesh_t1356156583 *);
static Mesh_Internal_Create_m1486058998_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_Internal_Create_m1486058998_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::Internal_Create(UnityEngine.Mesh)");
_il2cpp_icall_func(___mono0);
}
// System.Void UnityEngine.Mesh::Clear(System.Boolean)
extern "C" void Mesh_Clear_m3100797454 (Mesh_t1356156583 * __this, bool ___keepVertexLayout0, const MethodInfo* method)
{
typedef void (*Mesh_Clear_m3100797454_ftn) (Mesh_t1356156583 *, bool);
static Mesh_Clear_m3100797454_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_Clear_m3100797454_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::Clear(System.Boolean)");
_il2cpp_icall_func(__this, ___keepVertexLayout0);
}
// System.Void UnityEngine.Mesh::Clear()
extern "C" void Mesh_Clear_m231813403 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
bool V_0 = false;
{
V_0 = (bool)1;
bool L_0 = V_0;
Mesh_Clear_m3100797454(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Boolean UnityEngine.Mesh::get_canAccess()
extern "C" bool Mesh_get_canAccess_m2763498171 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
typedef bool (*Mesh_get_canAccess_m2763498171_ftn) (Mesh_t1356156583 *);
static Mesh_get_canAccess_m2763498171_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_get_canAccess_m2763498171_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::get_canAccess()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.Mesh::PrintErrorCantAccessMesh(UnityEngine.Mesh/InternalShaderChannel)
extern "C" void Mesh_PrintErrorCantAccessMesh_m2827771108 (Mesh_t1356156583 * __this, int32_t ___channel0, const MethodInfo* method)
{
typedef void (*Mesh_PrintErrorCantAccessMesh_m2827771108_ftn) (Mesh_t1356156583 *, int32_t);
static Mesh_PrintErrorCantAccessMesh_m2827771108_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_PrintErrorCantAccessMesh_m2827771108_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::PrintErrorCantAccessMesh(UnityEngine.Mesh/InternalShaderChannel)");
_il2cpp_icall_func(__this, ___channel0);
}
// System.Void UnityEngine.Mesh::PrintErrorCantAccessMeshForIndices()
extern "C" void Mesh_PrintErrorCantAccessMeshForIndices_m3276222682 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
typedef void (*Mesh_PrintErrorCantAccessMeshForIndices_m3276222682_ftn) (Mesh_t1356156583 *);
static Mesh_PrintErrorCantAccessMeshForIndices_m3276222682_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_PrintErrorCantAccessMeshForIndices_m3276222682_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::PrintErrorCantAccessMeshForIndices()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.Mesh::PrintErrorBadSubmeshIndexTriangles()
extern "C" void Mesh_PrintErrorBadSubmeshIndexTriangles_m3830862268 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
typedef void (*Mesh_PrintErrorBadSubmeshIndexTriangles_m3830862268_ftn) (Mesh_t1356156583 *);
static Mesh_PrintErrorBadSubmeshIndexTriangles_m3830862268_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_PrintErrorBadSubmeshIndexTriangles_m3830862268_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::PrintErrorBadSubmeshIndexTriangles()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.Mesh::PrintErrorBadSubmeshIndexIndices()
extern "C" void Mesh_PrintErrorBadSubmeshIndexIndices_m2104981732 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
typedef void (*Mesh_PrintErrorBadSubmeshIndexIndices_m2104981732_ftn) (Mesh_t1356156583 *);
static Mesh_PrintErrorBadSubmeshIndexIndices_m2104981732_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_PrintErrorBadSubmeshIndexIndices_m2104981732_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::PrintErrorBadSubmeshIndexIndices()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.Mesh::SetArrayForChannelImpl(UnityEngine.Mesh/InternalShaderChannel,UnityEngine.Mesh/InternalVertexChannelType,System.Int32,System.Array,System.Int32)
extern "C" void Mesh_SetArrayForChannelImpl_m271696022 (Mesh_t1356156583 * __this, int32_t ___channel0, int32_t ___format1, int32_t ___dim2, Il2CppArray * ___values3, int32_t ___arraySize4, const MethodInfo* method)
{
typedef void (*Mesh_SetArrayForChannelImpl_m271696022_ftn) (Mesh_t1356156583 *, int32_t, int32_t, int32_t, Il2CppArray *, int32_t);
static Mesh_SetArrayForChannelImpl_m271696022_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_SetArrayForChannelImpl_m271696022_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::SetArrayForChannelImpl(UnityEngine.Mesh/InternalShaderChannel,UnityEngine.Mesh/InternalVertexChannelType,System.Int32,System.Array,System.Int32)");
_il2cpp_icall_func(__this, ___channel0, ___format1, ___dim2, ___values3, ___arraySize4);
}
// System.Array UnityEngine.Mesh::GetAllocArrayFromChannelImpl(UnityEngine.Mesh/InternalShaderChannel,UnityEngine.Mesh/InternalVertexChannelType,System.Int32)
extern "C" Il2CppArray * Mesh_GetAllocArrayFromChannelImpl_m1663415136 (Mesh_t1356156583 * __this, int32_t ___channel0, int32_t ___format1, int32_t ___dim2, const MethodInfo* method)
{
typedef Il2CppArray * (*Mesh_GetAllocArrayFromChannelImpl_m1663415136_ftn) (Mesh_t1356156583 *, int32_t, int32_t, int32_t);
static Mesh_GetAllocArrayFromChannelImpl_m1663415136_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_GetAllocArrayFromChannelImpl_m1663415136_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::GetAllocArrayFromChannelImpl(UnityEngine.Mesh/InternalShaderChannel,UnityEngine.Mesh/InternalVertexChannelType,System.Int32)");
return _il2cpp_icall_func(__this, ___channel0, ___format1, ___dim2);
}
// System.Boolean UnityEngine.Mesh::HasChannel(UnityEngine.Mesh/InternalShaderChannel)
extern "C" bool Mesh_HasChannel_m3616583481 (Mesh_t1356156583 * __this, int32_t ___channel0, const MethodInfo* method)
{
typedef bool (*Mesh_HasChannel_m3616583481_ftn) (Mesh_t1356156583 *, int32_t);
static Mesh_HasChannel_m3616583481_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_HasChannel_m3616583481_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::HasChannel(UnityEngine.Mesh/InternalShaderChannel)");
return _il2cpp_icall_func(__this, ___channel0);
}
// System.Array UnityEngine.Mesh::ExtractArrayFromList(System.Object)
extern "C" Il2CppArray * Mesh_ExtractArrayFromList_m1349408169 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___list0, const MethodInfo* method)
{
typedef Il2CppArray * (*Mesh_ExtractArrayFromList_m1349408169_ftn) (Il2CppObject *);
static Mesh_ExtractArrayFromList_m1349408169_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_ExtractArrayFromList_m1349408169_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::ExtractArrayFromList(System.Object)");
return _il2cpp_icall_func(___list0);
}
// System.Int32[] UnityEngine.Mesh::GetIndicesImpl(System.Int32)
extern "C" Int32U5BU5D_t3030399641* Mesh_GetIndicesImpl_m2398977086 (Mesh_t1356156583 * __this, int32_t ___submesh0, const MethodInfo* method)
{
typedef Int32U5BU5D_t3030399641* (*Mesh_GetIndicesImpl_m2398977086_ftn) (Mesh_t1356156583 *, int32_t);
static Mesh_GetIndicesImpl_m2398977086_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_GetIndicesImpl_m2398977086_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::GetIndicesImpl(System.Int32)");
return _il2cpp_icall_func(__this, ___submesh0);
}
// System.Void UnityEngine.Mesh::SetTrianglesImpl(System.Int32,System.Array,System.Int32,System.Boolean)
extern "C" void Mesh_SetTrianglesImpl_m2743099196 (Mesh_t1356156583 * __this, int32_t ___submesh0, Il2CppArray * ___triangles1, int32_t ___arraySize2, bool ___calculateBounds3, const MethodInfo* method)
{
typedef void (*Mesh_SetTrianglesImpl_m2743099196_ftn) (Mesh_t1356156583 *, int32_t, Il2CppArray *, int32_t, bool);
static Mesh_SetTrianglesImpl_m2743099196_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_SetTrianglesImpl_m2743099196_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::SetTrianglesImpl(System.Int32,System.Array,System.Int32,System.Boolean)");
_il2cpp_icall_func(__this, ___submesh0, ___triangles1, ___arraySize2, ___calculateBounds3);
}
// System.Void UnityEngine.Mesh::SetTriangles(System.Collections.Generic.List`1<System.Int32>,System.Int32)
extern "C" void Mesh_SetTriangles_m2017297103 (Mesh_t1356156583 * __this, List_1_t1440998580 * ___triangles0, int32_t ___submesh1, const MethodInfo* method)
{
bool V_0 = false;
{
V_0 = (bool)1;
List_1_t1440998580 * L_0 = ___triangles0;
int32_t L_1 = ___submesh1;
bool L_2 = V_0;
Mesh_SetTriangles_m2506325172(__this, L_0, L_1, L_2, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Mesh::SetTriangles(System.Collections.Generic.List`1<System.Int32>,System.Int32,System.Boolean)
extern "C" void Mesh_SetTriangles_m2506325172 (Mesh_t1356156583 * __this, List_1_t1440998580 * ___triangles0, int32_t ___submesh1, bool ___calculateBounds2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_SetTriangles_m2506325172_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___submesh1;
bool L_1 = Mesh_CheckCanAccessSubmeshTriangles_m3203185587(__this, L_0, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0022;
}
}
{
int32_t L_2 = ___submesh1;
List_1_t1440998580 * L_3 = ___triangles0;
Il2CppArray * L_4 = Mesh_ExtractArrayFromList_m1349408169(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
List_1_t1440998580 * L_5 = ___triangles0;
int32_t L_6 = Mesh_SafeLength_TisInt32_t2071877448_m2504367186(__this, L_5, /*hidden argument*/Mesh_SafeLength_TisInt32_t2071877448_m2504367186_MethodInfo_var);
bool L_7 = ___calculateBounds2;
Mesh_SetTrianglesImpl_m2743099196(__this, L_2, L_4, L_6, L_7, /*hidden argument*/NULL);
}
IL_0022:
{
return;
}
}
// System.Void UnityEngine.Mesh::RecalculateBounds()
extern "C" void Mesh_RecalculateBounds_m3559909024 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
typedef void (*Mesh_RecalculateBounds_m3559909024_ftn) (Mesh_t1356156583 *);
static Mesh_RecalculateBounds_m3559909024_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_RecalculateBounds_m3559909024_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::RecalculateBounds()");
_il2cpp_icall_func(__this);
}
// System.Int32 UnityEngine.Mesh::get_subMeshCount()
extern "C" int32_t Mesh_get_subMeshCount_m1945011773 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
typedef int32_t (*Mesh_get_subMeshCount_m1945011773_ftn) (Mesh_t1356156583 *);
static Mesh_get_subMeshCount_m1945011773_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Mesh_get_subMeshCount_m1945011773_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Mesh::get_subMeshCount()");
return _il2cpp_icall_func(__this);
}
// UnityEngine.Mesh/InternalShaderChannel UnityEngine.Mesh::GetUVChannel(System.Int32)
extern "C" int32_t Mesh_GetUVChannel_m364477864 (Mesh_t1356156583 * __this, int32_t ___uvIndex0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_GetUVChannel_m364477864_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
int32_t L_0 = ___uvIndex0;
if ((((int32_t)L_0) < ((int32_t)0)))
{
goto IL_000f;
}
}
{
int32_t L_1 = ___uvIndex0;
if ((((int32_t)L_1) <= ((int32_t)3)))
{
goto IL_001f;
}
}
IL_000f:
{
ArgumentException_t3259014390 * L_2 = (ArgumentException_t3259014390 *)il2cpp_codegen_object_new(ArgumentException_t3259014390_il2cpp_TypeInfo_var);
ArgumentException__ctor_m544251339(L_2, _stringLiteral1489833396, _stringLiteral1296238845, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2);
}
IL_001f:
{
int32_t L_3 = ___uvIndex0;
V_0 = ((int32_t)((int32_t)3+(int32_t)L_3));
goto IL_0028;
}
IL_0028:
{
int32_t L_4 = V_0;
return L_4;
}
}
// System.Int32 UnityEngine.Mesh::DefaultDimensionForChannel(UnityEngine.Mesh/InternalShaderChannel)
extern "C" int32_t Mesh_DefaultDimensionForChannel_m153181993 (Il2CppObject * __this /* static, unused */, int32_t ___channel0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_DefaultDimensionForChannel_m153181993_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
int32_t L_0 = ___channel0;
if (!L_0)
{
goto IL_000e;
}
}
{
int32_t L_1 = ___channel0;
if ((!(((uint32_t)L_1) == ((uint32_t)1))))
{
goto IL_0015;
}
}
IL_000e:
{
V_0 = 3;
goto IL_004f;
}
IL_0015:
{
int32_t L_2 = ___channel0;
if ((((int32_t)L_2) < ((int32_t)3)))
{
goto IL_002a;
}
}
{
int32_t L_3 = ___channel0;
if ((((int32_t)L_3) > ((int32_t)6)))
{
goto IL_002a;
}
}
{
V_0 = 2;
goto IL_004f;
}
IL_002a:
{
int32_t L_4 = ___channel0;
if ((((int32_t)L_4) == ((int32_t)7)))
{
goto IL_0038;
}
}
{
int32_t L_5 = ___channel0;
if ((!(((uint32_t)L_5) == ((uint32_t)2))))
{
goto IL_003f;
}
}
IL_0038:
{
V_0 = 4;
goto IL_004f;
}
IL_003f:
{
ArgumentException_t3259014390 * L_6 = (ArgumentException_t3259014390 *)il2cpp_codegen_object_new(ArgumentException_t3259014390_il2cpp_TypeInfo_var);
ArgumentException__ctor_m544251339(L_6, _stringLiteral1066778515, _stringLiteral3637194755, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_6);
}
IL_004f:
{
int32_t L_7 = V_0;
return L_7;
}
}
// System.Void UnityEngine.Mesh::SetSizedArrayForChannel(UnityEngine.Mesh/InternalShaderChannel,UnityEngine.Mesh/InternalVertexChannelType,System.Int32,System.Array,System.Int32)
extern "C" void Mesh_SetSizedArrayForChannel_m299035387 (Mesh_t1356156583 * __this, int32_t ___channel0, int32_t ___format1, int32_t ___dim2, Il2CppArray * ___values3, int32_t ___valuesCount4, const MethodInfo* method)
{
{
bool L_0 = Mesh_get_canAccess_m2763498171(__this, /*hidden argument*/NULL);
if (!L_0)
{
goto IL_001e;
}
}
{
int32_t L_1 = ___channel0;
int32_t L_2 = ___format1;
int32_t L_3 = ___dim2;
Il2CppArray * L_4 = ___values3;
int32_t L_5 = ___valuesCount4;
Mesh_SetArrayForChannelImpl_m271696022(__this, L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
goto IL_0025;
}
IL_001e:
{
int32_t L_6 = ___channel0;
Mesh_PrintErrorCantAccessMesh_m2827771108(__this, L_6, /*hidden argument*/NULL);
}
IL_0025:
{
return;
}
}
// UnityEngine.Vector3[] UnityEngine.Mesh::get_vertices()
extern "C" Vector3U5BU5D_t1172311765* Mesh_get_vertices_m626989480 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_get_vertices_m626989480_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector3U5BU5D_t1172311765* V_0 = NULL;
{
Vector3U5BU5D_t1172311765* L_0 = Mesh_GetAllocArrayFromChannel_TisVector3_t2243707580_m2367580537(__this, 0, /*hidden argument*/Mesh_GetAllocArrayFromChannel_TisVector3_t2243707580_m2367580537_MethodInfo_var);
V_0 = L_0;
goto IL_000e;
}
IL_000e:
{
Vector3U5BU5D_t1172311765* L_1 = V_0;
return L_1;
}
}
// UnityEngine.Vector3[] UnityEngine.Mesh::get_normals()
extern "C" Vector3U5BU5D_t1172311765* Mesh_get_normals_m1837187359 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_get_normals_m1837187359_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector3U5BU5D_t1172311765* V_0 = NULL;
{
Vector3U5BU5D_t1172311765* L_0 = Mesh_GetAllocArrayFromChannel_TisVector3_t2243707580_m2367580537(__this, 1, /*hidden argument*/Mesh_GetAllocArrayFromChannel_TisVector3_t2243707580_m2367580537_MethodInfo_var);
V_0 = L_0;
goto IL_000e;
}
IL_000e:
{
Vector3U5BU5D_t1172311765* L_1 = V_0;
return L_1;
}
}
// UnityEngine.Vector4[] UnityEngine.Mesh::get_tangents()
extern "C" Vector4U5BU5D_t1658499504* Mesh_get_tangents_m2910922714 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_get_tangents_m2910922714_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector4U5BU5D_t1658499504* V_0 = NULL;
{
Vector4U5BU5D_t1658499504* L_0 = Mesh_GetAllocArrayFromChannel_TisVector4_t2243707581_m295947442(__this, 7, /*hidden argument*/Mesh_GetAllocArrayFromChannel_TisVector4_t2243707581_m295947442_MethodInfo_var);
V_0 = L_0;
goto IL_000e;
}
IL_000e:
{
Vector4U5BU5D_t1658499504* L_1 = V_0;
return L_1;
}
}
// UnityEngine.Vector2[] UnityEngine.Mesh::get_uv()
extern "C" Vector2U5BU5D_t686124026* Mesh_get_uv_m3811151337 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_get_uv_m3811151337_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2U5BU5D_t686124026* V_0 = NULL;
{
Vector2U5BU5D_t686124026* L_0 = Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716(__this, 3, /*hidden argument*/Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716_MethodInfo_var);
V_0 = L_0;
goto IL_000e;
}
IL_000e:
{
Vector2U5BU5D_t686124026* L_1 = V_0;
return L_1;
}
}
// UnityEngine.Vector2[] UnityEngine.Mesh::get_uv2()
extern "C" Vector2U5BU5D_t686124026* Mesh_get_uv2_m3215494975 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_get_uv2_m3215494975_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2U5BU5D_t686124026* V_0 = NULL;
{
Vector2U5BU5D_t686124026* L_0 = Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716(__this, 4, /*hidden argument*/Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716_MethodInfo_var);
V_0 = L_0;
goto IL_000e;
}
IL_000e:
{
Vector2U5BU5D_t686124026* L_1 = V_0;
return L_1;
}
}
// UnityEngine.Vector2[] UnityEngine.Mesh::get_uv3()
extern "C" Vector2U5BU5D_t686124026* Mesh_get_uv3_m3215494880 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_get_uv3_m3215494880_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2U5BU5D_t686124026* V_0 = NULL;
{
Vector2U5BU5D_t686124026* L_0 = Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716(__this, 5, /*hidden argument*/Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716_MethodInfo_var);
V_0 = L_0;
goto IL_000e;
}
IL_000e:
{
Vector2U5BU5D_t686124026* L_1 = V_0;
return L_1;
}
}
// UnityEngine.Vector2[] UnityEngine.Mesh::get_uv4()
extern "C" Vector2U5BU5D_t686124026* Mesh_get_uv4_m3215494777 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_get_uv4_m3215494777_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2U5BU5D_t686124026* V_0 = NULL;
{
Vector2U5BU5D_t686124026* L_0 = Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716(__this, 6, /*hidden argument*/Mesh_GetAllocArrayFromChannel_TisVector2_t2243707579_m3651973716_MethodInfo_var);
V_0 = L_0;
goto IL_000e;
}
IL_000e:
{
Vector2U5BU5D_t686124026* L_1 = V_0;
return L_1;
}
}
// UnityEngine.Color32[] UnityEngine.Mesh::get_colors32()
extern "C" Color32U5BU5D_t30278651* Mesh_get_colors32_m4153271224 (Mesh_t1356156583 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_get_colors32_m4153271224_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Color32U5BU5D_t30278651* V_0 = NULL;
{
Color32U5BU5D_t30278651* L_0 = Mesh_GetAllocArrayFromChannel_TisColor32_t874517518_m2030100417(__this, 2, 2, 1, /*hidden argument*/Mesh_GetAllocArrayFromChannel_TisColor32_t874517518_m2030100417_MethodInfo_var);
V_0 = L_0;
goto IL_0010;
}
IL_0010:
{
Color32U5BU5D_t30278651* L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.Mesh::SetVertices(System.Collections.Generic.List`1<UnityEngine.Vector3>)
extern "C" void Mesh_SetVertices_m3500868388 (Mesh_t1356156583 * __this, List_1_t1612828712 * ___inVertices0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_SetVertices_m3500868388_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
List_1_t1612828712 * L_0 = ___inVertices0;
Mesh_SetListForChannel_TisVector3_t2243707580_m2514561521(__this, 0, L_0, /*hidden argument*/Mesh_SetListForChannel_TisVector3_t2243707580_m2514561521_MethodInfo_var);
return;
}
}
// System.Void UnityEngine.Mesh::SetNormals(System.Collections.Generic.List`1<UnityEngine.Vector3>)
extern "C" void Mesh_SetNormals_m3341225499 (Mesh_t1356156583 * __this, List_1_t1612828712 * ___inNormals0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_SetNormals_m3341225499_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
List_1_t1612828712 * L_0 = ___inNormals0;
Mesh_SetListForChannel_TisVector3_t2243707580_m2514561521(__this, 1, L_0, /*hidden argument*/Mesh_SetListForChannel_TisVector3_t2243707580_m2514561521_MethodInfo_var);
return;
}
}
// System.Void UnityEngine.Mesh::SetTangents(System.Collections.Generic.List`1<UnityEngine.Vector4>)
extern "C" void Mesh_SetTangents_m282399504 (Mesh_t1356156583 * __this, List_1_t1612828713 * ___inTangents0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_SetTangents_m282399504_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
List_1_t1612828713 * L_0 = ___inTangents0;
Mesh_SetListForChannel_TisVector4_t2243707581_m3238986708(__this, 7, L_0, /*hidden argument*/Mesh_SetListForChannel_TisVector4_t2243707581_m3238986708_MethodInfo_var);
return;
}
}
// System.Void UnityEngine.Mesh::SetColors(System.Collections.Generic.List`1<UnityEngine.Color32>)
extern "C" void Mesh_SetColors_m3438776703 (Mesh_t1356156583 * __this, List_1_t243638650 * ___inColors0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_SetColors_m3438776703_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
List_1_t243638650 * L_0 = ___inColors0;
Mesh_SetListForChannel_TisColor32_t874517518_m1056672865(__this, 2, 2, 1, L_0, /*hidden argument*/Mesh_SetListForChannel_TisColor32_t874517518_m1056672865_MethodInfo_var);
return;
}
}
// System.Void UnityEngine.Mesh::SetUVs(System.Int32,System.Collections.Generic.List`1<UnityEngine.Vector2>)
extern "C" void Mesh_SetUVs_m841280343 (Mesh_t1356156583 * __this, int32_t ___channel0, List_1_t1612828711 * ___uvs1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_SetUVs_m841280343_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___channel0;
List_1_t1612828711 * L_1 = ___uvs1;
Mesh_SetUvsImpl_TisVector2_t2243707579_m3939959910(__this, L_0, 2, L_1, /*hidden argument*/Mesh_SetUvsImpl_TisVector2_t2243707579_m3939959910_MethodInfo_var);
return;
}
}
// System.Boolean UnityEngine.Mesh::CheckCanAccessSubmesh(System.Int32,System.Boolean)
extern "C" bool Mesh_CheckCanAccessSubmesh_m1826512193 (Mesh_t1356156583 * __this, int32_t ___submesh0, bool ___errorAboutTriangles1, const MethodInfo* method)
{
bool V_0 = false;
{
bool L_0 = Mesh_get_canAccess_m2763498171(__this, /*hidden argument*/NULL);
if (L_0)
{
goto IL_001a;
}
}
{
Mesh_PrintErrorCantAccessMeshForIndices_m3276222682(__this, /*hidden argument*/NULL);
V_0 = (bool)0;
goto IL_0053;
}
IL_001a:
{
int32_t L_1 = ___submesh0;
if ((((int32_t)L_1) < ((int32_t)0)))
{
goto IL_002d;
}
}
{
int32_t L_2 = ___submesh0;
int32_t L_3 = Mesh_get_subMeshCount_m1945011773(__this, /*hidden argument*/NULL);
if ((((int32_t)L_2) < ((int32_t)L_3)))
{
goto IL_004c;
}
}
IL_002d:
{
bool L_4 = ___errorAboutTriangles1;
if (!L_4)
{
goto IL_003f;
}
}
{
Mesh_PrintErrorBadSubmeshIndexTriangles_m3830862268(__this, /*hidden argument*/NULL);
goto IL_0045;
}
IL_003f:
{
Mesh_PrintErrorBadSubmeshIndexIndices_m2104981732(__this, /*hidden argument*/NULL);
}
IL_0045:
{
V_0 = (bool)0;
goto IL_0053;
}
IL_004c:
{
V_0 = (bool)1;
goto IL_0053;
}
IL_0053:
{
bool L_5 = V_0;
return L_5;
}
}
// System.Boolean UnityEngine.Mesh::CheckCanAccessSubmeshTriangles(System.Int32)
extern "C" bool Mesh_CheckCanAccessSubmeshTriangles_m3203185587 (Mesh_t1356156583 * __this, int32_t ___submesh0, const MethodInfo* method)
{
bool V_0 = false;
{
int32_t L_0 = ___submesh0;
bool L_1 = Mesh_CheckCanAccessSubmesh_m1826512193(__this, L_0, (bool)1, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000f;
}
IL_000f:
{
bool L_2 = V_0;
return L_2;
}
}
// System.Boolean UnityEngine.Mesh::CheckCanAccessSubmeshIndices(System.Int32)
extern "C" bool Mesh_CheckCanAccessSubmeshIndices_m2098382465 (Mesh_t1356156583 * __this, int32_t ___submesh0, const MethodInfo* method)
{
bool V_0 = false;
{
int32_t L_0 = ___submesh0;
bool L_1 = Mesh_CheckCanAccessSubmesh_m1826512193(__this, L_0, (bool)0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000f;
}
IL_000f:
{
bool L_2 = V_0;
return L_2;
}
}
// System.Int32[] UnityEngine.Mesh::GetIndices(System.Int32)
extern "C" Int32U5BU5D_t3030399641* Mesh_GetIndices_m3085881884 (Mesh_t1356156583 * __this, int32_t ___submesh0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Mesh_GetIndices_m3085881884_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Int32U5BU5D_t3030399641* V_0 = NULL;
Int32U5BU5D_t3030399641* G_B3_0 = NULL;
{
int32_t L_0 = ___submesh0;
bool L_1 = Mesh_CheckCanAccessSubmeshIndices_m2098382465(__this, L_0, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0019;
}
}
{
int32_t L_2 = ___submesh0;
Int32U5BU5D_t3030399641* L_3 = Mesh_GetIndicesImpl_m2398977086(__this, L_2, /*hidden argument*/NULL);
G_B3_0 = L_3;
goto IL_001f;
}
IL_0019:
{
G_B3_0 = ((Int32U5BU5D_t3030399641*)SZArrayNew(Int32U5BU5D_t3030399641_il2cpp_TypeInfo_var, (uint32_t)0));
}
IL_001f:
{
V_0 = G_B3_0;
goto IL_0025;
}
IL_0025:
{
Int32U5BU5D_t3030399641* L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.MonoBehaviour::.ctor()
extern "C" void MonoBehaviour__ctor_m2464341955 (MonoBehaviour_t1158329972 * __this, const MethodInfo* method)
{
{
Behaviour__ctor_m2699265412(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.MonoBehaviour::Internal_CancelInvokeAll()
extern "C" void MonoBehaviour_Internal_CancelInvokeAll_m3154116776 (MonoBehaviour_t1158329972 * __this, const MethodInfo* method)
{
typedef void (*MonoBehaviour_Internal_CancelInvokeAll_m3154116776_ftn) (MonoBehaviour_t1158329972 *);
static MonoBehaviour_Internal_CancelInvokeAll_m3154116776_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_Internal_CancelInvokeAll_m3154116776_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::Internal_CancelInvokeAll()");
_il2cpp_icall_func(__this);
}
// System.Boolean UnityEngine.MonoBehaviour::Internal_IsInvokingAll()
extern "C" bool MonoBehaviour_Internal_IsInvokingAll_m3504849565 (MonoBehaviour_t1158329972 * __this, const MethodInfo* method)
{
typedef bool (*MonoBehaviour_Internal_IsInvokingAll_m3504849565_ftn) (MonoBehaviour_t1158329972 *);
static MonoBehaviour_Internal_IsInvokingAll_m3504849565_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_Internal_IsInvokingAll_m3504849565_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::Internal_IsInvokingAll()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.MonoBehaviour::Invoke(System.String,System.Single)
extern "C" void MonoBehaviour_Invoke_m666563676 (MonoBehaviour_t1158329972 * __this, String_t* ___methodName0, float ___time1, const MethodInfo* method)
{
typedef void (*MonoBehaviour_Invoke_m666563676_ftn) (MonoBehaviour_t1158329972 *, String_t*, float);
static MonoBehaviour_Invoke_m666563676_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_Invoke_m666563676_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::Invoke(System.String,System.Single)");
_il2cpp_icall_func(__this, ___methodName0, ___time1);
}
// System.Void UnityEngine.MonoBehaviour::InvokeRepeating(System.String,System.Single,System.Single)
extern "C" void MonoBehaviour_InvokeRepeating_m3468262484 (MonoBehaviour_t1158329972 * __this, String_t* ___methodName0, float ___time1, float ___repeatRate2, const MethodInfo* method)
{
typedef void (*MonoBehaviour_InvokeRepeating_m3468262484_ftn) (MonoBehaviour_t1158329972 *, String_t*, float, float);
static MonoBehaviour_InvokeRepeating_m3468262484_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_InvokeRepeating_m3468262484_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::InvokeRepeating(System.String,System.Single,System.Single)");
_il2cpp_icall_func(__this, ___methodName0, ___time1, ___repeatRate2);
}
// System.Void UnityEngine.MonoBehaviour::CancelInvoke()
extern "C" void MonoBehaviour_CancelInvoke_m744713777 (MonoBehaviour_t1158329972 * __this, const MethodInfo* method)
{
{
MonoBehaviour_Internal_CancelInvokeAll_m3154116776(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.MonoBehaviour::CancelInvoke(System.String)
extern "C" void MonoBehaviour_CancelInvoke_m2508161963 (MonoBehaviour_t1158329972 * __this, String_t* ___methodName0, const MethodInfo* method)
{
typedef void (*MonoBehaviour_CancelInvoke_m2508161963_ftn) (MonoBehaviour_t1158329972 *, String_t*);
static MonoBehaviour_CancelInvoke_m2508161963_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_CancelInvoke_m2508161963_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::CancelInvoke(System.String)");
_il2cpp_icall_func(__this, ___methodName0);
}
// System.Boolean UnityEngine.MonoBehaviour::IsInvoking(System.String)
extern "C" bool MonoBehaviour_IsInvoking_m1469271462 (MonoBehaviour_t1158329972 * __this, String_t* ___methodName0, const MethodInfo* method)
{
typedef bool (*MonoBehaviour_IsInvoking_m1469271462_ftn) (MonoBehaviour_t1158329972 *, String_t*);
static MonoBehaviour_IsInvoking_m1469271462_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_IsInvoking_m1469271462_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::IsInvoking(System.String)");
return _il2cpp_icall_func(__this, ___methodName0);
}
// System.Boolean UnityEngine.MonoBehaviour::IsInvoking()
extern "C" bool MonoBehaviour_IsInvoking_m345622956 (MonoBehaviour_t1158329972 * __this, const MethodInfo* method)
{
bool V_0 = false;
{
bool L_0 = MonoBehaviour_Internal_IsInvokingAll_m3504849565(__this, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
bool L_1 = V_0;
return L_1;
}
}
// UnityEngine.Coroutine UnityEngine.MonoBehaviour::StartCoroutine(System.Collections.IEnumerator)
extern "C" Coroutine_t2299508840 * MonoBehaviour_StartCoroutine_m2470621050 (MonoBehaviour_t1158329972 * __this, Il2CppObject * ___routine0, const MethodInfo* method)
{
Coroutine_t2299508840 * V_0 = NULL;
{
Il2CppObject * L_0 = ___routine0;
Coroutine_t2299508840 * L_1 = MonoBehaviour_StartCoroutine_Auto_Internal_m1014513456(__this, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000e;
}
IL_000e:
{
Coroutine_t2299508840 * L_2 = V_0;
return L_2;
}
}
// UnityEngine.Coroutine UnityEngine.MonoBehaviour::StartCoroutine_Auto(System.Collections.IEnumerator)
extern "C" Coroutine_t2299508840 * MonoBehaviour_StartCoroutine_Auto_m1744905232 (MonoBehaviour_t1158329972 * __this, Il2CppObject * ___routine0, const MethodInfo* method)
{
Coroutine_t2299508840 * V_0 = NULL;
{
Il2CppObject * L_0 = ___routine0;
Coroutine_t2299508840 * L_1 = MonoBehaviour_StartCoroutine_m2470621050(__this, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000e;
}
IL_000e:
{
Coroutine_t2299508840 * L_2 = V_0;
return L_2;
}
}
// UnityEngine.Coroutine UnityEngine.MonoBehaviour::StartCoroutine_Auto_Internal(System.Collections.IEnumerator)
extern "C" Coroutine_t2299508840 * MonoBehaviour_StartCoroutine_Auto_Internal_m1014513456 (MonoBehaviour_t1158329972 * __this, Il2CppObject * ___routine0, const MethodInfo* method)
{
typedef Coroutine_t2299508840 * (*MonoBehaviour_StartCoroutine_Auto_Internal_m1014513456_ftn) (MonoBehaviour_t1158329972 *, Il2CppObject *);
static MonoBehaviour_StartCoroutine_Auto_Internal_m1014513456_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_StartCoroutine_Auto_Internal_m1014513456_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::StartCoroutine_Auto_Internal(System.Collections.IEnumerator)");
return _il2cpp_icall_func(__this, ___routine0);
}
// UnityEngine.Coroutine UnityEngine.MonoBehaviour::StartCoroutine(System.String,System.Object)
extern "C" Coroutine_t2299508840 * MonoBehaviour_StartCoroutine_m296997955 (MonoBehaviour_t1158329972 * __this, String_t* ___methodName0, Il2CppObject * ___value1, const MethodInfo* method)
{
typedef Coroutine_t2299508840 * (*MonoBehaviour_StartCoroutine_m296997955_ftn) (MonoBehaviour_t1158329972 *, String_t*, Il2CppObject *);
static MonoBehaviour_StartCoroutine_m296997955_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_StartCoroutine_m296997955_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::StartCoroutine(System.String,System.Object)");
return _il2cpp_icall_func(__this, ___methodName0, ___value1);
}
// UnityEngine.Coroutine UnityEngine.MonoBehaviour::StartCoroutine(System.String)
extern "C" Coroutine_t2299508840 * MonoBehaviour_StartCoroutine_m1399371129 (MonoBehaviour_t1158329972 * __this, String_t* ___methodName0, const MethodInfo* method)
{
Il2CppObject * V_0 = NULL;
Coroutine_t2299508840 * V_1 = NULL;
{
V_0 = NULL;
String_t* L_0 = ___methodName0;
Il2CppObject * L_1 = V_0;
Coroutine_t2299508840 * L_2 = MonoBehaviour_StartCoroutine_m296997955(__this, L_0, L_1, /*hidden argument*/NULL);
V_1 = L_2;
goto IL_0011;
}
IL_0011:
{
Coroutine_t2299508840 * L_3 = V_1;
return L_3;
}
}
// System.Void UnityEngine.MonoBehaviour::StopCoroutine(System.String)
extern "C" void MonoBehaviour_StopCoroutine_m987450539 (MonoBehaviour_t1158329972 * __this, String_t* ___methodName0, const MethodInfo* method)
{
typedef void (*MonoBehaviour_StopCoroutine_m987450539_ftn) (MonoBehaviour_t1158329972 *, String_t*);
static MonoBehaviour_StopCoroutine_m987450539_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_StopCoroutine_m987450539_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::StopCoroutine(System.String)");
_il2cpp_icall_func(__this, ___methodName0);
}
// System.Void UnityEngine.MonoBehaviour::StopCoroutine(System.Collections.IEnumerator)
extern "C" void MonoBehaviour_StopCoroutine_m1170478282 (MonoBehaviour_t1158329972 * __this, Il2CppObject * ___routine0, const MethodInfo* method)
{
{
Il2CppObject * L_0 = ___routine0;
MonoBehaviour_StopCoroutineViaEnumerator_Auto_m4046945826(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.MonoBehaviour::StopCoroutine(UnityEngine.Coroutine)
extern "C" void MonoBehaviour_StopCoroutine_m1668572632 (MonoBehaviour_t1158329972 * __this, Coroutine_t2299508840 * ___routine0, const MethodInfo* method)
{
{
Coroutine_t2299508840 * L_0 = ___routine0;
MonoBehaviour_StopCoroutine_Auto_m1923670638(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.MonoBehaviour::StopCoroutineViaEnumerator_Auto(System.Collections.IEnumerator)
extern "C" void MonoBehaviour_StopCoroutineViaEnumerator_Auto_m4046945826 (MonoBehaviour_t1158329972 * __this, Il2CppObject * ___routine0, const MethodInfo* method)
{
typedef void (*MonoBehaviour_StopCoroutineViaEnumerator_Auto_m4046945826_ftn) (MonoBehaviour_t1158329972 *, Il2CppObject *);
static MonoBehaviour_StopCoroutineViaEnumerator_Auto_m4046945826_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_StopCoroutineViaEnumerator_Auto_m4046945826_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::StopCoroutineViaEnumerator_Auto(System.Collections.IEnumerator)");
_il2cpp_icall_func(__this, ___routine0);
}
// System.Void UnityEngine.MonoBehaviour::StopCoroutine_Auto(UnityEngine.Coroutine)
extern "C" void MonoBehaviour_StopCoroutine_Auto_m1923670638 (MonoBehaviour_t1158329972 * __this, Coroutine_t2299508840 * ___routine0, const MethodInfo* method)
{
typedef void (*MonoBehaviour_StopCoroutine_Auto_m1923670638_ftn) (MonoBehaviour_t1158329972 *, Coroutine_t2299508840 *);
static MonoBehaviour_StopCoroutine_Auto_m1923670638_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_StopCoroutine_Auto_m1923670638_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::StopCoroutine_Auto(UnityEngine.Coroutine)");
_il2cpp_icall_func(__this, ___routine0);
}
// System.Void UnityEngine.MonoBehaviour::StopAllCoroutines()
extern "C" void MonoBehaviour_StopAllCoroutines_m1675795839 (MonoBehaviour_t1158329972 * __this, const MethodInfo* method)
{
typedef void (*MonoBehaviour_StopAllCoroutines_m1675795839_ftn) (MonoBehaviour_t1158329972 *);
static MonoBehaviour_StopAllCoroutines_m1675795839_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_StopAllCoroutines_m1675795839_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::StopAllCoroutines()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.MonoBehaviour::print(System.Object)
extern "C" void MonoBehaviour_print_m3437620292 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___message0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (MonoBehaviour_print_m3437620292_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Il2CppObject * L_0 = ___message0;
IL2CPP_RUNTIME_CLASS_INIT(Debug_t1368543263_il2cpp_TypeInfo_var);
Debug_Log_m920475918(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Boolean UnityEngine.MonoBehaviour::get_useGUILayout()
extern "C" bool MonoBehaviour_get_useGUILayout_m524237270 (MonoBehaviour_t1158329972 * __this, const MethodInfo* method)
{
typedef bool (*MonoBehaviour_get_useGUILayout_m524237270_ftn) (MonoBehaviour_t1158329972 *);
static MonoBehaviour_get_useGUILayout_m524237270_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_get_useGUILayout_m524237270_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::get_useGUILayout()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.MonoBehaviour::set_useGUILayout(System.Boolean)
extern "C" void MonoBehaviour_set_useGUILayout_m2666356651 (MonoBehaviour_t1158329972 * __this, bool ___value0, const MethodInfo* method)
{
typedef void (*MonoBehaviour_set_useGUILayout_m2666356651_ftn) (MonoBehaviour_t1158329972 *, bool);
static MonoBehaviour_set_useGUILayout_m2666356651_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (MonoBehaviour_set_useGUILayout_m2666356651_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.MonoBehaviour::set_useGUILayout(System.Boolean)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.NativeClassAttribute::.ctor(System.String)
extern "C" void NativeClassAttribute__ctor_m3215217838 (NativeClassAttribute_t1576243993 * __this, String_t* ___qualifiedCppName0, const MethodInfo* method)
{
{
Attribute__ctor_m1730479323(__this, /*hidden argument*/NULL);
String_t* L_0 = ___qualifiedCppName0;
NativeClassAttribute_set_QualifiedNativeName_m2790580781(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.NativeClassAttribute::set_QualifiedNativeName(System.String)
extern "C" void NativeClassAttribute_set_QualifiedNativeName_m2790580781 (NativeClassAttribute_t1576243993 * __this, String_t* ___value0, const MethodInfo* method)
{
{
String_t* L_0 = ___value0;
__this->set_U3CQualifiedNativeNameU3Ek__BackingField_0(L_0);
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.MessageEventArgs::.ctor()
extern "C" void MessageEventArgs__ctor_m2154443826 (MessageEventArgs_t301283622 * __this, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerConnection::.ctor()
extern "C" void PlayerConnection__ctor_m956924263 (PlayerConnection_t3517219175 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (PlayerConnection__ctor_m956924263_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
PlayerEditorConnectionEvents_t2252784345 * L_0 = (PlayerEditorConnectionEvents_t2252784345 *)il2cpp_codegen_object_new(PlayerEditorConnectionEvents_t2252784345_il2cpp_TypeInfo_var);
PlayerEditorConnectionEvents__ctor_m603950945(L_0, /*hidden argument*/NULL);
__this->set_m_PlayerEditorConnectionEvents_2(L_0);
List_1_t1440998580 * L_1 = (List_1_t1440998580 *)il2cpp_codegen_object_new(List_1_t1440998580_il2cpp_TypeInfo_var);
List_1__ctor_m1598946593(L_1, /*hidden argument*/List_1__ctor_m1598946593_MethodInfo_var);
__this->set_m_connectedPlayers_3(L_1);
ScriptableObject__ctor_m2671490429(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Networking.PlayerConnection.PlayerConnection UnityEngine.Networking.PlayerConnection.PlayerConnection::get_instance()
extern "C" PlayerConnection_t3517219175 * PlayerConnection_get_instance_m3885313185 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (PlayerConnection_get_instance_m3885313185_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
PlayerConnection_t3517219175 * V_0 = NULL;
{
PlayerConnection_t3517219175 * L_0 = ((PlayerConnection_t3517219175_StaticFields*)PlayerConnection_t3517219175_il2cpp_TypeInfo_var->static_fields)->get_s_Instance_4();
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_1 = Object_op_Equality_m3764089466(NULL /*static, unused*/, L_0, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_001d;
}
}
{
PlayerConnection_t3517219175 * L_2 = PlayerConnection_CreateInstance_m2276347858(NULL /*static, unused*/, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0028;
}
IL_001d:
{
PlayerConnection_t3517219175 * L_3 = ((PlayerConnection_t3517219175_StaticFields*)PlayerConnection_t3517219175_il2cpp_TypeInfo_var->static_fields)->get_s_Instance_4();
V_0 = L_3;
goto IL_0028;
}
IL_0028:
{
PlayerConnection_t3517219175 * L_4 = V_0;
return L_4;
}
}
// UnityEngine.Networking.PlayerConnection.PlayerConnection UnityEngine.Networking.PlayerConnection.PlayerConnection::CreateInstance()
extern "C" PlayerConnection_t3517219175 * PlayerConnection_CreateInstance_m2276347858 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (PlayerConnection_CreateInstance_m2276347858_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
PlayerConnection_t3517219175 * V_0 = NULL;
{
PlayerConnection_t3517219175 * L_0 = ScriptableObject_CreateInstance_TisPlayerConnection_t3517219175_m2823640524(NULL /*static, unused*/, /*hidden argument*/ScriptableObject_CreateInstance_TisPlayerConnection_t3517219175_m2823640524_MethodInfo_var);
((PlayerConnection_t3517219175_StaticFields*)PlayerConnection_t3517219175_il2cpp_TypeInfo_var->static_fields)->set_s_Instance_4(L_0);
PlayerConnection_t3517219175 * L_1 = ((PlayerConnection_t3517219175_StaticFields*)PlayerConnection_t3517219175_il2cpp_TypeInfo_var->static_fields)->get_s_Instance_4();
Object_set_hideFlags_m2204253440(L_1, ((int32_t)61), /*hidden argument*/NULL);
PlayerConnection_t3517219175 * L_2 = ((PlayerConnection_t3517219175_StaticFields*)PlayerConnection_t3517219175_il2cpp_TypeInfo_var->static_fields)->get_s_Instance_4();
V_0 = L_2;
goto IL_0022;
}
IL_0022:
{
PlayerConnection_t3517219175 * L_3 = V_0;
return L_3;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerConnection::MessageCallbackInternal(System.IntPtr,System.UInt64,System.UInt64,System.String)
extern "C" void PlayerConnection_MessageCallbackInternal_m267902474 (Il2CppObject * __this /* static, unused */, IntPtr_t ___data0, uint64_t ___size1, uint64_t ___guid2, String_t* ___messageId3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (PlayerConnection_MessageCallbackInternal_m267902474_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ByteU5BU5D_t3397334013* V_0 = NULL;
{
V_0 = (ByteU5BU5D_t3397334013*)NULL;
uint64_t L_0 = ___size1;
if ((!(((uint64_t)L_0) > ((uint64_t)(((int64_t)((int64_t)0)))))))
{
goto IL_001f;
}
}
{
uint64_t L_1 = ___size1;
if ((uint64_t)(L_1) > INTPTR_MAX) IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_overflow_exception());
V_0 = ((ByteU5BU5D_t3397334013*)SZArrayNew(ByteU5BU5D_t3397334013_il2cpp_TypeInfo_var, (uint32_t)(((intptr_t)L_1))));
IntPtr_t L_2 = ___data0;
ByteU5BU5D_t3397334013* L_3 = V_0;
uint64_t L_4 = ___size1;
IL2CPP_RUNTIME_CLASS_INIT(Marshal_t785896760_il2cpp_TypeInfo_var);
Marshal_Copy_m1683535972(NULL /*static, unused*/, L_2, L_3, 0, (((int32_t)((int32_t)L_4))), /*hidden argument*/NULL);
}
IL_001f:
{
PlayerConnection_t3517219175 * L_5 = PlayerConnection_get_instance_m3885313185(NULL /*static, unused*/, /*hidden argument*/NULL);
PlayerEditorConnectionEvents_t2252784345 * L_6 = L_5->get_m_PlayerEditorConnectionEvents_2();
String_t* L_7 = ___messageId3;
Guid_t L_8;
memset(&L_8, 0, sizeof(L_8));
Guid__ctor_m2599802704(&L_8, L_7, /*hidden argument*/NULL);
ByteU5BU5D_t3397334013* L_9 = V_0;
uint64_t L_10 = ___guid2;
PlayerEditorConnectionEvents_InvokeMessageIdSubscribers_m3217020342(L_6, L_8, L_9, (((int32_t)((int32_t)L_10))), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerConnection::ConnectedCallbackInternal(System.Int32)
extern "C" void PlayerConnection_ConnectedCallbackInternal_m2685675347 (Il2CppObject * __this /* static, unused */, int32_t ___playerId0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (PlayerConnection_ConnectedCallbackInternal_m2685675347_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
PlayerConnection_t3517219175 * L_0 = PlayerConnection_get_instance_m3885313185(NULL /*static, unused*/, /*hidden argument*/NULL);
List_1_t1440998580 * L_1 = L_0->get_m_connectedPlayers_3();
int32_t L_2 = ___playerId0;
List_1_Add_m688682013(L_1, L_2, /*hidden argument*/List_1_Add_m688682013_MethodInfo_var);
PlayerConnection_t3517219175 * L_3 = PlayerConnection_get_instance_m3885313185(NULL /*static, unused*/, /*hidden argument*/NULL);
PlayerEditorConnectionEvents_t2252784345 * L_4 = L_3->get_m_PlayerEditorConnectionEvents_2();
ConnectionChangeEvent_t536719976 * L_5 = L_4->get_connectionEvent_1();
int32_t L_6 = ___playerId0;
UnityEvent_1_Invoke_m1903741765(L_5, L_6, /*hidden argument*/UnityEvent_1_Invoke_m1903741765_MethodInfo_var);
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerConnection::DisconnectedCallback(System.Int32)
extern "C" void PlayerConnection_DisconnectedCallback_m4115432464 (Il2CppObject * __this /* static, unused */, int32_t ___playerId0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (PlayerConnection_DisconnectedCallback_m4115432464_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
PlayerConnection_t3517219175 * L_0 = PlayerConnection_get_instance_m3885313185(NULL /*static, unused*/, /*hidden argument*/NULL);
PlayerEditorConnectionEvents_t2252784345 * L_1 = L_0->get_m_PlayerEditorConnectionEvents_2();
ConnectionChangeEvent_t536719976 * L_2 = L_1->get_disconnectionEvent_2();
int32_t L_3 = ___playerId0;
UnityEvent_1_Invoke_m1903741765(L_2, L_3, /*hidden argument*/UnityEvent_1_Invoke_m1903741765_MethodInfo_var);
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents::.ctor()
extern "C" void PlayerEditorConnectionEvents__ctor_m603950945 (PlayerEditorConnectionEvents_t2252784345 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (PlayerEditorConnectionEvents__ctor_m603950945_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
List_1_t1660627182 * L_0 = (List_1_t1660627182 *)il2cpp_codegen_object_new(List_1_t1660627182_il2cpp_TypeInfo_var);
List_1__ctor_m1357675898(L_0, /*hidden argument*/List_1__ctor_m1357675898_MethodInfo_var);
__this->set_messageTypeSubscribers_0(L_0);
ConnectionChangeEvent_t536719976 * L_1 = (ConnectionChangeEvent_t536719976 *)il2cpp_codegen_object_new(ConnectionChangeEvent_t536719976_il2cpp_TypeInfo_var);
ConnectionChangeEvent__ctor_m616483304(L_1, /*hidden argument*/NULL);
__this->set_connectionEvent_1(L_1);
ConnectionChangeEvent_t536719976 * L_2 = (ConnectionChangeEvent_t536719976 *)il2cpp_codegen_object_new(ConnectionChangeEvent_t536719976_il2cpp_TypeInfo_var);
ConnectionChangeEvent__ctor_m616483304(L_2, /*hidden argument*/NULL);
__this->set_disconnectionEvent_2(L_2);
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents::InvokeMessageIdSubscribers(System.Guid,System.Byte[],System.Int32)
extern "C" void PlayerEditorConnectionEvents_InvokeMessageIdSubscribers_m3217020342 (PlayerEditorConnectionEvents_t2252784345 * __this, Guid_t ___messageId0, ByteU5BU5D_t3397334013* ___data1, int32_t ___playerId2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (PlayerEditorConnectionEvents_InvokeMessageIdSubscribers_m3217020342_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350 * V_0 = NULL;
Il2CppObject* V_1 = NULL;
MessageEventArgs_t301283622 * V_2 = NULL;
MessageEventArgs_t301283622 * V_3 = NULL;
MessageTypeSubscribers_t2291506050 * V_4 = NULL;
Il2CppObject* V_5 = NULL;
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
{
U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350 * L_0 = (U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350 *)il2cpp_codegen_object_new(U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350_il2cpp_TypeInfo_var);
U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0__ctor_m4027042344(L_0, /*hidden argument*/NULL);
V_0 = L_0;
U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350 * L_1 = V_0;
Guid_t L_2 = ___messageId0;
L_1->set_messageId_0(L_2);
List_1_t1660627182 * L_3 = __this->get_messageTypeSubscribers_0();
U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350 * L_4 = V_0;
IntPtr_t L_5;
L_5.set_m_value_0((void*)(void*)U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_U3CU3Em__0_m520813337_MethodInfo_var);
Func_2_t2919696197 * L_6 = (Func_2_t2919696197 *)il2cpp_codegen_object_new(Func_2_t2919696197_il2cpp_TypeInfo_var);
Func_2__ctor_m2608774846(L_6, L_4, L_5, /*hidden argument*/Func_2__ctor_m2608774846_MethodInfo_var);
Il2CppObject* L_7 = Enumerable_Where_TisMessageTypeSubscribers_t2291506050_m887802803(NULL /*static, unused*/, L_3, L_6, /*hidden argument*/Enumerable_Where_TisMessageTypeSubscribers_t2291506050_m887802803_MethodInfo_var);
V_1 = L_7;
Il2CppObject* L_8 = V_1;
bool L_9 = Enumerable_Any_TisMessageTypeSubscribers_t2291506050_m3682874628(NULL /*static, unused*/, L_8, /*hidden argument*/Enumerable_Any_TisMessageTypeSubscribers_t2291506050_m3682874628_MethodInfo_var);
if (L_9)
{
goto IL_0051;
}
}
{
U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350 * L_10 = V_0;
Guid_t L_11 = L_10->get_messageId_0();
Guid_t L_12 = L_11;
Il2CppObject * L_13 = Box(Guid_t_il2cpp_TypeInfo_var, &L_12);
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_14 = String_Concat_m56707527(NULL /*static, unused*/, _stringLiteral1281569593, L_13, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Debug_t1368543263_il2cpp_TypeInfo_var);
Debug_LogError_m3715728798(NULL /*static, unused*/, L_14, /*hidden argument*/NULL);
goto IL_00ad;
}
IL_0051:
{
MessageEventArgs_t301283622 * L_15 = (MessageEventArgs_t301283622 *)il2cpp_codegen_object_new(MessageEventArgs_t301283622_il2cpp_TypeInfo_var);
MessageEventArgs__ctor_m2154443826(L_15, /*hidden argument*/NULL);
V_3 = L_15;
MessageEventArgs_t301283622 * L_16 = V_3;
int32_t L_17 = ___playerId2;
L_16->set_playerId_0(L_17);
MessageEventArgs_t301283622 * L_18 = V_3;
ByteU5BU5D_t3397334013* L_19 = ___data1;
L_18->set_data_1(L_19);
MessageEventArgs_t301283622 * L_20 = V_3;
V_2 = L_20;
Il2CppObject* L_21 = V_1;
Il2CppObject* L_22 = InterfaceFuncInvoker0< Il2CppObject* >::Invoke(0 /* System.Collections.Generic.IEnumerator`1<!0> System.Collections.Generic.IEnumerable`1<UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers>::GetEnumerator() */, IEnumerable_1_t2583633095_il2cpp_TypeInfo_var, L_21);
V_5 = L_22;
}
IL_0070:
try
{ // begin try (depth: 1)
{
goto IL_008d;
}
IL_0075:
{
Il2CppObject* L_23 = V_5;
MessageTypeSubscribers_t2291506050 * L_24 = InterfaceFuncInvoker0< MessageTypeSubscribers_t2291506050 * >::Invoke(0 /* !0 System.Collections.Generic.IEnumerator`1<UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers>::get_Current() */, IEnumerator_1_t4061997173_il2cpp_TypeInfo_var, L_23);
V_4 = L_24;
MessageTypeSubscribers_t2291506050 * L_25 = V_4;
MessageEvent_t2167079021 * L_26 = L_25->get_messageCallback_2();
MessageEventArgs_t301283622 * L_27 = V_2;
UnityEvent_1_Invoke_m354862256(L_26, L_27, /*hidden argument*/UnityEvent_1_Invoke_m354862256_MethodInfo_var);
}
IL_008d:
{
Il2CppObject* L_28 = V_5;
bool L_29 = InterfaceFuncInvoker0< bool >::Invoke(1 /* System.Boolean System.Collections.IEnumerator::MoveNext() */, IEnumerator_t1466026749_il2cpp_TypeInfo_var, L_28);
if (L_29)
{
goto IL_0075;
}
}
IL_0099:
{
IL2CPP_LEAVE(0xAD, FINALLY_009e);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_009e;
}
FINALLY_009e:
{ // begin finally (depth: 1)
{
Il2CppObject* L_30 = V_5;
if (!L_30)
{
goto IL_00ac;
}
}
IL_00a5:
{
Il2CppObject* L_31 = V_5;
InterfaceActionInvoker0::Invoke(0 /* System.Void System.IDisposable::Dispose() */, IDisposable_t2427283555_il2cpp_TypeInfo_var, L_31);
}
IL_00ac:
{
IL2CPP_END_FINALLY(158)
}
} // end finally (depth: 1)
IL2CPP_CLEANUP(158)
{
IL2CPP_JUMP_TBL(0xAD, IL_00ad)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_00ad:
{
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/<InvokeMessageIdSubscribers>c__AnonStorey0::.ctor()
extern "C" void U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0__ctor_m4027042344 (U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350 * __this, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
return;
}
}
// System.Boolean UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/<InvokeMessageIdSubscribers>c__AnonStorey0::<>m__0(UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers)
extern "C" bool U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_U3CU3Em__0_m520813337 (U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_t1899782350 * __this, MessageTypeSubscribers_t2291506050 * ___x0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (U3CInvokeMessageIdSubscribersU3Ec__AnonStorey0_U3CU3Em__0_m520813337_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
MessageTypeSubscribers_t2291506050 * L_0 = ___x0;
Guid_t L_1 = MessageTypeSubscribers_get_MessageTypeId_m1191914268(L_0, /*hidden argument*/NULL);
Guid_t L_2 = __this->get_messageId_0();
IL2CPP_RUNTIME_CLASS_INIT(Guid_t_il2cpp_TypeInfo_var);
bool L_3 = Guid_op_Equality_m789465560(NULL /*static, unused*/, L_1, L_2, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_0017;
}
IL_0017:
{
bool L_4 = V_0;
return L_4;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/ConnectionChangeEvent::.ctor()
extern "C" void ConnectionChangeEvent__ctor_m616483304 (ConnectionChangeEvent_t536719976 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ConnectionChangeEvent__ctor_m616483304_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
UnityEvent_1__ctor_m2948712401(__this, /*hidden argument*/UnityEvent_1__ctor_m2948712401_MethodInfo_var);
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageEvent::.ctor()
extern "C" void MessageEvent__ctor_m3253032545 (MessageEvent_t2167079021 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (MessageEvent__ctor_m3253032545_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
UnityEvent_1__ctor_m3765336006(__this, /*hidden argument*/UnityEvent_1__ctor_m3765336006_MethodInfo_var);
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers::.ctor()
extern "C" void MessageTypeSubscribers__ctor_m743474932 (MessageTypeSubscribers_t2291506050 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (MessageTypeSubscribers__ctor_m743474932_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
__this->set_subscriberCount_1(0);
MessageEvent_t2167079021 * L_0 = (MessageEvent_t2167079021 *)il2cpp_codegen_object_new(MessageEvent_t2167079021_il2cpp_TypeInfo_var);
MessageEvent__ctor_m3253032545(L_0, /*hidden argument*/NULL);
__this->set_messageCallback_2(L_0);
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
return;
}
}
// System.Guid UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers::get_MessageTypeId()
extern "C" Guid_t MessageTypeSubscribers_get_MessageTypeId_m1191914268 (MessageTypeSubscribers_t2291506050 * __this, const MethodInfo* method)
{
Guid_t V_0;
memset(&V_0, 0, sizeof(V_0));
{
String_t* L_0 = __this->get_m_messageTypeId_0();
Guid_t L_1;
memset(&L_1, 0, sizeof(L_1));
Guid__ctor_m2599802704(&L_1, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_0012;
}
IL_0012:
{
Guid_t L_2 = V_0;
return L_2;
}
}
// Conversion methods for marshalling of: UnityEngine.Object
extern "C" void Object_t1021602117_marshal_pinvoke(const Object_t1021602117& unmarshaled, Object_t1021602117_marshaled_pinvoke& marshaled)
{
marshaled.___m_CachedPtr_0 = reinterpret_cast<intptr_t>((unmarshaled.get_m_CachedPtr_0()).get_m_value_0());
}
extern "C" void Object_t1021602117_marshal_pinvoke_back(const Object_t1021602117_marshaled_pinvoke& marshaled, Object_t1021602117& unmarshaled)
{
IntPtr_t unmarshaled_m_CachedPtr_temp_0;
memset(&unmarshaled_m_CachedPtr_temp_0, 0, sizeof(unmarshaled_m_CachedPtr_temp_0));
IntPtr_t unmarshaled_m_CachedPtr_temp_0_temp;
unmarshaled_m_CachedPtr_temp_0_temp.set_m_value_0(reinterpret_cast<void*>((intptr_t)(marshaled.___m_CachedPtr_0)));
unmarshaled_m_CachedPtr_temp_0 = unmarshaled_m_CachedPtr_temp_0_temp;
unmarshaled.set_m_CachedPtr_0(unmarshaled_m_CachedPtr_temp_0);
}
// Conversion method for clean up from marshalling of: UnityEngine.Object
extern "C" void Object_t1021602117_marshal_pinvoke_cleanup(Object_t1021602117_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.Object
extern "C" void Object_t1021602117_marshal_com(const Object_t1021602117& unmarshaled, Object_t1021602117_marshaled_com& marshaled)
{
marshaled.___m_CachedPtr_0 = reinterpret_cast<intptr_t>((unmarshaled.get_m_CachedPtr_0()).get_m_value_0());
}
extern "C" void Object_t1021602117_marshal_com_back(const Object_t1021602117_marshaled_com& marshaled, Object_t1021602117& unmarshaled)
{
IntPtr_t unmarshaled_m_CachedPtr_temp_0;
memset(&unmarshaled_m_CachedPtr_temp_0, 0, sizeof(unmarshaled_m_CachedPtr_temp_0));
IntPtr_t unmarshaled_m_CachedPtr_temp_0_temp;
unmarshaled_m_CachedPtr_temp_0_temp.set_m_value_0(reinterpret_cast<void*>((intptr_t)(marshaled.___m_CachedPtr_0)));
unmarshaled_m_CachedPtr_temp_0 = unmarshaled_m_CachedPtr_temp_0_temp;
unmarshaled.set_m_CachedPtr_0(unmarshaled_m_CachedPtr_temp_0);
}
// Conversion method for clean up from marshalling of: UnityEngine.Object
extern "C" void Object_t1021602117_marshal_com_cleanup(Object_t1021602117_marshaled_com& marshaled)
{
}
// System.Void UnityEngine.Object::.ctor()
extern "C" void Object__ctor_m197157284 (Object_t1021602117 * __this, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Object UnityEngine.Object::Internal_CloneSingle(UnityEngine.Object)
extern "C" Object_t1021602117 * Object_Internal_CloneSingle_m260620116 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, const MethodInfo* method)
{
typedef Object_t1021602117 * (*Object_Internal_CloneSingle_m260620116_ftn) (Object_t1021602117 *);
static Object_Internal_CloneSingle_m260620116_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_Internal_CloneSingle_m260620116_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::Internal_CloneSingle(UnityEngine.Object)");
return _il2cpp_icall_func(___data0);
}
// UnityEngine.Object UnityEngine.Object::Internal_CloneSingleWithParent(UnityEngine.Object,UnityEngine.Transform,System.Boolean)
extern "C" Object_t1021602117 * Object_Internal_CloneSingleWithParent_m665572246 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, Transform_t3275118058 * ___parent1, bool ___worldPositionStays2, const MethodInfo* method)
{
typedef Object_t1021602117 * (*Object_Internal_CloneSingleWithParent_m665572246_ftn) (Object_t1021602117 *, Transform_t3275118058 *, bool);
static Object_Internal_CloneSingleWithParent_m665572246_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_Internal_CloneSingleWithParent_m665572246_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::Internal_CloneSingleWithParent(UnityEngine.Object,UnityEngine.Transform,System.Boolean)");
return _il2cpp_icall_func(___data0, ___parent1, ___worldPositionStays2);
}
// UnityEngine.Object UnityEngine.Object::Internal_InstantiateSingle(UnityEngine.Object,UnityEngine.Vector3,UnityEngine.Quaternion)
extern "C" Object_t1021602117 * Object_Internal_InstantiateSingle_m2776302597 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, Vector3_t2243707580 ___pos1, Quaternion_t4030073918 ___rot2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_Internal_InstantiateSingle_m2776302597_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Object_t1021602117 * V_0 = NULL;
{
Object_t1021602117 * L_0 = ___data0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_t1021602117 * L_1 = Object_INTERNAL_CALL_Internal_InstantiateSingle_m3932420250(NULL /*static, unused*/, L_0, (&___pos1), (&___rot2), /*hidden argument*/NULL);
V_0 = L_1;
goto IL_0011;
}
IL_0011:
{
Object_t1021602117 * L_2 = V_0;
return L_2;
}
}
// UnityEngine.Object UnityEngine.Object::INTERNAL_CALL_Internal_InstantiateSingle(UnityEngine.Object,UnityEngine.Vector3&,UnityEngine.Quaternion&)
extern "C" Object_t1021602117 * Object_INTERNAL_CALL_Internal_InstantiateSingle_m3932420250 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, Vector3_t2243707580 * ___pos1, Quaternion_t4030073918 * ___rot2, const MethodInfo* method)
{
typedef Object_t1021602117 * (*Object_INTERNAL_CALL_Internal_InstantiateSingle_m3932420250_ftn) (Object_t1021602117 *, Vector3_t2243707580 *, Quaternion_t4030073918 *);
static Object_INTERNAL_CALL_Internal_InstantiateSingle_m3932420250_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_INTERNAL_CALL_Internal_InstantiateSingle_m3932420250_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::INTERNAL_CALL_Internal_InstantiateSingle(UnityEngine.Object,UnityEngine.Vector3&,UnityEngine.Quaternion&)");
return _il2cpp_icall_func(___data0, ___pos1, ___rot2);
}
// UnityEngine.Object UnityEngine.Object::Internal_InstantiateSingleWithParent(UnityEngine.Object,UnityEngine.Transform,UnityEngine.Vector3,UnityEngine.Quaternion)
extern "C" Object_t1021602117 * Object_Internal_InstantiateSingleWithParent_m509082884 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, Transform_t3275118058 * ___parent1, Vector3_t2243707580 ___pos2, Quaternion_t4030073918 ___rot3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_Internal_InstantiateSingleWithParent_m509082884_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Object_t1021602117 * V_0 = NULL;
{
Object_t1021602117 * L_0 = ___data0;
Transform_t3275118058 * L_1 = ___parent1;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_t1021602117 * L_2 = Object_INTERNAL_CALL_Internal_InstantiateSingleWithParent_m1401308849(NULL /*static, unused*/, L_0, L_1, (&___pos2), (&___rot3), /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0012;
}
IL_0012:
{
Object_t1021602117 * L_3 = V_0;
return L_3;
}
}
// UnityEngine.Object UnityEngine.Object::INTERNAL_CALL_Internal_InstantiateSingleWithParent(UnityEngine.Object,UnityEngine.Transform,UnityEngine.Vector3&,UnityEngine.Quaternion&)
extern "C" Object_t1021602117 * Object_INTERNAL_CALL_Internal_InstantiateSingleWithParent_m1401308849 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___data0, Transform_t3275118058 * ___parent1, Vector3_t2243707580 * ___pos2, Quaternion_t4030073918 * ___rot3, const MethodInfo* method)
{
typedef Object_t1021602117 * (*Object_INTERNAL_CALL_Internal_InstantiateSingleWithParent_m1401308849_ftn) (Object_t1021602117 *, Transform_t3275118058 *, Vector3_t2243707580 *, Quaternion_t4030073918 *);
static Object_INTERNAL_CALL_Internal_InstantiateSingleWithParent_m1401308849_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_INTERNAL_CALL_Internal_InstantiateSingleWithParent_m1401308849_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::INTERNAL_CALL_Internal_InstantiateSingleWithParent(UnityEngine.Object,UnityEngine.Transform,UnityEngine.Vector3&,UnityEngine.Quaternion&)");
return _il2cpp_icall_func(___data0, ___parent1, ___pos2, ___rot3);
}
// System.Int32 UnityEngine.Object::GetOffsetOfInstanceIDInCPlusPlusObject()
extern "C" int32_t Object_GetOffsetOfInstanceIDInCPlusPlusObject_m1587840561 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef int32_t (*Object_GetOffsetOfInstanceIDInCPlusPlusObject_m1587840561_ftn) ();
static Object_GetOffsetOfInstanceIDInCPlusPlusObject_m1587840561_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_GetOffsetOfInstanceIDInCPlusPlusObject_m1587840561_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::GetOffsetOfInstanceIDInCPlusPlusObject()");
return _il2cpp_icall_func();
}
// System.Void UnityEngine.Object::EnsureRunningOnMainThread()
extern "C" void Object_EnsureRunningOnMainThread_m3042842193 (Object_t1021602117 * __this, const MethodInfo* method)
{
typedef void (*Object_EnsureRunningOnMainThread_m3042842193_ftn) (Object_t1021602117 *);
static Object_EnsureRunningOnMainThread_m3042842193_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_EnsureRunningOnMainThread_m3042842193_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::EnsureRunningOnMainThread()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.Object::Destroy(UnityEngine.Object,System.Single)
extern "C" void Object_Destroy_m4279412553 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___obj0, float ___t1, const MethodInfo* method)
{
typedef void (*Object_Destroy_m4279412553_ftn) (Object_t1021602117 *, float);
static Object_Destroy_m4279412553_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_Destroy_m4279412553_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::Destroy(UnityEngine.Object,System.Single)");
_il2cpp_icall_func(___obj0, ___t1);
}
// System.Void UnityEngine.Object::Destroy(UnityEngine.Object)
extern "C" void Object_Destroy_m4145850038 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___obj0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_Destroy_m4145850038_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
{
V_0 = (0.0f);
Object_t1021602117 * L_0 = ___obj0;
float L_1 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_Destroy_m4279412553(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Object::DestroyImmediate(UnityEngine.Object,System.Boolean)
extern "C" void Object_DestroyImmediate_m3563317232 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___obj0, bool ___allowDestroyingAssets1, const MethodInfo* method)
{
typedef void (*Object_DestroyImmediate_m3563317232_ftn) (Object_t1021602117 *, bool);
static Object_DestroyImmediate_m3563317232_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_DestroyImmediate_m3563317232_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::DestroyImmediate(UnityEngine.Object,System.Boolean)");
_il2cpp_icall_func(___obj0, ___allowDestroyingAssets1);
}
// System.Void UnityEngine.Object::DestroyImmediate(UnityEngine.Object)
extern "C" void Object_DestroyImmediate_m95027445 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___obj0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_DestroyImmediate_m95027445_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
V_0 = (bool)0;
Object_t1021602117 * L_0 = ___obj0;
bool L_1 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_DestroyImmediate_m3563317232(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Object[] UnityEngine.Object::FindObjectsOfType(System.Type)
extern "C" ObjectU5BU5D_t4217747464* Object_FindObjectsOfType_m2121813744 (Il2CppObject * __this /* static, unused */, Type_t * ___type0, const MethodInfo* method)
{
typedef ObjectU5BU5D_t4217747464* (*Object_FindObjectsOfType_m2121813744_ftn) (Type_t *);
static Object_FindObjectsOfType_m2121813744_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_FindObjectsOfType_m2121813744_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::FindObjectsOfType(System.Type)");
return _il2cpp_icall_func(___type0);
}
// System.String UnityEngine.Object::get_name()
extern "C" String_t* Object_get_name_m2079638459 (Object_t1021602117 * __this, const MethodInfo* method)
{
typedef String_t* (*Object_get_name_m2079638459_ftn) (Object_t1021602117 *);
static Object_get_name_m2079638459_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_get_name_m2079638459_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::get_name()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.Object::set_name(System.String)
extern "C" void Object_set_name_m4157836998 (Object_t1021602117 * __this, String_t* ___value0, const MethodInfo* method)
{
typedef void (*Object_set_name_m4157836998_ftn) (Object_t1021602117 *, String_t*);
static Object_set_name_m4157836998_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_set_name_m4157836998_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::set_name(System.String)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Object::DontDestroyOnLoad(UnityEngine.Object)
extern "C" void Object_DontDestroyOnLoad_m2330762974 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___target0, const MethodInfo* method)
{
typedef void (*Object_DontDestroyOnLoad_m2330762974_ftn) (Object_t1021602117 *);
static Object_DontDestroyOnLoad_m2330762974_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_DontDestroyOnLoad_m2330762974_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::DontDestroyOnLoad(UnityEngine.Object)");
_il2cpp_icall_func(___target0);
}
// UnityEngine.HideFlags UnityEngine.Object::get_hideFlags()
extern "C" int32_t Object_get_hideFlags_m4158950869 (Object_t1021602117 * __this, const MethodInfo* method)
{
typedef int32_t (*Object_get_hideFlags_m4158950869_ftn) (Object_t1021602117 *);
static Object_get_hideFlags_m4158950869_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_get_hideFlags_m4158950869_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::get_hideFlags()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.Object::set_hideFlags(UnityEngine.HideFlags)
extern "C" void Object_set_hideFlags_m2204253440 (Object_t1021602117 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*Object_set_hideFlags_m2204253440_ftn) (Object_t1021602117 *, int32_t);
static Object_set_hideFlags_m2204253440_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_set_hideFlags_m2204253440_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::set_hideFlags(UnityEngine.HideFlags)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Object::DestroyObject(UnityEngine.Object,System.Single)
extern "C" void Object_DestroyObject_m282495858 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___obj0, float ___t1, const MethodInfo* method)
{
typedef void (*Object_DestroyObject_m282495858_ftn) (Object_t1021602117 *, float);
static Object_DestroyObject_m282495858_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_DestroyObject_m282495858_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::DestroyObject(UnityEngine.Object,System.Single)");
_il2cpp_icall_func(___obj0, ___t1);
}
// System.Void UnityEngine.Object::DestroyObject(UnityEngine.Object)
extern "C" void Object_DestroyObject_m2343493981 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___obj0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_DestroyObject_m2343493981_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
{
V_0 = (0.0f);
Object_t1021602117 * L_0 = ___obj0;
float L_1 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_DestroyObject_m282495858(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Object[] UnityEngine.Object::FindSceneObjectsOfType(System.Type)
extern "C" ObjectU5BU5D_t4217747464* Object_FindSceneObjectsOfType_m1833688338 (Il2CppObject * __this /* static, unused */, Type_t * ___type0, const MethodInfo* method)
{
typedef ObjectU5BU5D_t4217747464* (*Object_FindSceneObjectsOfType_m1833688338_ftn) (Type_t *);
static Object_FindSceneObjectsOfType_m1833688338_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_FindSceneObjectsOfType_m1833688338_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::FindSceneObjectsOfType(System.Type)");
return _il2cpp_icall_func(___type0);
}
// UnityEngine.Object[] UnityEngine.Object::FindObjectsOfTypeIncludingAssets(System.Type)
extern "C" ObjectU5BU5D_t4217747464* Object_FindObjectsOfTypeIncludingAssets_m3988851426 (Il2CppObject * __this /* static, unused */, Type_t * ___type0, const MethodInfo* method)
{
typedef ObjectU5BU5D_t4217747464* (*Object_FindObjectsOfTypeIncludingAssets_m3988851426_ftn) (Type_t *);
static Object_FindObjectsOfTypeIncludingAssets_m3988851426_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_FindObjectsOfTypeIncludingAssets_m3988851426_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::FindObjectsOfTypeIncludingAssets(System.Type)");
return _il2cpp_icall_func(___type0);
}
// System.String UnityEngine.Object::ToString()
extern "C" String_t* Object_ToString_m1947404527 (Object_t1021602117 * __this, const MethodInfo* method)
{
typedef String_t* (*Object_ToString_m1947404527_ftn) (Object_t1021602117 *);
static Object_ToString_m1947404527_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_ToString_m1947404527_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::ToString()");
return _il2cpp_icall_func(__this);
}
// System.Boolean UnityEngine.Object::DoesObjectWithInstanceIDExist(System.Int32)
extern "C" bool Object_DoesObjectWithInstanceIDExist_m2570795274 (Il2CppObject * __this /* static, unused */, int32_t ___instanceID0, const MethodInfo* method)
{
typedef bool (*Object_DoesObjectWithInstanceIDExist_m2570795274_ftn) (int32_t);
static Object_DoesObjectWithInstanceIDExist_m2570795274_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Object_DoesObjectWithInstanceIDExist_m2570795274_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Object::DoesObjectWithInstanceIDExist(System.Int32)");
return _il2cpp_icall_func(___instanceID0);
}
// System.Int32 UnityEngine.Object::GetInstanceID()
extern "C" int32_t Object_GetInstanceID_m1920497914 (Object_t1021602117 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_GetInstanceID_m1920497914_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
IntPtr_t L_0 = __this->get_m_CachedPtr_0();
IntPtr_t L_1 = ((IntPtr_t_StaticFields*)IntPtr_t_il2cpp_TypeInfo_var->static_fields)->get_Zero_1();
bool L_2 = IntPtr_op_Equality_m1573482188(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
if (!L_2)
{
goto IL_001d;
}
}
{
V_0 = 0;
goto IL_0056;
}
IL_001d:
{
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
int32_t L_3 = ((Object_t1021602117_StaticFields*)Object_t1021602117_il2cpp_TypeInfo_var->static_fields)->get_OffsetOfInstanceIDInCPlusPlusObject_1();
if ((!(((uint32_t)L_3) == ((uint32_t)(-1)))))
{
goto IL_0032;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
int32_t L_4 = Object_GetOffsetOfInstanceIDInCPlusPlusObject_m1587840561(NULL /*static, unused*/, /*hidden argument*/NULL);
((Object_t1021602117_StaticFields*)Object_t1021602117_il2cpp_TypeInfo_var->static_fields)->set_OffsetOfInstanceIDInCPlusPlusObject_1(L_4);
}
IL_0032:
{
IntPtr_t* L_5 = __this->get_address_of_m_CachedPtr_0();
int64_t L_6 = IntPtr_ToInt64_m39971741(L_5, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
int32_t L_7 = ((Object_t1021602117_StaticFields*)Object_t1021602117_il2cpp_TypeInfo_var->static_fields)->get_OffsetOfInstanceIDInCPlusPlusObject_1();
IntPtr_t L_8;
memset(&L_8, 0, sizeof(L_8));
IntPtr__ctor_m3803259710(&L_8, ((int64_t)((int64_t)L_6+(int64_t)(((int64_t)((int64_t)L_7))))), /*hidden argument*/NULL);
void* L_9 = IntPtr_op_Explicit_m1073656736(NULL /*static, unused*/, L_8, /*hidden argument*/NULL);
V_0 = (*((int32_t*)L_9));
goto IL_0056;
}
IL_0056:
{
int32_t L_10 = V_0;
return L_10;
}
}
// System.Int32 UnityEngine.Object::GetHashCode()
extern "C" int32_t Object_GetHashCode_m3431642059 (Object_t1021602117 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = Object_GetHashCode_m1715190285(__this, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
int32_t L_1 = V_0;
return L_1;
}
}
// System.Boolean UnityEngine.Object::Equals(System.Object)
extern "C" bool Object_Equals_m4029628913 (Object_t1021602117 * __this, Il2CppObject * ___other0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_Equals_m4029628913_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Object_t1021602117 * V_0 = NULL;
bool V_1 = false;
{
Il2CppObject * L_0 = ___other0;
V_0 = ((Object_t1021602117 *)IsInstClass(L_0, Object_t1021602117_il2cpp_TypeInfo_var));
Object_t1021602117 * L_1 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_2 = Object_op_Equality_m3764089466(NULL /*static, unused*/, L_1, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_2)
{
goto IL_002c;
}
}
{
Il2CppObject * L_3 = ___other0;
if (!L_3)
{
goto IL_002c;
}
}
{
Il2CppObject * L_4 = ___other0;
if (((Object_t1021602117 *)IsInstClass(L_4, Object_t1021602117_il2cpp_TypeInfo_var)))
{
goto IL_002c;
}
}
{
V_1 = (bool)0;
goto IL_0039;
}
IL_002c:
{
Object_t1021602117 * L_5 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_6 = Object_CompareBaseObjects_m3953996214(NULL /*static, unused*/, __this, L_5, /*hidden argument*/NULL);
V_1 = L_6;
goto IL_0039;
}
IL_0039:
{
bool L_7 = V_1;
return L_7;
}
}
// System.Boolean UnityEngine.Object::op_Implicit(UnityEngine.Object)
extern "C" bool Object_op_Implicit_m2856731593 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___exists0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_op_Implicit_m2856731593_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
Object_t1021602117 * L_0 = ___exists0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_1 = Object_CompareBaseObjects_m3953996214(NULL /*static, unused*/, L_0, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
V_0 = (bool)((((int32_t)L_1) == ((int32_t)0))? 1 : 0);
goto IL_0011;
}
IL_0011:
{
bool L_2 = V_0;
return L_2;
}
}
// System.Boolean UnityEngine.Object::CompareBaseObjects(UnityEngine.Object,UnityEngine.Object)
extern "C" bool Object_CompareBaseObjects_m3953996214 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___lhs0, Object_t1021602117 * ___rhs1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_CompareBaseObjects_m3953996214_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
bool V_2 = false;
{
Object_t1021602117 * L_0 = ___lhs0;
V_0 = (bool)((((Il2CppObject*)(Object_t1021602117 *)L_0) == ((Il2CppObject*)(Il2CppObject *)NULL))? 1 : 0);
Object_t1021602117 * L_1 = ___rhs1;
V_1 = (bool)((((Il2CppObject*)(Object_t1021602117 *)L_1) == ((Il2CppObject*)(Il2CppObject *)NULL))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_001e;
}
}
{
bool L_3 = V_0;
if (!L_3)
{
goto IL_001e;
}
}
{
V_2 = (bool)1;
goto IL_0055;
}
IL_001e:
{
bool L_4 = V_1;
if (!L_4)
{
goto IL_0033;
}
}
{
Object_t1021602117 * L_5 = ___lhs0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_6 = Object_IsNativeObjectAlive_m4056217615(NULL /*static, unused*/, L_5, /*hidden argument*/NULL);
V_2 = (bool)((((int32_t)L_6) == ((int32_t)0))? 1 : 0);
goto IL_0055;
}
IL_0033:
{
bool L_7 = V_0;
if (!L_7)
{
goto IL_0048;
}
}
{
Object_t1021602117 * L_8 = ___rhs1;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_9 = Object_IsNativeObjectAlive_m4056217615(NULL /*static, unused*/, L_8, /*hidden argument*/NULL);
V_2 = (bool)((((int32_t)L_9) == ((int32_t)0))? 1 : 0);
goto IL_0055;
}
IL_0048:
{
Object_t1021602117 * L_10 = ___lhs0;
Object_t1021602117 * L_11 = ___rhs1;
bool L_12 = Object_ReferenceEquals_m3900584722(NULL /*static, unused*/, L_10, L_11, /*hidden argument*/NULL);
V_2 = L_12;
goto IL_0055;
}
IL_0055:
{
bool L_13 = V_2;
return L_13;
}
}
// System.Boolean UnityEngine.Object::IsNativeObjectAlive(UnityEngine.Object)
extern "C" bool Object_IsNativeObjectAlive_m4056217615 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___o0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_IsNativeObjectAlive_m4056217615_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
Object_t1021602117 * L_0 = ___o0;
IntPtr_t L_1 = Object_GetCachedPtr_m943750213(L_0, /*hidden argument*/NULL);
IntPtr_t L_2 = ((IntPtr_t_StaticFields*)IntPtr_t_il2cpp_TypeInfo_var->static_fields)->get_Zero_1();
bool L_3 = IntPtr_op_Inequality_m3044532593(NULL /*static, unused*/, L_1, L_2, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_0017;
}
IL_0017:
{
bool L_4 = V_0;
return L_4;
}
}
// System.IntPtr UnityEngine.Object::GetCachedPtr()
extern "C" IntPtr_t Object_GetCachedPtr_m943750213 (Object_t1021602117 * __this, const MethodInfo* method)
{
IntPtr_t V_0;
memset(&V_0, 0, sizeof(V_0));
{
IntPtr_t L_0 = __this->get_m_CachedPtr_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
IntPtr_t L_1 = V_0;
return L_1;
}
}
// UnityEngine.Object UnityEngine.Object::Instantiate(UnityEngine.Object,UnityEngine.Vector3,UnityEngine.Quaternion)
extern "C" Object_t1021602117 * Object_Instantiate_m938141395 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___original0, Vector3_t2243707580 ___position1, Quaternion_t4030073918 ___rotation2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_Instantiate_m938141395_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Object_t1021602117 * V_0 = NULL;
{
Object_t1021602117 * L_0 = ___original0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_CheckNullArgument_m1711119106(NULL /*static, unused*/, L_0, _stringLiteral444318565, /*hidden argument*/NULL);
Object_t1021602117 * L_1 = ___original0;
if (!((ScriptableObject_t1975622470 *)IsInstClass(L_1, ScriptableObject_t1975622470_il2cpp_TypeInfo_var)))
{
goto IL_0022;
}
}
{
ArgumentException_t3259014390 * L_2 = (ArgumentException_t3259014390 *)il2cpp_codegen_object_new(ArgumentException_t3259014390_il2cpp_TypeInfo_var);
ArgumentException__ctor_m3739475201(L_2, _stringLiteral1912870611, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2);
}
IL_0022:
{
Object_t1021602117 * L_3 = ___original0;
Vector3_t2243707580 L_4 = ___position1;
Quaternion_t4030073918 L_5 = ___rotation2;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_t1021602117 * L_6 = Object_Internal_InstantiateSingle_m2776302597(NULL /*static, unused*/, L_3, L_4, L_5, /*hidden argument*/NULL);
V_0 = L_6;
goto IL_0030;
}
IL_0030:
{
Object_t1021602117 * L_7 = V_0;
return L_7;
}
}
// UnityEngine.Object UnityEngine.Object::Instantiate(UnityEngine.Object,UnityEngine.Vector3,UnityEngine.Quaternion,UnityEngine.Transform)
extern "C" Object_t1021602117 * Object_Instantiate_m2160322936 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___original0, Vector3_t2243707580 ___position1, Quaternion_t4030073918 ___rotation2, Transform_t3275118058 * ___parent3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_Instantiate_m2160322936_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Object_t1021602117 * V_0 = NULL;
{
Transform_t3275118058 * L_0 = ___parent3;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_1 = Object_op_Equality_m3764089466(NULL /*static, unused*/, L_0, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_001b;
}
}
{
Object_t1021602117 * L_2 = ___original0;
Vector3_t2243707580 L_3 = ___position1;
Quaternion_t4030073918 L_4 = ___rotation2;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_t1021602117 * L_5 = Object_Internal_InstantiateSingle_m2776302597(NULL /*static, unused*/, L_2, L_3, L_4, /*hidden argument*/NULL);
V_0 = L_5;
goto IL_0035;
}
IL_001b:
{
Object_t1021602117 * L_6 = ___original0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_CheckNullArgument_m1711119106(NULL /*static, unused*/, L_6, _stringLiteral444318565, /*hidden argument*/NULL);
Object_t1021602117 * L_7 = ___original0;
Transform_t3275118058 * L_8 = ___parent3;
Vector3_t2243707580 L_9 = ___position1;
Quaternion_t4030073918 L_10 = ___rotation2;
Object_t1021602117 * L_11 = Object_Internal_InstantiateSingleWithParent_m509082884(NULL /*static, unused*/, L_7, L_8, L_9, L_10, /*hidden argument*/NULL);
V_0 = L_11;
goto IL_0035;
}
IL_0035:
{
Object_t1021602117 * L_12 = V_0;
return L_12;
}
}
// UnityEngine.Object UnityEngine.Object::Instantiate(UnityEngine.Object)
extern "C" Object_t1021602117 * Object_Instantiate_m2439155489 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___original0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_Instantiate_m2439155489_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Object_t1021602117 * V_0 = NULL;
{
Object_t1021602117 * L_0 = ___original0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_CheckNullArgument_m1711119106(NULL /*static, unused*/, L_0, _stringLiteral444318565, /*hidden argument*/NULL);
Object_t1021602117 * L_1 = ___original0;
Object_t1021602117 * L_2 = Object_Internal_CloneSingle_m260620116(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0018;
}
IL_0018:
{
Object_t1021602117 * L_3 = V_0;
return L_3;
}
}
// UnityEngine.Object UnityEngine.Object::Instantiate(UnityEngine.Object,UnityEngine.Transform)
extern "C" Object_t1021602117 * Object_Instantiate_m2177117080 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___original0, Transform_t3275118058 * ___parent1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_Instantiate_m2177117080_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Object_t1021602117 * V_0 = NULL;
{
Object_t1021602117 * L_0 = ___original0;
Transform_t3275118058 * L_1 = ___parent1;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_t1021602117 * L_2 = Object_Instantiate_m2489341053(NULL /*static, unused*/, L_0, L_1, (bool)0, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_000f;
}
IL_000f:
{
Object_t1021602117 * L_3 = V_0;
return L_3;
}
}
// UnityEngine.Object UnityEngine.Object::Instantiate(UnityEngine.Object,UnityEngine.Transform,System.Boolean)
extern "C" Object_t1021602117 * Object_Instantiate_m2489341053 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___original0, Transform_t3275118058 * ___parent1, bool ___instantiateInWorldSpace2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_Instantiate_m2489341053_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Object_t1021602117 * V_0 = NULL;
{
Transform_t3275118058 * L_0 = ___parent1;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_1 = Object_op_Equality_m3764089466(NULL /*static, unused*/, L_0, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0019;
}
}
{
Object_t1021602117 * L_2 = ___original0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_t1021602117 * L_3 = Object_Internal_CloneSingle_m260620116(NULL /*static, unused*/, L_2, /*hidden argument*/NULL);
V_0 = L_3;
goto IL_0032;
}
IL_0019:
{
Object_t1021602117 * L_4 = ___original0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
Object_CheckNullArgument_m1711119106(NULL /*static, unused*/, L_4, _stringLiteral444318565, /*hidden argument*/NULL);
Object_t1021602117 * L_5 = ___original0;
Transform_t3275118058 * L_6 = ___parent1;
bool L_7 = ___instantiateInWorldSpace2;
Object_t1021602117 * L_8 = Object_Internal_CloneSingleWithParent_m665572246(NULL /*static, unused*/, L_5, L_6, L_7, /*hidden argument*/NULL);
V_0 = L_8;
goto IL_0032;
}
IL_0032:
{
Object_t1021602117 * L_9 = V_0;
return L_9;
}
}
// System.Void UnityEngine.Object::CheckNullArgument(System.Object,System.String)
extern "C" void Object_CheckNullArgument_m1711119106 (Il2CppObject * __this /* static, unused */, Il2CppObject * ___arg0, String_t* ___message1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_CheckNullArgument_m1711119106_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Il2CppObject * L_0 = ___arg0;
if (L_0)
{
goto IL_000e;
}
}
{
String_t* L_1 = ___message1;
ArgumentException_t3259014390 * L_2 = (ArgumentException_t3259014390 *)il2cpp_codegen_object_new(ArgumentException_t3259014390_il2cpp_TypeInfo_var);
ArgumentException__ctor_m3739475201(L_2, L_1, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2);
}
IL_000e:
{
return;
}
}
// UnityEngine.Object UnityEngine.Object::FindObjectOfType(System.Type)
extern "C" Object_t1021602117 * Object_FindObjectOfType_m2330404063 (Il2CppObject * __this /* static, unused */, Type_t * ___type0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_FindObjectOfType_m2330404063_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ObjectU5BU5D_t4217747464* V_0 = NULL;
Object_t1021602117 * V_1 = NULL;
{
Type_t * L_0 = ___type0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
ObjectU5BU5D_t4217747464* L_1 = Object_FindObjectsOfType_m2121813744(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
V_0 = L_1;
ObjectU5BU5D_t4217747464* L_2 = V_0;
if ((((int32_t)(((int32_t)((int32_t)(((Il2CppArray *)L_2)->max_length))))) <= ((int32_t)0)))
{
goto IL_001a;
}
}
{
ObjectU5BU5D_t4217747464* L_3 = V_0;
int32_t L_4 = 0;
Object_t1021602117 * L_5 = (L_3)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_4));
V_1 = L_5;
goto IL_0021;
}
IL_001a:
{
V_1 = (Object_t1021602117 *)NULL;
goto IL_0021;
}
IL_0021:
{
Object_t1021602117 * L_6 = V_1;
return L_6;
}
}
// System.Boolean UnityEngine.Object::op_Equality(UnityEngine.Object,UnityEngine.Object)
extern "C" bool Object_op_Equality_m3764089466 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___x0, Object_t1021602117 * ___y1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_op_Equality_m3764089466_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
Object_t1021602117 * L_0 = ___x0;
Object_t1021602117 * L_1 = ___y1;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_2 = Object_CompareBaseObjects_m3953996214(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_000e;
}
IL_000e:
{
bool L_3 = V_0;
return L_3;
}
}
// System.Boolean UnityEngine.Object::op_Inequality(UnityEngine.Object,UnityEngine.Object)
extern "C" bool Object_op_Inequality_m2402264703 (Il2CppObject * __this /* static, unused */, Object_t1021602117 * ___x0, Object_t1021602117 * ___y1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object_op_Inequality_m2402264703_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
Object_t1021602117 * L_0 = ___x0;
Object_t1021602117 * L_1 = ___y1;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_2 = Object_CompareBaseObjects_m3953996214(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
V_0 = (bool)((((int32_t)L_2) == ((int32_t)0))? 1 : 0);
goto IL_0011;
}
IL_0011:
{
bool L_3 = V_0;
return L_3;
}
}
// System.Void UnityEngine.Object::.cctor()
extern "C" void Object__cctor_m2991092887 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Object__cctor_m2991092887_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
((Object_t1021602117_StaticFields*)Object_t1021602117_il2cpp_TypeInfo_var->static_fields)->set_OffsetOfInstanceIDInCPlusPlusObject_1((-1));
return;
}
}
// System.Boolean UnityEngine.Physics2D::get_queriesHitTriggers()
extern "C" bool Physics2D_get_queriesHitTriggers_m361275035 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
typedef bool (*Physics2D_get_queriesHitTriggers_m361275035_ftn) ();
static Physics2D_get_queriesHitTriggers_m361275035_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics2D_get_queriesHitTriggers_m361275035_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics2D::get_queriesHitTriggers()");
return _il2cpp_icall_func();
}
// UnityEngine.RaycastHit2D UnityEngine.Physics2D::Raycast(UnityEngine.Vector2,UnityEngine.Vector2,System.Single,System.Int32,System.Single)
extern "C" RaycastHit2D_t4063908774 Physics2D_Raycast_m1220041042 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, float ___distance2, int32_t ___layerMask3, float ___minDepth4, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_Raycast_m1220041042_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
RaycastHit2D_t4063908774 V_1;
memset(&V_1, 0, sizeof(V_1));
{
V_0 = (std::numeric_limits<float>::infinity());
Vector2_t2243707579 L_0 = ___origin0;
Vector2_t2243707579 L_1 = ___direction1;
float L_2 = ___distance2;
int32_t L_3 = ___layerMask3;
float L_4 = ___minDepth4;
float L_5 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
RaycastHit2D_t4063908774 L_6 = Physics2D_Raycast_m2303387255(NULL /*static, unused*/, L_0, L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
V_1 = L_6;
goto IL_0019;
}
IL_0019:
{
RaycastHit2D_t4063908774 L_7 = V_1;
return L_7;
}
}
// UnityEngine.RaycastHit2D UnityEngine.Physics2D::Raycast(UnityEngine.Vector2,UnityEngine.Vector2,System.Single,System.Int32)
extern "C" RaycastHit2D_t4063908774 Physics2D_Raycast_m122312471 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, float ___distance2, int32_t ___layerMask3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_Raycast_m122312471_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
float V_1 = 0.0f;
RaycastHit2D_t4063908774 V_2;
memset(&V_2, 0, sizeof(V_2));
{
V_0 = (std::numeric_limits<float>::infinity());
V_1 = (-std::numeric_limits<float>::infinity());
Vector2_t2243707579 L_0 = ___origin0;
Vector2_t2243707579 L_1 = ___direction1;
float L_2 = ___distance2;
int32_t L_3 = ___layerMask3;
float L_4 = V_1;
float L_5 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
RaycastHit2D_t4063908774 L_6 = Physics2D_Raycast_m2303387255(NULL /*static, unused*/, L_0, L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
V_2 = L_6;
goto IL_001e;
}
IL_001e:
{
RaycastHit2D_t4063908774 L_7 = V_2;
return L_7;
}
}
// UnityEngine.RaycastHit2D UnityEngine.Physics2D::Raycast(UnityEngine.Vector2,UnityEngine.Vector2,System.Single)
extern "C" RaycastHit2D_t4063908774 Physics2D_Raycast_m3913913442 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, float ___distance2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_Raycast_m3913913442_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
float V_1 = 0.0f;
int32_t V_2 = 0;
RaycastHit2D_t4063908774 V_3;
memset(&V_3, 0, sizeof(V_3));
{
V_0 = (std::numeric_limits<float>::infinity());
V_1 = (-std::numeric_limits<float>::infinity());
V_2 = ((int32_t)-5);
Vector2_t2243707579 L_0 = ___origin0;
Vector2_t2243707579 L_1 = ___direction1;
float L_2 = ___distance2;
int32_t L_3 = V_2;
float L_4 = V_1;
float L_5 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
RaycastHit2D_t4063908774 L_6 = Physics2D_Raycast_m2303387255(NULL /*static, unused*/, L_0, L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
V_3 = L_6;
goto IL_0021;
}
IL_0021:
{
RaycastHit2D_t4063908774 L_7 = V_3;
return L_7;
}
}
// UnityEngine.RaycastHit2D UnityEngine.Physics2D::Raycast(UnityEngine.Vector2,UnityEngine.Vector2)
extern "C" RaycastHit2D_t4063908774 Physics2D_Raycast_m2560154475 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_Raycast_m2560154475_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
float V_1 = 0.0f;
int32_t V_2 = 0;
float V_3 = 0.0f;
RaycastHit2D_t4063908774 V_4;
memset(&V_4, 0, sizeof(V_4));
{
V_0 = (std::numeric_limits<float>::infinity());
V_1 = (-std::numeric_limits<float>::infinity());
V_2 = ((int32_t)-5);
V_3 = (std::numeric_limits<float>::infinity());
Vector2_t2243707579 L_0 = ___origin0;
Vector2_t2243707579 L_1 = ___direction1;
float L_2 = V_3;
int32_t L_3 = V_2;
float L_4 = V_1;
float L_5 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
RaycastHit2D_t4063908774 L_6 = Physics2D_Raycast_m2303387255(NULL /*static, unused*/, L_0, L_1, L_2, L_3, L_4, L_5, /*hidden argument*/NULL);
V_4 = L_6;
goto IL_0028;
}
IL_0028:
{
RaycastHit2D_t4063908774 L_7 = V_4;
return L_7;
}
}
// UnityEngine.RaycastHit2D UnityEngine.Physics2D::Raycast(UnityEngine.Vector2,UnityEngine.Vector2,System.Single,System.Int32,System.Single,System.Single)
extern "C" RaycastHit2D_t4063908774 Physics2D_Raycast_m2303387255 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, float ___distance2, int32_t ___layerMask3, float ___minDepth4, float ___maxDepth5, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_Raycast_m2303387255_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ContactFilter2D_t1672660996 V_0;
memset(&V_0, 0, sizeof(V_0));
RaycastHit2D_t4063908774 V_1;
memset(&V_1, 0, sizeof(V_1));
RaycastHit2D_t4063908774 V_2;
memset(&V_2, 0, sizeof(V_2));
{
int32_t L_0 = ___layerMask3;
float L_1 = ___minDepth4;
float L_2 = ___maxDepth5;
ContactFilter2D_t1672660996 L_3 = ContactFilter2D_CreateLegacyFilter_m1912787689(NULL /*static, unused*/, L_0, L_1, L_2, /*hidden argument*/NULL);
V_0 = L_3;
Vector2_t2243707579 L_4 = ___origin0;
Vector2_t2243707579 L_5 = ___direction1;
float L_6 = ___distance2;
ContactFilter2D_t1672660996 L_7 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
Physics2D_Internal_Raycast_m2213595168(NULL /*static, unused*/, L_4, L_5, L_6, L_7, (&V_1), /*hidden argument*/NULL);
RaycastHit2D_t4063908774 L_8 = V_1;
V_2 = L_8;
goto IL_001e;
}
IL_001e:
{
RaycastHit2D_t4063908774 L_9 = V_2;
return L_9;
}
}
// System.Int32 UnityEngine.Physics2D::Raycast(UnityEngine.Vector2,UnityEngine.Vector2,UnityEngine.ContactFilter2D,UnityEngine.RaycastHit2D[])
extern "C" int32_t Physics2D_Raycast_m2368200185 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, ContactFilter2D_t1672660996 ___contactFilter2, RaycastHit2DU5BU5D_t4176517891* ___results3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_Raycast_m2368200185_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
int32_t V_1 = 0;
{
V_0 = (std::numeric_limits<float>::infinity());
Vector2_t2243707579 L_0 = ___origin0;
Vector2_t2243707579 L_1 = ___direction1;
ContactFilter2D_t1672660996 L_2 = ___contactFilter2;
RaycastHit2DU5BU5D_t4176517891* L_3 = ___results3;
float L_4 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
int32_t L_5 = Physics2D_Raycast_m564567838(NULL /*static, unused*/, L_0, L_1, L_2, L_3, L_4, /*hidden argument*/NULL);
V_1 = L_5;
goto IL_0017;
}
IL_0017:
{
int32_t L_6 = V_1;
return L_6;
}
}
// System.Int32 UnityEngine.Physics2D::Raycast(UnityEngine.Vector2,UnityEngine.Vector2,UnityEngine.ContactFilter2D,UnityEngine.RaycastHit2D[],System.Single)
extern "C" int32_t Physics2D_Raycast_m564567838 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, ContactFilter2D_t1672660996 ___contactFilter2, RaycastHit2DU5BU5D_t4176517891* ___results3, float ___distance4, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_Raycast_m564567838_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
Vector2_t2243707579 L_0 = ___origin0;
Vector2_t2243707579 L_1 = ___direction1;
float L_2 = ___distance4;
ContactFilter2D_t1672660996 L_3 = ___contactFilter2;
RaycastHit2DU5BU5D_t4176517891* L_4 = ___results3;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
int32_t L_5 = Physics2D_Internal_RaycastNonAlloc_m1874107548(NULL /*static, unused*/, L_0, L_1, L_2, L_3, L_4, /*hidden argument*/NULL);
V_0 = L_5;
goto IL_0012;
}
IL_0012:
{
int32_t L_6 = V_0;
return L_6;
}
}
// System.Void UnityEngine.Physics2D::Internal_Raycast(UnityEngine.Vector2,UnityEngine.Vector2,System.Single,UnityEngine.ContactFilter2D,UnityEngine.RaycastHit2D&)
extern "C" void Physics2D_Internal_Raycast_m2213595168 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, float ___distance2, ContactFilter2D_t1672660996 ___contactFilter3, RaycastHit2D_t4063908774 * ___raycastHit4, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_Internal_Raycast_m2213595168_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
float L_0 = ___distance2;
RaycastHit2D_t4063908774 * L_1 = ___raycastHit4;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
Physics2D_INTERNAL_CALL_Internal_Raycast_m489831109(NULL /*static, unused*/, (&___origin0), (&___direction1), L_0, (&___contactFilter3), L_1, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Physics2D::INTERNAL_CALL_Internal_Raycast(UnityEngine.Vector2&,UnityEngine.Vector2&,System.Single,UnityEngine.ContactFilter2D&,UnityEngine.RaycastHit2D&)
extern "C" void Physics2D_INTERNAL_CALL_Internal_Raycast_m489831109 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___origin0, Vector2_t2243707579 * ___direction1, float ___distance2, ContactFilter2D_t1672660996 * ___contactFilter3, RaycastHit2D_t4063908774 * ___raycastHit4, const MethodInfo* method)
{
typedef void (*Physics2D_INTERNAL_CALL_Internal_Raycast_m489831109_ftn) (Vector2_t2243707579 *, Vector2_t2243707579 *, float, ContactFilter2D_t1672660996 *, RaycastHit2D_t4063908774 *);
static Physics2D_INTERNAL_CALL_Internal_Raycast_m489831109_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics2D_INTERNAL_CALL_Internal_Raycast_m489831109_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics2D::INTERNAL_CALL_Internal_Raycast(UnityEngine.Vector2&,UnityEngine.Vector2&,System.Single,UnityEngine.ContactFilter2D&,UnityEngine.RaycastHit2D&)");
_il2cpp_icall_func(___origin0, ___direction1, ___distance2, ___contactFilter3, ___raycastHit4);
}
// System.Int32 UnityEngine.Physics2D::Internal_RaycastNonAlloc(UnityEngine.Vector2,UnityEngine.Vector2,System.Single,UnityEngine.ContactFilter2D,UnityEngine.RaycastHit2D[])
extern "C" int32_t Physics2D_Internal_RaycastNonAlloc_m1874107548 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___origin0, Vector2_t2243707579 ___direction1, float ___distance2, ContactFilter2D_t1672660996 ___contactFilter3, RaycastHit2DU5BU5D_t4176517891* ___results4, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_Internal_RaycastNonAlloc_m1874107548_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
float L_0 = ___distance2;
RaycastHit2DU5BU5D_t4176517891* L_1 = ___results4;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
int32_t L_2 = Physics2D_INTERNAL_CALL_Internal_RaycastNonAlloc_m2253171281(NULL /*static, unused*/, (&___origin0), (&___direction1), L_0, (&___contactFilter3), L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0015;
}
IL_0015:
{
int32_t L_3 = V_0;
return L_3;
}
}
// System.Int32 UnityEngine.Physics2D::INTERNAL_CALL_Internal_RaycastNonAlloc(UnityEngine.Vector2&,UnityEngine.Vector2&,System.Single,UnityEngine.ContactFilter2D&,UnityEngine.RaycastHit2D[])
extern "C" int32_t Physics2D_INTERNAL_CALL_Internal_RaycastNonAlloc_m2253171281 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___origin0, Vector2_t2243707579 * ___direction1, float ___distance2, ContactFilter2D_t1672660996 * ___contactFilter3, RaycastHit2DU5BU5D_t4176517891* ___results4, const MethodInfo* method)
{
typedef int32_t (*Physics2D_INTERNAL_CALL_Internal_RaycastNonAlloc_m2253171281_ftn) (Vector2_t2243707579 *, Vector2_t2243707579 *, float, ContactFilter2D_t1672660996 *, RaycastHit2DU5BU5D_t4176517891*);
static Physics2D_INTERNAL_CALL_Internal_RaycastNonAlloc_m2253171281_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics2D_INTERNAL_CALL_Internal_RaycastNonAlloc_m2253171281_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics2D::INTERNAL_CALL_Internal_RaycastNonAlloc(UnityEngine.Vector2&,UnityEngine.Vector2&,System.Single,UnityEngine.ContactFilter2D&,UnityEngine.RaycastHit2D[])");
return _il2cpp_icall_func(___origin0, ___direction1, ___distance2, ___contactFilter3, ___results4);
}
// UnityEngine.RaycastHit2D[] UnityEngine.Physics2D::GetRayIntersectionAll(UnityEngine.Ray,System.Single,System.Int32)
extern "C" RaycastHit2DU5BU5D_t4176517891* Physics2D_GetRayIntersectionAll_m253330691 (Il2CppObject * __this /* static, unused */, Ray_t2469606224 ___ray0, float ___distance1, int32_t ___layerMask2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_GetRayIntersectionAll_m253330691_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RaycastHit2DU5BU5D_t4176517891* V_0 = NULL;
{
float L_0 = ___distance1;
int32_t L_1 = ___layerMask2;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
RaycastHit2DU5BU5D_t4176517891* L_2 = Physics2D_INTERNAL_CALL_GetRayIntersectionAll_m161475998(NULL /*static, unused*/, (&___ray0), L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0010;
}
IL_0010:
{
RaycastHit2DU5BU5D_t4176517891* L_3 = V_0;
return L_3;
}
}
// UnityEngine.RaycastHit2D[] UnityEngine.Physics2D::GetRayIntersectionAll(UnityEngine.Ray,System.Single)
extern "C" RaycastHit2DU5BU5D_t4176517891* Physics2D_GetRayIntersectionAll_m2808325432 (Il2CppObject * __this /* static, unused */, Ray_t2469606224 ___ray0, float ___distance1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_GetRayIntersectionAll_m2808325432_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
RaycastHit2DU5BU5D_t4176517891* V_1 = NULL;
{
V_0 = ((int32_t)-5);
float L_0 = ___distance1;
int32_t L_1 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
RaycastHit2DU5BU5D_t4176517891* L_2 = Physics2D_INTERNAL_CALL_GetRayIntersectionAll_m161475998(NULL /*static, unused*/, (&___ray0), L_0, L_1, /*hidden argument*/NULL);
V_1 = L_2;
goto IL_0013;
}
IL_0013:
{
RaycastHit2DU5BU5D_t4176517891* L_3 = V_1;
return L_3;
}
}
// UnityEngine.RaycastHit2D[] UnityEngine.Physics2D::GetRayIntersectionAll(UnityEngine.Ray)
extern "C" RaycastHit2DU5BU5D_t4176517891* Physics2D_GetRayIntersectionAll_m120415839 (Il2CppObject * __this /* static, unused */, Ray_t2469606224 ___ray0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D_GetRayIntersectionAll_m120415839_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
float V_1 = 0.0f;
RaycastHit2DU5BU5D_t4176517891* V_2 = NULL;
{
V_0 = ((int32_t)-5);
V_1 = (std::numeric_limits<float>::infinity());
float L_0 = V_1;
int32_t L_1 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Physics2D_t2540166467_il2cpp_TypeInfo_var);
RaycastHit2DU5BU5D_t4176517891* L_2 = Physics2D_INTERNAL_CALL_GetRayIntersectionAll_m161475998(NULL /*static, unused*/, (&___ray0), L_0, L_1, /*hidden argument*/NULL);
V_2 = L_2;
goto IL_0019;
}
IL_0019:
{
RaycastHit2DU5BU5D_t4176517891* L_3 = V_2;
return L_3;
}
}
// UnityEngine.RaycastHit2D[] UnityEngine.Physics2D::INTERNAL_CALL_GetRayIntersectionAll(UnityEngine.Ray&,System.Single,System.Int32)
extern "C" RaycastHit2DU5BU5D_t4176517891* Physics2D_INTERNAL_CALL_GetRayIntersectionAll_m161475998 (Il2CppObject * __this /* static, unused */, Ray_t2469606224 * ___ray0, float ___distance1, int32_t ___layerMask2, const MethodInfo* method)
{
typedef RaycastHit2DU5BU5D_t4176517891* (*Physics2D_INTERNAL_CALL_GetRayIntersectionAll_m161475998_ftn) (Ray_t2469606224 *, float, int32_t);
static Physics2D_INTERNAL_CALL_GetRayIntersectionAll_m161475998_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics2D_INTERNAL_CALL_GetRayIntersectionAll_m161475998_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics2D::INTERNAL_CALL_GetRayIntersectionAll(UnityEngine.Ray&,System.Single,System.Int32)");
return _il2cpp_icall_func(___ray0, ___distance1, ___layerMask2);
}
// UnityEngine.Rigidbody2D UnityEngine.Physics2D::GetRigidbodyFromInstanceID(System.Int32)
extern "C" Rigidbody2D_t502193897 * Physics2D_GetRigidbodyFromInstanceID_m3260338451 (Il2CppObject * __this /* static, unused */, int32_t ___instanceID0, const MethodInfo* method)
{
typedef Rigidbody2D_t502193897 * (*Physics2D_GetRigidbodyFromInstanceID_m3260338451_ftn) (int32_t);
static Physics2D_GetRigidbodyFromInstanceID_m3260338451_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics2D_GetRigidbodyFromInstanceID_m3260338451_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics2D::GetRigidbodyFromInstanceID(System.Int32)");
return _il2cpp_icall_func(___instanceID0);
}
// UnityEngine.Collider2D UnityEngine.Physics2D::GetColliderFromInstanceID(System.Int32)
extern "C" Collider2D_t646061738 * Physics2D_GetColliderFromInstanceID_m95920619 (Il2CppObject * __this /* static, unused */, int32_t ___instanceID0, const MethodInfo* method)
{
typedef Collider2D_t646061738 * (*Physics2D_GetColliderFromInstanceID_m95920619_ftn) (int32_t);
static Physics2D_GetColliderFromInstanceID_m95920619_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Physics2D_GetColliderFromInstanceID_m95920619_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Physics2D::GetColliderFromInstanceID(System.Int32)");
return _il2cpp_icall_func(___instanceID0);
}
// System.Void UnityEngine.Physics2D::.cctor()
extern "C" void Physics2D__cctor_m3532647019 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Physics2D__cctor_m3532647019_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
List_1_t4166282325 * L_0 = (List_1_t4166282325 *)il2cpp_codegen_object_new(List_1_t4166282325_il2cpp_TypeInfo_var);
List_1__ctor_m2338710192(L_0, /*hidden argument*/List_1__ctor_m2338710192_MethodInfo_var);
((Physics2D_t2540166467_StaticFields*)Physics2D_t2540166467_il2cpp_TypeInfo_var->static_fields)->set_m_LastDisabledRigidbody2D_0(L_0);
return;
}
}
// System.Void UnityEngine.Plane::.ctor(UnityEngine.Vector3,UnityEngine.Vector3)
extern "C" void Plane__ctor_m3187718367 (Plane_t3727654732 * __this, Vector3_t2243707580 ___inNormal0, Vector3_t2243707580 ___inPoint1, const MethodInfo* method)
{
{
Vector3_t2243707580 L_0 = ___inNormal0;
Vector3_t2243707580 L_1 = Vector3_Normalize_m2140428981(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
__this->set_m_Normal_0(L_1);
Vector3_t2243707580 L_2 = ___inNormal0;
Vector3_t2243707580 L_3 = ___inPoint1;
float L_4 = Vector3_Dot_m3161182818(NULL /*static, unused*/, L_2, L_3, /*hidden argument*/NULL);
__this->set_m_Distance_1(((-L_4)));
return;
}
}
extern "C" void Plane__ctor_m3187718367_AdjustorThunk (Il2CppObject * __this, Vector3_t2243707580 ___inNormal0, Vector3_t2243707580 ___inPoint1, const MethodInfo* method)
{
Plane_t3727654732 * _thisAdjusted = reinterpret_cast<Plane_t3727654732 *>(__this + 1);
Plane__ctor_m3187718367(_thisAdjusted, ___inNormal0, ___inPoint1, method);
}
// UnityEngine.Vector3 UnityEngine.Plane::get_normal()
extern "C" Vector3_t2243707580 Plane_get_normal_m1872443823 (Plane_t3727654732 * __this, const MethodInfo* method)
{
Vector3_t2243707580 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector3_t2243707580 L_0 = __this->get_m_Normal_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Vector3_t2243707580 L_1 = V_0;
return L_1;
}
}
extern "C" Vector3_t2243707580 Plane_get_normal_m1872443823_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Plane_t3727654732 * _thisAdjusted = reinterpret_cast<Plane_t3727654732 *>(__this + 1);
return Plane_get_normal_m1872443823(_thisAdjusted, method);
}
// System.Single UnityEngine.Plane::get_distance()
extern "C" float Plane_get_distance_m1834776091 (Plane_t3727654732 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_Distance_1();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Plane_get_distance_m1834776091_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Plane_t3727654732 * _thisAdjusted = reinterpret_cast<Plane_t3727654732 *>(__this + 1);
return Plane_get_distance_m1834776091(_thisAdjusted, method);
}
// System.Boolean UnityEngine.Plane::Raycast(UnityEngine.Ray,System.Single&)
extern "C" bool Plane_Raycast_m2870142810 (Plane_t3727654732 * __this, Ray_t2469606224 ___ray0, float* ___enter1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Plane_Raycast_m2870142810_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
float V_1 = 0.0f;
bool V_2 = false;
{
Vector3_t2243707580 L_0 = Ray_get_direction_m4059191533((&___ray0), /*hidden argument*/NULL);
Vector3_t2243707580 L_1 = Plane_get_normal_m1872443823(__this, /*hidden argument*/NULL);
float L_2 = Vector3_Dot_m3161182818(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
Vector3_t2243707580 L_3 = Ray_get_origin_m3339262500((&___ray0), /*hidden argument*/NULL);
Vector3_t2243707580 L_4 = Plane_get_normal_m1872443823(__this, /*hidden argument*/NULL);
float L_5 = Vector3_Dot_m3161182818(NULL /*static, unused*/, L_3, L_4, /*hidden argument*/NULL);
float L_6 = Plane_get_distance_m1834776091(__this, /*hidden argument*/NULL);
V_1 = ((float)((float)((-L_5))-(float)L_6));
float L_7 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Mathf_t2336485820_il2cpp_TypeInfo_var);
bool L_8 = Mathf_Approximately_m1064446634(NULL /*static, unused*/, L_7, (0.0f), /*hidden argument*/NULL);
if (!L_8)
{
goto IL_004e;
}
}
{
float* L_9 = ___enter1;
*((float*)(L_9)) = (float)(0.0f);
V_2 = (bool)0;
goto IL_0062;
}
IL_004e:
{
float* L_10 = ___enter1;
float L_11 = V_1;
float L_12 = V_0;
*((float*)(L_10)) = (float)((float)((float)L_11/(float)L_12));
float* L_13 = ___enter1;
V_2 = (bool)((((float)(*((float*)L_13))) > ((float)(0.0f)))? 1 : 0);
goto IL_0062;
}
IL_0062:
{
bool L_14 = V_2;
return L_14;
}
}
extern "C" bool Plane_Raycast_m2870142810_AdjustorThunk (Il2CppObject * __this, Ray_t2469606224 ___ray0, float* ___enter1, const MethodInfo* method)
{
Plane_t3727654732 * _thisAdjusted = reinterpret_cast<Plane_t3727654732 *>(__this + 1);
return Plane_Raycast_m2870142810(_thisAdjusted, ___ray0, ___enter1, method);
}
// System.Void UnityEngine.PreferBinarySerialization::.ctor()
extern "C" void PreferBinarySerialization__ctor_m2043201510 (PreferBinarySerialization_t2472773525 * __this, const MethodInfo* method)
{
{
Attribute__ctor_m1730479323(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.PropertyAttribute::.ctor()
extern "C" void PropertyAttribute__ctor_m3663555848 (PropertyAttribute_t2606999759 * __this, const MethodInfo* method)
{
{
Attribute__ctor_m1730479323(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Quaternion UnityEngine.Quaternion::Inverse(UnityEngine.Quaternion)
extern "C" Quaternion_t4030073918 Quaternion_Inverse_m3931399088 (Il2CppObject * __this /* static, unused */, Quaternion_t4030073918 ___rotation0, const MethodInfo* method)
{
Quaternion_t4030073918 V_0;
memset(&V_0, 0, sizeof(V_0));
Quaternion_t4030073918 V_1;
memset(&V_1, 0, sizeof(V_1));
{
Quaternion_INTERNAL_CALL_Inverse_m1043108654(NULL /*static, unused*/, (&___rotation0), (&V_0), /*hidden argument*/NULL);
Quaternion_t4030073918 L_0 = V_0;
V_1 = L_0;
goto IL_0011;
}
IL_0011:
{
Quaternion_t4030073918 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.Quaternion::INTERNAL_CALL_Inverse(UnityEngine.Quaternion&,UnityEngine.Quaternion&)
extern "C" void Quaternion_INTERNAL_CALL_Inverse_m1043108654 (Il2CppObject * __this /* static, unused */, Quaternion_t4030073918 * ___rotation0, Quaternion_t4030073918 * ___value1, const MethodInfo* method)
{
typedef void (*Quaternion_INTERNAL_CALL_Inverse_m1043108654_ftn) (Quaternion_t4030073918 *, Quaternion_t4030073918 *);
static Quaternion_INTERNAL_CALL_Inverse_m1043108654_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Quaternion_INTERNAL_CALL_Inverse_m1043108654_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Quaternion::INTERNAL_CALL_Inverse(UnityEngine.Quaternion&,UnityEngine.Quaternion&)");
_il2cpp_icall_func(___rotation0, ___value1);
}
// UnityEngine.Quaternion UnityEngine.Quaternion::Euler(UnityEngine.Vector3)
extern "C" Quaternion_t4030073918 Quaternion_Euler_m3586339259 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 ___euler0, const MethodInfo* method)
{
Quaternion_t4030073918 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector3_t2243707580 L_0 = ___euler0;
Vector3_t2243707580 L_1 = Vector3_op_Multiply_m1351554733(NULL /*static, unused*/, L_0, (0.0174532924f), /*hidden argument*/NULL);
Quaternion_t4030073918 L_2 = Quaternion_Internal_FromEulerRad_m1121344272(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0017;
}
IL_0017:
{
Quaternion_t4030073918 L_3 = V_0;
return L_3;
}
}
// UnityEngine.Quaternion UnityEngine.Quaternion::Internal_FromEulerRad(UnityEngine.Vector3)
extern "C" Quaternion_t4030073918 Quaternion_Internal_FromEulerRad_m1121344272 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 ___euler0, const MethodInfo* method)
{
Quaternion_t4030073918 V_0;
memset(&V_0, 0, sizeof(V_0));
Quaternion_t4030073918 V_1;
memset(&V_1, 0, sizeof(V_1));
{
Quaternion_INTERNAL_CALL_Internal_FromEulerRad_m1113788132(NULL /*static, unused*/, (&___euler0), (&V_0), /*hidden argument*/NULL);
Quaternion_t4030073918 L_0 = V_0;
V_1 = L_0;
goto IL_0011;
}
IL_0011:
{
Quaternion_t4030073918 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.Quaternion::INTERNAL_CALL_Internal_FromEulerRad(UnityEngine.Vector3&,UnityEngine.Quaternion&)
extern "C" void Quaternion_INTERNAL_CALL_Internal_FromEulerRad_m1113788132 (Il2CppObject * __this /* static, unused */, Vector3_t2243707580 * ___euler0, Quaternion_t4030073918 * ___value1, const MethodInfo* method)
{
typedef void (*Quaternion_INTERNAL_CALL_Internal_FromEulerRad_m1113788132_ftn) (Vector3_t2243707580 *, Quaternion_t4030073918 *);
static Quaternion_INTERNAL_CALL_Internal_FromEulerRad_m1113788132_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Quaternion_INTERNAL_CALL_Internal_FromEulerRad_m1113788132_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Quaternion::INTERNAL_CALL_Internal_FromEulerRad(UnityEngine.Vector3&,UnityEngine.Quaternion&)");
_il2cpp_icall_func(___euler0, ___value1);
}
// UnityEngine.Vector3 UnityEngine.Quaternion::op_Multiply(UnityEngine.Quaternion,UnityEngine.Vector3)
extern "C" Vector3_t2243707580 Quaternion_op_Multiply_m1483423721 (Il2CppObject * __this /* static, unused */, Quaternion_t4030073918 ___rotation0, Vector3_t2243707580 ___point1, const MethodInfo* method)
{
float V_0 = 0.0f;
float V_1 = 0.0f;
float V_2 = 0.0f;
float V_3 = 0.0f;
float V_4 = 0.0f;
float V_5 = 0.0f;
float V_6 = 0.0f;
float V_7 = 0.0f;
float V_8 = 0.0f;
float V_9 = 0.0f;
float V_10 = 0.0f;
float V_11 = 0.0f;
Vector3_t2243707580 V_12;
memset(&V_12, 0, sizeof(V_12));
Vector3_t2243707580 V_13;
memset(&V_13, 0, sizeof(V_13));
{
float L_0 = (&___rotation0)->get_x_0();
V_0 = ((float)((float)L_0*(float)(2.0f)));
float L_1 = (&___rotation0)->get_y_1();
V_1 = ((float)((float)L_1*(float)(2.0f)));
float L_2 = (&___rotation0)->get_z_2();
V_2 = ((float)((float)L_2*(float)(2.0f)));
float L_3 = (&___rotation0)->get_x_0();
float L_4 = V_0;
V_3 = ((float)((float)L_3*(float)L_4));
float L_5 = (&___rotation0)->get_y_1();
float L_6 = V_1;
V_4 = ((float)((float)L_5*(float)L_6));
float L_7 = (&___rotation0)->get_z_2();
float L_8 = V_2;
V_5 = ((float)((float)L_7*(float)L_8));
float L_9 = (&___rotation0)->get_x_0();
float L_10 = V_1;
V_6 = ((float)((float)L_9*(float)L_10));
float L_11 = (&___rotation0)->get_x_0();
float L_12 = V_2;
V_7 = ((float)((float)L_11*(float)L_12));
float L_13 = (&___rotation0)->get_y_1();
float L_14 = V_2;
V_8 = ((float)((float)L_13*(float)L_14));
float L_15 = (&___rotation0)->get_w_3();
float L_16 = V_0;
V_9 = ((float)((float)L_15*(float)L_16));
float L_17 = (&___rotation0)->get_w_3();
float L_18 = V_1;
V_10 = ((float)((float)L_17*(float)L_18));
float L_19 = (&___rotation0)->get_w_3();
float L_20 = V_2;
V_11 = ((float)((float)L_19*(float)L_20));
float L_21 = V_4;
float L_22 = V_5;
float L_23 = (&___point1)->get_x_1();
float L_24 = V_6;
float L_25 = V_11;
float L_26 = (&___point1)->get_y_2();
float L_27 = V_7;
float L_28 = V_10;
float L_29 = (&___point1)->get_z_3();
(&V_12)->set_x_1(((float)((float)((float)((float)((float)((float)((float)((float)(1.0f)-(float)((float)((float)L_21+(float)L_22))))*(float)L_23))+(float)((float)((float)((float)((float)L_24-(float)L_25))*(float)L_26))))+(float)((float)((float)((float)((float)L_27+(float)L_28))*(float)L_29)))));
float L_30 = V_6;
float L_31 = V_11;
float L_32 = (&___point1)->get_x_1();
float L_33 = V_3;
float L_34 = V_5;
float L_35 = (&___point1)->get_y_2();
float L_36 = V_8;
float L_37 = V_9;
float L_38 = (&___point1)->get_z_3();
(&V_12)->set_y_2(((float)((float)((float)((float)((float)((float)((float)((float)L_30+(float)L_31))*(float)L_32))+(float)((float)((float)((float)((float)(1.0f)-(float)((float)((float)L_33+(float)L_34))))*(float)L_35))))+(float)((float)((float)((float)((float)L_36-(float)L_37))*(float)L_38)))));
float L_39 = V_7;
float L_40 = V_10;
float L_41 = (&___point1)->get_x_1();
float L_42 = V_8;
float L_43 = V_9;
float L_44 = (&___point1)->get_y_2();
float L_45 = V_3;
float L_46 = V_4;
float L_47 = (&___point1)->get_z_3();
(&V_12)->set_z_3(((float)((float)((float)((float)((float)((float)((float)((float)L_39-(float)L_40))*(float)L_41))+(float)((float)((float)((float)((float)L_42+(float)L_43))*(float)L_44))))+(float)((float)((float)((float)((float)(1.0f)-(float)((float)((float)L_45+(float)L_46))))*(float)L_47)))));
Vector3_t2243707580 L_48 = V_12;
V_13 = L_48;
goto IL_0136;
}
IL_0136:
{
Vector3_t2243707580 L_49 = V_13;
return L_49;
}
}
// System.Boolean UnityEngine.Quaternion::op_Equality(UnityEngine.Quaternion,UnityEngine.Quaternion)
extern "C" bool Quaternion_op_Equality_m2308156925 (Il2CppObject * __this /* static, unused */, Quaternion_t4030073918 ___lhs0, Quaternion_t4030073918 ___rhs1, const MethodInfo* method)
{
bool V_0 = false;
{
Quaternion_t4030073918 L_0 = ___lhs0;
Quaternion_t4030073918 L_1 = ___rhs1;
float L_2 = Quaternion_Dot_m952616600(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
V_0 = (bool)((((float)L_2) > ((float)(0.999999f)))? 1 : 0);
goto IL_0015;
}
IL_0015:
{
bool L_3 = V_0;
return L_3;
}
}
// System.Boolean UnityEngine.Quaternion::op_Inequality(UnityEngine.Quaternion,UnityEngine.Quaternion)
extern "C" bool Quaternion_op_Inequality_m3629786166 (Il2CppObject * __this /* static, unused */, Quaternion_t4030073918 ___lhs0, Quaternion_t4030073918 ___rhs1, const MethodInfo* method)
{
bool V_0 = false;
{
Quaternion_t4030073918 L_0 = ___lhs0;
Quaternion_t4030073918 L_1 = ___rhs1;
bool L_2 = Quaternion_op_Equality_m2308156925(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
V_0 = (bool)((((int32_t)L_2) == ((int32_t)0))? 1 : 0);
goto IL_0011;
}
IL_0011:
{
bool L_3 = V_0;
return L_3;
}
}
// System.Single UnityEngine.Quaternion::Dot(UnityEngine.Quaternion,UnityEngine.Quaternion)
extern "C" float Quaternion_Dot_m952616600 (Il2CppObject * __this /* static, unused */, Quaternion_t4030073918 ___a0, Quaternion_t4030073918 ___b1, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = (&___a0)->get_x_0();
float L_1 = (&___b1)->get_x_0();
float L_2 = (&___a0)->get_y_1();
float L_3 = (&___b1)->get_y_1();
float L_4 = (&___a0)->get_z_2();
float L_5 = (&___b1)->get_z_2();
float L_6 = (&___a0)->get_w_3();
float L_7 = (&___b1)->get_w_3();
V_0 = ((float)((float)((float)((float)((float)((float)((float)((float)L_0*(float)L_1))+(float)((float)((float)L_2*(float)L_3))))+(float)((float)((float)L_4*(float)L_5))))+(float)((float)((float)L_6*(float)L_7))));
goto IL_0046;
}
IL_0046:
{
float L_8 = V_0;
return L_8;
}
}
// System.Int32 UnityEngine.Quaternion::GetHashCode()
extern "C" int32_t Quaternion_GetHashCode_m2270520528 (Quaternion_t4030073918 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
float* L_0 = __this->get_address_of_x_0();
int32_t L_1 = Single_GetHashCode_m3102305584(L_0, /*hidden argument*/NULL);
float* L_2 = __this->get_address_of_y_1();
int32_t L_3 = Single_GetHashCode_m3102305584(L_2, /*hidden argument*/NULL);
float* L_4 = __this->get_address_of_z_2();
int32_t L_5 = Single_GetHashCode_m3102305584(L_4, /*hidden argument*/NULL);
float* L_6 = __this->get_address_of_w_3();
int32_t L_7 = Single_GetHashCode_m3102305584(L_6, /*hidden argument*/NULL);
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_1^(int32_t)((int32_t)((int32_t)L_3<<(int32_t)2))))^(int32_t)((int32_t)((int32_t)L_5>>(int32_t)2))))^(int32_t)((int32_t)((int32_t)L_7>>(int32_t)1))));
goto IL_0054;
}
IL_0054:
{
int32_t L_8 = V_0;
return L_8;
}
}
extern "C" int32_t Quaternion_GetHashCode_m2270520528_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Quaternion_t4030073918 * _thisAdjusted = reinterpret_cast<Quaternion_t4030073918 *>(__this + 1);
return Quaternion_GetHashCode_m2270520528(_thisAdjusted, method);
}
// System.Boolean UnityEngine.Quaternion::Equals(System.Object)
extern "C" bool Quaternion_Equals_m3730391696 (Quaternion_t4030073918 * __this, Il2CppObject * ___other0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Quaternion_Equals_m3730391696_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
Quaternion_t4030073918 V_1;
memset(&V_1, 0, sizeof(V_1));
int32_t G_B7_0 = 0;
{
Il2CppObject * L_0 = ___other0;
if (((Il2CppObject *)IsInstSealed(L_0, Quaternion_t4030073918_il2cpp_TypeInfo_var)))
{
goto IL_0013;
}
}
{
V_0 = (bool)0;
goto IL_007a;
}
IL_0013:
{
Il2CppObject * L_1 = ___other0;
V_1 = ((*(Quaternion_t4030073918 *)((Quaternion_t4030073918 *)UnBox(L_1, Quaternion_t4030073918_il2cpp_TypeInfo_var))));
float* L_2 = __this->get_address_of_x_0();
float L_3 = (&V_1)->get_x_0();
bool L_4 = Single_Equals_m3359827399(L_2, L_3, /*hidden argument*/NULL);
if (!L_4)
{
goto IL_0073;
}
}
{
float* L_5 = __this->get_address_of_y_1();
float L_6 = (&V_1)->get_y_1();
bool L_7 = Single_Equals_m3359827399(L_5, L_6, /*hidden argument*/NULL);
if (!L_7)
{
goto IL_0073;
}
}
{
float* L_8 = __this->get_address_of_z_2();
float L_9 = (&V_1)->get_z_2();
bool L_10 = Single_Equals_m3359827399(L_8, L_9, /*hidden argument*/NULL);
if (!L_10)
{
goto IL_0073;
}
}
{
float* L_11 = __this->get_address_of_w_3();
float L_12 = (&V_1)->get_w_3();
bool L_13 = Single_Equals_m3359827399(L_11, L_12, /*hidden argument*/NULL);
G_B7_0 = ((int32_t)(L_13));
goto IL_0074;
}
IL_0073:
{
G_B7_0 = 0;
}
IL_0074:
{
V_0 = (bool)G_B7_0;
goto IL_007a;
}
IL_007a:
{
bool L_14 = V_0;
return L_14;
}
}
extern "C" bool Quaternion_Equals_m3730391696_AdjustorThunk (Il2CppObject * __this, Il2CppObject * ___other0, const MethodInfo* method)
{
Quaternion_t4030073918 * _thisAdjusted = reinterpret_cast<Quaternion_t4030073918 *>(__this + 1);
return Quaternion_Equals_m3730391696(_thisAdjusted, ___other0, method);
}
// System.String UnityEngine.Quaternion::ToString()
extern "C" String_t* Quaternion_ToString_m2638853272 (Quaternion_t4030073918 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Quaternion_ToString_m2638853272_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
ObjectU5BU5D_t3614634134* L_0 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)4));
float L_1 = __this->get_x_0();
float L_2 = L_1;
Il2CppObject * L_3 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_2);
ArrayElementTypeCheck (L_0, L_3);
(L_0)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)L_3);
ObjectU5BU5D_t3614634134* L_4 = L_0;
float L_5 = __this->get_y_1();
float L_6 = L_5;
Il2CppObject * L_7 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_6);
ArrayElementTypeCheck (L_4, L_7);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (Il2CppObject *)L_7);
ObjectU5BU5D_t3614634134* L_8 = L_4;
float L_9 = __this->get_z_2();
float L_10 = L_9;
Il2CppObject * L_11 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_10);
ArrayElementTypeCheck (L_8, L_11);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(2), (Il2CppObject *)L_11);
ObjectU5BU5D_t3614634134* L_12 = L_8;
float L_13 = __this->get_w_3();
float L_14 = L_13;
Il2CppObject * L_15 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_14);
ArrayElementTypeCheck (L_12, L_15);
(L_12)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(3), (Il2CppObject *)L_15);
String_t* L_16 = UnityString_Format_m2949645127(NULL /*static, unused*/, _stringLiteral3587482509, L_12, /*hidden argument*/NULL);
V_0 = L_16;
goto IL_004f;
}
IL_004f:
{
String_t* L_17 = V_0;
return L_17;
}
}
extern "C" String_t* Quaternion_ToString_m2638853272_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Quaternion_t4030073918 * _thisAdjusted = reinterpret_cast<Quaternion_t4030073918 *>(__this + 1);
return Quaternion_ToString_m2638853272(_thisAdjusted, method);
}
// System.Single UnityEngine.Random::Range(System.Single,System.Single)
extern "C" float Random_Range_m2884721203 (Il2CppObject * __this /* static, unused */, float ___min0, float ___max1, const MethodInfo* method)
{
typedef float (*Random_Range_m2884721203_ftn) (float, float);
static Random_Range_m2884721203_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Random_Range_m2884721203_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Random::Range(System.Single,System.Single)");
return _il2cpp_icall_func(___min0, ___max1);
}
// System.Int32 UnityEngine.Random::Range(System.Int32,System.Int32)
extern "C" int32_t Random_Range_m694320887 (Il2CppObject * __this /* static, unused */, int32_t ___min0, int32_t ___max1, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = ___min0;
int32_t L_1 = ___max1;
int32_t L_2 = Random_RandomRangeInt_m374035151(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_000e;
}
IL_000e:
{
int32_t L_3 = V_0;
return L_3;
}
}
// System.Int32 UnityEngine.Random::RandomRangeInt(System.Int32,System.Int32)
extern "C" int32_t Random_RandomRangeInt_m374035151 (Il2CppObject * __this /* static, unused */, int32_t ___min0, int32_t ___max1, const MethodInfo* method)
{
typedef int32_t (*Random_RandomRangeInt_m374035151_ftn) (int32_t, int32_t);
static Random_RandomRangeInt_m374035151_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Random_RandomRangeInt_m374035151_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Random::RandomRangeInt(System.Int32,System.Int32)");
return _il2cpp_icall_func(___min0, ___max1);
}
// System.Void UnityEngine.RangeAttribute::.ctor(System.Single,System.Single)
extern "C" void RangeAttribute__ctor_m1657271662 (RangeAttribute_t3336560921 * __this, float ___min0, float ___max1, const MethodInfo* method)
{
{
PropertyAttribute__ctor_m3663555848(__this, /*hidden argument*/NULL);
float L_0 = ___min0;
__this->set_min_0(L_0);
float L_1 = ___max1;
__this->set_max_1(L_1);
return;
}
}
// System.Void UnityEngine.RangeInt::.ctor(System.Int32,System.Int32)
extern "C" void RangeInt__ctor_m2462675305 (RangeInt_t2323401134 * __this, int32_t ___start0, int32_t ___length1, const MethodInfo* method)
{
{
int32_t L_0 = ___start0;
__this->set_start_0(L_0);
int32_t L_1 = ___length1;
__this->set_length_1(L_1);
return;
}
}
extern "C" void RangeInt__ctor_m2462675305_AdjustorThunk (Il2CppObject * __this, int32_t ___start0, int32_t ___length1, const MethodInfo* method)
{
RangeInt_t2323401134 * _thisAdjusted = reinterpret_cast<RangeInt_t2323401134 *>(__this + 1);
RangeInt__ctor_m2462675305(_thisAdjusted, ___start0, ___length1, method);
}
// System.Int32 UnityEngine.RangeInt::get_end()
extern "C" int32_t RangeInt_get_end_m913869897 (RangeInt_t2323401134 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_start_0();
int32_t L_1 = __this->get_length_1();
V_0 = ((int32_t)((int32_t)L_0+(int32_t)L_1));
goto IL_0014;
}
IL_0014:
{
int32_t L_2 = V_0;
return L_2;
}
}
extern "C" int32_t RangeInt_get_end_m913869897_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
RangeInt_t2323401134 * _thisAdjusted = reinterpret_cast<RangeInt_t2323401134 *>(__this + 1);
return RangeInt_get_end_m913869897(_thisAdjusted, method);
}
// System.Void UnityEngine.Ray::.ctor(UnityEngine.Vector3,UnityEngine.Vector3)
extern "C" void Ray__ctor_m3379034047 (Ray_t2469606224 * __this, Vector3_t2243707580 ___origin0, Vector3_t2243707580 ___direction1, const MethodInfo* method)
{
{
Vector3_t2243707580 L_0 = ___origin0;
__this->set_m_Origin_0(L_0);
Vector3_t2243707580 L_1 = Vector3_get_normalized_m936072361((&___direction1), /*hidden argument*/NULL);
__this->set_m_Direction_1(L_1);
return;
}
}
extern "C" void Ray__ctor_m3379034047_AdjustorThunk (Il2CppObject * __this, Vector3_t2243707580 ___origin0, Vector3_t2243707580 ___direction1, const MethodInfo* method)
{
Ray_t2469606224 * _thisAdjusted = reinterpret_cast<Ray_t2469606224 *>(__this + 1);
Ray__ctor_m3379034047(_thisAdjusted, ___origin0, ___direction1, method);
}
// UnityEngine.Vector3 UnityEngine.Ray::get_origin()
extern "C" Vector3_t2243707580 Ray_get_origin_m3339262500 (Ray_t2469606224 * __this, const MethodInfo* method)
{
Vector3_t2243707580 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector3_t2243707580 L_0 = __this->get_m_Origin_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Vector3_t2243707580 L_1 = V_0;
return L_1;
}
}
extern "C" Vector3_t2243707580 Ray_get_origin_m3339262500_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Ray_t2469606224 * _thisAdjusted = reinterpret_cast<Ray_t2469606224 *>(__this + 1);
return Ray_get_origin_m3339262500(_thisAdjusted, method);
}
// UnityEngine.Vector3 UnityEngine.Ray::get_direction()
extern "C" Vector3_t2243707580 Ray_get_direction_m4059191533 (Ray_t2469606224 * __this, const MethodInfo* method)
{
Vector3_t2243707580 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector3_t2243707580 L_0 = __this->get_m_Direction_1();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Vector3_t2243707580 L_1 = V_0;
return L_1;
}
}
extern "C" Vector3_t2243707580 Ray_get_direction_m4059191533_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Ray_t2469606224 * _thisAdjusted = reinterpret_cast<Ray_t2469606224 *>(__this + 1);
return Ray_get_direction_m4059191533(_thisAdjusted, method);
}
// UnityEngine.Vector3 UnityEngine.Ray::GetPoint(System.Single)
extern "C" Vector3_t2243707580 Ray_GetPoint_m1353702366 (Ray_t2469606224 * __this, float ___distance0, const MethodInfo* method)
{
Vector3_t2243707580 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector3_t2243707580 L_0 = __this->get_m_Origin_0();
Vector3_t2243707580 L_1 = __this->get_m_Direction_1();
float L_2 = ___distance0;
Vector3_t2243707580 L_3 = Vector3_op_Multiply_m1351554733(NULL /*static, unused*/, L_1, L_2, /*hidden argument*/NULL);
Vector3_t2243707580 L_4 = Vector3_op_Addition_m3146764857(NULL /*static, unused*/, L_0, L_3, /*hidden argument*/NULL);
V_0 = L_4;
goto IL_001e;
}
IL_001e:
{
Vector3_t2243707580 L_5 = V_0;
return L_5;
}
}
extern "C" Vector3_t2243707580 Ray_GetPoint_m1353702366_AdjustorThunk (Il2CppObject * __this, float ___distance0, const MethodInfo* method)
{
Ray_t2469606224 * _thisAdjusted = reinterpret_cast<Ray_t2469606224 *>(__this + 1);
return Ray_GetPoint_m1353702366(_thisAdjusted, ___distance0, method);
}
// System.String UnityEngine.Ray::ToString()
extern "C" String_t* Ray_ToString_m2019179238 (Ray_t2469606224 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Ray_ToString_m2019179238_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
ObjectU5BU5D_t3614634134* L_0 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)2));
Vector3_t2243707580 L_1 = __this->get_m_Origin_0();
Vector3_t2243707580 L_2 = L_1;
Il2CppObject * L_3 = Box(Vector3_t2243707580_il2cpp_TypeInfo_var, &L_2);
ArrayElementTypeCheck (L_0, L_3);
(L_0)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)L_3);
ObjectU5BU5D_t3614634134* L_4 = L_0;
Vector3_t2243707580 L_5 = __this->get_m_Direction_1();
Vector3_t2243707580 L_6 = L_5;
Il2CppObject * L_7 = Box(Vector3_t2243707580_il2cpp_TypeInfo_var, &L_6);
ArrayElementTypeCheck (L_4, L_7);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (Il2CppObject *)L_7);
String_t* L_8 = UnityString_Format_m2949645127(NULL /*static, unused*/, _stringLiteral1807026812, L_4, /*hidden argument*/NULL);
V_0 = L_8;
goto IL_0033;
}
IL_0033:
{
String_t* L_9 = V_0;
return L_9;
}
}
extern "C" String_t* Ray_ToString_m2019179238_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Ray_t2469606224 * _thisAdjusted = reinterpret_cast<Ray_t2469606224 *>(__this + 1);
return Ray_ToString_m2019179238(_thisAdjusted, method);
}
// Conversion methods for marshalling of: UnityEngine.RaycastHit
extern "C" void RaycastHit_t87180320_marshal_pinvoke(const RaycastHit_t87180320& unmarshaled, RaycastHit_t87180320_marshaled_pinvoke& marshaled)
{
Il2CppCodeGenException* ___m_Collider_5Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Collider' of type 'RaycastHit': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Collider_5Exception);
}
extern "C" void RaycastHit_t87180320_marshal_pinvoke_back(const RaycastHit_t87180320_marshaled_pinvoke& marshaled, RaycastHit_t87180320& unmarshaled)
{
Il2CppCodeGenException* ___m_Collider_5Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Collider' of type 'RaycastHit': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Collider_5Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.RaycastHit
extern "C" void RaycastHit_t87180320_marshal_pinvoke_cleanup(RaycastHit_t87180320_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.RaycastHit
extern "C" void RaycastHit_t87180320_marshal_com(const RaycastHit_t87180320& unmarshaled, RaycastHit_t87180320_marshaled_com& marshaled)
{
Il2CppCodeGenException* ___m_Collider_5Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Collider' of type 'RaycastHit': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Collider_5Exception);
}
extern "C" void RaycastHit_t87180320_marshal_com_back(const RaycastHit_t87180320_marshaled_com& marshaled, RaycastHit_t87180320& unmarshaled)
{
Il2CppCodeGenException* ___m_Collider_5Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Collider' of type 'RaycastHit': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Collider_5Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.RaycastHit
extern "C" void RaycastHit_t87180320_marshal_com_cleanup(RaycastHit_t87180320_marshaled_com& marshaled)
{
}
// UnityEngine.Vector3 UnityEngine.RaycastHit::get_point()
extern "C" Vector3_t2243707580 RaycastHit_get_point_m326143462 (RaycastHit_t87180320 * __this, const MethodInfo* method)
{
Vector3_t2243707580 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector3_t2243707580 L_0 = __this->get_m_Point_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Vector3_t2243707580 L_1 = V_0;
return L_1;
}
}
extern "C" Vector3_t2243707580 RaycastHit_get_point_m326143462_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
RaycastHit_t87180320 * _thisAdjusted = reinterpret_cast<RaycastHit_t87180320 *>(__this + 1);
return RaycastHit_get_point_m326143462(_thisAdjusted, method);
}
// UnityEngine.Vector3 UnityEngine.RaycastHit::get_normal()
extern "C" Vector3_t2243707580 RaycastHit_get_normal_m817665579 (RaycastHit_t87180320 * __this, const MethodInfo* method)
{
Vector3_t2243707580 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector3_t2243707580 L_0 = __this->get_m_Normal_1();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Vector3_t2243707580 L_1 = V_0;
return L_1;
}
}
extern "C" Vector3_t2243707580 RaycastHit_get_normal_m817665579_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
RaycastHit_t87180320 * _thisAdjusted = reinterpret_cast<RaycastHit_t87180320 *>(__this + 1);
return RaycastHit_get_normal_m817665579(_thisAdjusted, method);
}
// System.Single UnityEngine.RaycastHit::get_distance()
extern "C" float RaycastHit_get_distance_m1178709367 (RaycastHit_t87180320 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_Distance_3();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float RaycastHit_get_distance_m1178709367_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
RaycastHit_t87180320 * _thisAdjusted = reinterpret_cast<RaycastHit_t87180320 *>(__this + 1);
return RaycastHit_get_distance_m1178709367(_thisAdjusted, method);
}
// UnityEngine.Collider UnityEngine.RaycastHit::get_collider()
extern "C" Collider_t3497673348 * RaycastHit_get_collider_m301198172 (RaycastHit_t87180320 * __this, const MethodInfo* method)
{
Collider_t3497673348 * V_0 = NULL;
{
Collider_t3497673348 * L_0 = __this->get_m_Collider_5();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Collider_t3497673348 * L_1 = V_0;
return L_1;
}
}
extern "C" Collider_t3497673348 * RaycastHit_get_collider_m301198172_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
RaycastHit_t87180320 * _thisAdjusted = reinterpret_cast<RaycastHit_t87180320 *>(__this + 1);
return RaycastHit_get_collider_m301198172(_thisAdjusted, method);
}
// Conversion methods for marshalling of: UnityEngine.RaycastHit2D
extern "C" void RaycastHit2D_t4063908774_marshal_pinvoke(const RaycastHit2D_t4063908774& unmarshaled, RaycastHit2D_t4063908774_marshaled_pinvoke& marshaled)
{
Il2CppCodeGenException* ___m_Collider_5Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Collider' of type 'RaycastHit2D': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Collider_5Exception);
}
extern "C" void RaycastHit2D_t4063908774_marshal_pinvoke_back(const RaycastHit2D_t4063908774_marshaled_pinvoke& marshaled, RaycastHit2D_t4063908774& unmarshaled)
{
Il2CppCodeGenException* ___m_Collider_5Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Collider' of type 'RaycastHit2D': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Collider_5Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.RaycastHit2D
extern "C" void RaycastHit2D_t4063908774_marshal_pinvoke_cleanup(RaycastHit2D_t4063908774_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.RaycastHit2D
extern "C" void RaycastHit2D_t4063908774_marshal_com(const RaycastHit2D_t4063908774& unmarshaled, RaycastHit2D_t4063908774_marshaled_com& marshaled)
{
Il2CppCodeGenException* ___m_Collider_5Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Collider' of type 'RaycastHit2D': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Collider_5Exception);
}
extern "C" void RaycastHit2D_t4063908774_marshal_com_back(const RaycastHit2D_t4063908774_marshaled_com& marshaled, RaycastHit2D_t4063908774& unmarshaled)
{
Il2CppCodeGenException* ___m_Collider_5Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Collider' of type 'RaycastHit2D': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Collider_5Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.RaycastHit2D
extern "C" void RaycastHit2D_t4063908774_marshal_com_cleanup(RaycastHit2D_t4063908774_marshaled_com& marshaled)
{
}
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::get_point()
extern "C" Vector2_t2243707579 RaycastHit2D_get_point_m442317739 (RaycastHit2D_t4063908774 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector2_t2243707579 L_0 = __this->get_m_Point_1();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Vector2_t2243707579 L_1 = V_0;
return L_1;
}
}
extern "C" Vector2_t2243707579 RaycastHit2D_get_point_m442317739_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
RaycastHit2D_t4063908774 * _thisAdjusted = reinterpret_cast<RaycastHit2D_t4063908774 *>(__this + 1);
return RaycastHit2D_get_point_m442317739(_thisAdjusted, method);
}
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::get_normal()
extern "C" Vector2_t2243707579 RaycastHit2D_get_normal_m3768105386 (RaycastHit2D_t4063908774 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector2_t2243707579 L_0 = __this->get_m_Normal_2();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Vector2_t2243707579 L_1 = V_0;
return L_1;
}
}
extern "C" Vector2_t2243707579 RaycastHit2D_get_normal_m3768105386_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
RaycastHit2D_t4063908774 * _thisAdjusted = reinterpret_cast<RaycastHit2D_t4063908774 *>(__this + 1);
return RaycastHit2D_get_normal_m3768105386(_thisAdjusted, method);
}
// System.Single UnityEngine.RaycastHit2D::get_fraction()
extern "C" float RaycastHit2D_get_fraction_m1296150410 (RaycastHit2D_t4063908774 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_Fraction_4();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float RaycastHit2D_get_fraction_m1296150410_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
RaycastHit2D_t4063908774 * _thisAdjusted = reinterpret_cast<RaycastHit2D_t4063908774 *>(__this + 1);
return RaycastHit2D_get_fraction_m1296150410(_thisAdjusted, method);
}
// UnityEngine.Collider2D UnityEngine.RaycastHit2D::get_collider()
extern "C" Collider2D_t646061738 * RaycastHit2D_get_collider_m2568504212 (RaycastHit2D_t4063908774 * __this, const MethodInfo* method)
{
Collider2D_t646061738 * V_0 = NULL;
{
Collider2D_t646061738 * L_0 = __this->get_m_Collider_5();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
Collider2D_t646061738 * L_1 = V_0;
return L_1;
}
}
extern "C" Collider2D_t646061738 * RaycastHit2D_get_collider_m2568504212_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
RaycastHit2D_t4063908774 * _thisAdjusted = reinterpret_cast<RaycastHit2D_t4063908774 *>(__this + 1);
return RaycastHit2D_get_collider_m2568504212(_thisAdjusted, method);
}
// System.Void UnityEngine.Rect::.ctor(System.Single,System.Single,System.Single,System.Single)
extern "C" void Rect__ctor_m1220545469 (Rect_t3681755626 * __this, float ___x0, float ___y1, float ___width2, float ___height3, const MethodInfo* method)
{
{
float L_0 = ___x0;
__this->set_m_XMin_0(L_0);
float L_1 = ___y1;
__this->set_m_YMin_1(L_1);
float L_2 = ___width2;
__this->set_m_Width_2(L_2);
float L_3 = ___height3;
__this->set_m_Height_3(L_3);
return;
}
}
extern "C" void Rect__ctor_m1220545469_AdjustorThunk (Il2CppObject * __this, float ___x0, float ___y1, float ___width2, float ___height3, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
Rect__ctor_m1220545469(_thisAdjusted, ___x0, ___y1, ___width2, ___height3, method);
}
// System.Single UnityEngine.Rect::get_x()
extern "C" float Rect_get_x_m1393582490 (Rect_t3681755626 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_XMin_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Rect_get_x_m1393582490_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_x_m1393582490(_thisAdjusted, method);
}
// System.Void UnityEngine.Rect::set_x(System.Single)
extern "C" void Rect_set_x_m3783700513 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method)
{
{
float L_0 = ___value0;
__this->set_m_XMin_0(L_0);
return;
}
}
extern "C" void Rect_set_x_m3783700513_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
Rect_set_x_m3783700513(_thisAdjusted, ___value0, method);
}
// System.Single UnityEngine.Rect::get_y()
extern "C" float Rect_get_y_m1393582395 (Rect_t3681755626 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_YMin_1();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Rect_get_y_m1393582395_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_y_m1393582395(_thisAdjusted, method);
}
// System.Void UnityEngine.Rect::set_y(System.Single)
extern "C" void Rect_set_y_m4294916608 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method)
{
{
float L_0 = ___value0;
__this->set_m_YMin_1(L_0);
return;
}
}
extern "C" void Rect_set_y_m4294916608_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
Rect_set_y_m4294916608(_thisAdjusted, ___value0, method);
}
// UnityEngine.Vector2 UnityEngine.Rect::get_position()
extern "C" Vector2_t2243707579 Rect_get_position_m24550734 (Rect_t3681755626 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
float L_0 = __this->get_m_XMin_0();
float L_1 = __this->get_m_YMin_1();
Vector2_t2243707579 L_2;
memset(&L_2, 0, sizeof(L_2));
Vector2__ctor_m3067419446(&L_2, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0018;
}
IL_0018:
{
Vector2_t2243707579 L_3 = V_0;
return L_3;
}
}
extern "C" Vector2_t2243707579 Rect_get_position_m24550734_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_position_m24550734(_thisAdjusted, method);
}
// UnityEngine.Vector2 UnityEngine.Rect::get_center()
extern "C" Vector2_t2243707579 Rect_get_center_m3049923624 (Rect_t3681755626 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
float L_0 = Rect_get_x_m1393582490(__this, /*hidden argument*/NULL);
float L_1 = __this->get_m_Width_2();
float L_2 = Rect_get_y_m1393582395(__this, /*hidden argument*/NULL);
float L_3 = __this->get_m_Height_3();
Vector2_t2243707579 L_4;
memset(&L_4, 0, sizeof(L_4));
Vector2__ctor_m3067419446(&L_4, ((float)((float)L_0+(float)((float)((float)L_1/(float)(2.0f))))), ((float)((float)L_2+(float)((float)((float)L_3/(float)(2.0f))))), /*hidden argument*/NULL);
V_0 = L_4;
goto IL_0032;
}
IL_0032:
{
Vector2_t2243707579 L_5 = V_0;
return L_5;
}
}
extern "C" Vector2_t2243707579 Rect_get_center_m3049923624_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_center_m3049923624(_thisAdjusted, method);
}
// UnityEngine.Vector2 UnityEngine.Rect::get_min()
extern "C" Vector2_t2243707579 Rect_get_min_m2549872833 (Rect_t3681755626 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
float L_0 = Rect_get_xMin_m1161102488(__this, /*hidden argument*/NULL);
float L_1 = Rect_get_yMin_m1161103577(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_2;
memset(&L_2, 0, sizeof(L_2));
Vector2__ctor_m3067419446(&L_2, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0018;
}
IL_0018:
{
Vector2_t2243707579 L_3 = V_0;
return L_3;
}
}
extern "C" Vector2_t2243707579 Rect_get_min_m2549872833_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_min_m2549872833(_thisAdjusted, method);
}
// UnityEngine.Vector2 UnityEngine.Rect::get_max()
extern "C" Vector2_t2243707579 Rect_get_max_m96665935 (Rect_t3681755626 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
float L_0 = Rect_get_xMax_m2915145014(__this, /*hidden argument*/NULL);
float L_1 = Rect_get_yMax_m2915146103(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_2;
memset(&L_2, 0, sizeof(L_2));
Vector2__ctor_m3067419446(&L_2, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0018;
}
IL_0018:
{
Vector2_t2243707579 L_3 = V_0;
return L_3;
}
}
extern "C" Vector2_t2243707579 Rect_get_max_m96665935_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_max_m96665935(_thisAdjusted, method);
}
// System.Single UnityEngine.Rect::get_width()
extern "C" float Rect_get_width_m1138015702 (Rect_t3681755626 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_Width_2();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Rect_get_width_m1138015702_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_width_m1138015702(_thisAdjusted, method);
}
// System.Void UnityEngine.Rect::set_width(System.Single)
extern "C" void Rect_set_width_m1921257731 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method)
{
{
float L_0 = ___value0;
__this->set_m_Width_2(L_0);
return;
}
}
extern "C" void Rect_set_width_m1921257731_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
Rect_set_width_m1921257731(_thisAdjusted, ___value0, method);
}
// System.Single UnityEngine.Rect::get_height()
extern "C" float Rect_get_height_m3128694305 (Rect_t3681755626 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_Height_3();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Rect_get_height_m3128694305_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_height_m3128694305(_thisAdjusted, method);
}
// System.Void UnityEngine.Rect::set_height(System.Single)
extern "C" void Rect_set_height_m2019122814 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method)
{
{
float L_0 = ___value0;
__this->set_m_Height_3(L_0);
return;
}
}
extern "C" void Rect_set_height_m2019122814_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
Rect_set_height_m2019122814(_thisAdjusted, ___value0, method);
}
// UnityEngine.Vector2 UnityEngine.Rect::get_size()
extern "C" Vector2_t2243707579 Rect_get_size_m3833121112 (Rect_t3681755626 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
float L_0 = __this->get_m_Width_2();
float L_1 = __this->get_m_Height_3();
Vector2_t2243707579 L_2;
memset(&L_2, 0, sizeof(L_2));
Vector2__ctor_m3067419446(&L_2, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0018;
}
IL_0018:
{
Vector2_t2243707579 L_3 = V_0;
return L_3;
}
}
extern "C" Vector2_t2243707579 Rect_get_size_m3833121112_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_size_m3833121112(_thisAdjusted, method);
}
// System.Single UnityEngine.Rect::get_xMin()
extern "C" float Rect_get_xMin_m1161102488 (Rect_t3681755626 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_XMin_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Rect_get_xMin_m1161102488_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_xMin_m1161102488(_thisAdjusted, method);
}
// System.Void UnityEngine.Rect::set_xMin(System.Single)
extern "C" void Rect_set_xMin_m4214255623 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = Rect_get_xMax_m2915145014(__this, /*hidden argument*/NULL);
V_0 = L_0;
float L_1 = ___value0;
__this->set_m_XMin_0(L_1);
float L_2 = V_0;
float L_3 = __this->get_m_XMin_0();
__this->set_m_Width_2(((float)((float)L_2-(float)L_3)));
return;
}
}
extern "C" void Rect_set_xMin_m4214255623_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
Rect_set_xMin_m4214255623(_thisAdjusted, ___value0, method);
}
// System.Single UnityEngine.Rect::get_yMin()
extern "C" float Rect_get_yMin_m1161103577 (Rect_t3681755626 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_YMin_1();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
float L_1 = V_0;
return L_1;
}
}
extern "C" float Rect_get_yMin_m1161103577_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_yMin_m1161103577(_thisAdjusted, method);
}
// System.Void UnityEngine.Rect::set_yMin(System.Single)
extern "C" void Rect_set_yMin_m734445288 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = Rect_get_yMax_m2915146103(__this, /*hidden argument*/NULL);
V_0 = L_0;
float L_1 = ___value0;
__this->set_m_YMin_1(L_1);
float L_2 = V_0;
float L_3 = __this->get_m_YMin_1();
__this->set_m_Height_3(((float)((float)L_2-(float)L_3)));
return;
}
}
extern "C" void Rect_set_yMin_m734445288_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
Rect_set_yMin_m734445288(_thisAdjusted, ___value0, method);
}
// System.Single UnityEngine.Rect::get_xMax()
extern "C" float Rect_get_xMax_m2915145014 (Rect_t3681755626 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_Width_2();
float L_1 = __this->get_m_XMin_0();
V_0 = ((float)((float)L_0+(float)L_1));
goto IL_0014;
}
IL_0014:
{
float L_2 = V_0;
return L_2;
}
}
extern "C" float Rect_get_xMax_m2915145014_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_xMax_m2915145014(_thisAdjusted, method);
}
// System.Void UnityEngine.Rect::set_xMax(System.Single)
extern "C" void Rect_set_xMax_m3501625033 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method)
{
{
float L_0 = ___value0;
float L_1 = __this->get_m_XMin_0();
__this->set_m_Width_2(((float)((float)L_0-(float)L_1)));
return;
}
}
extern "C" void Rect_set_xMax_m3501625033_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
Rect_set_xMax_m3501625033(_thisAdjusted, ___value0, method);
}
// System.Single UnityEngine.Rect::get_yMax()
extern "C" float Rect_get_yMax_m2915146103 (Rect_t3681755626 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
{
float L_0 = __this->get_m_Height_3();
float L_1 = __this->get_m_YMin_1();
V_0 = ((float)((float)L_0+(float)L_1));
goto IL_0014;
}
IL_0014:
{
float L_2 = V_0;
return L_2;
}
}
extern "C" float Rect_get_yMax_m2915146103_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_get_yMax_m2915146103(_thisAdjusted, method);
}
// System.Void UnityEngine.Rect::set_yMax(System.Single)
extern "C" void Rect_set_yMax_m21814698 (Rect_t3681755626 * __this, float ___value0, const MethodInfo* method)
{
{
float L_0 = ___value0;
float L_1 = __this->get_m_YMin_1();
__this->set_m_Height_3(((float)((float)L_0-(float)L_1)));
return;
}
}
extern "C" void Rect_set_yMax_m21814698_AdjustorThunk (Il2CppObject * __this, float ___value0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
Rect_set_yMax_m21814698(_thisAdjusted, ___value0, method);
}
// System.Boolean UnityEngine.Rect::Contains(UnityEngine.Vector2)
extern "C" bool Rect_Contains_m1334685290 (Rect_t3681755626 * __this, Vector2_t2243707579 ___point0, const MethodInfo* method)
{
bool V_0 = false;
int32_t G_B5_0 = 0;
{
float L_0 = (&___point0)->get_x_0();
float L_1 = Rect_get_xMin_m1161102488(__this, /*hidden argument*/NULL);
if ((!(((float)L_0) >= ((float)L_1))))
{
goto IL_0048;
}
}
{
float L_2 = (&___point0)->get_x_0();
float L_3 = Rect_get_xMax_m2915145014(__this, /*hidden argument*/NULL);
if ((!(((float)L_2) < ((float)L_3))))
{
goto IL_0048;
}
}
{
float L_4 = (&___point0)->get_y_1();
float L_5 = Rect_get_yMin_m1161103577(__this, /*hidden argument*/NULL);
if ((!(((float)L_4) >= ((float)L_5))))
{
goto IL_0048;
}
}
{
float L_6 = (&___point0)->get_y_1();
float L_7 = Rect_get_yMax_m2915146103(__this, /*hidden argument*/NULL);
G_B5_0 = ((((float)L_6) < ((float)L_7))? 1 : 0);
goto IL_0049;
}
IL_0048:
{
G_B5_0 = 0;
}
IL_0049:
{
V_0 = (bool)G_B5_0;
goto IL_004f;
}
IL_004f:
{
bool L_8 = V_0;
return L_8;
}
}
extern "C" bool Rect_Contains_m1334685290_AdjustorThunk (Il2CppObject * __this, Vector2_t2243707579 ___point0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_Contains_m1334685290(_thisAdjusted, ___point0, method);
}
// System.Boolean UnityEngine.Rect::Contains(UnityEngine.Vector3)
extern "C" bool Rect_Contains_m1334685291 (Rect_t3681755626 * __this, Vector3_t2243707580 ___point0, const MethodInfo* method)
{
bool V_0 = false;
int32_t G_B5_0 = 0;
{
float L_0 = (&___point0)->get_x_1();
float L_1 = Rect_get_xMin_m1161102488(__this, /*hidden argument*/NULL);
if ((!(((float)L_0) >= ((float)L_1))))
{
goto IL_0048;
}
}
{
float L_2 = (&___point0)->get_x_1();
float L_3 = Rect_get_xMax_m2915145014(__this, /*hidden argument*/NULL);
if ((!(((float)L_2) < ((float)L_3))))
{
goto IL_0048;
}
}
{
float L_4 = (&___point0)->get_y_2();
float L_5 = Rect_get_yMin_m1161103577(__this, /*hidden argument*/NULL);
if ((!(((float)L_4) >= ((float)L_5))))
{
goto IL_0048;
}
}
{
float L_6 = (&___point0)->get_y_2();
float L_7 = Rect_get_yMax_m2915146103(__this, /*hidden argument*/NULL);
G_B5_0 = ((((float)L_6) < ((float)L_7))? 1 : 0);
goto IL_0049;
}
IL_0048:
{
G_B5_0 = 0;
}
IL_0049:
{
V_0 = (bool)G_B5_0;
goto IL_004f;
}
IL_004f:
{
bool L_8 = V_0;
return L_8;
}
}
extern "C" bool Rect_Contains_m1334685291_AdjustorThunk (Il2CppObject * __this, Vector3_t2243707580 ___point0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_Contains_m1334685291(_thisAdjusted, ___point0, method);
}
// UnityEngine.Rect UnityEngine.Rect::OrderMinMax(UnityEngine.Rect)
extern "C" Rect_t3681755626 Rect_OrderMinMax_m1783437776 (Il2CppObject * __this /* static, unused */, Rect_t3681755626 ___rect0, const MethodInfo* method)
{
float V_0 = 0.0f;
float V_1 = 0.0f;
Rect_t3681755626 V_2;
memset(&V_2, 0, sizeof(V_2));
{
float L_0 = Rect_get_xMin_m1161102488((&___rect0), /*hidden argument*/NULL);
float L_1 = Rect_get_xMax_m2915145014((&___rect0), /*hidden argument*/NULL);
if ((!(((float)L_0) > ((float)L_1))))
{
goto IL_0034;
}
}
{
float L_2 = Rect_get_xMin_m1161102488((&___rect0), /*hidden argument*/NULL);
V_0 = L_2;
float L_3 = Rect_get_xMax_m2915145014((&___rect0), /*hidden argument*/NULL);
Rect_set_xMin_m4214255623((&___rect0), L_3, /*hidden argument*/NULL);
float L_4 = V_0;
Rect_set_xMax_m3501625033((&___rect0), L_4, /*hidden argument*/NULL);
}
IL_0034:
{
float L_5 = Rect_get_yMin_m1161103577((&___rect0), /*hidden argument*/NULL);
float L_6 = Rect_get_yMax_m2915146103((&___rect0), /*hidden argument*/NULL);
if ((!(((float)L_5) > ((float)L_6))))
{
goto IL_0067;
}
}
{
float L_7 = Rect_get_yMin_m1161103577((&___rect0), /*hidden argument*/NULL);
V_1 = L_7;
float L_8 = Rect_get_yMax_m2915146103((&___rect0), /*hidden argument*/NULL);
Rect_set_yMin_m734445288((&___rect0), L_8, /*hidden argument*/NULL);
float L_9 = V_1;
Rect_set_yMax_m21814698((&___rect0), L_9, /*hidden argument*/NULL);
}
IL_0067:
{
Rect_t3681755626 L_10 = ___rect0;
V_2 = L_10;
goto IL_006e;
}
IL_006e:
{
Rect_t3681755626 L_11 = V_2;
return L_11;
}
}
// System.Boolean UnityEngine.Rect::Overlaps(UnityEngine.Rect)
extern "C" bool Rect_Overlaps_m210444568 (Rect_t3681755626 * __this, Rect_t3681755626 ___other0, const MethodInfo* method)
{
bool V_0 = false;
int32_t G_B5_0 = 0;
{
float L_0 = Rect_get_xMax_m2915145014((&___other0), /*hidden argument*/NULL);
float L_1 = Rect_get_xMin_m1161102488(__this, /*hidden argument*/NULL);
if ((!(((float)L_0) > ((float)L_1))))
{
goto IL_0048;
}
}
{
float L_2 = Rect_get_xMin_m1161102488((&___other0), /*hidden argument*/NULL);
float L_3 = Rect_get_xMax_m2915145014(__this, /*hidden argument*/NULL);
if ((!(((float)L_2) < ((float)L_3))))
{
goto IL_0048;
}
}
{
float L_4 = Rect_get_yMax_m2915146103((&___other0), /*hidden argument*/NULL);
float L_5 = Rect_get_yMin_m1161103577(__this, /*hidden argument*/NULL);
if ((!(((float)L_4) > ((float)L_5))))
{
goto IL_0048;
}
}
{
float L_6 = Rect_get_yMin_m1161103577((&___other0), /*hidden argument*/NULL);
float L_7 = Rect_get_yMax_m2915146103(__this, /*hidden argument*/NULL);
G_B5_0 = ((((float)L_6) < ((float)L_7))? 1 : 0);
goto IL_0049;
}
IL_0048:
{
G_B5_0 = 0;
}
IL_0049:
{
V_0 = (bool)G_B5_0;
goto IL_004f;
}
IL_004f:
{
bool L_8 = V_0;
return L_8;
}
}
extern "C" bool Rect_Overlaps_m210444568_AdjustorThunk (Il2CppObject * __this, Rect_t3681755626 ___other0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_Overlaps_m210444568(_thisAdjusted, ___other0, method);
}
// System.Boolean UnityEngine.Rect::Overlaps(UnityEngine.Rect,System.Boolean)
extern "C" bool Rect_Overlaps_m4145874649 (Rect_t3681755626 * __this, Rect_t3681755626 ___other0, bool ___allowInverse1, const MethodInfo* method)
{
Rect_t3681755626 V_0;
memset(&V_0, 0, sizeof(V_0));
bool V_1 = false;
{
V_0 = (*(Rect_t3681755626 *)__this);
bool L_0 = ___allowInverse1;
if (!L_0)
{
goto IL_001f;
}
}
{
Rect_t3681755626 L_1 = V_0;
Rect_t3681755626 L_2 = Rect_OrderMinMax_m1783437776(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
V_0 = L_2;
Rect_t3681755626 L_3 = ___other0;
Rect_t3681755626 L_4 = Rect_OrderMinMax_m1783437776(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
___other0 = L_4;
}
IL_001f:
{
Rect_t3681755626 L_5 = ___other0;
bool L_6 = Rect_Overlaps_m210444568((&V_0), L_5, /*hidden argument*/NULL);
V_1 = L_6;
goto IL_002d;
}
IL_002d:
{
bool L_7 = V_1;
return L_7;
}
}
extern "C" bool Rect_Overlaps_m4145874649_AdjustorThunk (Il2CppObject * __this, Rect_t3681755626 ___other0, bool ___allowInverse1, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_Overlaps_m4145874649(_thisAdjusted, ___other0, ___allowInverse1, method);
}
// System.Boolean UnityEngine.Rect::op_Inequality(UnityEngine.Rect,UnityEngine.Rect)
extern "C" bool Rect_op_Inequality_m3595915756 (Il2CppObject * __this /* static, unused */, Rect_t3681755626 ___lhs0, Rect_t3681755626 ___rhs1, const MethodInfo* method)
{
bool V_0 = false;
{
Rect_t3681755626 L_0 = ___lhs0;
Rect_t3681755626 L_1 = ___rhs1;
bool L_2 = Rect_op_Equality_m2793663577(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
V_0 = (bool)((((int32_t)L_2) == ((int32_t)0))? 1 : 0);
goto IL_0011;
}
IL_0011:
{
bool L_3 = V_0;
return L_3;
}
}
// System.Boolean UnityEngine.Rect::op_Equality(UnityEngine.Rect,UnityEngine.Rect)
extern "C" bool Rect_op_Equality_m2793663577 (Il2CppObject * __this /* static, unused */, Rect_t3681755626 ___lhs0, Rect_t3681755626 ___rhs1, const MethodInfo* method)
{
bool V_0 = false;
int32_t G_B5_0 = 0;
{
float L_0 = Rect_get_x_m1393582490((&___lhs0), /*hidden argument*/NULL);
float L_1 = Rect_get_x_m1393582490((&___rhs1), /*hidden argument*/NULL);
if ((!(((float)L_0) == ((float)L_1))))
{
goto IL_004c;
}
}
{
float L_2 = Rect_get_y_m1393582395((&___lhs0), /*hidden argument*/NULL);
float L_3 = Rect_get_y_m1393582395((&___rhs1), /*hidden argument*/NULL);
if ((!(((float)L_2) == ((float)L_3))))
{
goto IL_004c;
}
}
{
float L_4 = Rect_get_width_m1138015702((&___lhs0), /*hidden argument*/NULL);
float L_5 = Rect_get_width_m1138015702((&___rhs1), /*hidden argument*/NULL);
if ((!(((float)L_4) == ((float)L_5))))
{
goto IL_004c;
}
}
{
float L_6 = Rect_get_height_m3128694305((&___lhs0), /*hidden argument*/NULL);
float L_7 = Rect_get_height_m3128694305((&___rhs1), /*hidden argument*/NULL);
G_B5_0 = ((((float)L_6) == ((float)L_7))? 1 : 0);
goto IL_004d;
}
IL_004c:
{
G_B5_0 = 0;
}
IL_004d:
{
V_0 = (bool)G_B5_0;
goto IL_0053;
}
IL_0053:
{
bool L_8 = V_0;
return L_8;
}
}
// System.Int32 UnityEngine.Rect::GetHashCode()
extern "C" int32_t Rect_GetHashCode_m559954498 (Rect_t3681755626 * __this, const MethodInfo* method)
{
float V_0 = 0.0f;
float V_1 = 0.0f;
float V_2 = 0.0f;
float V_3 = 0.0f;
int32_t V_4 = 0;
{
float L_0 = Rect_get_x_m1393582490(__this, /*hidden argument*/NULL);
V_0 = L_0;
int32_t L_1 = Single_GetHashCode_m3102305584((&V_0), /*hidden argument*/NULL);
float L_2 = Rect_get_width_m1138015702(__this, /*hidden argument*/NULL);
V_1 = L_2;
int32_t L_3 = Single_GetHashCode_m3102305584((&V_1), /*hidden argument*/NULL);
float L_4 = Rect_get_y_m1393582395(__this, /*hidden argument*/NULL);
V_2 = L_4;
int32_t L_5 = Single_GetHashCode_m3102305584((&V_2), /*hidden argument*/NULL);
float L_6 = Rect_get_height_m3128694305(__this, /*hidden argument*/NULL);
V_3 = L_6;
int32_t L_7 = Single_GetHashCode_m3102305584((&V_3), /*hidden argument*/NULL);
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_1^(int32_t)((int32_t)((int32_t)L_3<<(int32_t)2))))^(int32_t)((int32_t)((int32_t)L_5>>(int32_t)2))))^(int32_t)((int32_t)((int32_t)L_7>>(int32_t)1))));
goto IL_0061;
}
IL_0061:
{
int32_t L_8 = V_4;
return L_8;
}
}
extern "C" int32_t Rect_GetHashCode_m559954498_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_GetHashCode_m559954498(_thisAdjusted, method);
}
// System.Boolean UnityEngine.Rect::Equals(System.Object)
extern "C" bool Rect_Equals_m3806390726 (Rect_t3681755626 * __this, Il2CppObject * ___other0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Rect_Equals_m3806390726_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
Rect_t3681755626 V_1;
memset(&V_1, 0, sizeof(V_1));
float V_2 = 0.0f;
float V_3 = 0.0f;
float V_4 = 0.0f;
float V_5 = 0.0f;
int32_t G_B7_0 = 0;
{
Il2CppObject * L_0 = ___other0;
if (((Il2CppObject *)IsInstSealed(L_0, Rect_t3681755626_il2cpp_TypeInfo_var)))
{
goto IL_0013;
}
}
{
V_0 = (bool)0;
goto IL_0088;
}
IL_0013:
{
Il2CppObject * L_1 = ___other0;
V_1 = ((*(Rect_t3681755626 *)((Rect_t3681755626 *)UnBox(L_1, Rect_t3681755626_il2cpp_TypeInfo_var))));
float L_2 = Rect_get_x_m1393582490(__this, /*hidden argument*/NULL);
V_2 = L_2;
float L_3 = Rect_get_x_m1393582490((&V_1), /*hidden argument*/NULL);
bool L_4 = Single_Equals_m3359827399((&V_2), L_3, /*hidden argument*/NULL);
if (!L_4)
{
goto IL_0081;
}
}
{
float L_5 = Rect_get_y_m1393582395(__this, /*hidden argument*/NULL);
V_3 = L_5;
float L_6 = Rect_get_y_m1393582395((&V_1), /*hidden argument*/NULL);
bool L_7 = Single_Equals_m3359827399((&V_3), L_6, /*hidden argument*/NULL);
if (!L_7)
{
goto IL_0081;
}
}
{
float L_8 = Rect_get_width_m1138015702(__this, /*hidden argument*/NULL);
V_4 = L_8;
float L_9 = Rect_get_width_m1138015702((&V_1), /*hidden argument*/NULL);
bool L_10 = Single_Equals_m3359827399((&V_4), L_9, /*hidden argument*/NULL);
if (!L_10)
{
goto IL_0081;
}
}
{
float L_11 = Rect_get_height_m3128694305(__this, /*hidden argument*/NULL);
V_5 = L_11;
float L_12 = Rect_get_height_m3128694305((&V_1), /*hidden argument*/NULL);
bool L_13 = Single_Equals_m3359827399((&V_5), L_12, /*hidden argument*/NULL);
G_B7_0 = ((int32_t)(L_13));
goto IL_0082;
}
IL_0081:
{
G_B7_0 = 0;
}
IL_0082:
{
V_0 = (bool)G_B7_0;
goto IL_0088;
}
IL_0088:
{
bool L_14 = V_0;
return L_14;
}
}
extern "C" bool Rect_Equals_m3806390726_AdjustorThunk (Il2CppObject * __this, Il2CppObject * ___other0, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_Equals_m3806390726(_thisAdjusted, ___other0, method);
}
// System.String UnityEngine.Rect::ToString()
extern "C" String_t* Rect_ToString_m2728794442 (Rect_t3681755626 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Rect_ToString_m2728794442_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
ObjectU5BU5D_t3614634134* L_0 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)4));
float L_1 = Rect_get_x_m1393582490(__this, /*hidden argument*/NULL);
float L_2 = L_1;
Il2CppObject * L_3 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_2);
ArrayElementTypeCheck (L_0, L_3);
(L_0)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)L_3);
ObjectU5BU5D_t3614634134* L_4 = L_0;
float L_5 = Rect_get_y_m1393582395(__this, /*hidden argument*/NULL);
float L_6 = L_5;
Il2CppObject * L_7 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_6);
ArrayElementTypeCheck (L_4, L_7);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (Il2CppObject *)L_7);
ObjectU5BU5D_t3614634134* L_8 = L_4;
float L_9 = Rect_get_width_m1138015702(__this, /*hidden argument*/NULL);
float L_10 = L_9;
Il2CppObject * L_11 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_10);
ArrayElementTypeCheck (L_8, L_11);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(2), (Il2CppObject *)L_11);
ObjectU5BU5D_t3614634134* L_12 = L_8;
float L_13 = Rect_get_height_m3128694305(__this, /*hidden argument*/NULL);
float L_14 = L_13;
Il2CppObject * L_15 = Box(Single_t2076509932_il2cpp_TypeInfo_var, &L_14);
ArrayElementTypeCheck (L_12, L_15);
(L_12)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(3), (Il2CppObject *)L_15);
String_t* L_16 = UnityString_Format_m2949645127(NULL /*static, unused*/, _stringLiteral1853817013, L_12, /*hidden argument*/NULL);
V_0 = L_16;
goto IL_004f;
}
IL_004f:
{
String_t* L_17 = V_0;
return L_17;
}
}
extern "C" String_t* Rect_ToString_m2728794442_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Rect_t3681755626 * _thisAdjusted = reinterpret_cast<Rect_t3681755626 *>(__this + 1);
return Rect_ToString_m2728794442(_thisAdjusted, method);
}
// Conversion methods for marshalling of: UnityEngine.RectOffset
extern "C" void RectOffset_t3387826427_marshal_pinvoke(const RectOffset_t3387826427& unmarshaled, RectOffset_t3387826427_marshaled_pinvoke& marshaled)
{
marshaled.___m_Ptr_0 = reinterpret_cast<intptr_t>((unmarshaled.get_m_Ptr_0()).get_m_value_0());
if (unmarshaled.get_m_SourceStyle_1() != NULL)
{
if ((unmarshaled.get_m_SourceStyle_1())->klass->is_import_or_windows_runtime)
{
il2cpp_hresult_t hr = ((Il2CppComObject *)unmarshaled.get_m_SourceStyle_1())->identity->QueryInterface(Il2CppIUnknown::IID, reinterpret_cast<void**>(&marshaled.___m_SourceStyle_1));
il2cpp_codegen_com_raise_exception_if_failed(hr, false);
}
else
{
marshaled.___m_SourceStyle_1 = il2cpp_codegen_com_get_or_create_ccw<Il2CppIUnknown>(unmarshaled.get_m_SourceStyle_1());
}
}
else
{
marshaled.___m_SourceStyle_1 = NULL;
}
}
extern "C" void RectOffset_t3387826427_marshal_pinvoke_back(const RectOffset_t3387826427_marshaled_pinvoke& marshaled, RectOffset_t3387826427& unmarshaled)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectOffset_t3387826427_pinvoke_FromNativeMethodDefinition_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
IntPtr_t unmarshaled_m_Ptr_temp_0;
memset(&unmarshaled_m_Ptr_temp_0, 0, sizeof(unmarshaled_m_Ptr_temp_0));
IntPtr_t unmarshaled_m_Ptr_temp_0_temp;
unmarshaled_m_Ptr_temp_0_temp.set_m_value_0(reinterpret_cast<void*>((intptr_t)(marshaled.___m_Ptr_0)));
unmarshaled_m_Ptr_temp_0 = unmarshaled_m_Ptr_temp_0_temp;
unmarshaled.set_m_Ptr_0(unmarshaled_m_Ptr_temp_0);
if (marshaled.___m_SourceStyle_1 != NULL)
{
unmarshaled.set_m_SourceStyle_1(il2cpp_codegen_com_get_or_create_rcw_from_iunknown<Il2CppObject>(marshaled.___m_SourceStyle_1, Il2CppComObject_il2cpp_TypeInfo_var));
}
else
{
unmarshaled.set_m_SourceStyle_1(NULL);
}
}
// Conversion method for clean up from marshalling of: UnityEngine.RectOffset
extern "C" void RectOffset_t3387826427_marshal_pinvoke_cleanup(RectOffset_t3387826427_marshaled_pinvoke& marshaled)
{
if (marshaled.___m_SourceStyle_1 != NULL)
{
(marshaled.___m_SourceStyle_1)->Release();
marshaled.___m_SourceStyle_1 = NULL;
}
}
// Conversion methods for marshalling of: UnityEngine.RectOffset
extern "C" void RectOffset_t3387826427_marshal_com(const RectOffset_t3387826427& unmarshaled, RectOffset_t3387826427_marshaled_com& marshaled)
{
marshaled.___m_Ptr_0 = reinterpret_cast<intptr_t>((unmarshaled.get_m_Ptr_0()).get_m_value_0());
if (unmarshaled.get_m_SourceStyle_1() != NULL)
{
if ((unmarshaled.get_m_SourceStyle_1())->klass->is_import_or_windows_runtime)
{
il2cpp_hresult_t hr = ((Il2CppComObject *)unmarshaled.get_m_SourceStyle_1())->identity->QueryInterface(Il2CppIUnknown::IID, reinterpret_cast<void**>(&marshaled.___m_SourceStyle_1));
il2cpp_codegen_com_raise_exception_if_failed(hr, true);
}
else
{
marshaled.___m_SourceStyle_1 = il2cpp_codegen_com_get_or_create_ccw<Il2CppIUnknown>(unmarshaled.get_m_SourceStyle_1());
}
}
else
{
marshaled.___m_SourceStyle_1 = NULL;
}
}
extern "C" void RectOffset_t3387826427_marshal_com_back(const RectOffset_t3387826427_marshaled_com& marshaled, RectOffset_t3387826427& unmarshaled)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectOffset_t3387826427_com_FromNativeMethodDefinition_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
IntPtr_t unmarshaled_m_Ptr_temp_0;
memset(&unmarshaled_m_Ptr_temp_0, 0, sizeof(unmarshaled_m_Ptr_temp_0));
IntPtr_t unmarshaled_m_Ptr_temp_0_temp;
unmarshaled_m_Ptr_temp_0_temp.set_m_value_0(reinterpret_cast<void*>((intptr_t)(marshaled.___m_Ptr_0)));
unmarshaled_m_Ptr_temp_0 = unmarshaled_m_Ptr_temp_0_temp;
unmarshaled.set_m_Ptr_0(unmarshaled_m_Ptr_temp_0);
if (marshaled.___m_SourceStyle_1 != NULL)
{
unmarshaled.set_m_SourceStyle_1(il2cpp_codegen_com_get_or_create_rcw_from_iunknown<Il2CppObject>(marshaled.___m_SourceStyle_1, Il2CppComObject_il2cpp_TypeInfo_var));
}
else
{
unmarshaled.set_m_SourceStyle_1(NULL);
}
}
// Conversion method for clean up from marshalling of: UnityEngine.RectOffset
extern "C" void RectOffset_t3387826427_marshal_com_cleanup(RectOffset_t3387826427_marshaled_com& marshaled)
{
if (marshaled.___m_SourceStyle_1 != NULL)
{
(marshaled.___m_SourceStyle_1)->Release();
marshaled.___m_SourceStyle_1 = NULL;
}
}
// System.Void UnityEngine.RectOffset::.ctor()
extern "C" void RectOffset__ctor_m2227510254 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
RectOffset_Init_m4361650(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.RectOffset::.ctor(System.Object,System.IntPtr)
extern "C" void RectOffset__ctor_m1265077918 (RectOffset_t3387826427 * __this, Il2CppObject * ___sourceStyle0, IntPtr_t ___source1, const MethodInfo* method)
{
{
Object__ctor_m2551263788(__this, /*hidden argument*/NULL);
Il2CppObject * L_0 = ___sourceStyle0;
__this->set_m_SourceStyle_1(L_0);
IntPtr_t L_1 = ___source1;
__this->set_m_Ptr_0(L_1);
return;
}
}
// System.Void UnityEngine.RectOffset::Init()
extern "C" void RectOffset_Init_m4361650 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
typedef void (*RectOffset_Init_m4361650_ftn) (RectOffset_t3387826427 *);
static RectOffset_Init_m4361650_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_Init_m4361650_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::Init()");
_il2cpp_icall_func(__this);
}
// System.Void UnityEngine.RectOffset::Cleanup()
extern "C" void RectOffset_Cleanup_m3198970074 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
typedef void (*RectOffset_Cleanup_m3198970074_ftn) (RectOffset_t3387826427 *);
static RectOffset_Cleanup_m3198970074_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_Cleanup_m3198970074_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::Cleanup()");
_il2cpp_icall_func(__this);
}
// System.Int32 UnityEngine.RectOffset::get_left()
extern "C" int32_t RectOffset_get_left_m439065308 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
typedef int32_t (*RectOffset_get_left_m439065308_ftn) (RectOffset_t3387826427 *);
static RectOffset_get_left_m439065308_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_get_left_m439065308_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::get_left()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.RectOffset::set_left(System.Int32)
extern "C" void RectOffset_set_left_m620681523 (RectOffset_t3387826427 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*RectOffset_set_left_m620681523_ftn) (RectOffset_t3387826427 *, int32_t);
static RectOffset_set_left_m620681523_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_set_left_m620681523_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::set_left(System.Int32)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Int32 UnityEngine.RectOffset::get_right()
extern "C" int32_t RectOffset_get_right_m281378687 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
typedef int32_t (*RectOffset_get_right_m281378687_ftn) (RectOffset_t3387826427 *);
static RectOffset_get_right_m281378687_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_get_right_m281378687_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::get_right()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.RectOffset::set_right(System.Int32)
extern "C" void RectOffset_set_right_m1671272302 (RectOffset_t3387826427 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*RectOffset_set_right_m1671272302_ftn) (RectOffset_t3387826427 *, int32_t);
static RectOffset_set_right_m1671272302_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_set_right_m1671272302_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::set_right(System.Int32)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Int32 UnityEngine.RectOffset::get_top()
extern "C" int32_t RectOffset_get_top_m3629049358 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
typedef int32_t (*RectOffset_get_top_m3629049358_ftn) (RectOffset_t3387826427 *);
static RectOffset_get_top_m3629049358_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_get_top_m3629049358_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::get_top()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.RectOffset::set_top(System.Int32)
extern "C" void RectOffset_set_top_m3579196427 (RectOffset_t3387826427 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*RectOffset_set_top_m3579196427_ftn) (RectOffset_t3387826427 *, int32_t);
static RectOffset_set_top_m3579196427_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_set_top_m3579196427_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::set_top(System.Int32)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Int32 UnityEngine.RectOffset::get_bottom()
extern "C" int32_t RectOffset_get_bottom_m4112328858 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
typedef int32_t (*RectOffset_get_bottom_m4112328858_ftn) (RectOffset_t3387826427 *);
static RectOffset_get_bottom_m4112328858_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_get_bottom_m4112328858_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::get_bottom()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.RectOffset::set_bottom(System.Int32)
extern "C" void RectOffset_set_bottom_m4065521443 (RectOffset_t3387826427 * __this, int32_t ___value0, const MethodInfo* method)
{
typedef void (*RectOffset_set_bottom_m4065521443_ftn) (RectOffset_t3387826427 *, int32_t);
static RectOffset_set_bottom_m4065521443_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_set_bottom_m4065521443_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::set_bottom(System.Int32)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Int32 UnityEngine.RectOffset::get_horizontal()
extern "C" int32_t RectOffset_get_horizontal_m3818523637 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
typedef int32_t (*RectOffset_get_horizontal_m3818523637_ftn) (RectOffset_t3387826427 *);
static RectOffset_get_horizontal_m3818523637_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_get_horizontal_m3818523637_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::get_horizontal()");
return _il2cpp_icall_func(__this);
}
// System.Int32 UnityEngine.RectOffset::get_vertical()
extern "C" int32_t RectOffset_get_vertical_m3856345169 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
typedef int32_t (*RectOffset_get_vertical_m3856345169_ftn) (RectOffset_t3387826427 *);
static RectOffset_get_vertical_m3856345169_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectOffset_get_vertical_m3856345169_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectOffset::get_vertical()");
return _il2cpp_icall_func(__this);
}
// System.Void UnityEngine.RectOffset::Finalize()
extern "C" void RectOffset_Finalize_m901770914 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
Exception_t1927440687 * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t1927440687 * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
{
}
IL_0001:
try
{ // begin try (depth: 1)
{
Il2CppObject * L_0 = __this->get_m_SourceStyle_1();
if (L_0)
{
goto IL_0012;
}
}
IL_000c:
{
RectOffset_Cleanup_m3198970074(__this, /*hidden argument*/NULL);
}
IL_0012:
{
IL2CPP_LEAVE(0x1E, FINALLY_0017);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t1927440687 *)e.ex;
goto FINALLY_0017;
}
FINALLY_0017:
{ // begin finally (depth: 1)
Object_Finalize_m4087144328(__this, /*hidden argument*/NULL);
IL2CPP_END_FINALLY(23)
} // end finally (depth: 1)
IL2CPP_CLEANUP(23)
{
IL2CPP_JUMP_TBL(0x1E, IL_001e)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t1927440687 *)
}
IL_001e:
{
return;
}
}
// System.String UnityEngine.RectOffset::ToString()
extern "C" String_t* RectOffset_ToString_m1281517011 (RectOffset_t3387826427 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectOffset_ToString_m1281517011_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
ObjectU5BU5D_t3614634134* L_0 = ((ObjectU5BU5D_t3614634134*)SZArrayNew(ObjectU5BU5D_t3614634134_il2cpp_TypeInfo_var, (uint32_t)4));
int32_t L_1 = RectOffset_get_left_m439065308(__this, /*hidden argument*/NULL);
int32_t L_2 = L_1;
Il2CppObject * L_3 = Box(Int32_t2071877448_il2cpp_TypeInfo_var, &L_2);
ArrayElementTypeCheck (L_0, L_3);
(L_0)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (Il2CppObject *)L_3);
ObjectU5BU5D_t3614634134* L_4 = L_0;
int32_t L_5 = RectOffset_get_right_m281378687(__this, /*hidden argument*/NULL);
int32_t L_6 = L_5;
Il2CppObject * L_7 = Box(Int32_t2071877448_il2cpp_TypeInfo_var, &L_6);
ArrayElementTypeCheck (L_4, L_7);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (Il2CppObject *)L_7);
ObjectU5BU5D_t3614634134* L_8 = L_4;
int32_t L_9 = RectOffset_get_top_m3629049358(__this, /*hidden argument*/NULL);
int32_t L_10 = L_9;
Il2CppObject * L_11 = Box(Int32_t2071877448_il2cpp_TypeInfo_var, &L_10);
ArrayElementTypeCheck (L_8, L_11);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(2), (Il2CppObject *)L_11);
ObjectU5BU5D_t3614634134* L_12 = L_8;
int32_t L_13 = RectOffset_get_bottom_m4112328858(__this, /*hidden argument*/NULL);
int32_t L_14 = L_13;
Il2CppObject * L_15 = Box(Int32_t2071877448_il2cpp_TypeInfo_var, &L_14);
ArrayElementTypeCheck (L_12, L_15);
(L_12)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(3), (Il2CppObject *)L_15);
String_t* L_16 = UnityString_Format_m2949645127(NULL /*static, unused*/, _stringLiteral3899275604, L_12, /*hidden argument*/NULL);
V_0 = L_16;
goto IL_004f;
}
IL_004f:
{
String_t* L_17 = V_0;
return L_17;
}
}
// UnityEngine.Rect UnityEngine.RectTransform::get_rect()
extern "C" Rect_t3681755626 RectTransform_get_rect_m73954734 (RectTransform_t3349966182 * __this, const MethodInfo* method)
{
Rect_t3681755626 V_0;
memset(&V_0, 0, sizeof(V_0));
Rect_t3681755626 V_1;
memset(&V_1, 0, sizeof(V_1));
{
RectTransform_INTERNAL_get_rect_m1177342209(__this, (&V_0), /*hidden argument*/NULL);
Rect_t3681755626 L_0 = V_0;
V_1 = L_0;
goto IL_0010;
}
IL_0010:
{
Rect_t3681755626 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.RectTransform::INTERNAL_get_rect(UnityEngine.Rect&)
extern "C" void RectTransform_INTERNAL_get_rect_m1177342209 (RectTransform_t3349966182 * __this, Rect_t3681755626 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_get_rect_m1177342209_ftn) (RectTransform_t3349966182 *, Rect_t3681755626 *);
static RectTransform_INTERNAL_get_rect_m1177342209_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_get_rect_m1177342209_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_get_rect(UnityEngine.Rect&)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Vector2 UnityEngine.RectTransform::get_anchorMin()
extern "C" Vector2_t2243707579 RectTransform_get_anchorMin_m1497323108 (RectTransform_t3349966182 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
RectTransform_INTERNAL_get_anchorMin_m3180545469(__this, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_0 = V_0;
V_1 = L_0;
goto IL_0010;
}
IL_0010:
{
Vector2_t2243707579 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.RectTransform::set_anchorMin(UnityEngine.Vector2)
extern "C" void RectTransform_set_anchorMin_m4247668187 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
{
RectTransform_INTERNAL_set_anchorMin_m885423409(__this, (&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.RectTransform::INTERNAL_get_anchorMin(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_get_anchorMin_m3180545469 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_get_anchorMin_m3180545469_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *);
static RectTransform_INTERNAL_get_anchorMin_m3180545469_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_get_anchorMin_m3180545469_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_get_anchorMin(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.RectTransform::INTERNAL_set_anchorMin(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_set_anchorMin_m885423409 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_set_anchorMin_m885423409_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *);
static RectTransform_INTERNAL_set_anchorMin_m885423409_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_set_anchorMin_m885423409_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_set_anchorMin(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Vector2 UnityEngine.RectTransform::get_anchorMax()
extern "C" Vector2_t2243707579 RectTransform_get_anchorMax_m3816015142 (RectTransform_t3349966182 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
RectTransform_INTERNAL_get_anchorMax_m834202955(__this, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_0 = V_0;
V_1 = L_0;
goto IL_0010;
}
IL_0010:
{
Vector2_t2243707579 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.RectTransform::set_anchorMax(UnityEngine.Vector2)
extern "C" void RectTransform_set_anchorMax_m2955899993 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
{
RectTransform_INTERNAL_set_anchorMax_m1551648727(__this, (&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.RectTransform::INTERNAL_get_anchorMax(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_get_anchorMax_m834202955 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_get_anchorMax_m834202955_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *);
static RectTransform_INTERNAL_get_anchorMax_m834202955_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_get_anchorMax_m834202955_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_get_anchorMax(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.RectTransform::INTERNAL_set_anchorMax(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_set_anchorMax_m1551648727 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_set_anchorMax_m1551648727_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *);
static RectTransform_INTERNAL_set_anchorMax_m1551648727_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_set_anchorMax_m1551648727_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_set_anchorMax(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Vector2 UnityEngine.RectTransform::get_anchoredPosition()
extern "C" Vector2_t2243707579 RectTransform_get_anchoredPosition_m3570822376 (RectTransform_t3349966182 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
RectTransform_INTERNAL_get_anchoredPosition_m3564306187(__this, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_0 = V_0;
V_1 = L_0;
goto IL_0010;
}
IL_0010:
{
Vector2_t2243707579 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.RectTransform::set_anchoredPosition(UnityEngine.Vector2)
extern "C" void RectTransform_set_anchoredPosition_m2077229449 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
{
RectTransform_INTERNAL_set_anchoredPosition_m693024247(__this, (&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.RectTransform::INTERNAL_get_anchoredPosition(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_get_anchoredPosition_m3564306187 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_get_anchoredPosition_m3564306187_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *);
static RectTransform_INTERNAL_get_anchoredPosition_m3564306187_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_get_anchoredPosition_m3564306187_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_get_anchoredPosition(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.RectTransform::INTERNAL_set_anchoredPosition(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_set_anchoredPosition_m693024247 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_set_anchoredPosition_m693024247_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *);
static RectTransform_INTERNAL_set_anchoredPosition_m693024247_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_set_anchoredPosition_m693024247_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_set_anchoredPosition(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Vector2 UnityEngine.RectTransform::get_sizeDelta()
extern "C" Vector2_t2243707579 RectTransform_get_sizeDelta_m2157326342 (RectTransform_t3349966182 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
RectTransform_INTERNAL_get_sizeDelta_m3975625099(__this, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_0 = V_0;
V_1 = L_0;
goto IL_0010;
}
IL_0010:
{
Vector2_t2243707579 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.RectTransform::set_sizeDelta(UnityEngine.Vector2)
extern "C" void RectTransform_set_sizeDelta_m2319668137 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
{
RectTransform_INTERNAL_set_sizeDelta_m1402803191(__this, (&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.RectTransform::INTERNAL_get_sizeDelta(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_get_sizeDelta_m3975625099 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_get_sizeDelta_m3975625099_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *);
static RectTransform_INTERNAL_get_sizeDelta_m3975625099_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_get_sizeDelta_m3975625099_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_get_sizeDelta(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.RectTransform::INTERNAL_set_sizeDelta(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_set_sizeDelta_m1402803191 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_set_sizeDelta_m1402803191_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *);
static RectTransform_INTERNAL_set_sizeDelta_m1402803191_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_set_sizeDelta_m1402803191_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_set_sizeDelta(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// UnityEngine.Vector2 UnityEngine.RectTransform::get_pivot()
extern "C" Vector2_t2243707579 RectTransform_get_pivot_m759087479 (RectTransform_t3349966182 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
RectTransform_INTERNAL_get_pivot_m3003734630(__this, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_0 = V_0;
V_1 = L_0;
goto IL_0010;
}
IL_0010:
{
Vector2_t2243707579 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.RectTransform::set_pivot(UnityEngine.Vector2)
extern "C" void RectTransform_set_pivot_m1360548980 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
{
RectTransform_INTERNAL_set_pivot_m2764958706(__this, (&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.RectTransform::INTERNAL_get_pivot(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_get_pivot_m3003734630 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_get_pivot_m3003734630_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *);
static RectTransform_INTERNAL_get_pivot_m3003734630_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_get_pivot_m3003734630_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_get_pivot(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.RectTransform::INTERNAL_set_pivot(UnityEngine.Vector2&)
extern "C" void RectTransform_INTERNAL_set_pivot_m2764958706 (RectTransform_t3349966182 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*RectTransform_INTERNAL_set_pivot_m2764958706_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *);
static RectTransform_INTERNAL_set_pivot_m2764958706_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransform_INTERNAL_set_pivot_m2764958706_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransform::INTERNAL_set_pivot(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.RectTransform::add_reapplyDrivenProperties(UnityEngine.RectTransform/ReapplyDrivenProperties)
extern "C" void RectTransform_add_reapplyDrivenProperties_m1603911943 (Il2CppObject * __this /* static, unused */, ReapplyDrivenProperties_t2020713228 * ___value0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransform_add_reapplyDrivenProperties_m1603911943_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ReapplyDrivenProperties_t2020713228 * V_0 = NULL;
ReapplyDrivenProperties_t2020713228 * V_1 = NULL;
{
ReapplyDrivenProperties_t2020713228 * L_0 = ((RectTransform_t3349966182_StaticFields*)RectTransform_t3349966182_il2cpp_TypeInfo_var->static_fields)->get_reapplyDrivenProperties_2();
V_0 = L_0;
}
IL_0006:
{
ReapplyDrivenProperties_t2020713228 * L_1 = V_0;
V_1 = L_1;
ReapplyDrivenProperties_t2020713228 * L_2 = V_1;
ReapplyDrivenProperties_t2020713228 * L_3 = ___value0;
Delegate_t3022476291 * L_4 = Delegate_Combine_m3791207084(NULL /*static, unused*/, L_2, L_3, /*hidden argument*/NULL);
ReapplyDrivenProperties_t2020713228 * L_5 = V_0;
ReapplyDrivenProperties_t2020713228 * L_6 = InterlockedCompareExchangeImpl<ReapplyDrivenProperties_t2020713228 *>((((RectTransform_t3349966182_StaticFields*)RectTransform_t3349966182_il2cpp_TypeInfo_var->static_fields)->get_address_of_reapplyDrivenProperties_2()), ((ReapplyDrivenProperties_t2020713228 *)CastclassSealed(L_4, ReapplyDrivenProperties_t2020713228_il2cpp_TypeInfo_var)), L_5);
V_0 = L_6;
ReapplyDrivenProperties_t2020713228 * L_7 = V_0;
ReapplyDrivenProperties_t2020713228 * L_8 = V_1;
if ((!(((Il2CppObject*)(ReapplyDrivenProperties_t2020713228 *)L_7) == ((Il2CppObject*)(ReapplyDrivenProperties_t2020713228 *)L_8))))
{
goto IL_0006;
}
}
{
return;
}
}
// System.Void UnityEngine.RectTransform::remove_reapplyDrivenProperties(UnityEngine.RectTransform/ReapplyDrivenProperties)
extern "C" void RectTransform_remove_reapplyDrivenProperties_m4209881182 (Il2CppObject * __this /* static, unused */, ReapplyDrivenProperties_t2020713228 * ___value0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransform_remove_reapplyDrivenProperties_m4209881182_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ReapplyDrivenProperties_t2020713228 * V_0 = NULL;
ReapplyDrivenProperties_t2020713228 * V_1 = NULL;
{
ReapplyDrivenProperties_t2020713228 * L_0 = ((RectTransform_t3349966182_StaticFields*)RectTransform_t3349966182_il2cpp_TypeInfo_var->static_fields)->get_reapplyDrivenProperties_2();
V_0 = L_0;
}
IL_0006:
{
ReapplyDrivenProperties_t2020713228 * L_1 = V_0;
V_1 = L_1;
ReapplyDrivenProperties_t2020713228 * L_2 = V_1;
ReapplyDrivenProperties_t2020713228 * L_3 = ___value0;
Delegate_t3022476291 * L_4 = Delegate_Remove_m2626518725(NULL /*static, unused*/, L_2, L_3, /*hidden argument*/NULL);
ReapplyDrivenProperties_t2020713228 * L_5 = V_0;
ReapplyDrivenProperties_t2020713228 * L_6 = InterlockedCompareExchangeImpl<ReapplyDrivenProperties_t2020713228 *>((((RectTransform_t3349966182_StaticFields*)RectTransform_t3349966182_il2cpp_TypeInfo_var->static_fields)->get_address_of_reapplyDrivenProperties_2()), ((ReapplyDrivenProperties_t2020713228 *)CastclassSealed(L_4, ReapplyDrivenProperties_t2020713228_il2cpp_TypeInfo_var)), L_5);
V_0 = L_6;
ReapplyDrivenProperties_t2020713228 * L_7 = V_0;
ReapplyDrivenProperties_t2020713228 * L_8 = V_1;
if ((!(((Il2CppObject*)(ReapplyDrivenProperties_t2020713228 *)L_7) == ((Il2CppObject*)(ReapplyDrivenProperties_t2020713228 *)L_8))))
{
goto IL_0006;
}
}
{
return;
}
}
// System.Void UnityEngine.RectTransform::SendReapplyDrivenProperties(UnityEngine.RectTransform)
extern "C" void RectTransform_SendReapplyDrivenProperties_m90487700 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___driven0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransform_SendReapplyDrivenProperties_m90487700_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ReapplyDrivenProperties_t2020713228 * L_0 = ((RectTransform_t3349966182_StaticFields*)RectTransform_t3349966182_il2cpp_TypeInfo_var->static_fields)->get_reapplyDrivenProperties_2();
if (!L_0)
{
goto IL_0016;
}
}
{
ReapplyDrivenProperties_t2020713228 * L_1 = ((RectTransform_t3349966182_StaticFields*)RectTransform_t3349966182_il2cpp_TypeInfo_var->static_fields)->get_reapplyDrivenProperties_2();
RectTransform_t3349966182 * L_2 = ___driven0;
ReapplyDrivenProperties_Invoke_m1090213637(L_1, L_2, /*hidden argument*/NULL);
}
IL_0016:
{
return;
}
}
// System.Void UnityEngine.RectTransform::GetLocalCorners(UnityEngine.Vector3[])
extern "C" void RectTransform_GetLocalCorners_m1836626405 (RectTransform_t3349966182 * __this, Vector3U5BU5D_t1172311765* ___fourCornersArray0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransform_GetLocalCorners_m1836626405_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Rect_t3681755626 V_0;
memset(&V_0, 0, sizeof(V_0));
float V_1 = 0.0f;
float V_2 = 0.0f;
float V_3 = 0.0f;
float V_4 = 0.0f;
{
Vector3U5BU5D_t1172311765* L_0 = ___fourCornersArray0;
if (!L_0)
{
goto IL_0010;
}
}
{
Vector3U5BU5D_t1172311765* L_1 = ___fourCornersArray0;
if ((((int32_t)(((int32_t)((int32_t)(((Il2CppArray *)L_1)->max_length))))) >= ((int32_t)4)))
{
goto IL_0020;
}
}
IL_0010:
{
IL2CPP_RUNTIME_CLASS_INIT(Debug_t1368543263_il2cpp_TypeInfo_var);
Debug_LogError_m3715728798(NULL /*static, unused*/, _stringLiteral895140023, /*hidden argument*/NULL);
goto IL_00aa;
}
IL_0020:
{
Rect_t3681755626 L_2 = RectTransform_get_rect_m73954734(__this, /*hidden argument*/NULL);
V_0 = L_2;
float L_3 = Rect_get_x_m1393582490((&V_0), /*hidden argument*/NULL);
V_1 = L_3;
float L_4 = Rect_get_y_m1393582395((&V_0), /*hidden argument*/NULL);
V_2 = L_4;
float L_5 = Rect_get_xMax_m2915145014((&V_0), /*hidden argument*/NULL);
V_3 = L_5;
float L_6 = Rect_get_yMax_m2915146103((&V_0), /*hidden argument*/NULL);
V_4 = L_6;
Vector3U5BU5D_t1172311765* L_7 = ___fourCornersArray0;
float L_8 = V_1;
float L_9 = V_2;
Vector3_t2243707580 L_10;
memset(&L_10, 0, sizeof(L_10));
Vector3__ctor_m2638739322(&L_10, L_8, L_9, (0.0f), /*hidden argument*/NULL);
(*(Vector3_t2243707580 *)((L_7)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(0)))) = L_10;
Vector3U5BU5D_t1172311765* L_11 = ___fourCornersArray0;
float L_12 = V_1;
float L_13 = V_4;
Vector3_t2243707580 L_14;
memset(&L_14, 0, sizeof(L_14));
Vector3__ctor_m2638739322(&L_14, L_12, L_13, (0.0f), /*hidden argument*/NULL);
(*(Vector3_t2243707580 *)((L_11)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(1)))) = L_14;
Vector3U5BU5D_t1172311765* L_15 = ___fourCornersArray0;
float L_16 = V_3;
float L_17 = V_4;
Vector3_t2243707580 L_18;
memset(&L_18, 0, sizeof(L_18));
Vector3__ctor_m2638739322(&L_18, L_16, L_17, (0.0f), /*hidden argument*/NULL);
(*(Vector3_t2243707580 *)((L_15)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(2)))) = L_18;
Vector3U5BU5D_t1172311765* L_19 = ___fourCornersArray0;
float L_20 = V_3;
float L_21 = V_2;
Vector3_t2243707580 L_22;
memset(&L_22, 0, sizeof(L_22));
Vector3__ctor_m2638739322(&L_22, L_20, L_21, (0.0f), /*hidden argument*/NULL);
(*(Vector3_t2243707580 *)((L_19)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(3)))) = L_22;
}
IL_00aa:
{
return;
}
}
// System.Void UnityEngine.RectTransform::GetWorldCorners(UnityEngine.Vector3[])
extern "C" void RectTransform_GetWorldCorners_m3873546362 (RectTransform_t3349966182 * __this, Vector3U5BU5D_t1172311765* ___fourCornersArray0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransform_GetWorldCorners_m3873546362_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Transform_t3275118058 * V_0 = NULL;
int32_t V_1 = 0;
{
Vector3U5BU5D_t1172311765* L_0 = ___fourCornersArray0;
if (!L_0)
{
goto IL_0010;
}
}
{
Vector3U5BU5D_t1172311765* L_1 = ___fourCornersArray0;
if ((((int32_t)(((int32_t)((int32_t)(((Il2CppArray *)L_1)->max_length))))) >= ((int32_t)4)))
{
goto IL_0020;
}
}
IL_0010:
{
IL2CPP_RUNTIME_CLASS_INIT(Debug_t1368543263_il2cpp_TypeInfo_var);
Debug_LogError_m3715728798(NULL /*static, unused*/, _stringLiteral3518247078, /*hidden argument*/NULL);
goto IL_005e;
}
IL_0020:
{
Vector3U5BU5D_t1172311765* L_2 = ___fourCornersArray0;
RectTransform_GetLocalCorners_m1836626405(__this, L_2, /*hidden argument*/NULL);
Transform_t3275118058 * L_3 = Component_get_transform_m2697483695(__this, /*hidden argument*/NULL);
V_0 = L_3;
V_1 = 0;
goto IL_0057;
}
IL_0035:
{
Vector3U5BU5D_t1172311765* L_4 = ___fourCornersArray0;
int32_t L_5 = V_1;
Transform_t3275118058 * L_6 = V_0;
Vector3U5BU5D_t1172311765* L_7 = ___fourCornersArray0;
int32_t L_8 = V_1;
Vector3_t2243707580 L_9 = Transform_TransformPoint_m3272254198(L_6, (*(Vector3_t2243707580 *)((L_7)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(L_8)))), /*hidden argument*/NULL);
(*(Vector3_t2243707580 *)((L_4)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(L_5)))) = L_9;
int32_t L_10 = V_1;
V_1 = ((int32_t)((int32_t)L_10+(int32_t)1));
}
IL_0057:
{
int32_t L_11 = V_1;
if ((((int32_t)L_11) < ((int32_t)4)))
{
goto IL_0035;
}
}
IL_005e:
{
return;
}
}
// System.Void UnityEngine.RectTransform::set_offsetMin(UnityEngine.Vector2)
extern "C" void RectTransform_set_offsetMin_m2982698987 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector2_t2243707579 L_0 = ___value0;
Vector2_t2243707579 L_1 = RectTransform_get_anchoredPosition_m3570822376(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_2 = RectTransform_get_sizeDelta_m2157326342(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_3 = RectTransform_get_pivot_m759087479(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_4 = Vector2_Scale_m3228063809(NULL /*static, unused*/, L_2, L_3, /*hidden argument*/NULL);
Vector2_t2243707579 L_5 = Vector2_op_Subtraction_m1984215297(NULL /*static, unused*/, L_1, L_4, /*hidden argument*/NULL);
Vector2_t2243707579 L_6 = Vector2_op_Subtraction_m1984215297(NULL /*static, unused*/, L_0, L_5, /*hidden argument*/NULL);
V_0 = L_6;
Vector2_t2243707579 L_7 = RectTransform_get_sizeDelta_m2157326342(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_8 = V_0;
Vector2_t2243707579 L_9 = Vector2_op_Subtraction_m1984215297(NULL /*static, unused*/, L_7, L_8, /*hidden argument*/NULL);
RectTransform_set_sizeDelta_m2319668137(__this, L_9, /*hidden argument*/NULL);
Vector2_t2243707579 L_10 = RectTransform_get_anchoredPosition_m3570822376(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_11 = V_0;
Vector2_t2243707579 L_12 = Vector2_get_one_m3174311904(NULL /*static, unused*/, /*hidden argument*/NULL);
Vector2_t2243707579 L_13 = RectTransform_get_pivot_m759087479(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_14 = Vector2_op_Subtraction_m1984215297(NULL /*static, unused*/, L_12, L_13, /*hidden argument*/NULL);
Vector2_t2243707579 L_15 = Vector2_Scale_m3228063809(NULL /*static, unused*/, L_11, L_14, /*hidden argument*/NULL);
Vector2_t2243707579 L_16 = Vector2_op_Addition_m1389598521(NULL /*static, unused*/, L_10, L_15, /*hidden argument*/NULL);
RectTransform_set_anchoredPosition_m2077229449(__this, L_16, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.RectTransform::set_offsetMax(UnityEngine.Vector2)
extern "C" void RectTransform_set_offsetMax_m3702115945 (RectTransform_t3349966182 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Vector2_t2243707579 L_0 = ___value0;
Vector2_t2243707579 L_1 = RectTransform_get_anchoredPosition_m3570822376(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_2 = RectTransform_get_sizeDelta_m2157326342(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_3 = Vector2_get_one_m3174311904(NULL /*static, unused*/, /*hidden argument*/NULL);
Vector2_t2243707579 L_4 = RectTransform_get_pivot_m759087479(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_5 = Vector2_op_Subtraction_m1984215297(NULL /*static, unused*/, L_3, L_4, /*hidden argument*/NULL);
Vector2_t2243707579 L_6 = Vector2_Scale_m3228063809(NULL /*static, unused*/, L_2, L_5, /*hidden argument*/NULL);
Vector2_t2243707579 L_7 = Vector2_op_Addition_m1389598521(NULL /*static, unused*/, L_1, L_6, /*hidden argument*/NULL);
Vector2_t2243707579 L_8 = Vector2_op_Subtraction_m1984215297(NULL /*static, unused*/, L_0, L_7, /*hidden argument*/NULL);
V_0 = L_8;
Vector2_t2243707579 L_9 = RectTransform_get_sizeDelta_m2157326342(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_10 = V_0;
Vector2_t2243707579 L_11 = Vector2_op_Addition_m1389598521(NULL /*static, unused*/, L_9, L_10, /*hidden argument*/NULL);
RectTransform_set_sizeDelta_m2319668137(__this, L_11, /*hidden argument*/NULL);
Vector2_t2243707579 L_12 = RectTransform_get_anchoredPosition_m3570822376(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_13 = V_0;
Vector2_t2243707579 L_14 = RectTransform_get_pivot_m759087479(__this, /*hidden argument*/NULL);
Vector2_t2243707579 L_15 = Vector2_Scale_m3228063809(NULL /*static, unused*/, L_13, L_14, /*hidden argument*/NULL);
Vector2_t2243707579 L_16 = Vector2_op_Addition_m1389598521(NULL /*static, unused*/, L_12, L_15, /*hidden argument*/NULL);
RectTransform_set_anchoredPosition_m2077229449(__this, L_16, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.RectTransform::SetInsetAndSizeFromParentEdge(UnityEngine.RectTransform/Edge,System.Single,System.Single)
extern "C" void RectTransform_SetInsetAndSizeFromParentEdge_m2835026182 (RectTransform_t3349966182 * __this, int32_t ___edge0, float ___inset1, float ___size2, const MethodInfo* method)
{
int32_t V_0 = 0;
bool V_1 = false;
float V_2 = 0.0f;
Vector2_t2243707579 V_3;
memset(&V_3, 0, sizeof(V_3));
Vector2_t2243707579 V_4;
memset(&V_4, 0, sizeof(V_4));
Vector2_t2243707579 V_5;
memset(&V_5, 0, sizeof(V_5));
Vector2_t2243707579 V_6;
memset(&V_6, 0, sizeof(V_6));
Vector2_t2243707579 V_7;
memset(&V_7, 0, sizeof(V_7));
int32_t G_B4_0 = 0;
int32_t G_B7_0 = 0;
int32_t G_B10_0 = 0;
int32_t G_B12_0 = 0;
Vector2_t2243707579 * G_B12_1 = NULL;
int32_t G_B11_0 = 0;
Vector2_t2243707579 * G_B11_1 = NULL;
float G_B13_0 = 0.0f;
int32_t G_B13_1 = 0;
Vector2_t2243707579 * G_B13_2 = NULL;
{
int32_t L_0 = ___edge0;
if ((((int32_t)L_0) == ((int32_t)2)))
{
goto IL_000f;
}
}
{
int32_t L_1 = ___edge0;
if ((!(((uint32_t)L_1) == ((uint32_t)3))))
{
goto IL_0015;
}
}
IL_000f:
{
G_B4_0 = 1;
goto IL_0016;
}
IL_0015:
{
G_B4_0 = 0;
}
IL_0016:
{
V_0 = G_B4_0;
int32_t L_2 = ___edge0;
if ((((int32_t)L_2) == ((int32_t)2)))
{
goto IL_0024;
}
}
{
int32_t L_3 = ___edge0;
G_B7_0 = ((((int32_t)L_3) == ((int32_t)1))? 1 : 0);
goto IL_0025;
}
IL_0024:
{
G_B7_0 = 1;
}
IL_0025:
{
V_1 = (bool)G_B7_0;
bool L_4 = V_1;
if (!L_4)
{
goto IL_0032;
}
}
{
G_B10_0 = 1;
goto IL_0033;
}
IL_0032:
{
G_B10_0 = 0;
}
IL_0033:
{
V_2 = (((float)((float)G_B10_0)));
Vector2_t2243707579 L_5 = RectTransform_get_anchorMin_m1497323108(__this, /*hidden argument*/NULL);
V_3 = L_5;
int32_t L_6 = V_0;
float L_7 = V_2;
Vector2_set_Item_m3881967114((&V_3), L_6, L_7, /*hidden argument*/NULL);
Vector2_t2243707579 L_8 = V_3;
RectTransform_set_anchorMin_m4247668187(__this, L_8, /*hidden argument*/NULL);
Vector2_t2243707579 L_9 = RectTransform_get_anchorMax_m3816015142(__this, /*hidden argument*/NULL);
V_3 = L_9;
int32_t L_10 = V_0;
float L_11 = V_2;
Vector2_set_Item_m3881967114((&V_3), L_10, L_11, /*hidden argument*/NULL);
Vector2_t2243707579 L_12 = V_3;
RectTransform_set_anchorMax_m2955899993(__this, L_12, /*hidden argument*/NULL);
Vector2_t2243707579 L_13 = RectTransform_get_sizeDelta_m2157326342(__this, /*hidden argument*/NULL);
V_4 = L_13;
int32_t L_14 = V_0;
float L_15 = ___size2;
Vector2_set_Item_m3881967114((&V_4), L_14, L_15, /*hidden argument*/NULL);
Vector2_t2243707579 L_16 = V_4;
RectTransform_set_sizeDelta_m2319668137(__this, L_16, /*hidden argument*/NULL);
Vector2_t2243707579 L_17 = RectTransform_get_anchoredPosition_m3570822376(__this, /*hidden argument*/NULL);
V_5 = L_17;
int32_t L_18 = V_0;
bool L_19 = V_1;
G_B11_0 = L_18;
G_B11_1 = (&V_5);
if (!L_19)
{
G_B12_0 = L_18;
G_B12_1 = (&V_5);
goto IL_00ad;
}
}
{
float L_20 = ___inset1;
float L_21 = ___size2;
Vector2_t2243707579 L_22 = RectTransform_get_pivot_m759087479(__this, /*hidden argument*/NULL);
V_6 = L_22;
int32_t L_23 = V_0;
float L_24 = Vector2_get_Item_m2792130561((&V_6), L_23, /*hidden argument*/NULL);
G_B13_0 = ((float)((float)((-L_20))-(float)((float)((float)L_21*(float)((float)((float)(1.0f)-(float)L_24))))));
G_B13_1 = G_B11_0;
G_B13_2 = G_B11_1;
goto IL_00c1;
}
IL_00ad:
{
float L_25 = ___inset1;
float L_26 = ___size2;
Vector2_t2243707579 L_27 = RectTransform_get_pivot_m759087479(__this, /*hidden argument*/NULL);
V_7 = L_27;
int32_t L_28 = V_0;
float L_29 = Vector2_get_Item_m2792130561((&V_7), L_28, /*hidden argument*/NULL);
G_B13_0 = ((float)((float)L_25+(float)((float)((float)L_26*(float)L_29))));
G_B13_1 = G_B12_0;
G_B13_2 = G_B12_1;
}
IL_00c1:
{
Vector2_set_Item_m3881967114(G_B13_2, G_B13_1, G_B13_0, /*hidden argument*/NULL);
Vector2_t2243707579 L_30 = V_5;
RectTransform_set_anchoredPosition_m2077229449(__this, L_30, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.RectTransform::SetSizeWithCurrentAnchors(UnityEngine.RectTransform/Axis,System.Single)
extern "C" void RectTransform_SetSizeWithCurrentAnchors_m2368352721 (RectTransform_t3349966182 * __this, int32_t ___axis0, float ___size1, const MethodInfo* method)
{
int32_t V_0 = 0;
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
Vector2_t2243707579 V_2;
memset(&V_2, 0, sizeof(V_2));
Vector2_t2243707579 V_3;
memset(&V_3, 0, sizeof(V_3));
Vector2_t2243707579 V_4;
memset(&V_4, 0, sizeof(V_4));
{
int32_t L_0 = ___axis0;
V_0 = L_0;
Vector2_t2243707579 L_1 = RectTransform_get_sizeDelta_m2157326342(__this, /*hidden argument*/NULL);
V_1 = L_1;
int32_t L_2 = V_0;
float L_3 = ___size1;
Vector2_t2243707579 L_4 = RectTransform_GetParentSize_m1571597933(__this, /*hidden argument*/NULL);
V_2 = L_4;
int32_t L_5 = V_0;
float L_6 = Vector2_get_Item_m2792130561((&V_2), L_5, /*hidden argument*/NULL);
Vector2_t2243707579 L_7 = RectTransform_get_anchorMax_m3816015142(__this, /*hidden argument*/NULL);
V_3 = L_7;
int32_t L_8 = V_0;
float L_9 = Vector2_get_Item_m2792130561((&V_3), L_8, /*hidden argument*/NULL);
Vector2_t2243707579 L_10 = RectTransform_get_anchorMin_m1497323108(__this, /*hidden argument*/NULL);
V_4 = L_10;
int32_t L_11 = V_0;
float L_12 = Vector2_get_Item_m2792130561((&V_4), L_11, /*hidden argument*/NULL);
Vector2_set_Item_m3881967114((&V_1), L_2, ((float)((float)L_3-(float)((float)((float)L_6*(float)((float)((float)L_9-(float)L_12)))))), /*hidden argument*/NULL);
Vector2_t2243707579 L_13 = V_1;
RectTransform_set_sizeDelta_m2319668137(__this, L_13, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Vector2 UnityEngine.RectTransform::GetParentSize()
extern "C" Vector2_t2243707579 RectTransform_GetParentSize_m1571597933 (RectTransform_t3349966182 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransform_GetParentSize_m1571597933_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RectTransform_t3349966182 * V_0 = NULL;
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
Rect_t3681755626 V_2;
memset(&V_2, 0, sizeof(V_2));
{
Transform_t3275118058 * L_0 = Transform_get_parent_m147407266(__this, /*hidden argument*/NULL);
V_0 = ((RectTransform_t3349966182 *)IsInstSealed(L_0, RectTransform_t3349966182_il2cpp_TypeInfo_var));
RectTransform_t3349966182 * L_1 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_2 = Object_op_Implicit_m2856731593(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
if (L_2)
{
goto IL_0023;
}
}
{
Vector2_t2243707579 L_3 = Vector2_get_zero_m3966848876(NULL /*static, unused*/, /*hidden argument*/NULL);
V_1 = L_3;
goto IL_0037;
}
IL_0023:
{
RectTransform_t3349966182 * L_4 = V_0;
Rect_t3681755626 L_5 = RectTransform_get_rect_m73954734(L_4, /*hidden argument*/NULL);
V_2 = L_5;
Vector2_t2243707579 L_6 = Rect_get_size_m3833121112((&V_2), /*hidden argument*/NULL);
V_1 = L_6;
goto IL_0037;
}
IL_0037:
{
Vector2_t2243707579 L_7 = V_1;
return L_7;
}
}
// System.Void UnityEngine.RectTransform/ReapplyDrivenProperties::.ctor(System.Object,System.IntPtr)
extern "C" void ReapplyDrivenProperties__ctor_m210072638 (ReapplyDrivenProperties_t2020713228 * __this, Il2CppObject * ___object0, IntPtr_t ___method1, const MethodInfo* method)
{
__this->set_method_ptr_0((Il2CppMethodPointer)((MethodInfo*)___method1.get_m_value_0())->methodPointer);
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.RectTransform/ReapplyDrivenProperties::Invoke(UnityEngine.RectTransform)
extern "C" void ReapplyDrivenProperties_Invoke_m1090213637 (ReapplyDrivenProperties_t2020713228 * __this, RectTransform_t3349966182 * ___driven0, const MethodInfo* method)
{
if(__this->get_prev_9() != NULL)
{
ReapplyDrivenProperties_Invoke_m1090213637((ReapplyDrivenProperties_t2020713228 *)__this->get_prev_9(),___driven0, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->get_method_3().get_m_value_0()));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->get_method_3().get_m_value_0()));
if (__this->get_m_target_2() != NULL && ___methodIsStatic)
{
typedef void (*FunctionPointerType) (Il2CppObject *, void* __this, RectTransform_t3349966182 * ___driven0, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(NULL,__this->get_m_target_2(),___driven0,(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
else if (__this->get_m_target_2() != NULL || ___methodIsStatic)
{
typedef void (*FunctionPointerType) (void* __this, RectTransform_t3349966182 * ___driven0, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(__this->get_m_target_2(),___driven0,(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
else
{
typedef void (*FunctionPointerType) (void* __this, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(___driven0,(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
}
// System.IAsyncResult UnityEngine.RectTransform/ReapplyDrivenProperties::BeginInvoke(UnityEngine.RectTransform,System.AsyncCallback,System.Object)
extern "C" Il2CppObject * ReapplyDrivenProperties_BeginInvoke_m2337529776 (ReapplyDrivenProperties_t2020713228 * __this, RectTransform_t3349966182 * ___driven0, AsyncCallback_t163412349 * ___callback1, Il2CppObject * ___object2, const MethodInfo* method)
{
void *__d_args[2] = {0};
__d_args[0] = ___driven0;
return (Il2CppObject *)il2cpp_codegen_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback1, (Il2CppObject*)___object2);
}
// System.Void UnityEngine.RectTransform/ReapplyDrivenProperties::EndInvoke(System.IAsyncResult)
extern "C" void ReapplyDrivenProperties_EndInvoke_m2375002944 (ReapplyDrivenProperties_t2020713228 * __this, Il2CppObject * ___result0, const MethodInfo* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
// System.Boolean UnityEngine.RectTransformUtility::ScreenPointToWorldPointInRectangle(UnityEngine.RectTransform,UnityEngine.Vector2,UnityEngine.Camera,UnityEngine.Vector3&)
extern "C" bool RectTransformUtility_ScreenPointToWorldPointInRectangle_m2304638810 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rect0, Vector2_t2243707579 ___screenPoint1, Camera_t189460977 * ___cam2, Vector3_t2243707580 * ___worldPoint3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransformUtility_ScreenPointToWorldPointInRectangle_m2304638810_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Ray_t2469606224 V_0;
memset(&V_0, 0, sizeof(V_0));
Plane_t3727654732 V_1;
memset(&V_1, 0, sizeof(V_1));
float V_2 = 0.0f;
bool V_3 = false;
{
Vector3_t2243707580 * L_0 = ___worldPoint3;
Vector2_t2243707579 L_1 = Vector2_get_zero_m3966848876(NULL /*static, unused*/, /*hidden argument*/NULL);
Vector3_t2243707580 L_2 = Vector2_op_Implicit_m176791411(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
(*(Vector3_t2243707580 *)L_0) = L_2;
Camera_t189460977 * L_3 = ___cam2;
Vector2_t2243707579 L_4 = ___screenPoint1;
IL2CPP_RUNTIME_CLASS_INIT(RectTransformUtility_t2941082270_il2cpp_TypeInfo_var);
Ray_t2469606224 L_5 = RectTransformUtility_ScreenPointToRay_m1842507230(NULL /*static, unused*/, L_3, L_4, /*hidden argument*/NULL);
V_0 = L_5;
RectTransform_t3349966182 * L_6 = ___rect0;
Quaternion_t4030073918 L_7 = Transform_get_rotation_m1033555130(L_6, /*hidden argument*/NULL);
Vector3_t2243707580 L_8 = Vector3_get_back_m4246539215(NULL /*static, unused*/, /*hidden argument*/NULL);
Vector3_t2243707580 L_9 = Quaternion_op_Multiply_m1483423721(NULL /*static, unused*/, L_7, L_8, /*hidden argument*/NULL);
RectTransform_t3349966182 * L_10 = ___rect0;
Vector3_t2243707580 L_11 = Transform_get_position_m1104419803(L_10, /*hidden argument*/NULL);
Plane__ctor_m3187718367((&V_1), L_9, L_11, /*hidden argument*/NULL);
Ray_t2469606224 L_12 = V_0;
bool L_13 = Plane_Raycast_m2870142810((&V_1), L_12, (&V_2), /*hidden argument*/NULL);
if (L_13)
{
goto IL_004c;
}
}
{
V_3 = (bool)0;
goto IL_0061;
}
IL_004c:
{
Vector3_t2243707580 * L_14 = ___worldPoint3;
float L_15 = V_2;
Vector3_t2243707580 L_16 = Ray_GetPoint_m1353702366((&V_0), L_15, /*hidden argument*/NULL);
(*(Vector3_t2243707580 *)L_14) = L_16;
V_3 = (bool)1;
goto IL_0061;
}
IL_0061:
{
bool L_17 = V_3;
return L_17;
}
}
// System.Boolean UnityEngine.RectTransformUtility::ScreenPointToLocalPointInRectangle(UnityEngine.RectTransform,UnityEngine.Vector2,UnityEngine.Camera,UnityEngine.Vector2&)
extern "C" bool RectTransformUtility_ScreenPointToLocalPointInRectangle_m2398565080 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rect0, Vector2_t2243707579 ___screenPoint1, Camera_t189460977 * ___cam2, Vector2_t2243707579 * ___localPoint3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransformUtility_ScreenPointToLocalPointInRectangle_m2398565080_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector3_t2243707580 V_0;
memset(&V_0, 0, sizeof(V_0));
bool V_1 = false;
{
Vector2_t2243707579 * L_0 = ___localPoint3;
Vector2_t2243707579 L_1 = Vector2_get_zero_m3966848876(NULL /*static, unused*/, /*hidden argument*/NULL);
(*(Vector2_t2243707579 *)L_0) = L_1;
RectTransform_t3349966182 * L_2 = ___rect0;
Vector2_t2243707579 L_3 = ___screenPoint1;
Camera_t189460977 * L_4 = ___cam2;
IL2CPP_RUNTIME_CLASS_INIT(RectTransformUtility_t2941082270_il2cpp_TypeInfo_var);
bool L_5 = RectTransformUtility_ScreenPointToWorldPointInRectangle_m2304638810(NULL /*static, unused*/, L_2, L_3, L_4, (&V_0), /*hidden argument*/NULL);
if (!L_5)
{
goto IL_0035;
}
}
{
Vector2_t2243707579 * L_6 = ___localPoint3;
RectTransform_t3349966182 * L_7 = ___rect0;
Vector3_t2243707580 L_8 = V_0;
Vector3_t2243707580 L_9 = Transform_InverseTransformPoint_m2648491174(L_7, L_8, /*hidden argument*/NULL);
Vector2_t2243707579 L_10 = Vector2_op_Implicit_m1064335535(NULL /*static, unused*/, L_9, /*hidden argument*/NULL);
(*(Vector2_t2243707579 *)L_6) = L_10;
V_1 = (bool)1;
goto IL_003c;
}
IL_0035:
{
V_1 = (bool)0;
goto IL_003c;
}
IL_003c:
{
bool L_11 = V_1;
return L_11;
}
}
// UnityEngine.Ray UnityEngine.RectTransformUtility::ScreenPointToRay(UnityEngine.Camera,UnityEngine.Vector2)
extern "C" Ray_t2469606224 RectTransformUtility_ScreenPointToRay_m1842507230 (Il2CppObject * __this /* static, unused */, Camera_t189460977 * ___cam0, Vector2_t2243707579 ___screenPos1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransformUtility_ScreenPointToRay_m1842507230_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Ray_t2469606224 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector3_t2243707580 V_1;
memset(&V_1, 0, sizeof(V_1));
{
Camera_t189460977 * L_0 = ___cam0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_1 = Object_op_Inequality_m2402264703(NULL /*static, unused*/, L_0, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_001f;
}
}
{
Camera_t189460977 * L_2 = ___cam0;
Vector2_t2243707579 L_3 = ___screenPos1;
Vector3_t2243707580 L_4 = Vector2_op_Implicit_m176791411(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
Ray_t2469606224 L_5 = Camera_ScreenPointToRay_m614889538(L_2, L_4, /*hidden argument*/NULL);
V_0 = L_5;
goto IL_004a;
}
IL_001f:
{
Vector2_t2243707579 L_6 = ___screenPos1;
Vector3_t2243707580 L_7 = Vector2_op_Implicit_m176791411(NULL /*static, unused*/, L_6, /*hidden argument*/NULL);
V_1 = L_7;
Vector3_t2243707580 * L_8 = (&V_1);
float L_9 = L_8->get_z_3();
L_8->set_z_3(((float)((float)L_9-(float)(100.0f))));
Vector3_t2243707580 L_10 = V_1;
Vector3_t2243707580 L_11 = Vector3_get_forward_m1201659139(NULL /*static, unused*/, /*hidden argument*/NULL);
Ray_t2469606224 L_12;
memset(&L_12, 0, sizeof(L_12));
Ray__ctor_m3379034047(&L_12, L_10, L_11, /*hidden argument*/NULL);
V_0 = L_12;
goto IL_004a;
}
IL_004a:
{
Ray_t2469606224 L_13 = V_0;
return L_13;
}
}
// System.Void UnityEngine.RectTransformUtility::FlipLayoutOnAxis(UnityEngine.RectTransform,System.Int32,System.Boolean,System.Boolean)
extern "C" void RectTransformUtility_FlipLayoutOnAxis_m3920364518 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rect0, int32_t ___axis1, bool ___keepPositioning2, bool ___recursive3, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransformUtility_FlipLayoutOnAxis_m3920364518_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
RectTransform_t3349966182 * V_1 = NULL;
Vector2_t2243707579 V_2;
memset(&V_2, 0, sizeof(V_2));
Vector2_t2243707579 V_3;
memset(&V_3, 0, sizeof(V_3));
Vector2_t2243707579 V_4;
memset(&V_4, 0, sizeof(V_4));
Vector2_t2243707579 V_5;
memset(&V_5, 0, sizeof(V_5));
float V_6 = 0.0f;
{
RectTransform_t3349966182 * L_0 = ___rect0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_1 = Object_op_Equality_m3764089466(NULL /*static, unused*/, L_0, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0012;
}
}
{
goto IL_00f3;
}
IL_0012:
{
bool L_2 = ___recursive3;
if (!L_2)
{
goto IL_0055;
}
}
{
V_0 = 0;
goto IL_0048;
}
IL_0020:
{
RectTransform_t3349966182 * L_3 = ___rect0;
int32_t L_4 = V_0;
Transform_t3275118058 * L_5 = Transform_GetChild_m3838588184(L_3, L_4, /*hidden argument*/NULL);
V_1 = ((RectTransform_t3349966182 *)IsInstSealed(L_5, RectTransform_t3349966182_il2cpp_TypeInfo_var));
RectTransform_t3349966182 * L_6 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_7 = Object_op_Inequality_m2402264703(NULL /*static, unused*/, L_6, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_7)
{
goto IL_0043;
}
}
{
RectTransform_t3349966182 * L_8 = V_1;
int32_t L_9 = ___axis1;
IL2CPP_RUNTIME_CLASS_INIT(RectTransformUtility_t2941082270_il2cpp_TypeInfo_var);
RectTransformUtility_FlipLayoutOnAxis_m3920364518(NULL /*static, unused*/, L_8, L_9, (bool)0, (bool)1, /*hidden argument*/NULL);
}
IL_0043:
{
int32_t L_10 = V_0;
V_0 = ((int32_t)((int32_t)L_10+(int32_t)1));
}
IL_0048:
{
int32_t L_11 = V_0;
RectTransform_t3349966182 * L_12 = ___rect0;
int32_t L_13 = Transform_get_childCount_m881385315(L_12, /*hidden argument*/NULL);
if ((((int32_t)L_11) < ((int32_t)L_13)))
{
goto IL_0020;
}
}
{
}
IL_0055:
{
RectTransform_t3349966182 * L_14 = ___rect0;
Vector2_t2243707579 L_15 = RectTransform_get_pivot_m759087479(L_14, /*hidden argument*/NULL);
V_2 = L_15;
int32_t L_16 = ___axis1;
int32_t L_17 = ___axis1;
float L_18 = Vector2_get_Item_m2792130561((&V_2), L_17, /*hidden argument*/NULL);
Vector2_set_Item_m3881967114((&V_2), L_16, ((float)((float)(1.0f)-(float)L_18)), /*hidden argument*/NULL);
RectTransform_t3349966182 * L_19 = ___rect0;
Vector2_t2243707579 L_20 = V_2;
RectTransform_set_pivot_m1360548980(L_19, L_20, /*hidden argument*/NULL);
bool L_21 = ___keepPositioning2;
if (!L_21)
{
goto IL_0084;
}
}
{
goto IL_00f3;
}
IL_0084:
{
RectTransform_t3349966182 * L_22 = ___rect0;
Vector2_t2243707579 L_23 = RectTransform_get_anchoredPosition_m3570822376(L_22, /*hidden argument*/NULL);
V_3 = L_23;
int32_t L_24 = ___axis1;
int32_t L_25 = ___axis1;
float L_26 = Vector2_get_Item_m2792130561((&V_3), L_25, /*hidden argument*/NULL);
Vector2_set_Item_m3881967114((&V_3), L_24, ((-L_26)), /*hidden argument*/NULL);
RectTransform_t3349966182 * L_27 = ___rect0;
Vector2_t2243707579 L_28 = V_3;
RectTransform_set_anchoredPosition_m2077229449(L_27, L_28, /*hidden argument*/NULL);
RectTransform_t3349966182 * L_29 = ___rect0;
Vector2_t2243707579 L_30 = RectTransform_get_anchorMin_m1497323108(L_29, /*hidden argument*/NULL);
V_4 = L_30;
RectTransform_t3349966182 * L_31 = ___rect0;
Vector2_t2243707579 L_32 = RectTransform_get_anchorMax_m3816015142(L_31, /*hidden argument*/NULL);
V_5 = L_32;
int32_t L_33 = ___axis1;
float L_34 = Vector2_get_Item_m2792130561((&V_4), L_33, /*hidden argument*/NULL);
V_6 = L_34;
int32_t L_35 = ___axis1;
int32_t L_36 = ___axis1;
float L_37 = Vector2_get_Item_m2792130561((&V_5), L_36, /*hidden argument*/NULL);
Vector2_set_Item_m3881967114((&V_4), L_35, ((float)((float)(1.0f)-(float)L_37)), /*hidden argument*/NULL);
int32_t L_38 = ___axis1;
float L_39 = V_6;
Vector2_set_Item_m3881967114((&V_5), L_38, ((float)((float)(1.0f)-(float)L_39)), /*hidden argument*/NULL);
RectTransform_t3349966182 * L_40 = ___rect0;
Vector2_t2243707579 L_41 = V_4;
RectTransform_set_anchorMin_m4247668187(L_40, L_41, /*hidden argument*/NULL);
RectTransform_t3349966182 * L_42 = ___rect0;
Vector2_t2243707579 L_43 = V_5;
RectTransform_set_anchorMax_m2955899993(L_42, L_43, /*hidden argument*/NULL);
}
IL_00f3:
{
return;
}
}
// System.Void UnityEngine.RectTransformUtility::FlipLayoutAxes(UnityEngine.RectTransform,System.Boolean,System.Boolean)
extern "C" void RectTransformUtility_FlipLayoutAxes_m532748168 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rect0, bool ___keepPositioning1, bool ___recursive2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransformUtility_FlipLayoutAxes_m532748168_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
RectTransform_t3349966182 * V_1 = NULL;
{
RectTransform_t3349966182 * L_0 = ___rect0;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_1 = Object_op_Equality_m3764089466(NULL /*static, unused*/, L_0, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0012;
}
}
{
goto IL_00b4;
}
IL_0012:
{
bool L_2 = ___recursive2;
if (!L_2)
{
goto IL_0054;
}
}
{
V_0 = 0;
goto IL_0047;
}
IL_0020:
{
RectTransform_t3349966182 * L_3 = ___rect0;
int32_t L_4 = V_0;
Transform_t3275118058 * L_5 = Transform_GetChild_m3838588184(L_3, L_4, /*hidden argument*/NULL);
V_1 = ((RectTransform_t3349966182 *)IsInstSealed(L_5, RectTransform_t3349966182_il2cpp_TypeInfo_var));
RectTransform_t3349966182 * L_6 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(Object_t1021602117_il2cpp_TypeInfo_var);
bool L_7 = Object_op_Inequality_m2402264703(NULL /*static, unused*/, L_6, (Object_t1021602117 *)NULL, /*hidden argument*/NULL);
if (!L_7)
{
goto IL_0042;
}
}
{
RectTransform_t3349966182 * L_8 = V_1;
IL2CPP_RUNTIME_CLASS_INIT(RectTransformUtility_t2941082270_il2cpp_TypeInfo_var);
RectTransformUtility_FlipLayoutAxes_m532748168(NULL /*static, unused*/, L_8, (bool)0, (bool)1, /*hidden argument*/NULL);
}
IL_0042:
{
int32_t L_9 = V_0;
V_0 = ((int32_t)((int32_t)L_9+(int32_t)1));
}
IL_0047:
{
int32_t L_10 = V_0;
RectTransform_t3349966182 * L_11 = ___rect0;
int32_t L_12 = Transform_get_childCount_m881385315(L_11, /*hidden argument*/NULL);
if ((((int32_t)L_10) < ((int32_t)L_12)))
{
goto IL_0020;
}
}
{
}
IL_0054:
{
RectTransform_t3349966182 * L_13 = ___rect0;
RectTransform_t3349966182 * L_14 = ___rect0;
Vector2_t2243707579 L_15 = RectTransform_get_pivot_m759087479(L_14, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(RectTransformUtility_t2941082270_il2cpp_TypeInfo_var);
Vector2_t2243707579 L_16 = RectTransformUtility_GetTransposed_m1770338235(NULL /*static, unused*/, L_15, /*hidden argument*/NULL);
RectTransform_set_pivot_m1360548980(L_13, L_16, /*hidden argument*/NULL);
RectTransform_t3349966182 * L_17 = ___rect0;
RectTransform_t3349966182 * L_18 = ___rect0;
Vector2_t2243707579 L_19 = RectTransform_get_sizeDelta_m2157326342(L_18, /*hidden argument*/NULL);
Vector2_t2243707579 L_20 = RectTransformUtility_GetTransposed_m1770338235(NULL /*static, unused*/, L_19, /*hidden argument*/NULL);
RectTransform_set_sizeDelta_m2319668137(L_17, L_20, /*hidden argument*/NULL);
bool L_21 = ___keepPositioning1;
if (!L_21)
{
goto IL_0081;
}
}
{
goto IL_00b4;
}
IL_0081:
{
RectTransform_t3349966182 * L_22 = ___rect0;
RectTransform_t3349966182 * L_23 = ___rect0;
Vector2_t2243707579 L_24 = RectTransform_get_anchoredPosition_m3570822376(L_23, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(RectTransformUtility_t2941082270_il2cpp_TypeInfo_var);
Vector2_t2243707579 L_25 = RectTransformUtility_GetTransposed_m1770338235(NULL /*static, unused*/, L_24, /*hidden argument*/NULL);
RectTransform_set_anchoredPosition_m2077229449(L_22, L_25, /*hidden argument*/NULL);
RectTransform_t3349966182 * L_26 = ___rect0;
RectTransform_t3349966182 * L_27 = ___rect0;
Vector2_t2243707579 L_28 = RectTransform_get_anchorMin_m1497323108(L_27, /*hidden argument*/NULL);
Vector2_t2243707579 L_29 = RectTransformUtility_GetTransposed_m1770338235(NULL /*static, unused*/, L_28, /*hidden argument*/NULL);
RectTransform_set_anchorMin_m4247668187(L_26, L_29, /*hidden argument*/NULL);
RectTransform_t3349966182 * L_30 = ___rect0;
RectTransform_t3349966182 * L_31 = ___rect0;
Vector2_t2243707579 L_32 = RectTransform_get_anchorMax_m3816015142(L_31, /*hidden argument*/NULL);
Vector2_t2243707579 L_33 = RectTransformUtility_GetTransposed_m1770338235(NULL /*static, unused*/, L_32, /*hidden argument*/NULL);
RectTransform_set_anchorMax_m2955899993(L_30, L_33, /*hidden argument*/NULL);
}
IL_00b4:
{
return;
}
}
// UnityEngine.Vector2 UnityEngine.RectTransformUtility::GetTransposed(UnityEngine.Vector2)
extern "C" Vector2_t2243707579 RectTransformUtility_GetTransposed_m1770338235 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___input0, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
{
float L_0 = (&___input0)->get_y_1();
float L_1 = (&___input0)->get_x_0();
Vector2_t2243707579 L_2;
memset(&L_2, 0, sizeof(L_2));
Vector2__ctor_m3067419446(&L_2, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_001a;
}
IL_001a:
{
Vector2_t2243707579 L_3 = V_0;
return L_3;
}
}
// System.Boolean UnityEngine.RectTransformUtility::RectangleContainsScreenPoint(UnityEngine.RectTransform,UnityEngine.Vector2,UnityEngine.Camera)
extern "C" bool RectTransformUtility_RectangleContainsScreenPoint_m1244853728 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rect0, Vector2_t2243707579 ___screenPoint1, Camera_t189460977 * ___cam2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransformUtility_RectangleContainsScreenPoint_m1244853728_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
{
RectTransform_t3349966182 * L_0 = ___rect0;
Camera_t189460977 * L_1 = ___cam2;
IL2CPP_RUNTIME_CLASS_INIT(RectTransformUtility_t2941082270_il2cpp_TypeInfo_var);
bool L_2 = RectTransformUtility_INTERNAL_CALL_RectangleContainsScreenPoint_m3362263993(NULL /*static, unused*/, L_0, (&___screenPoint1), L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0010;
}
IL_0010:
{
bool L_3 = V_0;
return L_3;
}
}
// System.Boolean UnityEngine.RectTransformUtility::INTERNAL_CALL_RectangleContainsScreenPoint(UnityEngine.RectTransform,UnityEngine.Vector2&,UnityEngine.Camera)
extern "C" bool RectTransformUtility_INTERNAL_CALL_RectangleContainsScreenPoint_m3362263993 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rect0, Vector2_t2243707579 * ___screenPoint1, Camera_t189460977 * ___cam2, const MethodInfo* method)
{
typedef bool (*RectTransformUtility_INTERNAL_CALL_RectangleContainsScreenPoint_m3362263993_ftn) (RectTransform_t3349966182 *, Vector2_t2243707579 *, Camera_t189460977 *);
static RectTransformUtility_INTERNAL_CALL_RectangleContainsScreenPoint_m3362263993_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransformUtility_INTERNAL_CALL_RectangleContainsScreenPoint_m3362263993_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransformUtility::INTERNAL_CALL_RectangleContainsScreenPoint(UnityEngine.RectTransform,UnityEngine.Vector2&,UnityEngine.Camera)");
return _il2cpp_icall_func(___rect0, ___screenPoint1, ___cam2);
}
// UnityEngine.Vector2 UnityEngine.RectTransformUtility::PixelAdjustPoint(UnityEngine.Vector2,UnityEngine.Transform,UnityEngine.Canvas)
extern "C" Vector2_t2243707579 RectTransformUtility_PixelAdjustPoint_m560908615 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 ___point0, Transform_t3275118058 * ___elementTransform1, Canvas_t209405766 * ___canvas2, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransformUtility_PixelAdjustPoint_m560908615_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
Transform_t3275118058 * L_0 = ___elementTransform1;
Canvas_t209405766 * L_1 = ___canvas2;
IL2CPP_RUNTIME_CLASS_INIT(RectTransformUtility_t2941082270_il2cpp_TypeInfo_var);
RectTransformUtility_INTERNAL_CALL_PixelAdjustPoint_m2153046669(NULL /*static, unused*/, (&___point0), L_0, L_1, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_2 = V_0;
V_1 = L_2;
goto IL_0013;
}
IL_0013:
{
Vector2_t2243707579 L_3 = V_1;
return L_3;
}
}
// System.Void UnityEngine.RectTransformUtility::INTERNAL_CALL_PixelAdjustPoint(UnityEngine.Vector2&,UnityEngine.Transform,UnityEngine.Canvas,UnityEngine.Vector2&)
extern "C" void RectTransformUtility_INTERNAL_CALL_PixelAdjustPoint_m2153046669 (Il2CppObject * __this /* static, unused */, Vector2_t2243707579 * ___point0, Transform_t3275118058 * ___elementTransform1, Canvas_t209405766 * ___canvas2, Vector2_t2243707579 * ___value3, const MethodInfo* method)
{
typedef void (*RectTransformUtility_INTERNAL_CALL_PixelAdjustPoint_m2153046669_ftn) (Vector2_t2243707579 *, Transform_t3275118058 *, Canvas_t209405766 *, Vector2_t2243707579 *);
static RectTransformUtility_INTERNAL_CALL_PixelAdjustPoint_m2153046669_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransformUtility_INTERNAL_CALL_PixelAdjustPoint_m2153046669_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransformUtility::INTERNAL_CALL_PixelAdjustPoint(UnityEngine.Vector2&,UnityEngine.Transform,UnityEngine.Canvas,UnityEngine.Vector2&)");
_il2cpp_icall_func(___point0, ___elementTransform1, ___canvas2, ___value3);
}
// UnityEngine.Rect UnityEngine.RectTransformUtility::PixelAdjustRect(UnityEngine.RectTransform,UnityEngine.Canvas)
extern "C" Rect_t3681755626 RectTransformUtility_PixelAdjustRect_m93024038 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rectTransform0, Canvas_t209405766 * ___canvas1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransformUtility_PixelAdjustRect_m93024038_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Rect_t3681755626 V_0;
memset(&V_0, 0, sizeof(V_0));
Rect_t3681755626 V_1;
memset(&V_1, 0, sizeof(V_1));
{
RectTransform_t3349966182 * L_0 = ___rectTransform0;
Canvas_t209405766 * L_1 = ___canvas1;
IL2CPP_RUNTIME_CLASS_INIT(RectTransformUtility_t2941082270_il2cpp_TypeInfo_var);
RectTransformUtility_INTERNAL_CALL_PixelAdjustRect_m1237215542(NULL /*static, unused*/, L_0, L_1, (&V_0), /*hidden argument*/NULL);
Rect_t3681755626 L_2 = V_0;
V_1 = L_2;
goto IL_0011;
}
IL_0011:
{
Rect_t3681755626 L_3 = V_1;
return L_3;
}
}
// System.Void UnityEngine.RectTransformUtility::INTERNAL_CALL_PixelAdjustRect(UnityEngine.RectTransform,UnityEngine.Canvas,UnityEngine.Rect&)
extern "C" void RectTransformUtility_INTERNAL_CALL_PixelAdjustRect_m1237215542 (Il2CppObject * __this /* static, unused */, RectTransform_t3349966182 * ___rectTransform0, Canvas_t209405766 * ___canvas1, Rect_t3681755626 * ___value2, const MethodInfo* method)
{
typedef void (*RectTransformUtility_INTERNAL_CALL_PixelAdjustRect_m1237215542_ftn) (RectTransform_t3349966182 *, Canvas_t209405766 *, Rect_t3681755626 *);
static RectTransformUtility_INTERNAL_CALL_PixelAdjustRect_m1237215542_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RectTransformUtility_INTERNAL_CALL_PixelAdjustRect_m1237215542_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RectTransformUtility::INTERNAL_CALL_PixelAdjustRect(UnityEngine.RectTransform,UnityEngine.Canvas,UnityEngine.Rect&)");
_il2cpp_icall_func(___rectTransform0, ___canvas1, ___value2);
}
// System.Void UnityEngine.RectTransformUtility::.cctor()
extern "C" void RectTransformUtility__cctor_m1866023382 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RectTransformUtility__cctor_m1866023382_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
((RectTransformUtility_t2941082270_StaticFields*)RectTransformUtility_t2941082270_il2cpp_TypeInfo_var->static_fields)->set_s_Corners_0(((Vector3U5BU5D_t1172311765*)SZArrayNew(Vector3U5BU5D_t1172311765_il2cpp_TypeInfo_var, (uint32_t)4)));
return;
}
}
// System.Void UnityEngine.RemoteSettings::CallOnUpdate()
extern "C" void RemoteSettings_CallOnUpdate_m1624968574 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (RemoteSettings_CallOnUpdate_m1624968574_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
UpdatedEventHandler_t3033456180 * V_0 = NULL;
{
UpdatedEventHandler_t3033456180 * L_0 = ((RemoteSettings_t392466225_StaticFields*)RemoteSettings_t392466225_il2cpp_TypeInfo_var->static_fields)->get_Updated_0();
V_0 = L_0;
UpdatedEventHandler_t3033456180 * L_1 = V_0;
if (!L_1)
{
goto IL_0013;
}
}
{
UpdatedEventHandler_t3033456180 * L_2 = V_0;
UpdatedEventHandler_Invoke_m159598802(L_2, /*hidden argument*/NULL);
}
IL_0013:
{
return;
}
}
extern "C" void DelegatePInvokeWrapper_UpdatedEventHandler_t3033456180 (UpdatedEventHandler_t3033456180 * __this, const MethodInfo* method)
{
typedef void (STDCALL *PInvokeFunc)();
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(((Il2CppDelegate*)__this)->method->methodPointer);
// Native function invocation
il2cppPInvokeFunc();
}
// System.Void UnityEngine.RemoteSettings/UpdatedEventHandler::.ctor(System.Object,System.IntPtr)
extern "C" void UpdatedEventHandler__ctor_m1393569768 (UpdatedEventHandler_t3033456180 * __this, Il2CppObject * ___object0, IntPtr_t ___method1, const MethodInfo* method)
{
__this->set_method_ptr_0((Il2CppMethodPointer)((MethodInfo*)___method1.get_m_value_0())->methodPointer);
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.RemoteSettings/UpdatedEventHandler::Invoke()
extern "C" void UpdatedEventHandler_Invoke_m159598802 (UpdatedEventHandler_t3033456180 * __this, const MethodInfo* method)
{
if(__this->get_prev_9() != NULL)
{
UpdatedEventHandler_Invoke_m159598802((UpdatedEventHandler_t3033456180 *)__this->get_prev_9(), method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->get_method_3().get_m_value_0()));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->get_method_3().get_m_value_0()));
if ((__this->get_m_target_2() != NULL || MethodHasParameters((MethodInfo*)(__this->get_method_3().get_m_value_0()))) && ___methodIsStatic)
{
typedef void (*FunctionPointerType) (Il2CppObject *, void* __this, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(NULL,__this->get_m_target_2(),(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
else
{
typedef void (*FunctionPointerType) (void* __this, const MethodInfo* method);
((FunctionPointerType)__this->get_method_ptr_0())(__this->get_m_target_2(),(MethodInfo*)(__this->get_method_3().get_m_value_0()));
}
}
// System.IAsyncResult UnityEngine.RemoteSettings/UpdatedEventHandler::BeginInvoke(System.AsyncCallback,System.Object)
extern "C" Il2CppObject * UpdatedEventHandler_BeginInvoke_m4238510153 (UpdatedEventHandler_t3033456180 * __this, AsyncCallback_t163412349 * ___callback0, Il2CppObject * ___object1, const MethodInfo* method)
{
void *__d_args[1] = {0};
return (Il2CppObject *)il2cpp_codegen_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback0, (Il2CppObject*)___object1);
}
// System.Void UnityEngine.RemoteSettings/UpdatedEventHandler::EndInvoke(System.IAsyncResult)
extern "C" void UpdatedEventHandler_EndInvoke_m224684362 (UpdatedEventHandler_t3033456180 * __this, Il2CppObject * ___result0, const MethodInfo* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
// UnityEngine.Material UnityEngine.Renderer::get_material()
extern "C" Material_t193706927 * Renderer_get_material_m2553789785 (Renderer_t257310565 * __this, const MethodInfo* method)
{
typedef Material_t193706927 * (*Renderer_get_material_m2553789785_ftn) (Renderer_t257310565 *);
static Renderer_get_material_m2553789785_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Renderer_get_material_m2553789785_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Renderer::get_material()");
return _il2cpp_icall_func(__this);
}
// System.Int32 UnityEngine.Renderer::get_sortingLayerID()
extern "C" int32_t Renderer_get_sortingLayerID_m2403577271 (Renderer_t257310565 * __this, const MethodInfo* method)
{
typedef int32_t (*Renderer_get_sortingLayerID_m2403577271_ftn) (Renderer_t257310565 *);
static Renderer_get_sortingLayerID_m2403577271_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Renderer_get_sortingLayerID_m2403577271_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Renderer::get_sortingLayerID()");
return _il2cpp_icall_func(__this);
}
// System.Int32 UnityEngine.Renderer::get_sortingOrder()
extern "C" int32_t Renderer_get_sortingOrder_m1544525007 (Renderer_t257310565 * __this, const MethodInfo* method)
{
typedef int32_t (*Renderer_get_sortingOrder_m1544525007_ftn) (Renderer_t257310565 *);
static Renderer_get_sortingOrder_m1544525007_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Renderer_get_sortingOrder_m1544525007_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Renderer::get_sortingOrder()");
return _il2cpp_icall_func(__this);
}
// System.Int32 UnityEngine.RenderTexture::Internal_GetWidth(UnityEngine.RenderTexture)
extern "C" int32_t RenderTexture_Internal_GetWidth_m2317917654 (Il2CppObject * __this /* static, unused */, RenderTexture_t2666733923 * ___mono0, const MethodInfo* method)
{
typedef int32_t (*RenderTexture_Internal_GetWidth_m2317917654_ftn) (RenderTexture_t2666733923 *);
static RenderTexture_Internal_GetWidth_m2317917654_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RenderTexture_Internal_GetWidth_m2317917654_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RenderTexture::Internal_GetWidth(UnityEngine.RenderTexture)");
return _il2cpp_icall_func(___mono0);
}
// System.Int32 UnityEngine.RenderTexture::Internal_GetHeight(UnityEngine.RenderTexture)
extern "C" int32_t RenderTexture_Internal_GetHeight_m2780941261 (Il2CppObject * __this /* static, unused */, RenderTexture_t2666733923 * ___mono0, const MethodInfo* method)
{
typedef int32_t (*RenderTexture_Internal_GetHeight_m2780941261_ftn) (RenderTexture_t2666733923 *);
static RenderTexture_Internal_GetHeight_m2780941261_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (RenderTexture_Internal_GetHeight_m2780941261_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.RenderTexture::Internal_GetHeight(UnityEngine.RenderTexture)");
return _il2cpp_icall_func(___mono0);
}
// System.Int32 UnityEngine.RenderTexture::get_width()
extern "C" int32_t RenderTexture_get_width_m1471807677 (RenderTexture_t2666733923 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = RenderTexture_Internal_GetWidth_m2317917654(NULL /*static, unused*/, __this, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
int32_t L_1 = V_0;
return L_1;
}
}
// System.Int32 UnityEngine.RenderTexture::get_height()
extern "C" int32_t RenderTexture_get_height_m1108175848 (RenderTexture_t2666733923 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = RenderTexture_Internal_GetHeight_m2780941261(NULL /*static, unused*/, __this, /*hidden argument*/NULL);
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
int32_t L_1 = V_0;
return L_1;
}
}
// System.Void UnityEngine.RequireComponent::.ctor(System.Type)
extern "C" void RequireComponent__ctor_m3475141952 (RequireComponent_t864575032 * __this, Type_t * ___requiredComponent0, const MethodInfo* method)
{
{
Attribute__ctor_m1730479323(__this, /*hidden argument*/NULL);
Type_t * L_0 = ___requiredComponent0;
__this->set_m_Type0_0(L_0);
return;
}
}
// Conversion methods for marshalling of: UnityEngine.ResourceRequest
extern "C" void ResourceRequest_t2560315377_marshal_pinvoke(const ResourceRequest_t2560315377& unmarshaled, ResourceRequest_t2560315377_marshaled_pinvoke& marshaled)
{
Il2CppCodeGenException* ___m_Type_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Type' of type 'ResourceRequest': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Type_2Exception);
}
extern "C" void ResourceRequest_t2560315377_marshal_pinvoke_back(const ResourceRequest_t2560315377_marshaled_pinvoke& marshaled, ResourceRequest_t2560315377& unmarshaled)
{
Il2CppCodeGenException* ___m_Type_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Type' of type 'ResourceRequest': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Type_2Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.ResourceRequest
extern "C" void ResourceRequest_t2560315377_marshal_pinvoke_cleanup(ResourceRequest_t2560315377_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.ResourceRequest
extern "C" void ResourceRequest_t2560315377_marshal_com(const ResourceRequest_t2560315377& unmarshaled, ResourceRequest_t2560315377_marshaled_com& marshaled)
{
Il2CppCodeGenException* ___m_Type_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Type' of type 'ResourceRequest': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Type_2Exception);
}
extern "C" void ResourceRequest_t2560315377_marshal_com_back(const ResourceRequest_t2560315377_marshaled_com& marshaled, ResourceRequest_t2560315377& unmarshaled)
{
Il2CppCodeGenException* ___m_Type_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_Type' of type 'ResourceRequest': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_Type_2Exception);
}
// Conversion method for clean up from marshalling of: UnityEngine.ResourceRequest
extern "C" void ResourceRequest_t2560315377_marshal_com_cleanup(ResourceRequest_t2560315377_marshaled_com& marshaled)
{
}
// System.Void UnityEngine.ResourceRequest::.ctor()
extern "C" void ResourceRequest__ctor_m3340010930 (ResourceRequest_t2560315377 * __this, const MethodInfo* method)
{
{
AsyncOperation__ctor_m2914860946(__this, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.Object UnityEngine.ResourceRequest::get_asset()
extern "C" Object_t1021602117 * ResourceRequest_get_asset_m3527928488 (ResourceRequest_t2560315377 * __this, const MethodInfo* method)
{
Object_t1021602117 * V_0 = NULL;
{
String_t* L_0 = __this->get_m_Path_1();
Type_t * L_1 = __this->get_m_Type_2();
Object_t1021602117 * L_2 = Resources_Load_m243305716(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0018;
}
IL_0018:
{
Object_t1021602117 * L_3 = V_0;
return L_3;
}
}
// UnityEngine.Object UnityEngine.Resources::Load(System.String,System.Type)
extern "C" Object_t1021602117 * Resources_Load_m243305716 (Il2CppObject * __this /* static, unused */, String_t* ___path0, Type_t * ___systemTypeInstance1, const MethodInfo* method)
{
typedef Object_t1021602117 * (*Resources_Load_m243305716_ftn) (String_t*, Type_t *);
static Resources_Load_m243305716_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Resources_Load_m243305716_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Resources::Load(System.String,System.Type)");
return _il2cpp_icall_func(___path0, ___systemTypeInstance1);
}
// UnityEngine.Object UnityEngine.Resources::GetBuiltinResource(System.Type,System.String)
extern "C" Object_t1021602117 * Resources_GetBuiltinResource_m582410469 (Il2CppObject * __this /* static, unused */, Type_t * ___type0, String_t* ___path1, const MethodInfo* method)
{
typedef Object_t1021602117 * (*Resources_GetBuiltinResource_m582410469_ftn) (Type_t *, String_t*);
static Resources_GetBuiltinResource_m582410469_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Resources_GetBuiltinResource_m582410469_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Resources::GetBuiltinResource(System.Type,System.String)");
return _il2cpp_icall_func(___type0, ___path1);
}
// UnityEngine.Vector2 UnityEngine.Rigidbody2D::get_velocity()
extern "C" Vector2_t2243707579 Rigidbody2D_get_velocity_m3310151195 (Rigidbody2D_t502193897 * __this, const MethodInfo* method)
{
Vector2_t2243707579 V_0;
memset(&V_0, 0, sizeof(V_0));
Vector2_t2243707579 V_1;
memset(&V_1, 0, sizeof(V_1));
{
Rigidbody2D_INTERNAL_get_velocity_m3018296454(__this, (&V_0), /*hidden argument*/NULL);
Vector2_t2243707579 L_0 = V_0;
V_1 = L_0;
goto IL_0010;
}
IL_0010:
{
Vector2_t2243707579 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.Rigidbody2D::set_velocity(UnityEngine.Vector2)
extern "C" void Rigidbody2D_set_velocity_m3592751374 (Rigidbody2D_t502193897 * __this, Vector2_t2243707579 ___value0, const MethodInfo* method)
{
{
Rigidbody2D_INTERNAL_set_velocity_m1537663346(__this, (&___value0), /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Rigidbody2D::INTERNAL_get_velocity(UnityEngine.Vector2&)
extern "C" void Rigidbody2D_INTERNAL_get_velocity_m3018296454 (Rigidbody2D_t502193897 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*Rigidbody2D_INTERNAL_get_velocity_m3018296454_ftn) (Rigidbody2D_t502193897 *, Vector2_t2243707579 *);
static Rigidbody2D_INTERNAL_get_velocity_m3018296454_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody2D_INTERNAL_get_velocity_m3018296454_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody2D::INTERNAL_get_velocity(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Void UnityEngine.Rigidbody2D::INTERNAL_set_velocity(UnityEngine.Vector2&)
extern "C" void Rigidbody2D_INTERNAL_set_velocity_m1537663346 (Rigidbody2D_t502193897 * __this, Vector2_t2243707579 * ___value0, const MethodInfo* method)
{
typedef void (*Rigidbody2D_INTERNAL_set_velocity_m1537663346_ftn) (Rigidbody2D_t502193897 *, Vector2_t2243707579 *);
static Rigidbody2D_INTERNAL_set_velocity_m1537663346_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Rigidbody2D_INTERNAL_set_velocity_m1537663346_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.Rigidbody2D::INTERNAL_set_velocity(UnityEngine.Vector2&)");
_il2cpp_icall_func(__this, ___value0);
}
// System.Int32 UnityEngine.SceneManagement.Scene::get_handle()
extern "C" int32_t Scene_get_handle_m1555912301 (Scene_t1684909666 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_m_Handle_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
int32_t L_1 = V_0;
return L_1;
}
}
extern "C" int32_t Scene_get_handle_m1555912301_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Scene_t1684909666 * _thisAdjusted = reinterpret_cast<Scene_t1684909666 *>(__this + 1);
return Scene_get_handle_m1555912301(_thisAdjusted, method);
}
// System.Int32 UnityEngine.SceneManagement.Scene::get_buildIndex()
extern "C" int32_t Scene_get_buildIndex_m3735680091 (Scene_t1684909666 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = Scene_get_handle_m1555912301(__this, /*hidden argument*/NULL);
int32_t L_1 = Scene_GetBuildIndexInternal_m287561822(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_0012;
}
IL_0012:
{
int32_t L_2 = V_0;
return L_2;
}
}
extern "C" int32_t Scene_get_buildIndex_m3735680091_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Scene_t1684909666 * _thisAdjusted = reinterpret_cast<Scene_t1684909666 *>(__this + 1);
return Scene_get_buildIndex_m3735680091(_thisAdjusted, method);
}
// System.Int32 UnityEngine.SceneManagement.Scene::GetHashCode()
extern "C" int32_t Scene_GetHashCode_m3223653899 (Scene_t1684909666 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_m_Handle_0();
V_0 = L_0;
goto IL_000d;
}
IL_000d:
{
int32_t L_1 = V_0;
return L_1;
}
}
extern "C" int32_t Scene_GetHashCode_m3223653899_AdjustorThunk (Il2CppObject * __this, const MethodInfo* method)
{
Scene_t1684909666 * _thisAdjusted = reinterpret_cast<Scene_t1684909666 *>(__this + 1);
return Scene_GetHashCode_m3223653899(_thisAdjusted, method);
}
// System.Boolean UnityEngine.SceneManagement.Scene::Equals(System.Object)
extern "C" bool Scene_Equals_m3588907349 (Scene_t1684909666 * __this, Il2CppObject * ___other0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Scene_Equals_m3588907349_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
Scene_t1684909666 V_1;
memset(&V_1, 0, sizeof(V_1));
{
Il2CppObject * L_0 = ___other0;
if (((Il2CppObject *)IsInstSealed(L_0, Scene_t1684909666_il2cpp_TypeInfo_var)))
{
goto IL_0013;
}
}
{
V_0 = (bool)0;
goto IL_002f;
}
IL_0013:
{
Il2CppObject * L_1 = ___other0;
V_1 = ((*(Scene_t1684909666 *)((Scene_t1684909666 *)UnBox(L_1, Scene_t1684909666_il2cpp_TypeInfo_var))));
int32_t L_2 = Scene_get_handle_m1555912301(__this, /*hidden argument*/NULL);
int32_t L_3 = Scene_get_handle_m1555912301((&V_1), /*hidden argument*/NULL);
V_0 = (bool)((((int32_t)L_2) == ((int32_t)L_3))? 1 : 0);
goto IL_002f;
}
IL_002f:
{
bool L_4 = V_0;
return L_4;
}
}
extern "C" bool Scene_Equals_m3588907349_AdjustorThunk (Il2CppObject * __this, Il2CppObject * ___other0, const MethodInfo* method)
{
Scene_t1684909666 * _thisAdjusted = reinterpret_cast<Scene_t1684909666 *>(__this + 1);
return Scene_Equals_m3588907349(_thisAdjusted, ___other0, method);
}
// System.Int32 UnityEngine.SceneManagement.Scene::GetBuildIndexInternal(System.Int32)
extern "C" int32_t Scene_GetBuildIndexInternal_m287561822 (Il2CppObject * __this /* static, unused */, int32_t ___sceneHandle0, const MethodInfo* method)
{
typedef int32_t (*Scene_GetBuildIndexInternal_m287561822_ftn) (int32_t);
static Scene_GetBuildIndexInternal_m287561822_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (Scene_GetBuildIndexInternal_m287561822_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.SceneManagement.Scene::GetBuildIndexInternal(System.Int32)");
return _il2cpp_icall_func(___sceneHandle0);
}
// UnityEngine.SceneManagement.Scene UnityEngine.SceneManagement.SceneManager::GetActiveScene()
extern "C" Scene_t1684909666 SceneManager_GetActiveScene_m2964039490 (Il2CppObject * __this /* static, unused */, const MethodInfo* method)
{
Scene_t1684909666 V_0;
memset(&V_0, 0, sizeof(V_0));
Scene_t1684909666 V_1;
memset(&V_1, 0, sizeof(V_1));
{
SceneManager_INTERNAL_CALL_GetActiveScene_m1595803318(NULL /*static, unused*/, (&V_0), /*hidden argument*/NULL);
Scene_t1684909666 L_0 = V_0;
V_1 = L_0;
goto IL_000f;
}
IL_000f:
{
Scene_t1684909666 L_1 = V_1;
return L_1;
}
}
// System.Void UnityEngine.SceneManagement.SceneManager::INTERNAL_CALL_GetActiveScene(UnityEngine.SceneManagement.Scene&)
extern "C" void SceneManager_INTERNAL_CALL_GetActiveScene_m1595803318 (Il2CppObject * __this /* static, unused */, Scene_t1684909666 * ___value0, const MethodInfo* method)
{
typedef void (*SceneManager_INTERNAL_CALL_GetActiveScene_m1595803318_ftn) (Scene_t1684909666 *);
static SceneManager_INTERNAL_CALL_GetActiveScene_m1595803318_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (SceneManager_INTERNAL_CALL_GetActiveScene_m1595803318_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.SceneManagement.SceneManager::INTERNAL_CALL_GetActiveScene(UnityEngine.SceneManagement.Scene&)");
_il2cpp_icall_func(___value0);
}
// System.Void UnityEngine.SceneManagement.SceneManager::LoadScene(System.Int32)
extern "C" void SceneManager_LoadScene_m87258056 (Il2CppObject * __this /* static, unused */, int32_t ___sceneBuildIndex0, const MethodInfo* method)
{
int32_t V_0 = 0;
{
V_0 = 0;
int32_t L_0 = ___sceneBuildIndex0;
int32_t L_1 = V_0;
SceneManager_LoadScene_m592643733(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.SceneManagement.SceneManager::LoadScene(System.Int32,UnityEngine.SceneManagement.LoadSceneMode)
extern "C" void SceneManager_LoadScene_m592643733 (Il2CppObject * __this /* static, unused */, int32_t ___sceneBuildIndex0, int32_t ___mode1, const MethodInfo* method)
{
int32_t G_B2_0 = 0;
Il2CppObject * G_B2_1 = NULL;
int32_t G_B1_0 = 0;
Il2CppObject * G_B1_1 = NULL;
int32_t G_B3_0 = 0;
int32_t G_B3_1 = 0;
Il2CppObject * G_B3_2 = NULL;
{
int32_t L_0 = ___sceneBuildIndex0;
int32_t L_1 = ___mode1;
G_B1_0 = L_0;
G_B1_1 = NULL;
if ((!(((uint32_t)L_1) == ((uint32_t)1))))
{
G_B2_0 = L_0;
G_B2_1 = NULL;
goto IL_0010;
}
}
{
G_B3_0 = 1;
G_B3_1 = G_B1_0;
G_B3_2 = G_B1_1;
goto IL_0011;
}
IL_0010:
{
G_B3_0 = 0;
G_B3_1 = G_B2_0;
G_B3_2 = G_B2_1;
}
IL_0011:
{
SceneManager_LoadSceneAsyncNameIndexInternal_m3279056043(NULL /*static, unused*/, (String_t*)G_B3_2, G_B3_1, (bool)G_B3_0, (bool)1, /*hidden argument*/NULL);
return;
}
}
// UnityEngine.AsyncOperation UnityEngine.SceneManagement.SceneManager::LoadSceneAsyncNameIndexInternal(System.String,System.Int32,System.Boolean,System.Boolean)
extern "C" AsyncOperation_t3814632279 * SceneManager_LoadSceneAsyncNameIndexInternal_m3279056043 (Il2CppObject * __this /* static, unused */, String_t* ___sceneName0, int32_t ___sceneBuildIndex1, bool ___isAdditive2, bool ___mustCompleteNextFrame3, const MethodInfo* method)
{
typedef AsyncOperation_t3814632279 * (*SceneManager_LoadSceneAsyncNameIndexInternal_m3279056043_ftn) (String_t*, int32_t, bool, bool);
static SceneManager_LoadSceneAsyncNameIndexInternal_m3279056043_ftn _il2cpp_icall_func;
if (!_il2cpp_icall_func)
_il2cpp_icall_func = (SceneManager_LoadSceneAsyncNameIndexInternal_m3279056043_ftn)il2cpp_codegen_resolve_icall ("UnityEngine.SceneManagement.SceneManager::LoadSceneAsyncNameIndexInternal(System.String,System.Int32,System.Boolean,System.Boolean)");
return _il2cpp_icall_func(___sceneName0, ___sceneBuildIndex1, ___isAdditive2, ___mustCompleteNextFrame3);
}
// System.Void UnityEngine.SceneManagement.SceneManager::Internal_SceneLoaded(UnityEngine.SceneManagement.Scene,UnityEngine.SceneManagement.LoadSceneMode)
extern "C" void SceneManager_Internal_SceneLoaded_m4005732915 (Il2CppObject * __this /* static, unused */, Scene_t1684909666 ___scene0, int32_t ___mode1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (SceneManager_Internal_SceneLoaded_m4005732915_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
UnityAction_2_t1903595547 * L_0 = ((SceneManager_t90660965_StaticFields*)SceneManager_t90660965_il2cpp_TypeInfo_var->static_fields)->get_sceneLoaded_0();
if (!L_0)
{
goto IL_0019;
}
}
{
UnityAction_2_t1903595547 * L_1 = ((SceneManager_t90660965_StaticFields*)SceneManager_t90660965_il2cpp_TypeInfo_var->static_fields)->get_sceneLoaded_0();
Scene_t1684909666 L_2 = ___scene0;
int32_t L_3 = ___mode1;
UnityAction_2_Invoke_m1528820797(L_1, L_2, L_3, /*hidden argument*/UnityAction_2_Invoke_m1528820797_MethodInfo_var);
}
IL_0019:
{
return;
}
}
// System.Void UnityEngine.SceneManagement.SceneManager::Internal_SceneUnloaded(UnityEngine.SceneManagement.Scene)
extern "C" void SceneManager_Internal_SceneUnloaded_m4108957131 (Il2CppObject * __this /* static, unused */, Scene_t1684909666 ___scene0, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (SceneManager_Internal_SceneUnloaded_m4108957131_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
UnityAction_1_t3051495417 * L_0 = ((SceneManager_t90660965_StaticFields*)SceneManager_t90660965_il2cpp_TypeInfo_var->static_fields)->get_sceneUnloaded_1();
if (!L_0)
{
goto IL_0018;
}
}
{
UnityAction_1_t3051495417 * L_1 = ((SceneManager_t90660965_StaticFields*)SceneManager_t90660965_il2cpp_TypeInfo_var->static_fields)->get_sceneUnloaded_1();
Scene_t1684909666 L_2 = ___scene0;
UnityAction_1_Invoke_m3061904506(L_1, L_2, /*hidden argument*/UnityAction_1_Invoke_m3061904506_MethodInfo_var);
}
IL_0018:
{
return;
}
}
// System.Void UnityEngine.SceneManagement.SceneManager::Internal_ActiveSceneChanged(UnityEngine.SceneManagement.Scene,UnityEngine.SceneManagement.Scene)
extern "C" void SceneManager_Internal_ActiveSceneChanged_m1162592635 (Il2CppObject * __this /* static, unused */, Scene_t1684909666 ___previousActiveScene0, Scene_t1684909666 ___newActiveScene1, const MethodInfo* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (SceneManager_Internal_ActiveSceneChanged_m1162592635_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
UnityAction_2_t606618774 * L_0 = ((SceneManager_t90660965_StaticFields*)SceneManager_t90660965_il2cpp_TypeInfo_var->static_fields)->get_activeSceneChanged_2();
if (!L_0)
{
goto IL_0019;
}
}
{
UnityAction_2_t606618774 * L_1 = ((SceneManager_t90660965_StaticFields*)SceneManager_t90660965_il2cpp_TypeInfo_var->static_fields)->get_activeSceneChanged_2();
Scene_t1684909666 L_2 = ___previousActiveScene0;
Scene_t1684909666 L_3 = ___newActiveScene1;
UnityAction_2_Invoke_m670567184(L_1, L_2, L_3, /*hidden argument*/UnityAction_2_Invoke_m670567184_MethodInfo_var);
}
IL_0019:
{
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"peternickell@gmail.com"
] | peternickell@gmail.com |
5efee3ab4719979d4295b1b883763a7ba7c23ae7 | d43e1ec775f194c2dd6d45007c50ed999571bd5d | /Contests/ICPC/NEERC Southern Subregional/2014/E/election.cpp | 2489b340a74986c2524665b1cc7a859a2b3599cd | [] | no_license | marcoskwkm/code | 842fd498ec625b25f361b435f0bca843b8d81967 | 636866a7ee28f9f24da62c5dcf93dc1bce7a496e | refs/heads/master | 2022-10-28T16:40:50.710771 | 2022-09-24T20:10:59 | 2022-09-24T20:10:59 | 57,255,944 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,541 | cpp | #include <bits/stdc++.h>
using namespace std;
#define debug(args...) fprintf(stderr,args)
typedef long long lint;
typedef pair<int, int> pii;
typedef pair<lint, lint> pll;
typedef tuple<int, int, int> tiii;
const int INF = 0x3f3f3f3f;
const lint LINF = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = (int)2e5 + 10;
int m[MAXN], r[MAXN];
/* Data structure to represent a network flow graph */
struct FlowGraph {
struct Edge {
int v, cap;
Edge(int _v, int _cap) : v(_v), cap(_cap) {}
};
int V;
vector<Edge> edges;
vector<vector<int>> adj;
FlowGraph(int _V) : V(_V) { adj.resize(V); }
void add_edge(int u, int v, int cap) {
adj[u].push_back(edges.size());
edges.push_back(Edge(v, cap));
adj[v].push_back(edges.size());
edges.push_back(Edge(u, 0));
}
};
/*
Dinic maxflow algorithm - O(EV^2)
O(EV^(2/3)) for unit capacities
O(EV^(1/2)) for bipartite graphs
*/
struct Dinic {
vector<int> ptr, dist;
FlowGraph &g;
Dinic(FlowGraph &_g) : g(_g) {
ptr.resize(g.V);
dist.resize(g.V);
}
bool bfs(int s, int t) {
fill(dist.begin(), dist.end(), -1);
dist[s] = 0;
queue<int> q({s});
while (!q.empty()) {
int v = q.front();
if (dist[v] == dist[t]) break;
q.pop();
for (int i: g.adj[v]) {
int nxt = g.edges[i].v;
if (dist[nxt] == -1 && g.edges[i].cap) {
dist[nxt] = dist[v] + 1;
q.push(nxt);
}
}
}
return dist[t] != -1;
}
int dfs(int v, int t, int flow) {
if (v == t) return flow;
for (int &p = ptr[v]; p < (int)g.adj[v].size(); p++) {
int i = g.adj[v][p];
int nxt = g.edges[i].v;
if (dist[nxt] == dist[v] + 1 && g.edges[i].cap) {
int got = dfs(nxt, t, min(flow, g.edges[i].cap));
if (got) {
g.edges[i].cap -= got;
g.edges[i^1].cap += got;
return got;
}
}
}
return 0;
}
int max_flow(int s, int t) {
int ret = 0;
while (bfs(s, t)) {
fill(ptr.begin(), ptr.end(), 0);
while (int got = dfs(s, t, INF)) ret += got;
}
return ret;
}
};
int main() {
int n;
cin >> n;
int n_win = 0;
FlowGraph g(n + 2);
int s = n, t = n + 1;
for (int i = 0; i < n; i++) {
scanf("%d%d", &m[i], &r[i]);
if (m[i] > r[i]) n_win++;
if (i & 1) g.add_edge(i, t, 1);
else g.add_edge(s, i, 1);
}
for (int i = 0; i + 1 < n; i++) {
int u = i, v = i + 1;
if (m[u] - r[u] < m[v] - r[v]) swap(u, v);
if ((m[u] > r[u] && m[v] <= r[v] && m[u] + m[v] > r[u] + r[v]) ||
m[u] <= r[u]) {
if (i & 1) g.add_edge(i + 1, i, 1);
else g.add_edge(i, i + 1, 1);
}
}
int needs = max(0, n - (2 * n_win - 1));
Dinic mf(g);
int got = mf.max_flow(s, t);
if (got < needs) printf("-1\n");
else {
printf("%d\n", needs);
int cnt = 0;
for (int i = 0; i < n && cnt < needs; i += 2) {
for (int idx: g.adj[i]) {
if (g.edges[idx].cap == 0 && g.edges[idx].v != s) {
cnt++;
printf("%d %d\n", i + 1, g.edges[idx].v + 1);
}
}
}
}
return 0;
}
| [
"marcoskwkm@gmail.com"
] | marcoskwkm@gmail.com |
38b3e3c1f1c9163286f4ddae60470cd9535166b0 | 58a0ba5ee99ec7a0bba36748ba96a557eb798023 | /GeeksForGeeks/Practice/SecondLargest.cpp | 82a13c371e8d4dc56c7ae85f784f251e3e430826 | [
"MIT"
] | permissive | adityanjr/code-DS-ALGO | 5bdd503fb5f70d459c8e9b8e58690f9da159dd53 | 1c104c33d2f56fe671d586b702528a559925f875 | refs/heads/master | 2022-10-22T21:22:09.640237 | 2022-10-18T15:38:46 | 2022-10-18T15:38:46 | 217,567,198 | 40 | 54 | MIT | 2022-10-18T15:38:47 | 2019-10-25T15:50:28 | C++ | UTF-8 | C++ | false | false | 651 | cpp | #include <iostream>
#include <vector>
#include <queue>
using namespace std;
int main() {
//code
int test;
cin >> test;
while(test--){
int n;
cin >> n;
vector<int> temp(n);
for(int i = 0; i < n; i++){
cin >> temp[i];
}
priority_queue<int, vector<int>, greater<int> > q;
q.push(temp[0]);
q.push(temp[1]);
for(int i = 2; i < n; i++){
if(q.top() < temp[i]){
q.pop();
q.push(temp[i]);
}
}
cout << q.top() << endl;
}
return 0;
}
| [
"samant04aditya@gmail.com"
] | samant04aditya@gmail.com |
a7a5769f494767e982868beffb819ee89a9667a6 | 7a0227101077002f64bcacdd07666e073126ec34 | /dlgmsxml.cpp | 4721e0618b586be21bc2ce5644e4055b9c26292c | [] | no_license | andychen065/mfc-msxml | 3bd7b1f05732820af125c94ce91c5f8145025ccb | 4bb351d4b9ab6c85e69e6b78419ef20c9f2d1b18 | refs/heads/master | 2020-06-24T17:00:35.883254 | 2019-07-26T13:42:46 | 2019-07-26T13:42:46 | 199,023,413 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,017 | cpp | // dlgmsxml.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include "dlgmsxml.h"
#include "dlgmsxmlDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CDlgmsxmlApp
BEGIN_MESSAGE_MAP(CDlgmsxmlApp, CWinApp)
//{{AFX_MSG_MAP(CDlgmsxmlApp)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG
ON_COMMAND(ID_HELP, CWinApp::OnHelp)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CDlgmsxmlApp construction
CDlgmsxmlApp::CDlgmsxmlApp()
{
// TODO: add construction code here,
// Place all significant initialization in InitInstance
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CDlgmsxmlApp object
CDlgmsxmlApp theApp;
/////////////////////////////////////////////////////////////////////////////
// CDlgmsxmlApp initialization
BOOL CDlgmsxmlApp::InitInstance()
{
AfxEnableControlContainer();
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
CDlgmsxmlDlg dlg;
m_pMainWnd = &dlg;
int nResponse = dlg.DoModal();
if (nResponse == IDOK)
{
// TODO: Place code here to handle when the dialog is
// dismissed with OK
}
else if (nResponse == IDCANCEL)
{
// TODO: Place code here to handle when the dialog is
// dismissed with Cancel
}
// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}
| [
"12344276@qq.com"
] | 12344276@qq.com |
642eec40f3b729d3a682281f7c451c591f30b7d4 | c74e77aed37c97ad459a876720e4e2848bb75d60 | /800-899/844/(31267179)[OK]A[ b'Diversity' ].cpp | 5f4641f734fcf47cc51aaf66539005345c2c47e5 | [] | no_license | yashar-sb-sb/my-codeforces-submissions | aebecf4e906a955f066db43cb97b478d218a720e | a044fccb2e2b2411a4fbd40c3788df2487c5e747 | refs/heads/master | 2021-01-21T21:06:06.327357 | 2017-11-14T21:20:28 | 2017-11-14T21:28:39 | 98,517,002 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 438 | cpp | #include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef long double ldb;
typedef pair<int,int> pii;
int main()
{
ios_base::sync_with_stdio(0);cin.tie(0);
string s;
int k;
cin>>s>>k;
if(k > int(s.size()))
return cout<<"impossible"<<endl, 0;
set<char> se;
for(char c:s)
se.insert(c);
cout<<max(int(k-se.size()), 0)<<endl;
return 0;
}
| [
"yashar_sb_sb@yahoo.com"
] | yashar_sb_sb@yahoo.com |
b278b5afcbfbb2109c5faba567b5b046daf96a59 | 6af8134c657fc4b6fa542ef4cd84744328801be1 | /Path Tracer CUDA/Settings.h | d586a1f6c0c0aa18662c7b40e2a7a384def74aaa | [] | no_license | DharshanV/Path-Tracer-CUDA | c6f8d332cc512fc90545b41a4d9447109c40ffc4 | 73872cd89d55137d4d063943cf9a0d215998da51 | refs/heads/master | 2023-02-28T12:52:17.322885 | 2021-02-08T05:58:19 | 2021-02-08T05:58:19 | 334,610,501 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 471 | h | #pragma once
//Render properties
constexpr auto WIDTH = 500;
constexpr auto HEIGHT = 500;
constexpr auto SAMPLE_MIN = 1;
constexpr auto SAMPLE_MAX = 50;
constexpr auto MAX_DEPTH = 5;
constexpr auto QUASI_SAMPLE_N = 5;
constexpr auto EPSILON = 0.001f;
//Camera properties
constexpr auto PI = 3.14159265f;
constexpr auto YAW = -90.0f;
constexpr auto PITCH = 0.0f;
constexpr auto MOVEMENT_SPEED = 2.5f;
constexpr auto MOUSE_SENSITIVITY = 0.1f;
constexpr auto ZOOM = 45.0f; | [
"ddvyukjng7@gmail.com"
] | ddvyukjng7@gmail.com |
bb485304eb20d4bf2315e9469e8b086532ad2ef0 | 2a3eee409d57c7be5a30ca3184af485d63ce97ae | /SortedList.cpp | 5def3bf2593254038f898226214b9bb2e249d359 | [] | no_license | TylerMurray1/cpp-linked-list | 61da9c7d68b212fdddd5246c53883cdde0dfd0d2 | 394c14807249d22bcad99e8754b915c9ef8e6d16 | refs/heads/master | 2020-03-23T19:57:39.686373 | 2018-07-23T12:44:11 | 2018-07-23T12:44:11 | 142,012,648 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,496 | cpp | #include "SortedList.h"
#include <cstdlib>
#include <iostream>
#include <fstream>
using namespace std;
template<class ItemType>
SortedList<ItemType>::SortedList(){
listData = NULL;
length = 0;
}//SortedList
template<class ItemType>
SortedList<ItemType>::~SortedList(){
length = 0;
}//destructor
template<class ItemType>
bool SortedList<ItemType>::isEmpty() const{
if(length == 0){
return true;
}
else{
return false;
}
}//isEmpty
template<class ItemType>
int SortedList<ItemType>::getLength() const{
return length;
}//getLength
template<class ItemType>
void SortedList<ItemType>::insertItem(ItemType newItem){
NodeType<ItemType> * newNode; //pointer to inserted node
NodeType<ItemType> * predLoc; //follower pointer
NodeType<ItemType> * location; //traveling pointer
location = listData;
predLoc = NULL;
//Find insertion point
while(location != NULL){
if(newItem > location -> info){
predLoc = location;
location = location->next;
}
else if(newItem < location->info){
break;
}
}//while
//Prepare node for insersion
newNode = new NodeType<ItemType>;
newNode->info = newItem;
//insert node into list
if(predLoc == NULL){
newNode->next = listData;
listData = newNode;
}
else{
newNode->next = location;
predLoc->next = newNode;
}
length++;
}//insertItem
template<class ItemType>
void SortedList<ItemType>::deleteItem(ItemType item){
//findItem and then delete Item
NodeType<ItemType> * pred;
NodeType<ItemType> * temp;
temp = listData;
if(findItem(item, pred) && pred == NULL){
temp = listData;
listData = listData->next;
}
else{
temp = pred -> next;
pred->next = temp->next;
}
delete temp;
length--;
}//deleteItem
template<class ItemType>
ItemType SortedList<ItemType>::get(int index){
NodeType<ItemType> * temp;
int i = 1;
temp = listData;
while(temp != NULL){
if(i == index){
return temp->info;
}//if
temp = temp->next;
i++;
}//while
}//get
template<class ItemType>
void SortedList<ItemType>::makeEmpty(){
while(listData != NULL){
NodeType<ItemType> * temp;
temp = listData;
listData = listData->next;
delete temp;
}
length = 0;
}//makeEmpty
template<class ItemType>
void SortedList<ItemType>::printList(ofstream& file){
NodeType<ItemType> * temp;
temp = listData;
while(temp != NULL){
file << temp->info << " ";
temp = temp->next;
}//while
file << endl;
}//printList
template<class ItemType>
SortedList<ItemType> SortedList<ItemType>::merge(SortedList<ItemType> otherList){
NodeType<ItemType> * temp;
temp = otherList.listData;
while(temp != NULL){
insertItem(temp->info);
temp = temp->next;
}
}//merge
template<class ItemType>
bool SortedList<ItemType>::findItem(ItemType item, NodeType<ItemType> *&predecessor){
NodeType<ItemType> * temp;
bool flag = false;
temp = listData;
//special case for if Item is in spot 1
if(temp->info == item){
predecessor = NULL;
flag = true;
return flag;
}
//set predecessor to spot 1 and temp to spot 2
predecessor = listData;
temp = temp->next;
//go through until you find it incrementing temp and predecessor each iteration
while(temp != NULL){
if(temp->info == item){
flag == true;
break;
}
else{
predecessor = predecessor->next;
temp = temp->next;
}
}
return flag;
}//findItem
| [
"34780822+TylerMurray1@users.noreply.github.com"
] | 34780822+TylerMurray1@users.noreply.github.com |
06f0494ac69e4342026911f869f000305c8a9ac1 | 5179bb98f62a6017c0f4ad1cc483e9b3e0c3fa09 | /core/org/stand/SimpleScore.h | dc8bfbc8b0317a921c1916f8c4105c021ccc9725 | [
"BSD-3-Clause"
] | permissive | haruneko/SimpleSynthesizer | e27628030f6bb1e60f37c791c2ae1f996e7ed36d | 28d8d2c658e093a3f6f33fc67fe3b7e5ee009b6f | refs/heads/master | 2020-04-26T18:00:21.057429 | 2014-02-01T07:11:06 | 2014-02-01T07:11:06 | 16,381,561 | 12 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 552 | h | #ifndef SIMPLESCORE_H
#define SIMPLESCORE_H
#include <QFileInfo>
#include <QTextCodec>
#include "SimpleNote.h"
namespace org
{
namespace stand
{
typedef QList<SimpleNote> SimpleScore;
class SimpleScoreFactory
{
public:
explicit SimpleScoreFactory(QTextCodec *codec = QTextCodec::codecForName("Shift-JIS"));
virtual ~SimpleScoreFactory(){ }
virtual SimpleScore read(const QFileInfo &fileinfo) const;
virtual SimpleScore parse(const QList<QString> &lines) const;
private:
QTextCodec *textCodec;
};
}
}
#endif // SIMPLESCORE_H
| [
"harunyann@hotmail.com"
] | harunyann@hotmail.com |
0baad833e06ae2f42caab50ff053cf9f82115cfb | 6cbd3e19e12c131952827c1bc3257347cf5be41d | /PROVA/stack.cpp | 9444b8a1382a6ff80674da82c6b4d2c44232aaf5 | [] | no_license | regisfaria/POO_UFSC | 566daf0a5eaab18eb79b122949b17816aeeef7e4 | 132e2f8ac01e86cdf018a1031cc731563549cb7e | refs/heads/master | 2020-07-09T03:32:12.573239 | 2019-08-22T19:54:07 | 2019-08-22T19:54:07 | 203,863,218 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 352 | cpp | #include "stack.hpp"
Stack::Stack()
{
}
Stack::Stack(EstruturaDados *&a)
{
m_value = a->getValues();
}
Stack::~Stack()
{
}
void Stack::insert(int value)
{
m_value.push_back(value);
}
void Stack::remove()
{
m_value.pop_back();
}
void Stack::print()
{
for(int i=0; i<m_value.size(); i++)
{
cout << m_value.at(i) << " ";
}
cout << endl;
} | [
"rgisfaria@yahoo.com.br"
] | rgisfaria@yahoo.com.br |
8f251cfc0deae7b5e25f1665813b472cbf05e255 | 3c68fd5ad44942f647fc4c14c67f8cb8e84cfcc2 | /TestGenericCodec.cpp | f81ee28c28bcbc686856cc55a586d1d0f11595c2 | [] | no_license | dongfusong/TlvProject | f4734a30e0db57a175a6c3cd25a1ec97f7ec1c91 | 51cba3b67fb50201323cf2027250318eb57cdd56 | refs/heads/master | 2016-09-06T12:45:35.014408 | 2014-09-24T10:27:13 | 2014-09-24T10:27:13 | 27,031,295 | 0 | 1 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 843 | cpp | /*
* TestGenericCodec.cpp
*
* Created on: 2014Äê9ÔÂ24ÈÕ
* Author: Thoughtworks
*/
#include <gtest/gtest.h>
#include "codec.h"
class TestGenericCodec: public testing::Test {
public:
void SetUp() {
}
void TearDown() {
}
protected:
};
TEST_F(TestGenericCodec, can_decode_ul)
{
_UC buf[] = {0x12,0x34,0x56,0x78};
Buffer bufObj(buf, sizeof(buf));
GenericCodec<_UL> codec;
_UL value = 0;
codec.decode(bufObj, (_UC*)&value);
EXPECT_EQ(0x12345678, value);
}
TEST_F(TestGenericCodec, test_offsetCodec){
struct MyStruct{
_UC index;
_UL value;
};
_UC buf[] = {
0x12,0x34,0x56,0x78//_UL
};
Buffer bufObj(buf, sizeof(buf));
MyStruct structVal;
OffsetCodec<_UL, GenericCodec<_UL>, offsetof(MyStruct, value) > codec;
codec.decode(bufObj, (_UC*)&structVal);
EXPECT_EQ(0x12345678, structVal.value);
}
| [
"dongfusong@126.com"
] | dongfusong@126.com |
9ab4f370089320c00e88fd595494a5cc214d8ab2 | 229116ff4296a824f50c40f222d953c4148c8024 | /PCViewer/Tests/KinectViewer.cpp | 2ae5c4f023adc6217c3c59c694c3c30f0a19b079 | [] | no_license | xijunke/VisualInertialKinectFusion | 51e22f234963b7343bdd8cfb98fe88ed3c39599b | 610910dca00e9ffe6b0844411f9479d2a15a4b1b | refs/heads/master | 2021-10-09T10:35:13.905499 | 2018-12-26T11:10:30 | 2018-12-26T11:10:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,586 | cpp | #include "KinectViewer.h"
#include "ui_KinectViewer.h"
KinectViewer::KinectViewer (QWidget *parent) : QMainWindow (parent), ui (new Ui::KinectViewer)
{
ui->setupUi (this);
this->setWindowTitle ("Kinect viewer");
/* QString defaultSavingPath = QString("%1/PointClouds/%2-AcqKinFu/")
.arg(QDir::homePath())
.arg(QDate::currentDate().toString("yyyy-MM-dd"));
*/
//ui->lineEdit_savingPath->setText(defaultSavingPath);
/*if (!QDir(defaultSavingPath).exists())
QDir().mkdir(defaultSavingPath);
*/
KinectCloud.reset(new pcl::PointCloud<pcl::PointXYZRGBA>);
// Timer for 3D/UI update
tmrTimer = new QTimer(this);
connect(tmrTimer,SIGNAL(timeout()),this,SLOT(processFrameAndUpdateGUI()));
tmrTimer->start(10); // msec
KinFreqTimer = new QTimer(this);
connect(KinFreqTimer,SIGNAL(timeout()),this,SLOT(restartKinFreqCounter()));
KinFreqTimer->start(1000); // msec
KinFreqCounter = 0;
WinFreqTimer = new QTimer(this);
connect(WinFreqTimer,SIGNAL(timeout()),this,SLOT(restartWinFreqCounter()));
WinFreqTimer->start(1000); // msec
WinFreqCounter = 0;
// Setup Kinect
// bRun = false;
interface = NULL;
// Run Kinect grabber
run();
// Set up the QVTK window
viewer.reset (new pcl::visualization::PCLVisualizer ("viewer", false));
ui->qvtkWidget->SetRenderWindow (viewer->getRenderWindow ());
viewer->setupInteractor (ui->qvtkWidget->GetInteractor (), ui->qvtkWidget->GetRenderWindow ());
viewer->addCoordinateSystem(1.0, "Main Corrodinate System");
ui->qvtkWidget->update ();
viewer->addText ("window frequency is " + std::to_string(WinFreqCounter) + "Hz", 2, 30, 15, 34, 135, 246, "WinFreqCounter");
viewer->addText ("call back frequency is " + std::to_string(KinFreqCounter) + "Hz", 2, 15, 15, 34, 135, 246, "KinFreqCounter");
// Show stream
// StopStream = false;
}
void KinectViewer::processFrameAndUpdateGUI()
{
QMutexLocker locker(&mex);
if(/*bCopying == false &&*/ ui->checkBox_startStream->isChecked())
{
// Add point cloud on first call
if(!viewer->contains("cloud"))
{
viewer->addPointCloud(KinectCloud,"cloud");
viewer->resetCamera();
}
// Update point cloud
else
{
viewer->updatePointCloud (KinectCloud,"cloud");
viewer->updatePointCloudPose("cloud", Eigen::Affine3f(KinectCloud->sensor_orientation_));
}
ui->qvtkWidget->update ();
WinFreqCounter++;
}
}
KinectViewer::~KinectViewer ()
{
stop();
myAda.close();
delete ui;
}
void KinectViewer::on_checkBox_startStream_clicked(bool checked)
{
//checkBox_startStream
}
void KinectViewer::on_checkBox_savePointCloud_clicked(bool checked)
{
if (checked)
{
qDebug() << "Starting to Save PC " ;
}
else
{
// QMutexLocker locker(&mex);
qDebug() << "saving is still checked? (should NOT be, ie [false]) : " << ui->checkBox_savePointCloud->isChecked();
qDebug() << "Can now save " << PCtoSave.length() << " PCs :";
// PCtoSave.clear();
}
}
void KinectViewer::on_btnResetCamera_clicked()
{
viewer->resetCamera();
ui->qvtkWidget->update();
}
void KinectViewer::restartKinFreqCounter()
{
viewer->updateText("call back frequency is " + std::to_string(KinFreqCounter) + "Hz", 2, 15, 15, 34, 135, 246, "KinFreqCounter");
// std::cout << "call back frequency is " << KinFreqCounter << "Hz"<< std::endl;
KinFreqCounter = 0;
}
void KinectViewer::restartWinFreqCounter()
{
viewer->updateText ("window frequency is " + std::to_string(WinFreqCounter) + "Hz", 2, 30, 15, 34, 135, 246, "WinFreqCounter");
// std::cout << "window frequency is " << WinFreqCounter << "Hz" << std::endl;
WinFreqCounter = 0;
}
// Point cloud callback
void KinectViewer::cloud_cb_ (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud)
{
// QTime t;
// t.start();
QMutexLocker locker(&mex);
//bCopying = true;
KinFreqCounter++;
pcl::copyPointCloud(*cloud, *KinectCloud);
// KinectCloud = cloud;
// bCopying = false;
//std::cout << t.elapsed() << std::endl;
if (ui->checkBox_includeOrientation->isChecked())
KinectCloud->sensor_orientation_ = myAda.returnPose();
KinectCloud->header.frame_id = QDateTime::currentDateTime().toString("yyyy-MM-dd-HH-mm-ss-zzz").toStdString();
// bool binary = true;
// qDebug() << QString::fromStdString(KinectCloud->header.frame_id);
if (ui->checkBox_savePointCloud->isChecked())
{
pcl::PointCloud<pcl::PointXYZRGBA>::Ptr newPCtoSave(new pcl::PointCloud<pcl::PointXYZRGBA>);
pcl::copyPointCloud(*KinectCloud, *newPCtoSave);
PCtoSave.append(newPCtoSave);
}
// pcl::io::savePCDFile(KinectCloud->header.frame_id, *KinectCloud, binary);
}
// Run Kinect
int KinectViewer::run() {
if (interface != NULL)
if (interface->isRunning() == true)
return -1;
interface = new pcl::OpenNIGrabber("",pcl::OpenNIGrabber::Mode::OpenNI_VGA_30Hz, pcl::OpenNIGrabber::Mode::OpenNI_VGA_30Hz);
boost::function<void (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr&)> f = boost::bind (&KinectViewer::cloud_cb_, this, _1);
interface->registerCallback(f);
// Start interface
interface->start();
// Running
// bRun = true;
return 0;
}
// Stop Kinect
int KinectViewer::stop() {
if(interface->isRunning() == false)
return -1;
// Not running
// bRun = false;
// Stop interface
interface->stop();
return 0;
}
void KinectViewer::on_checkBox_includeOrientation_clicked(bool checked)
{
if (checked)
{
stop();
if (myAda.open() == SUCCESS)
myAda.init();
myAda.setPlayMode(false);
run();
}
else
{
myAda.close();
}
}
void KinectViewer::on_pushButton_save_clicked()
{
QString fulldir = QString("%1/PointClouds/%2-AcqKinFu")
.arg(QDir::homePath())
.arg(QDateTime::currentDateTime().toString("yyyy-MM-dd-HH-mm"));
if (!QDir(fulldir).exists())
QDir().mkdir(fulldir);
foreach (pcl::PointCloud<pcl::PointXYZRGBA>::Ptr PC, PCtoSave)
{
bool binary = true;
QString fullpath = QString("%1/%2.pcd").arg(fulldir)
.arg(QString::fromStdString(PC->header.frame_id));
qDebug() << fullpath;
pcl::io::savePCDFile(fullpath.toStdString(), *PC, binary);
}
}
| [
"silvio.giancola@gmail.com"
] | silvio.giancola@gmail.com |
f4a9bd70c551126b1f11ee16acf7999075535b1f | 811e05b62feb742571f5c1d5c7f6b57bf6e6a922 | /teste/teste.ino | 3b367e849430788a5af47fb9963c6ba6669118dc | [] | no_license | HenriqueRamalho/tutoriais-robocore | e35b0ce3dce664987f0c25ee7e7b5d911888e1f3 | 30982d7485b0fea1d26156a63556a158639de0f3 | refs/heads/master | 2020-04-27T03:50:33.850674 | 2019-03-06T00:38:07 | 2019-03-06T00:38:07 | 174,036,539 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 231 | ino | void setup() {
// put your setup code here, to run once:
pinMode(10, OUTPUT);
}
void loop() {
// put your main code here, to run repeatedly:
digitalWrite(10, HIGH);
delay(250);
digitalWrite(10, LOW);
delay(250);
}
| [
"hrd.ramalho@gmail.com"
] | hrd.ramalho@gmail.com |
a5f2eeced2909892de73f5a12413d41cd41fac99 | 45dfd61ae02c0e6a7b0bed2eb23230f0d7b10689 | /Student details struct.cpp | c72ab3233827464f57e882734612c00e3d056937 | [] | no_license | jayesh-685/ComputerLab | 35c79950552bbe853727bd57fa0a9a7a40ebd49d | 472f8cb3625cf35d9d6d6b21b6f1b6861a9d7861 | refs/heads/main | 2023-03-20T15:43:27.576911 | 2021-03-08T04:05:28 | 2021-03-08T04:05:28 | 345,526,122 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 764 | cpp | #include <iostream>
using namespace std;
struct Student {
char name[50];
int rollNo;
int marks;
void setStudentData();
void getStudentData();
};
void Student::setStudentData() {
cout << "Enter name: ";
cin >> name;
cout << "Enter roll number: ";
cin >> rollNo;
cout << "Enter marks: ";
cin >> marks;
}
void Student::getStudentData() {
cout << name << endl << rollNo << endl << marks << endl;
}
int main () {
Student studentsArr[3];
for (int i=0; i<3; i++) {
cout << "Enter details of student " << i+1 << endl;
studentsArr[i].setStudentData();
}
cout << "\n\n";
for (int i=0; i<3; i++) {
cout << "Details of student " << i+1 << " are:\n";
studentsArr[i].getStudentData();
}
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
f1e12727aee2769b7c7de510436cff7600578cc0 | 771a4e3846212eabbabf6b68bf73d4a326d0973e | /src/internal.h | 81634eb6a23de2182682ef147218e2c79af9bca3 | [] | no_license | ganboing/crt.vc12 | 4e65b96bb5bd6c5b5be6a08d04c9b712b269461f | f1d47126bf13d1c9dccaa6c53b72217fd0474968 | refs/heads/master | 2021-01-13T08:48:12.365115 | 2016-09-24T20:16:46 | 2016-09-24T20:16:46 | 69,113,159 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 45,476 | h | /***
*internal.h - contains declarations of internal routines and variables
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*
*Purpose:
* Declares routines and variables used internally by the C run-time.
*
* [Internal]
*
****/
#pragma once
#ifndef _INC_INTERNAL
#define _INC_INTERNAL
#include <crtdefs.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#include <cruntime.h>
#include <limits.h>
/*
* Conditionally include windows.h to pick up the definition of
* CRITICAL_SECTION.
*/
#include <windows.h>
#include <mtdll.h>
#pragma pack(push,_CRT_PACKING)
/* Define function types used in several startup sources */
typedef void (__cdecl *_PVFV)(void);
typedef int (__cdecl *_PIFV)(void);
typedef void (__cdecl *_PVFI)(int);
#if defined (_M_CEE)
typedef const void* (__clrcall *_PVFVM)(void);
typedef int (__clrcall *_PIFVM)(void);
typedef void (__clrcall *_CPVFV)(void);
#endif /* defined (_M_CEE) */
#if defined (_M_CEE_PURE) || (defined (_DLL) && defined (_M_IX86))
/* Retained for compatibility with VC++ 5.0 and earlier versions */
_CRTIMP int * __cdecl __p__commode(void);
#endif /* defined (_M_CEE_PURE) || (defined (_DLL) && defined (_M_IX86)) */
#if defined (SPECIAL_CRTEXE) && defined (_DLL)
extern int _commode;
#else /* defined (SPECIAL_CRTEXE) && defined (_DLL) */
#ifndef _M_CEE_PURE
_CRTIMP extern int _commode;
#else /* _M_CEE_PURE */
#define _commode (*__p___commode())
#endif /* _M_CEE_PURE */
#endif /* defined (SPECIAL_CRTEXE) && defined (_DLL) */
#define __IOINFO_TM_ANSI 0 /* Regular Text */
#define __IOINFO_TM_UTF8 1 /* UTF8 Encoded */
#define __IOINFO_TM_UTF16LE 2 /* UTF16 Little Endian Encoded */
#define LF 10 /* line feed */
#define CR 13 /* carriage return */
#define CTRLZ 26 /* ctrl-z means eof for text */
extern char _lookuptrailbytes[256];
/* Most significant Bit */
#define _msbit(c) ((c) & 0x80)
/* Independent byte has most significant bit set to 0 */
#define _utf8_is_independent(c) (_msbit(c) == 0)
/* Any leadbyte will have the patterns 11000xxx 11100xxx or 11110xxx */
#define _utf8_is_leadbyte(c) (_lookuptrailbytes[(unsigned char)c] != 0)
/* Get no of trailing bytes from the lookup table */
#define _utf8_no_of_trailbytes(c) _lookuptrailbytes[(unsigned char)c]
/*
* Control structure for lowio file handles
*/
typedef struct {
intptr_t osfhnd; /* underlying OS file HANDLE */
char osfile; /* attributes of file (e.g., open in text mode?) */
char pipech; /* one char buffer for handles opened on pipes */
int lockinitflag;
CRITICAL_SECTION lock;
#ifndef _SAFECRT_IMPL
/* Not used in the safecrt downlevel. We do not define them, so we cannot use them accidentally */
char textmode : 7; /* __IOINFO_TM_ANSI or __IOINFO_TM_UTF8 or __IOINFO_TM_UTF16LE */
char unicode : 1; /* Was the file opened as unicode? */
char pipech2[2]; /* 2 more peak ahead chars for UNICODE mode */
__int64 startpos; /* File position that matches buffer start */
BOOL utf8translations; /* Buffer contains translations other than CRLF*/
char dbcsBuffer; /* Buffer for the lead byte of dbcs when converting from dbcs to unicode */
BOOL dbcsBufferUsed; /* Bool for the lead byte buffer is used or not */
#endif /* _SAFECRT_IMPL */
} ioinfo;
/*
* Definition of IOINFO_L2E, the log base 2 of the number of elements in each
* array of ioinfo structs.
*/
#define IOINFO_L2E 5
/*
* Definition of IOINFO_ARRAY_ELTS, the number of elements in ioinfo array
*/
#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)
/*
* Definition of IOINFO_ARRAYS, maximum number of supported ioinfo arrays.
*/
#define IOINFO_ARRAYS 64
#define _NHANDLE_ (IOINFO_ARRAYS * IOINFO_ARRAY_ELTS)
#define _TZ_STRINGS_SIZE 64
#define STDIO_HANDLES_COUNT 3
/*
* Access macros for getting at an ioinfo struct and its fields from a
* file handle
*/
#define _pioinfo(i) ( __pioinfo[(i) >> IOINFO_L2E] + ((i) & (IOINFO_ARRAY_ELTS - 1)) )
#define _osfhnd(i) ( _pioinfo(i)->osfhnd )
#define _osfile(i) ( _pioinfo(i)->osfile )
#define _pipech(i) ( _pioinfo(i)->pipech )
#define _pipech2(i) ( _pioinfo(i)->pipech2 )
#define _textmode(i) ( _pioinfo(i)->textmode )
#define _tm_unicode(i) ( _pioinfo(i)->unicode )
#define _startpos(i) ( _pioinfo(i)->startpos )
#define _utf8translations(i) ( _pioinfo(i)->utf8translations )
#define _dbcsBuffer(i) ( _pioinfo(i)->dbcsBuffer )
#define _dbcsBufferUsed(i) ( _pioinfo(i)->dbcsBufferUsed )
/*
* Safer versions of the above macros. Currently, only _osfile_safe is
* used.
*/
#define _pioinfo_safe(i) ( (((i) != -1) && ((i) != -2)) ? _pioinfo(i) : &__badioinfo )
#define _osfhnd_safe(i) ( _pioinfo_safe(i)->osfhnd )
#define _osfile_safe(i) ( _pioinfo_safe(i)->osfile )
#define _pipech_safe(i) ( _pioinfo_safe(i)->pipech )
#define _pipech2_safe(i) ( _pioinfo_safe(i)->pipech2 )
#ifdef _SAFECRT_IMPL
/* safecrt does not have support for textmode, so we always return __IOINFO_TM_ANSI */
#define _textmode_safe(i) __IOINFO_TM_ANSI
#define _tm_unicode_safe(i) 0
#define _startpos_safe(i) ( 0 )
#define _utf8translations_safe(i) ( FALSE )
#else /* _SAFECRT_IMPL */
#define _textmode_safe(i) ( _pioinfo_safe(i)->textmode )
#define _tm_unicode_safe(i) ( _pioinfo_safe(i)->unicode )
#define _startpos_safe(i) ( _pioinfo_safe(i)->startpos )
#define _utf8translations_safe(i) ( _pioinfo_safe(i)->utf8translations )
#endif /* _SAFECRT_IMPL */
#ifndef _M_CEE_PURE
#ifdef _SAFECRT_IMPL
/* We need to get this from the downlevel DLL, even when we build safecrt.lib */
extern __declspec(dllimport) ioinfo __badioinfo;
extern __declspec(dllimport) ioinfo * __pioinfo[];
#else /* _SAFECRT_IMPL */
/*
* Special, static ioinfo structure used only for more graceful handling
* of a C file handle value of -1 (results from common errors at the stdio
* level).
*/
extern _CRTIMP ioinfo __badioinfo;
/*
* Array of arrays of control structures for lowio files.
*/
extern _CRTIMP ioinfo * __pioinfo[];
#endif /* _SAFECRT_IMPL */
#endif /* _M_CEE_PURE */
/*
* Current number of allocated ioinfo structures (_NHANDLE_ is the upper
* limit).
*/
extern int _nhandle;
int __cdecl _alloc_osfhnd(void);
int __cdecl _free_osfhnd(int);
int __cdecl _set_osfhnd(int, intptr_t);
/*
fileno for stdout, stdin & stderr when there is no console
*/
#define _NO_CONSOLE_FILENO (intptr_t)-2
extern const char __dnames[];
extern const char __mnames[];
extern int _days[];
extern int _lpdays[];
extern __time32_t __cdecl __loctotime32_t(int, int, int, int, int, int, int);
extern __time64_t __cdecl __loctotime64_t(int, int, int, int, int, int, int);
#ifdef _TM_DEFINED
extern int __cdecl _isindst(_In_ struct tm * _Time);
#endif /* _TM_DEFINED */
extern void __cdecl __tzset(void);
extern int __cdecl _validdrive(unsigned);
/*
* If we are only interested in years between 1901 and 2099, we could use this:
*
* #define IS_LEAP_YEAR(y) (y % 4 == 0)
*/
#define IS_LEAP_YEAR(y) (((y) % 4 == 0 && (y) % 100 != 0) || (y) % 400 == 0)
/*
* get the buffer used by gmtime
*/
struct tm * __cdecl __getgmtimebuf ();
/*
* This variable is in the C start-up; the length must be kept synchronized
* It is used by the *cenvarg.c modules
*/
extern char _acfinfo[]; /* "_C_FILE_INFO=" */
#define CFI_LENGTH 12 /* "_C_FILE_INFO" is 12 bytes long */
/*
* latest instruction set available for use
*/
#include <isa_availability.h>
extern int __isa_available;
#if defined (_M_IX86) || defined (_M_X64)
extern int __isa_enabled;
extern int __favor;
#endif /* defined (_M_IX86) || defined (_M_X64) */
/*
* stdio internals
*/
#ifndef _FILE_DEFINED
struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;
};
typedef struct _iobuf FILE;
#define _FILE_DEFINED
#endif /* _FILE_DEFINED */
#if !defined (_FILEX_DEFINED) && defined (_WINDOWS_)
/*
* Variation of FILE type used for the dynamically allocated portion of
* __piob[]. For single thread, _FILEX is the same as FILE. For multithread
* models, _FILEX has two fields: the FILE struct and the CRITICAL_SECTION
* struct used to serialize access to the FILE.
*/
typedef struct {
FILE f;
CRITICAL_SECTION lock;
} _FILEX;
#define _FILEX_DEFINED
#endif /* !defined (_FILEX_DEFINED) && defined (_WINDOWS_) */
/*
* Number of entries supported in the array pointed to by __piob[]. That is,
* the number of stdio-level files which may be open simultaneously. This
* is normally set to _NSTREAM_ by the stdio initialization code.
*/
extern int _nstream;
/*
* Pointer to the array of pointers to FILE/_FILEX structures that are used
* to manage stdio-level files.
*/
extern void **__piob;
FILE * __cdecl _getstream(void);
FILE * __cdecl _openfile(_In_z_ const char * _Filename, _In_z_ const char * _Mode, _In_ int _ShFlag, _Out_ FILE * _File);
FILE * __cdecl _wopenfile(_In_z_ const wchar_t * _Filename, _In_z_ const wchar_t * _Mode, _In_ int _ShFlag, _Out_ FILE * _File);
void __cdecl _getbuf(_Out_ FILE * _File);
int __cdecl _filwbuf (_Inout_ FILE * _File);
int __cdecl _flswbuf(_In_ int _Ch, _Inout_ FILE * _File);
void __cdecl _freebuf(_Inout_ FILE * _File);
int __cdecl _stbuf(_Inout_ FILE * _File);
void __cdecl _ftbuf(int _Flag, _Inout_ FILE * _File);
#ifdef _SAFECRT_IMPL
int __cdecl _output(_Inout_ FILE * _File, _In_z_ _Printf_format_string_ const char *_Format, va_list _ArgList);
int __cdecl _woutput(_Inout_ FILE * _File, _In_z_ _Printf_format_string_ const wchar_t *_Format, va_list _ArgList);
int __cdecl _output_s(_Inout_ FILE * _File, _In_z_ _Printf_format_string_ const char *_Format, va_list _ArgList);
int __cdecl _output_p(_Inout_ FILE * _File, _In_z_ _Printf_format_string_ const char *_Format, va_list _ArgList);
int __cdecl _woutput_s(_Inout_ FILE * _File, _In_z_ _Printf_format_string_ const wchar_t *_Format, va_list _ArgList);
int __cdecl _woutput_p(_Inout_ FILE * _File, _In_z_ _Printf_format_string_ const wchar_t *_Format, va_list _ArgList);
typedef int (*OUTPUTFN)(FILE *, const char *, va_list);
typedef int (*WOUTPUTFN)(FILE *, const wchar_t *, va_list);
#else /* _SAFECRT_IMPL */
int __cdecl _output_l(_Inout_ FILE * _File, _In_z_ _Printf_format_string_params_(2) const char *_Format, _In_opt_ _locale_t _Locale, va_list _ArgList);
int __cdecl _woutput_l(_Inout_ FILE * _File, _In_z_ _Printf_format_string_params_(2) const wchar_t *_Format, _In_opt_ _locale_t _Locale, va_list _ArgList);
int __cdecl _output_s_l(_Inout_ FILE * _File, _In_z_ _Printf_format_string_params_(2) const char *_Format, _In_opt_ _locale_t _Locale, va_list _ArgList);
int __cdecl _output_p_l(_Inout_ FILE * _File, _In_z_ _Printf_format_string_params_(2) const char *_Format, _In_opt_ _locale_t _Locale, va_list _ArgList);
int __cdecl _woutput_s_l(_Inout_ FILE * _File, _In_z_ _Printf_format_string_params_(2) const wchar_t *_Format, _In_opt_ _locale_t _Locale, va_list _ArgList);
int __cdecl _woutput_p_l(_Inout_ FILE * _File, _In_z_ _Printf_format_string_params_(2) const wchar_t *_Format, _In_opt_ _locale_t _Locale, va_list _ArgList);
typedef int (*OUTPUTFN)(_Inout_ FILE * _File, const char *, _locale_t, va_list);
typedef int (*WOUTPUTFN)(_Inout_ FILE * _File, const wchar_t *, _locale_t, va_list);
#endif /* _SAFECRT_IMPL */
#ifdef _SAFECRT_IMPL
int __cdecl _input(_In_ FILE * _File, _In_z_ _Scanf_format_string_ const unsigned char * _Format, va_list _ArgList);
int __cdecl _winput(_In_ FILE * _File, _In_z_ _Scanf_format_string_ const wchar_t * _Format, va_list _ArgList);
int __cdecl _input_s(_In_ FILE * _File, _In_z_ _Scanf_s_format_string_ const unsigned char * _Format, va_list _ArgList);
int __cdecl _winput_s(_In_ FILE * _File, _In_z_ _Scanf_s_format_string_ const wchar_t * _Format, va_list _ArgList);
typedef int (*INPUTFN)(FILE *, const unsigned char *, va_list);
typedef int (*WINPUTFN)(FILE *, const wchar_t *, va_list);
#else /* _SAFECRT_IMPL */
int __cdecl _input_l(_Inout_ FILE * _File, _In_z_ _Scanf_format_string_params_(2) const unsigned char *, _In_opt_ _locale_t _Locale, va_list _ArgList);
int __cdecl _winput_l(_Inout_ FILE * _File, _In_z_ _Scanf_format_string_params_(2) const wchar_t *, _In_opt_ _locale_t _Locale, va_list _ArgList);
int __cdecl _input_s_l(_Inout_ FILE * _File, _In_z_ _Scanf_s_format_string_params_(2) const unsigned char *, _In_opt_ _locale_t _Locale, va_list _ArgList);
int __cdecl _winput_s_l(_Inout_ FILE * _File, _In_z_ _Scanf_s_format_string_params_(2) const wchar_t *, _In_opt_ _locale_t _Locale, va_list _ArgList);
typedef int (*INPUTFN)(FILE *, const unsigned char *, _locale_t, va_list);
typedef int (*WINPUTFN)(FILE *, const wchar_t *, _locale_t, va_list);
#ifdef _UNICODE
#define TINPUTFN WINPUTFN
#else /* _UNICODE */
#define TINPUTFN INPUTFN
#endif /* _UNICODE */
#endif /* _SAFECRT_IMPL */
int __cdecl _flush(_Inout_ FILE * _File);
void __cdecl _endstdio(void);
errno_t __cdecl _sopen_helper(_In_z_ const char * _Filename,
_In_ int _OFlag, _In_ int _ShFlag, _In_ int _PMode,
_Out_ int * _PFileHandle, int _BSecure);
errno_t __cdecl _wsopen_helper(_In_z_ const wchar_t * _Filename,
_In_ int _OFlag, _In_ int _ShFlag, _In_ int _PMode,
_Out_ int * _PFileHandle, int _BSecure);
errno_t __cdecl _sopen_nolock (_Out_ int * UnlockFlag,
_Out_ int * _FileHandle, _In_z_ const char * _Filename,
_In_ int _OpenFlag, _In_ int _ShareFlag,
_In_ int _PermissionFlag, _In_ int _SecureFlag);
errno_t __cdecl _wsopen_nolock (_Out_ int * UnlockFlag,
_Out_ int * _FileHandle, _In_z_ const wchar_t * _Filename,
_In_ int _OpenFlag, _In_ int _ShareFlag,
_In_ int _PermissionFlag, _In_ int _SecureFlag);
#ifndef CRTDLL
extern int _cflush;
#endif /* CRTDLL */
extern unsigned int _tempoff;
extern unsigned int _old_pfxlen;
extern int _umaskval; /* the umask value */
extern char _pipech[]; /* pipe lookahead */
extern char _exitflag; /* callable termination flag */
extern int _C_Termination_Done; /* termination done flag */
char * __cdecl _getpath(_In_z_ const char * _Src, _Out_writes_z_(_SizeInChars) char * _Dst, _In_ size_t _SizeInChars);
wchar_t * __cdecl _wgetpath(_In_z_ const wchar_t * _Src, _Out_writes_z_(_SizeInWords) wchar_t * _Dst, _In_ size_t _SizeInWords);
extern int _dowildcard; /* flag to enable argv[] wildcard expansion */
#ifndef _PNH_DEFINED
typedef int (__cdecl * _PNH)( size_t );
#define _PNH_DEFINED
#endif /* _PNH_DEFINED */
#if defined (_M_CEE)
#ifndef __MPNH_DEFINED
typedef int (__clrcall * __MPNH)( size_t );
#define __MPNH_DEFINED
#endif /* __MPNH_DEFINED */
#endif /* defined (_M_CEE) */
/* calls the currently installed new handler */
int __cdecl _callnewh(_In_ size_t _Size);
extern int _newmode; /* malloc new() handler mode */
/* pointer to initial environment block that is passed to [w]main */
#ifndef _M_CEE_PURE
extern _CRTIMP wchar_t **__winitenv;
extern _CRTIMP char **__initenv;
#endif /* _M_CEE_PURE */
/* _calloca helper */
#define _calloca(count, size) ((count<=0 || size<=0 || ((((size_t)_HEAP_MAXREQ) / ((size_t)count)) < ((size_t)size)))? NULL : _malloca(count * size))
/* startup set values */
extern char *_aenvptr; /* environment ptr */
extern wchar_t *_wenvptr; /* wide environment ptr */
/* command line */
#if defined (_DLL)
_CRTIMP char ** __cdecl __p__acmdln(void);
_CRTIMP wchar_t ** __cdecl __p__wcmdln(void);
#endif /* defined (_DLL) */
#ifndef _M_CEE_PURE
_CRTIMP extern char *_acmdln;
_CRTIMP extern wchar_t *_wcmdln;
#else /* _M_CEE_PURE */
#define _acmdln (*__p__acmdln())
#define _wcmdln (*__p__wcmdln())
#endif /* _M_CEE_PURE */
/*
* prototypes for internal startup functions
*/
int __cdecl _cwild(void); /* wild.c */
int __cdecl _wcwild(void); /* wwild.c */
int __cdecl _mtinit(void); /* tidtable.c */
void __cdecl _mtterm(void); /* tidtable.c */
int __cdecl _mtinitlocks(void); /* mlock.c */
void __cdecl _mtdeletelocks(void); /* mlock.c */
int __cdecl _mtinitlocknum(_In_ int); /* mlock.c */
#define _CRT_SPINCOUNT 4000
/*
* C source build only!!!!
*
* more prototypes for internal startup functions
*/
void __cdecl _amsg_exit(int); /* crt0.c */
void __cdecl __crtExitProcess(int); /* crt0dat.c */
void __cdecl __crtCorExitProcess(int); /* crt0dat.c */
void __cdecl __crtdll_callstaticterminators(void); /* crt0dat.c */
#ifdef _CRT_APP
_CRTIMP void __cdecl _exit_app(void); /* crt0dat.c */
#endif /* _CRT_APP */
/*
_cinit now allows the caller to suppress floating point precision init
This allows the DLLs that use the CRT to not initialise FP precision,
allowing the EXE's setting to persist even when a DLL is loaded
*/
int __cdecl _cinit(int /* initFloatingPrecision */); /* crt0dat.c */
void __cdecl __doinits(void); /* astart.asm */
void __cdecl __doterms(void); /* astart.asm */
void __cdecl __dopreterms(void); /* astart.asm */
void __cdecl _fpmath(int /*initPrecision*/);
void __cdecl _fptrap(void); /* crt0fp.c */
void __cdecl __freeCrtMemory(); /* crt0dat.c */
int __cdecl _heap_init(void);
void __cdecl _heap_term(void);
void __cdecl _heap_abort(void);
void __cdecl __initconin(void); /* initcon.c */
void __cdecl __initconout(void); /* initcon.c */
int __cdecl _ioinit(void); /* crt0.c, crtlib.c */
void __cdecl _ioterm(void); /* crt0.c, crtlib.c */
const wchar_t * __cdecl _GET_RTERRMSG(int);
int __CRTDECL _setargv(void); /* setargv.c, stdargv.c */
int __CRTDECL __setargv(void); /* stdargv.c */
int __CRTDECL _wsetargv(void); /* wsetargv.c, wstdargv.c */
int __CRTDECL __wsetargv(void); /* wstdargv.c */
int __cdecl _setenvp(void); /* stdenvp.c */
int __cdecl _wsetenvp(void); /* wstdenvp.c */
void __cdecl __setmbctable(unsigned int); /* mbctype.c */
#if !defined (_CRT_APP) || defined (_KERNELX) || defined (_DEBUG)
void __cdecl _FF_MSGBANNER(void);
void __cdecl _NMSG_WRITE(int);
#endif /* !defined (_CRT_APP) || defined (_DEBUG) */
#ifdef _MBCS
int __cdecl __initmbctable(void); /* mbctype.c */
#endif /* _MBCS */
#ifndef _MANAGED_MAIN
int __CRTDECL main(_In_ int _Argc, _In_reads_(_Argc) _Pre_z_ char ** _Argv, _In_z_ char ** _Env);
int __CRTDECL wmain(_In_ int _Argc, _In_reads_(_Argc) _Pre_z_ wchar_t ** _Argv, _In_z_ wchar_t ** _Env);
#endif /* _MANAGED_MAIN */
/* helper functions for wide/multibyte environment conversion */
int __cdecl __mbtow_environ (void);
int __cdecl __wtomb_environ (void);
/* These two functions take a char ** for the environment option
At some point during their execution, they take ownership of the
memory block passed in using option. At this point, they
NULL out the incoming char * / wchar_t * to ensure there is no
double-free
*/
int __cdecl __crtsetenv (_Inout_ _Deref_prepost_opt_valid_ char ** _POption, _In_ const int _Primary);
int __cdecl __crtwsetenv (_Inout_ _Deref_prepost_opt_valid_ wchar_t ** _POption, _In_ const int _Primary);
#if defined (_DLL) || defined (CRTDLL)
#ifndef _STARTUP_INFO_DEFINED
typedef struct
{
int newmode;
} _startupinfo;
#define _STARTUP_INFO_DEFINED
#endif /* _STARTUP_INFO_DEFINED */
_CRTIMP int __cdecl __getmainargs(_Out_ int * _Argc, _Outptr_result_buffer_(*_Argc) char *** _Argv,
_Outptr_result_maybenull_ char *** _Env, _In_ int _DoWildCard,
_In_ _startupinfo * _StartInfo);
_CRTIMP int __cdecl __wgetmainargs(_Out_ int * _Argc, _Outptr_result_buffer_(*_Argc) wchar_t *** _Argv,
_Outptr_result_maybenull_ wchar_t *** _Env, _In_ int _DoWildCard,
_In_ _startupinfo * _StartInfo);
#endif /* defined (_DLL) || defined (CRTDLL) */
/*
* Prototype, variables and constants which determine how error messages are
* written out.
*/
#define _UNKNOWN_APP 0
#define _CONSOLE_APP 1
#define _GUI_APP 2
extern int __app_type;
#if !defined (_M_CEE_PURE)
typedef enum {
__uninitialized,
__initializing,
__initialized
} __enative_startup_state;
extern volatile __enative_startup_state __native_startup_state;
extern void * volatile __native_startup_lock;
#define __NO_REASON UINT_MAX
extern volatile unsigned int __native_dllmain_reason;
#if defined (__cplusplus)
#pragma warning(push)
#pragma warning(disable: 4483)
#define _NATIVE_STARTUP_NAMESPACE __identifier("<CrtImplementationDetails>")
namespace _NATIVE_STARTUP_NAMESPACE
{
class NativeDll
{
private:
static const unsigned int ProcessDetach = 0;
static const unsigned int ProcessAttach = 1;
static const unsigned int ThreadAttach = 2;
static const unsigned int ThreadDetach = 3;
static const unsigned int ProcessVerifier = 4;
public:
inline static bool IsInDllMain()
{
return (__native_dllmain_reason != __NO_REASON);
}
inline static bool IsInProcessAttach()
{
return (__native_dllmain_reason == ProcessAttach);
}
inline static bool IsInProcessDetach()
{
return (__native_dllmain_reason == ProcessDetach);
}
inline static bool IsSafeForManagedCode()
{
if (!IsInDllMain())
{
return true;
}
return !IsInProcessAttach() && !IsInProcessDetach();
}
};
}
#pragma warning(pop)
#endif /* defined (__cplusplus) */
#endif /* !defined (_M_CEE_PURE) */
extern int __error_mode;
#if !defined (_CRT_APP) || defined (_KERNELX)
_CRTIMP void __cdecl __set_app_type(int);
#endif /* _CRT_APP */
/*
* C source build only!!!!
*
* map Win32 errors into Xenix errno values -- for modules written in C
*/
_CRTIMP void __cdecl _dosmaperr(unsigned long);
extern int __cdecl _get_errno_from_oserr(unsigned long);
/*
* internal routines used by the exec/spawn functions
*/
extern intptr_t __cdecl _dospawn(_In_ int _Mode, _In_opt_z_ const char * _Name, _Inout_z_ char * _Cmd, _In_opt_z_ char * _Env);
extern intptr_t __cdecl _wdospawn(_In_ int _Mode, _In_opt_z_ const wchar_t * _Name, _Inout_z_ wchar_t * _Cmd, _In_opt_z_ wchar_t * _Env);
extern int __cdecl _cenvarg(_In_z_ const char * const * _Argv, _In_opt_z_ const char * const * _Env,
_Outptr_result_maybenull_ char ** _ArgBlk, _Outptr_result_maybenull_ char ** _EnvBlk, _In_z_ const char *_Name);
extern int __cdecl _wcenvarg(_In_z_ const wchar_t * const * _Argv, _In_opt_z_ const wchar_t * const * _Env,
_Outptr_result_maybenull_ wchar_t ** _ArgBlk, _Outptr_result_maybenull_ wchar_t ** _EnvBlk, _In_z_ const wchar_t * _Name);
#ifndef _M_IX86
extern char ** _capture_argv(_In_ va_list *, _In_z_ const char * _FirstArg, _Out_writes_z_(_MaxCount) char ** _Static_argv, _In_ size_t _MaxCount);
extern wchar_t ** _wcapture_argv(_In_ va_list *, _In_z_ const wchar_t * _FirstArg, _Out_writes_z_(_MaxCount) wchar_t ** _Static_argv, _In_ size_t _MaxCount);
#endif /* _M_IX86 */
/*
* internal routine used by the abort
*/
extern _PHNDLR __cdecl __get_sigabrt(void);
/*
* Type from ntdef.h
*/
typedef LONG NTSTATUS;
/*
* Exception code used in _invalid_parameter
*/
#ifndef STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER ((NTSTATUS)0xC000000DL)
#endif /* STATUS_INVALID_PARAMETER */
/*
* Exception code used for abort and _CALL_REPORTFAULT
*/
#ifndef STATUS_FATAL_APP_EXIT
#define STATUS_FATAL_APP_EXIT ((NTSTATUS)0x40000015L)
#endif /* STATUS_FATAL_APP_EXIT */
/*
* Validate functions
*/
#include <crtdbg.h> /* _ASSERTE */
#include <errno.h>
#define __STR2WSTR(str) L##str
#define _STR2WSTR(str) __STR2WSTR(str)
#define __FILEW__ _STR2WSTR(__FILE__)
#define __FUNCTIONW__ _STR2WSTR(__FUNCTION__)
/* We completely fill the buffer only in debug (see _SECURECRT__FILL_STRING
* and _SECURECRT__FILL_BYTE macros).
*/
#if !defined (_SECURECRT_FILL_BUFFER)
#ifdef _DEBUG
#define _SECURECRT_FILL_BUFFER 1
#else /* _DEBUG */
#define _SECURECRT_FILL_BUFFER 0
#endif /* _DEBUG */
#endif /* !defined (_SECURECRT_FILL_BUFFER) */
/* In ARM and Win8 we promptly call __fastfail intrinsic instead */
#if defined (_M_IX86) || defined (_M_X64)
void __cdecl _call_reportfault(int nDbgHookCode, DWORD dwExceptionCode, DWORD dwExceptionFlags);
#endif /* defined (_M_IX86) || defined (_M_X64) */
/* Invoke Watson if _ExpressionError is not 0; otherwise simply return _EspressionError */
SECURITYCRITICAL_ATTRIBUTE
__forceinline
void _invoke_watson_if_error(
errno_t _ExpressionError,
_In_opt_z_ const wchar_t *_Expression,
_In_opt_z_ const wchar_t *_Function,
_In_opt_z_ const wchar_t *_File,
unsigned int _Line,
uintptr_t _Reserved
)
{
if (_ExpressionError == 0)
{
return;
}
_invoke_watson(_Expression, _Function, _File, _Line, _Reserved);
}
/* Invoke Watson if _ExpressionError is not 0 and equal to _ErrorValue1 or _ErrorValue2; otherwise simply return _EspressionError */
__forceinline
errno_t _invoke_watson_if_oneof(
errno_t _ExpressionError,
errno_t _ErrorValue1,
errno_t _ErrorValue2,
_In_opt_z_ const wchar_t *_Expression,
_In_opt_z_ const wchar_t *_Function,
_In_opt_z_ const wchar_t *_File,
unsigned int _Line,
uintptr_t _Reserved
)
{
if (_ExpressionError == 0 || (_ExpressionError != _ErrorValue1 && _ExpressionError != _ErrorValue2))
{
return _ExpressionError;
}
_invoke_watson(_Expression, _Function, _File, _Line, _Reserved);
return _ExpressionError;
}
/*
* Assert in debug builds.
* set errno and return
*
*/
#ifdef _DEBUG
#define _CALL_INVALID_PARAMETER(expr) _invalid_parameter(expr, __FUNCTIONW__, __FILEW__, __LINE__, 0)
#define _INVOKE_WATSON_IF_ERROR(expr) _invoke_watson_if_error((expr), __STR2WSTR(#expr), __FUNCTIONW__, __FILEW__, __LINE__, 0)
#define _INVOKE_WATSON_IF_ONEOF(expr, errvalue1, errvalue2) _invoke_watson_if_oneof(expr, (errvalue1), (errvalue2), __STR2WSTR(#expr), __FUNCTIONW__, __FILEW__, __LINE__, 0)
#else /* _DEBUG */
#define _CALL_INVALID_PARAMETER(expr) _invalid_parameter_noinfo()
#define _INVOKE_WATSON_IF_ERROR(expr) _invoke_watson_if_error(expr, NULL, NULL, NULL, 0, 0)
#define _INVOKE_WATSON_IF_ONEOF(expr, errvalue1, errvalue2) _invoke_watson_if_oneof((expr), (errvalue1), (errvalue2), NULL, NULL, NULL, 0, 0)
#endif /* _DEBUG */
#define _INVALID_PARAMETER(expr) _CALL_INVALID_PARAMETER(expr)
#define _VALIDATE_RETURN_VOID( expr, errorcode ) \
{ \
int _Expr_val=!!(expr); \
_ASSERT_EXPR( ( _Expr_val ), _CRT_WIDE(#expr) ); \
if ( !( _Expr_val ) ) \
{ \
errno = errorcode; \
_INVALID_PARAMETER(_CRT_WIDE(#expr)); \
return; \
} \
}
/*
* Assert in debug builds.
* set errno and return value
*/
#ifndef _VALIDATE_RETURN
#define _VALIDATE_RETURN( expr, errorcode, retexpr ) \
{ \
int _Expr_val=!!(expr); \
_ASSERT_EXPR( ( _Expr_val ), _CRT_WIDE(#expr) ); \
if ( !( _Expr_val ) ) \
{ \
errno = errorcode; \
_INVALID_PARAMETER(_CRT_WIDE(#expr) ); \
return ( retexpr ); \
} \
}
#endif /* _VALIDATE_RETURN */
#ifndef _VALIDATE_RETURN_NOEXC
#define _VALIDATE_RETURN_NOEXC( expr, errorcode, retexpr ) \
{ \
if ( !(expr) ) \
{ \
errno = errorcode; \
return ( retexpr ); \
} \
}
#endif /* _VALIDATE_RETURN_NOEXC */
/*
* Assert in debug builds.
* set errno and set retval for later usage
*/
#define _VALIDATE_SETRET( expr, errorcode, retval, retexpr ) \
{ \
int _Expr_val=!!(expr); \
_ASSERT_EXPR( ( _Expr_val ), _CRT_WIDE(#expr) ); \
if ( !( _Expr_val ) ) \
{ \
errno = errorcode; \
_INVALID_PARAMETER(_CRT_WIDE(#expr)); \
retval=( retexpr ); \
} \
}
#define _CHECK_FH_RETURN( handle, errorcode, retexpr ) \
{ \
if(handle == _NO_CONSOLE_FILENO) \
{ \
errno = errorcode; \
return ( retexpr ); \
} \
}
/*
We use _VALIDATE_STREAM_ANSI_RETURN to ensure that ANSI file operations(
fprintf etc) aren't called on files opened as UNICODE. We do this check
only if it's an actual FILE pointer & not a string
*/
#define _VALIDATE_STREAM_ANSI_RETURN( stream, errorcode, retexpr ) \
{ \
FILE *_Stream=stream; \
int fn; \
_VALIDATE_RETURN(( (_Stream->_flag & _IOSTRG) || \
( fn = _fileno(_Stream), \
( (_textmode_safe(fn) == __IOINFO_TM_ANSI) && \
!_tm_unicode_safe(fn)))), \
errorcode, retexpr) \
}
/*
We use _VALIDATE_STREAM_ANSI_SETRET to ensure that ANSI file operations(
fprintf etc) aren't called on files opened as UNICODE. We do this check
only if it's an actual FILE pointer & not a string. It doesn't actually return
immediately
*/
#define _VALIDATE_STREAM_ANSI_SETRET( stream, errorcode, retval, retexpr) \
{ \
FILE *_Stream=stream; \
int fn; \
_VALIDATE_SETRET(( (_Stream->_flag & _IOSTRG) || \
( fn = _fileno(_Stream), \
( (_textmode_safe(fn) == __IOINFO_TM_ANSI) && \
!_tm_unicode_safe(fn)))), \
errorcode, retval, retexpr) \
}
/*
* Assert in debug builds.
* Return value (do not set errno)
*/
#define _VALIDATE_RETURN_NOERRNO( expr, retexpr ) \
{ \
int _Expr_val=!!(expr); \
_ASSERT_EXPR( ( _Expr_val ), _CRT_WIDE(#expr) ); \
if ( !( _Expr_val ) ) \
{ \
_INVALID_PARAMETER(_CRT_WIDE(#expr)); \
return ( retexpr ); \
} \
}
/*
* Assert in debug builds.
* set errno and return errorcode
*/
#define _VALIDATE_RETURN_ERRCODE( expr, errorcode ) \
{ \
int _Expr_val=!!(expr); \
_ASSERT_EXPR( ( _Expr_val ), _CRT_WIDE(#expr) ); \
if ( !( _Expr_val ) ) \
{ \
errno = errorcode; \
_INVALID_PARAMETER(_CRT_WIDE(#expr)); \
return ( errorcode ); \
} \
}
#define _VALIDATE_RETURN_ERRCODE_NOEXC( expr, errorcode ) \
{ \
if (!(expr)) \
{ \
errno = errorcode; \
return ( errorcode ); \
} \
}
#define _VALIDATE_CLEAR_OSSERR_RETURN( expr, errorcode, retexpr ) \
{ \
int _Expr_val=!!(expr); \
_ASSERT_EXPR( ( _Expr_val ), _CRT_WIDE(#expr) ); \
if ( !( _Expr_val ) ) \
{ \
_doserrno = 0L; \
errno = errorcode; \
_INVALID_PARAMETER(_CRT_WIDE(#expr) ); \
return ( retexpr ); \
} \
}
#define _CHECK_FH_CLEAR_OSSERR_RETURN( handle, errorcode, retexpr ) \
{ \
if(handle == _NO_CONSOLE_FILENO) \
{ \
_doserrno = 0L; \
errno = errorcode; \
return ( retexpr ); \
} \
}
#define _VALIDATE_CLEAR_OSSERR_RETURN_ERRCODE( expr, errorcode ) \
{ \
int _Expr_val=!!(expr); \
_ASSERT_EXPR( ( _Expr_val ), _CRT_WIDE(#expr) ); \
if ( !( _Expr_val ) ) \
{ \
_doserrno = 0L; \
errno = errorcode; \
_INVALID_PARAMETER(_CRT_WIDE(#expr)); \
return ( errorcode ); \
} \
}
#define _CHECK_FH_CLEAR_OSSERR_RETURN_ERRCODE( handle, retexpr ) \
{ \
if(handle == _NO_CONSOLE_FILENO) \
{ \
_doserrno = 0L; \
return ( retexpr ); \
} \
}
#ifdef _DEBUG
extern size_t __crtDebugFillThreshold;
#endif /* _DEBUG */
#if !defined (_SECURECRT_FILL_BUFFER_THRESHOLD)
#ifdef _DEBUG
#define _SECURECRT_FILL_BUFFER_THRESHOLD __crtDebugFillThreshold
#else /* _DEBUG */
#define _SECURECRT_FILL_BUFFER_THRESHOLD ((size_t)0)
#endif /* _DEBUG */
#endif /* !defined (_SECURECRT_FILL_BUFFER_THRESHOLD) */
#if _SECURECRT_FILL_BUFFER
#define _SECURECRT__FILL_STRING(_String, _Size, _Offset) \
if ((_Size) != ((size_t)-1) && (_Size) != INT_MAX && \
((size_t)(_Offset)) < (_Size)) \
{ \
memset((_String) + (_Offset), \
_SECURECRT_FILL_BUFFER_PATTERN, \
(_SECURECRT_FILL_BUFFER_THRESHOLD < ((size_t)((_Size) - (_Offset))) ? \
_SECURECRT_FILL_BUFFER_THRESHOLD : \
((_Size) - (_Offset))) * sizeof(*(_String))); \
}
#else /* _SECURECRT_FILL_BUFFER */
#define _SECURECRT__FILL_STRING(_String, _Size, _Offset)
#endif /* _SECURECRT_FILL_BUFFER */
#if _SECURECRT_FILL_BUFFER
#define _SECURECRT__FILL_BYTE(_Position) \
if (_SECURECRT_FILL_BUFFER_THRESHOLD > 0) \
{ \
(_Position) = _SECURECRT_FILL_BUFFER_PATTERN; \
}
#else /* _SECURECRT_FILL_BUFFER */
#define _SECURECRT__FILL_BYTE(_Position)
#endif /* _SECURECRT_FILL_BUFFER */
#ifdef __cplusplus
#define _REDIRECT_TO_L_VERSION_FUNC_PROLOGUE extern "C"
#else /* __cplusplus */
#define _REDIRECT_TO_L_VERSION_FUNC_PROLOGUE
#endif /* __cplusplus */
/* helper macros to redirect an mbs function to the corresponding _l version */
#define _REDIRECT_TO_L_VERSION_1(_ReturnType, _FunctionName, _Type1) \
_REDIRECT_TO_L_VERSION_FUNC_PROLOGUE \
_ReturnType __cdecl _FunctionName(_Type1 _Arg1) \
{ \
return _FunctionName##_l(_Arg1, NULL); \
}
#define _REDIRECT_TO_L_VERSION_2(_ReturnType, _FunctionName, _Type1, _Type2) \
_REDIRECT_TO_L_VERSION_FUNC_PROLOGUE \
_ReturnType __cdecl _FunctionName(_Type1 _Arg1, _Type2 _Arg2) \
{ \
return _FunctionName##_l(_Arg1, _Arg2, NULL); \
}
#define _REDIRECT_TO_L_VERSION_3(_ReturnType, _FunctionName, _Type1, _Type2, _Type3) \
_REDIRECT_TO_L_VERSION_FUNC_PROLOGUE \
_ReturnType __cdecl _FunctionName(_Type1 _Arg1, _Type2 _Arg2, _Type3 _Arg3) \
{ \
return _FunctionName##_l(_Arg1, _Arg2, _Arg3, NULL); \
}
#define _REDIRECT_TO_L_VERSION_4(_ReturnType, _FunctionName, _Type1, _Type2, _Type3, _Type4) \
_REDIRECT_TO_L_VERSION_FUNC_PROLOGUE \
_ReturnType __cdecl _FunctionName(_Type1 _Arg1, _Type2 _Arg2, _Type3 _Arg3, _Type4 _Arg4) \
{ \
return _FunctionName##_l(_Arg1, _Arg2, _Arg3, _Arg4, NULL); \
}
#define _REDIRECT_TO_L_VERSION_5(_ReturnType, _FunctionName, _Type1, _Type2, _Type3, _Type4, _Type5) \
_REDIRECT_TO_L_VERSION_FUNC_PROLOGUE \
_ReturnType __cdecl _FunctionName(_Type1 _Arg1, _Type2 _Arg2, _Type3 _Arg3, _Type4 _Arg4, _Type5 _Arg5) \
{ \
return _FunctionName##_l(_Arg1, _Arg2, _Arg3, _Arg4, _Arg5, NULL); \
}
#define _REDIRECT_TO_L_VERSION_6(_ReturnType, _FunctionName, _Type1, _Type2, _Type3, _Type4, _Type5, _Type6) \
_REDIRECT_TO_L_VERSION_FUNC_PROLOGUE \
_ReturnType __cdecl _FunctionName(_Type1 _Arg1, _Type2 _Arg2, _Type3 _Arg3, _Type4 _Arg4, _Type5 _Arg5, _Type6 _Arg6) \
{ \
return _FunctionName##_l(_Arg1, _Arg2, _Arg3, _Arg4, _Arg5, _Arg6, NULL); \
}
/* internal helper functions for encoding and decoding pointers */
void __cdecl _init_pointers();
/* These functions need to be declared with these security attributes. Otherwise they will
result in System.Security.SecurityException
*/
_SUPPRESS_UNMANAGED_CODE_SECURITY
SECURITYCRITICAL_ATTRIBUTE
_RELIABILITY_CONTRACT
_INTEROPSERVICES_DLLIMPORT("KERNEL32.dll", "EncodePointer", _CALLING_CONVENTION_WINAPI)
WINBASEAPI
_Ret_maybenull_
PVOID
WINAPI
EncodePointer (
_In_opt_ PVOID Ptr
);
_SUPPRESS_UNMANAGED_CODE_SECURITY
SECURITYCRITICAL_ATTRIBUTE
_RELIABILITY_CONTRACT
_INTEROPSERVICES_DLLIMPORT("KERNEL32.dll", "DecodePointer", _CALLING_CONVENTION_WINAPI)
WINBASEAPI
_Ret_maybenull_
PVOID
WINAPI
DecodePointer (
_In_opt_ PVOID Ptr
);
/* Macros to simplify the use of Secure CRT in the CRT itself.
* We should use [_BEGIN/_END]_SECURE_CRT_DEPRECATION_DISABLE sparingly.
*/
#define _BEGIN_SECURE_CRT_DEPRECATION_DISABLE \
__pragma(warning(push)) \
__pragma(warning(disable:4996)) \
__pragma(warning(disable:6053))
#define _END_SECURE_CRT_DEPRECATION_DISABLE \
__pragma(warning(pop))
#define _ERRCHECK(e) \
_INVOKE_WATSON_IF_ERROR(e)
#define _ERRCHECK_EINVAL(e) \
_INVOKE_WATSON_IF_ONEOF(e, EINVAL, EINVAL)
#define _ERRCHECK_EINVAL_ERANGE(e) \
_INVOKE_WATSON_IF_ONEOF(e, EINVAL, ERANGE)
#define _ERRCHECK_SPRINTF(_PrintfCall) \
{ \
errno_t _SaveErrno = errno; \
errno = 0; \
if ( ( _PrintfCall ) < 0) \
{ \
_ERRCHECK_EINVAL_ERANGE(errno); \
} \
errno = _SaveErrno; \
}
/* internal helper function to access environment variable in read-only mode */
const wchar_t * __cdecl _wgetenv_helper_nolock(const wchar_t *);
const char * __cdecl _getenv_helper_nolock(const char *);
/* internal helper routines used to query a PE image header. */
BOOL __cdecl _ValidateImageBase(PBYTE pImageBase);
PIMAGE_SECTION_HEADER __cdecl _FindPESection(PBYTE pImageBase, DWORD_PTR rva);
BOOL __cdecl _IsNonwritableInCurrentImage(PBYTE pTarget);
/*
* Helper function to convert an ANSI/MBCS string to wide char using the current ANSI code set
*
*/
BOOL __cdecl __copy_path_to_wide_string (const char* _Str, wchar_t** _WStr);
BOOL __cdecl __copy_to_char(const wchar_t* inString, char** outString);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#define CRT_WARNING_DISABLE_PUSH(x,y) __pragma(warning(push)); __pragma(warning(disable: x))
#define CRT_WARNING_POP __pragma(warning(pop))
#pragma pack(pop)
#endif /* _INC_INTERNAL */
| [
"gan.bo@columbia.edu"
] | gan.bo@columbia.edu |
f1128055cef7e0c84e6c3b800eee9cdc8fa86c5e | 7c9cf81ef08b927942e758b90962f12a14b79774 | /gloom/gloom/src/gloom/noiseTexture.cpp | 8d482a51a47c0f9156dee2287a7c224dc1714a80 | [
"MIT"
] | permissive | olalium/RayMarchingTDT4230 | 29b99684ffd98521cfe4293884748b57b2c9f239 | 3a32f31410ac117e4932f09215dfe86a95665711 | refs/heads/master | 2020-06-04T20:01:41.288520 | 2019-06-16T09:51:54 | 2019-06-16T09:51:54 | 192,171,854 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 791 | cpp | #include "noiseTexture.hpp"
#include <iostream>
NoiseTexture generateNoiseTexture(FastNoise noise, unsigned int width, unsigned int height, unsigned int depth) {
std::vector<float> voxels; //in form RGBA
float alpha; // transparency level between 0 and 1
// i think this is necessary to make the data open_gl friendly..
for(unsigned int z = 0; z < depth; z++) {
for(unsigned int y = 0; y < height; y++) {
for(unsigned int x = 0; x < width; x++) {
alpha = (1 + noise.GetPerlin(x,y,z)) / 2;
voxels.push_back(1.0f); // R
voxels.push_back(1.0f); // G
voxels.push_back(1.0f); // B
voxels.push_back(alpha);// A
}
}
}
NoiseTexture texture;
texture.width = width;
texture.height = height;
texture.depth = depth;
texture.voxels = voxels;
return texture;
} | [
"olalium@gmail.com"
] | olalium@gmail.com |
f7726eb14450d8309834d3842e003cc22a494365 | 0bd876a9a9a3c0e6addc477d9d149fc1dae32040 | /co/include/co/closure.h | c930d0773cfa024e9c7c89bbcc73b07c2c25148b | [] | no_license | 1647606255/Anson | 82062796f873ee04351fe59e8f4036b299ed6a30 | ca89caf0c47a20b2043239dc935a269ffad90bb3 | refs/heads/master | 2022-08-21T02:35:46.148718 | 2022-07-30T14:27:50 | 2022-07-30T14:27:50 | 215,726,269 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,895 | h | #pragma once
#include <functional>
#include <type_traits>
namespace co {
class Closure {
public:
Closure() = default;
virtual ~Closure() = default;
virtual void run() = 0;
};
namespace xx {
template<typename F>
class Function0 : public Closure {
public:
Function0(F&& f) : _f(std::forward<F>(f)) {}
virtual void run() {
_f();
delete this;
}
private:
typename std::remove_reference<F>::type _f;
virtual ~Function0() {}
};
template<typename F>
class Function0p : public Closure {
public:
Function0p(F* f) : _f(f) {}
virtual void run() {
(*_f)();
delete this;
}
private:
typename std::remove_reference<F>::type* _f;
virtual ~Function0p() {}
};
template<typename F, typename P>
class Function1 : public Closure {
public:
Function1(F&& f, P&& p) : _f(std::forward<F>(f)), _p(std::forward<P>(p)) {}
virtual void run() {
_f(_p);
delete this;
}
private:
typename std::remove_reference<F>::type _f;
typename std::remove_reference<P>::type _p;
virtual ~Function1() {}
};
template<typename F, typename P>
class Function1p : public Closure {
public:
Function1p(F* f, P&& p) : _f(f), _p(std::forward<P>(p)) {}
virtual void run() {
(*_f)(_p);
delete this;
}
private:
typename std::remove_reference<F>::type* _f;
typename std::remove_reference<P>::type _p;
virtual ~Function1p() {}
};
template<typename T>
class Method0 : public Closure {
public:
typedef void (T::*F)();
Method0(F f, T* o) : _f(f), _o(o) {}
virtual void run() {
(_o->*_f)();
delete this;
}
private:
F _f;
T* _o;
virtual ~Method0() {}
};
template<typename F, typename T, typename P>
class Method1 : public Closure {
public:
Method1(F&& f, T* o, P&& p)
: _f(std::forward<F>(f)), _o(o), _p(std::forward<P>(p)) {
}
virtual void run() {
(_o->*_f)(_p);
delete this;
}
private:
typename std::remove_reference<F>::type _f;
T* _o;
typename std::remove_reference<P>::type _p;
virtual ~Method1() {}
};
} // xx
/**
* @param f any runnable object, as long as we can call f().
*/
template<typename F>
inline Closure* new_closure(F&& f) {
return new xx::Function0<F>(std::forward<F>(f));
}
/**
* @param f pointer to any runnable object, as long as we can call (*f)().
*/
template<typename F>
inline Closure* new_closure(F* f) {
return new xx::Function0p<F>(f);
}
/**
* function with a single parameter
*
* @param f any runnable object, as long as we can call f(p).
* @param p parameter of f.
*/
template<typename F, typename P>
inline Closure* new_closure(F&& f, P&& p) {
return new xx::Function1<F, P>(std::forward<F>(f), std::forward<P>(p));
}
/**
* function with a single parameter
*
* @param f any runnable object, as long as we can call (*f)(p).
* @param p parameter.
*/
template<typename F, typename P>
inline Closure* new_closure(F* f, P&& p) {
return new xx::Function1p<F, P>(f, std::forward<P>(p));
}
/**
* method (function in a class) without parameter
*
* @param f pointer to a method without parameter in class T.
* @param o pointer to an object of T.
*/
template<typename T>
inline Closure* new_closure(void (T::*f)(), T* o) {
return new xx::Method0<T>(f, o);
}
/**
* method (function in a class) with a single parameter
*
* @tparam F method type, void (T::*)(P).
* @tparam T type of the class.
* @tparam P type of the parameter.
* @param f pointer to a method with a parameter in class T.
* @param o pointer to an object of T.
* @param p parameter of f.
*/
template<typename F, typename T, typename P>
inline Closure* new_closure(F&& f, T* o, P&& p) {
return new xx::Method1<F, T, P>(std::forward<F>(f), o, std::forward<P>(p));
}
} // co
| [
"weixiong@seaeverit.com"
] | weixiong@seaeverit.com |
d0767eea20033a657d81ed202b3b24260573e02b | 92a7084bab9d732078d7d704ec0fde3865039038 | /Week1/Engine/Event/EventListener.cpp | 63e421170b718bc73ddb6794ca6037a98c540194 | [] | no_license | MohdAAyyad/S5Engine | 5c28331aa76bdf10bc7aebcefb23b1cacead33d4 | 3e33c7d29d207b81d2cb84546087b6ef4c0c12d8 | refs/heads/main | 2023-01-14T02:42:59.549254 | 2020-11-15T22:21:13 | 2020-11-15T22:21:13 | 300,655,169 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 528 | cpp | #include "EventListener.h"
#include "../Core/CoreEngine.h"
#include "MouseEventListener.h"
EventListener::~EventListener()
{
}
void EventListener::Update()
{
SDL_Event sdlEvent;
while (SDL_PollEvent(&sdlEvent))
{
switch (sdlEvent.type)
{
case SDL_QUIT:
MouseEventListener::ClearGameObjects();
CoreEngine::GetInstance()->Exit();
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEMOTION:
case SDL_MOUSEWHEEL:
MouseEventListener::Update(sdlEvent);
break;
default:
break;
}
}
} | [
"mohd.ayyad.maa@gmail.com"
] | mohd.ayyad.maa@gmail.com |
dca18124feaec8dbee6dcb801f87f183a15d97bc | 4e0cb3bd6513558d3c9dd63c79877deacc3ac225 | /TouchGFX/gui/include/gui/screen1_screen/Screen1View.hpp | 96a840412efa65b3fed946a76b7f3b3021180170 | [] | no_license | Mattia-Zambetti/TouchGFXlearningTest | adbbae195b75dc21947b9f3125d9ee671e070c24 | 0f1013eaa032c06aa114b9cf8176e2c482b3c994 | refs/heads/master | 2023-01-31T15:40:16.937149 | 2020-12-16T23:00:32 | 2020-12-16T23:00:32 | 320,912,718 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 593 | hpp | #ifndef SCREEN1VIEW_HPP
#define SCREEN1VIEW_HPP
#include <gui_generated/screen1_screen/Screen1ViewBase.hpp>
#include <gui/screen1_screen/Screen1Presenter.hpp>
#include <Utils.hpp>
#include <touchgfx/Color.hpp>
#include <texts/TextKeysAndLanguages.hpp>
#include "BitmapDatabase.hpp"
class Screen1View : public Screen1ViewBase
{
public:
Screen1View();
virtual ~Screen1View() {}
virtual void setupScreen();
virtual void tearDownScreen();
virtual void AnalogUpdate( uint16_t value );
virtual void ProgressBarUpdate( uint16_t value );
protected:
};
#endif // SCREEN1VIEW_HPP
| [
"mattia.zambetti2000@gmail.com"
] | mattia.zambetti2000@gmail.com |
f3f731c8da29a38869eb281d2c9ab3875589a39a | c082c6de0dc12084d213e96eb5a13b49f380de3d | /实验10.2（3）/usedll/usedllDoc.h | 87e8c189ee6498e0f67da33b4084bf4f2a52d45b | [] | no_license | levi-Ackerman6/test1 | 395ad496dfbf28db0d217d0fcdfef4c001185cf7 | bdee6c2de604ae3d2ca1d26a3dfebad52cd84209 | refs/heads/master | 2022-11-16T09:32:37.600772 | 2020-07-05T19:22:01 | 2020-07-05T19:22:01 | 261,464,799 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 845 | h |
// usedllDoc.h : CusedllDoc 类的接口
//
#pragma once
class CusedllDoc : public CDocument
{
protected: // 仅从序列化创建
CusedllDoc();
DECLARE_DYNCREATE(CusedllDoc)
// 特性
public:
// 操作
public:
// 重写
public:
virtual BOOL OnNewDocument();
virtual void Serialize(CArchive& ar);
#ifdef SHARED_HANDLERS
virtual void InitializeSearchContent();
virtual void OnDrawThumbnail(CDC& dc, LPRECT lprcBounds);
#endif // SHARED_HANDLERS
// 实现
public:
virtual ~CusedllDoc();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// 生成的消息映射函数
protected:
DECLARE_MESSAGE_MAP()
#ifdef SHARED_HANDLERS
// 用于为搜索处理程序设置搜索内容的 Helper 函数
void SetSearchContent(const CString& value);
#endif // SHARED_HANDLERS
};
| [
"2535133278@qq.com"
] | 2535133278@qq.com |
deda802980fb0c03aa3a881b3b131fd6ae6b560a | fa8fc8757485be4d7db12bf92459981f6eb65b3a | /src/mergesort.cpp | 51a949d73988d009174e3d0044d282ebf2906fca | [] | no_license | zhang19960128/mergesort | a27490a64d87da0ed5b36866007d0d9b1feb2030 | 834ee64da7bab5f2fe19cde9729ce9db7cbfca9b | refs/heads/master | 2021-08-22T10:55:22.304545 | 2017-11-30T01:48:08 | 2017-11-30T01:48:08 | 112,425,563 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 195 | cpp | #include <iostream>
#include "mergesort.h"
int main(){
double A[]={11,10,5,4,6,8,12,10};
mergesort<double>(A,0,7);
for(size_t t=0;t<8;t++){
std::cout<<A[t]<<" ";
}
std::cout<<std::endl;
}
| [
"jiahaozhang@modv-ve504-0939.apn.wlan.upenn.edu"
] | jiahaozhang@modv-ve504-0939.apn.wlan.upenn.edu |
fb88b737a74c89f7a0e9f482f9085e1a3af336f4 | 1974b8591d725c3befdc7b8037076d2d60eeff50 | /dali/operators/generic/reduce/reduce.h | 056a6ee02c319bdfe16b5dd4b9202ae6e5badf8a | [
"Apache-2.0"
] | permissive | awolant/DALI | d7288685443696032e3f371d5cecd667e9cf2980 | a407c54d27a5ef7ffb4ea66e314a92e140b6ddae | refs/heads/master | 2023-09-04T18:01:37.524365 | 2022-02-18T08:57:08 | 2022-02-18T08:57:08 | 157,438,718 | 0 | 0 | Apache-2.0 | 2023-05-26T12:08:10 | 2018-11-13T20:01:14 | C++ | UTF-8 | C++ | false | false | 6,250 | h | // Copyright (c) 2020-2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef DALI_OPERATORS_GENERIC_REDUCE_REDUCE_H__
#define DALI_OPERATORS_GENERIC_REDUCE_REDUCE_H__
#include <vector>
#include <algorithm>
#include "dali/pipeline/operator/operator.h"
#include "dali/kernels/kernel_manager.h"
#include "dali/kernels/reduce/reductions.h"
#include "dali/kernels/reduce/reduce_cpu.h"
#include "dali/kernels/reduce/reduce_gpu.h"
#include "dali/kernels/reduce/reduce_setup_utils.h"
#define REDUCE_TYPES (uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t, float) // NOLINT
namespace dali {
namespace detail {
class AxesHelper {
public:
explicit inline AxesHelper(const OpSpec &spec) {
has_axes_arg_ = spec.TryGetRepeatedArgument(axes_, "axes");
has_axis_names_arg_ = spec.TryGetArgument(axis_names_, "axis_names");
has_empty_axes_arg_ =
(has_axes_arg_ && axes_.empty()) || (has_axis_names_arg_ && axis_names_.empty());
DALI_ENFORCE(!has_axes_arg_ || !has_axis_names_arg_,
"Arguments `axes` and `axis_names` are mutually exclusive");
}
void PrepareAxes(const TensorLayout &layout, int sample_dim) {
if (has_axis_names_arg_) {
axes_ = GetDimIndices(layout, axis_names_).to_vector();
return;
}
if (!has_axes_arg_) {
axes_.resize(sample_dim);
std::iota(axes_.begin(), axes_.end(), 0);
}
}
bool has_axes_arg_;
bool has_axis_names_arg_;
bool has_empty_axes_arg_;
vector<int> axes_;
TensorLayout axis_names_;
};
} // namespace detail
template <
template <typename T, typename R> class ReductionType,
typename Backend,
template <template <typename X, typename Y> class RType, typename BType> class ImplType>
class Reduce : public Operator<Backend>, detail::AxesHelper {
public:
explicit inline Reduce(const OpSpec &spec) :
Operator<Backend>(spec),
AxesHelper(spec),
keep_dims_(spec.GetArgument<bool>("keep_dims")) {
spec.TryGetArgument<DALIDataType>(output_type_, "dtype");
}
bool CanInferOutputs() const override { return true; }
inline ~Reduce() override = default;
bool SetupImpl(
std::vector<OutputDesc> &output_desc, const workspace_t<Backend> &ws) override {
output_desc.resize(1);
auto &input = ws.template Input<Backend>(0);
output_desc[0].type = OutputType(input.type());
output_desc[0].shape = input.shape();
PrepareAxes(input.GetLayout(), input.shape().sample_dim());
TensorListShape<> output_shape;
kernels::reduce_impl::CalculateReducedShape(
output_shape,
input.shape(),
make_span(axes_),
keep_dims_,
false);
output_desc[0].shape = output_shape;
return true;
}
void RunImpl(workspace_t<Backend> &ws) override {
auto& reduce_impl = static_cast<ImplType<ReductionType, Backend>&>(*this);
reduce_impl.RunImplImpl(ws);
}
template <typename OutputType, typename InputType>
void RunTyped(HostWorkspace &ws) {
auto& in = ws.Input<CPUBackend>(0);
auto in_view = view<const InputType>(in);
auto &out = ws.Output<CPUBackend>(0);
auto out_view = view<OutputType>(out);
auto &thread_pool = ws.GetThreadPool();
int num_threads = thread_pool.NumThreads();
using Kernel = ReductionType<OutputType, InputType>;
kmgr_.template Resize<Kernel>(num_threads);
for (int sample = 0; sample < in_view.num_samples(); sample++) {
int64_t priority = volume(in_view.shape.tensor_shape_span(sample));
thread_pool.AddWork(
[&, sample](int thread_id) {
auto in_sample_view = in_view[sample];
auto out_sample_view = out_view[sample];
kernels::KernelContext ctx;
kmgr_.Setup<Kernel>(
thread_id, ctx, out_sample_view, in_sample_view, make_cspan(axes_));
kmgr_.Run<Kernel>(thread_id, ctx);
},
priority);
}
thread_pool.RunAll();
}
template <typename OutputType, typename InputType>
void RunTyped(DeviceWorkspace &ws) {
auto& in = ws.Input<GPUBackend>(0);
auto in_view = view<const InputType>(in);
auto &out = ws.Output<GPUBackend>(0);
auto out_view = view<OutputType>(out);
using Kernel = ReductionType<OutputType, InputType>;
kmgr_.template Resize<Kernel>(1);
kernels::KernelContext ctx;
ctx.gpu.stream = ws.stream();
kmgr_.Setup<Kernel>(
0,
ctx,
in_view.shape,
make_cspan(axes_),
keep_dims_,
false);
kmgr_.Run<Kernel>(0, ctx, out_view, in_view);
}
DALIDataType OutputType(DALIDataType input_type) const {
auto& reduce_impl = static_cast<const ImplType<ReductionType, Backend>&>(*this);
return reduce_impl.OutputTypeImpl(input_type);
}
DALIDataType OutputTypeImpl(DALIDataType input_type) const { return input_type; }
DALIDataType output_type_ = DALI_NO_TYPE;
private:
USE_OPERATOR_MEMBERS();
bool keep_dims_;
kernels::KernelManager kmgr_;
};
template <template <typename T, typename R> class ReductionType, typename Backend>
class ReduceOp : public Reduce<ReductionType, Backend, ReduceOp> {
public:
explicit inline ReduceOp(const OpSpec &spec) : Reduce<ReductionType, Backend, ReduceOp>(spec) {}
void RunImplImpl(workspace_t<Backend> &ws) {
auto& in = ws.template Input<Backend>(0);
DALIDataType input_type = in.type();
TYPE_SWITCH(input_type, type2id, DataType, REDUCE_TYPES, (
auto& base = static_cast<Reduce<ReductionType, Backend, ReduceOp>&>(*this);
base.template RunTyped<DataType, DataType>(ws);),
DALI_FAIL(make_string("Unsupported input type: ", input_type)))
}
};
} // namespace dali
#endif // DALI_OPERATORS_GENERIC_REDUCE_REDUCE_H_
| [
"noreply@github.com"
] | noreply@github.com |
2f9a3bb2d525ac1ece39221ec981df694b37a9dc | b71a29660a029b569288e0b5329f5a2c41587c31 | /A1051/A1051.cpp | 581d61748e4ba5b39d78740bb27689bfbafdf7e1 | [] | no_license | PiggerZZM/PAT | 50b6aac7ce2c80948c006deea716138465f6bcfa | bb5ecc4f8606a8adfeb6c5c1592d36f67e29ac3b | refs/heads/master | 2020-07-02T09:09:56.915648 | 2019-09-01T06:28:06 | 2019-09-01T06:28:06 | 167,808,478 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 920 | cpp | #include <cstdio>
#include <stack>
using namespace std;
int a[1010];
int main()
{
int m, n, k;
scanf("%d %d %d", &m, &n, &k);
stack<int> s;
bool flag;
while(k--)
{
int N = 1;
int current = 0;
flag = false;
for (int j = 0; j < n; j++)
scanf("%d", &a[j]);
while (s.size() != 0)
s.pop();
s.push(N++);
while(N <= n+1)
{
if (s.size() != 0 && a[current] == s.top())
{
s.pop();
current++;
if(current == n)
{
flag = true;
break;
}
}
else if (s.size() >= m)
break;
else
s.push(N++);
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| [
"442823793@qq.com"
] | 442823793@qq.com |
cbc1d13970430062701970a4f32e1e09a7410b8c | 4728c8d66b28dbc2644b0e89713d1815804da237 | /src/storage/volume_image/fvm/fvm_descriptor.h | bcd12e5d0c0a13ba7696dfc5621d41dd0478abae | [
"BSD-3-Clause"
] | permissive | osphea/zircon-rpi | 094aca2d06c9a5f58ceb66c3e7d3d57e8bde9e0c | 82c90329892e1cb3d09c99fee0f967210d11dcb2 | refs/heads/master | 2022-11-08T00:22:37.817127 | 2020-06-29T23:16:20 | 2020-06-29T23:16:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,453 | h | // Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef SRC_STORAGE_VOLUME_IMAGE_FVM_FVM_DESCRIPTOR_H_
#define SRC_STORAGE_VOLUME_IMAGE_FVM_FVM_DESCRIPTOR_H_
#include <lib/fit/result.h>
#include <set>
#include <string>
#include <vector>
#include "src/storage/volume_image/fvm/options.h"
#include "src/storage/volume_image/fvm/partition.h"
#include "src/storage/volume_image/options.h"
namespace storage::volume_image {
namespace internal {
// Returns the minimum size for addressing the a set of |slice_count| slices.
// Accounts for both primary and secondary control block.
uint64_t GetMetadataSize(const FvmOptions& options, uint64_t slice_count);
} // namespace internal
// A FVM descriptor represents a collection of partitions and constraints that should eventually be
// converted into an image.
class FvmDescriptor {
public:
// This class provides the mechanism for generating a valid FVM descriptor, so that constraints
// can be verified.
class Builder {
public:
Builder() = default;
explicit Builder(FvmDescriptor descriptor);
Builder(const Builder&) = delete;
Builder(Builder&&) = default;
Builder& operator=(const Builder&) = delete;
Builder& operator=(Builder&&) = default;
~Builder() = default;
// Adds partition to the image to be constructed.
Builder& AddPartition(Partition partition);
// Sets the options for the image to be constructed.
Builder& SetOptions(const FvmOptions& options);
// Verifies that constraints are met and returns an FvmDescriptor containing the data.
//
// This method will always consume all added partitions. On success the ownership is taken by
// the returned descriptor, and on error the partitions are destroyed.
fit::result<FvmDescriptor, std::string> Build();
private:
std::vector<Partition> partitions_;
std::optional<FvmOptions> options_;
uint64_t accumulated_slices_ = 0;
uint64_t metadata_allocated_size_ = 0;
};
FvmDescriptor() = default;
FvmDescriptor(const FvmDescriptor&) = delete;
FvmDescriptor(FvmDescriptor&&) = default;
FvmDescriptor& operator=(const FvmDescriptor&) = delete;
FvmDescriptor& operator=(FvmDescriptor&&) = default;
~FvmDescriptor() = default;
// Returns the partitions that belong to this fvm descriptor.
const std::set<Partition, Partition::LessThan>& partitions() const { return partitions_; }
// Returns the options of this descriptor.
const FvmOptions& options() const { return options_; }
// Returns the amount of slices required for the partitions of this descriptor,
// once a volume is formatted with it.
uint64_t slice_count() const { return slice_count_; }
// Returns the amount of bytes required for this descriptor to format a volume.
uint64_t metadata_required_size() const { return metadata_required_size_; }
private:
// Set of partitions that belong to the fvm.
std::set<Partition, Partition::LessThan> partitions_;
// Options used to construct and validate this descriptor.
FvmOptions options_;
// Number of slices required for this fvm descriptor.
uint64_t slice_count_ = 0;
// Size in bytes of the metadata required to generate this image.
uint64_t metadata_required_size_ = 0;
};
} // namespace storage::volume_image
#endif // SRC_STORAGE_VOLUME_IMAGE_FVM_FVM_DESCRIPTOR_H_
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
343f9d55f155189213489ca9ef32212630d5eb04 | c76adc973e5251452e1beb3de7776d0a2b709fce | /submissions/c3.s820.ncu100502001.Group1C.cpp.0.100502001.cpp | 40607ebccaab4fbde8214eb71c7a22e1ea3af429 | [] | no_license | ncuoolab/domjudge | 779a167f695f45a6a33437996ec5ad0f9d01c563 | bda18c69d418c829ff653f9183b3244520139f8a | refs/heads/master | 2020-05-19T08:10:39.974107 | 2015-03-10T19:35:03 | 2015-03-10T19:43:26 | 31,972,137 | 0 | 0 | null | null | null | null | BIG5 | C++ | false | false | 3,930 | cpp | #include<iostream>
#include<cstdlib>
#include<string>
#include<string.h>
using namespace std;
string result="";
int numTest=-1;
int RE_id(char msg[],int startId){
bool cStart,inSpace=false;
numTest=-1;
int i;
for(i=startId;i<strlen(msg);i++){
int num=msg[i]-'a';
if((num>=0&&num<=25)||(num>=-32&&num<=-7)||(num==-2)){
if(inSpace)
return -1;//錯誤訊息
cStart=true;
continue;
}
else if(num==-57||num==-56){//遇到右括號要回傳
return i-1;
}
else if(num==-65){
if((num==-65)&&cStart){
inSpace=true;
continue;
}
if(num==-65)
numTest=-65;
}
else{
return -1;//錯誤訊息
}
}
}
int RE_inum(char msg[], int startId){
bool cStart,inSpace=false;
numTest=-1;
int i;
for(i=startId;i<strlen(msg);i++){
int num=msg[i]-'a';
if((num>=-49&&num<=-40)){
if(inSpace)
return -1;//錯誤訊息
cStart=true;
continue;
}//0~9
else if(num==-56){//遇到右括號要回傳
if((num==-65)&&cStart){
inSpace=true;
continue;
}
if(num==-65)
numTest=-65;
return i-1;
}
else if(num==-65){
if((num==-65)&&cStart){
inSpace=true;
continue;
}
if(num==-65)
numTest=-65;
}
else{
return -1;//錯誤訊息
}
}
}
void RE_space(char msg){
int num=msg-'a';
if(num==-65){
return;
}
else{
result="invalid input";
}
}
void RE_lparenthesie(char msg){
int num=msg-'a';
if(num==-57){
string temp(1,msg);
result+="lparenthesis "+temp+"\n";
}
else{
result="invalid input";
}
}
void RE_rparenthesie(char msg){
int num=msg-'a';
if(num==-56){
string temp(1,msg);
result+="rparenthesis "+temp+"\n";
}
else{
result="invalid input";
}
}
void Para(char msg[], int startId){
string temp;
int id=RE_id(msg,startId);
int inum=RE_inum(msg,startId);
if(id!=-1){
if(numTest==-65)
return;
else
result+="id "+temp.assign(msg,startId,id-startId+1)+"\n";
}
else if(inum!=-1){
if(numTest==-65)
return;
else
result+="inum "+temp.assign(msg,startId,inum-startId+1)+"\n";
}
else if(msg[startId+1]==NULL){//空字串
return;
}
else{
result="invalid input";
}
}
void Func(char msg[], int startId){
RE_lparenthesie(msg[startId]);
int num=msg[startId+1]-'a';
if(num==-65)
startId++;
if(result!="invalid input"){
Para(msg,startId+1);
}
else{
return;
}
if(result!="invalid input"){
RE_rparenthesie(msg[strlen(msg)-1]);
}
else{result="invalid input";
return;
}
}
void Stmt(char msg[]){
if(strlen(msg)<=1){
result="invalid input";
return;
}
string temp;
int id=RE_id(msg,0);
if(id!=-1){
result+="id "+temp.assign(msg,0,id+1)+"\n";
}
else{
result="invalid input";
return;
}
if(result!="invalid input"){
int num=msg[id+1]-'a';
if(num==-65)
Func(msg,id+2);
else
Func(msg,id+1);
}
else{
return;
}
}
int main(){
const int size=50;
char msg[size] ;
cin.getline(msg,size);
Stmt(msg);
cout <<result << endl;
return 0;
}
| [
"fntsrlike@gmail.com"
] | fntsrlike@gmail.com |
8459973170a5f52cd76ebe0d021132091a00bf15 | f3c27477dc0404c42537ffa5fc5073c0a8c0c882 | /Ch02_Lighting/Sec04_LightingMaps/LightingMaps_Ex02/LightingMaps_Ex02/Window.hpp | bd9811da78860654ba7ad97cb469af10cebf75ab | [] | no_license | Hoke/LearnOpenGL | cf65e44838b3c12bc91d9fb61f606db8b19e04c8 | 380ceb7c58b7e6eb5abb34e22d2825e08be17d70 | refs/heads/master | 2023-03-05T03:14:54.893423 | 2021-02-14T10:35:23 | 2021-02-14T10:35:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,770 | hpp | //
// Window.hpp
// LightingMaps_Ex02
//
// Created by shenyuanluo on 2017/8/20.
// Copyright © 2017年 http://blog.shenyuanluo.com/ All rights reserved.
//
#ifndef Window_hpp
#define Window_hpp
#include <iostream>
#include <glad/glad.h>
#include <GLFW//glfw3.h>
typedef enum __retStatus {
Ret_failure = 0, /* 失败 */
Ret_success = 1, /* 成功 */
}RetStatus;
class Window
{
private:
GLFWwindow* m_window; /** 窗体实例 */
const GLuint m_width; /** 窗体宽度 */
const GLuint m_height; /** 窗体高度 */
const GLchar* m_title; /** 窗体标题 */
std::string m_cwd; /** 可执行文件路径 */
GLfloat m_currFTime; /* 当前帧时间 */
GLfloat m_lastFTime; /* 上一帧时间 */
GLfloat m_dealFTime; /* 每一帧处理时间 */
/**
创建 GLFW 窗体实例
@return GLFW 实例
*/
GLFWwindow* createWindow();
/**
初始化 GLAD
@return 参见‘RetStatus’
*/
RetStatus initGlad();
/**
获取文件的绝对路径
@param filePath 文件相对路径
@return 绝对路径
*/
std::string fullPath(const std::string &filePath);
/**
处理用户输入回调
@param window GLFW 窗体实例
*/
void processInput(GLFWwindow* window);
/**
清理资源
*/
void clearWindow();
/**
设置顶点数组对象
@param outVBO 顶点缓存对象引用 ID
@param vertexBuff 顶点缓存
@param vbLen 顶点缓存长度
@param outEBO 索引缓存对象引用 ID
@param indicesBuff 索引缓存
@param ibLen 索引缓存长度
@return 成功，则返回顶点数组对象引用 ID；失败，则返回 0
*/
GLuint configObjectVAO(GLuint* outVBO, GLfloat* vertexBuff, GLuint vbLen, GLuint* outEBO, GLuint* indicesBuff, GLuint ibLen);
/**
创建光源的顶点数组对象
@return 成功，则返回顶点数组对象引用 ID；失败，则返回 0
*/
GLuint configLightVAO(GLuint* outVBO, GLfloat* vertexBuff, GLuint vbLen, GLuint* outEBO, GLuint* indicesBuff, GLuint ibLen);
/**
GLFW 错误回调
@param errorCode 错误代码
@param description 错误描述
*/
static void errorCallback(GLint errorCode, const GLchar* description);
/**
GLFW 窗体大小回调
@param window GLFW 窗体实例
@param width 窗体款第
@param height 窗体高度
*/
static void frameBufferSizeCB(GLFWwindow* window, GLint width, GLint height);
/**
鼠标（移动）事件回调
@param window GLFW 窗体实例
@param posX 鼠标当前位置 x 坐标
@param posY 鼠标当前位置 y 坐标
*/
static void mouseMoveCB(GLFWwindow* window, GLdouble posX, GLdouble posY);
/**
鼠标（滚动）事件回调
@param window GLFW 窗体实例
@param offsetX 鼠标滚动 x 偏移量
@param offsetY 鼠标滚动 y 偏移量
*/
static void mouseScrollCB(GLFWwindow* window, GLdouble offsetX, GLdouble offsetY);
public:
Window(GLuint width, GLuint height, const GLchar* title);
~Window();
/**
设置可执行文件所在目录·绝对路径
@param cwdPath 可执行文件绝对路径
*/
void setCWD(const std::string &cwdPath);
/**
渲染
@param vertexBuff 顶点缓冲
@param buffLen 缓冲长度
*/
void render(GLfloat* vertexBuff, GLuint buffLen);
};
#endif /* Window_hpp */
| [
"shenyuanluo@163.com"
] | shenyuanluo@163.com |
41523f3cd6f2ef066ab806daa941ce2885d0f9be | b215e50bcc1328f715caa9a9b738eed0ce098abc | /C习题库/92.1，2，5组合.cpp | 1c6d453eb82f85005a755e682d2fe65b222fb95c | [] | no_license | sssouth/south | 8cd0dcd749e5b113bbc9668985a2e084cc10af5d | 3e84262e9c911354def292417df68e99aef3d2e9 | refs/heads/master | 2022-06-23T23:21:13.328731 | 2020-02-23T14:41:22 | 2020-02-23T14:41:22 | 165,342,324 | 0 | 0 | null | 2022-06-21T02:50:56 | 2019-01-12T03:36:02 | C++ | GB18030 | C++ | false | false | 481 | cpp | //题目：如何组合1、2、5这三个数使其和为100.
#include <stdio.h>
int main(void)
{
int x,y,z,count=0;//x,y,z代表1，2，5的个数
printf("所有可能情况:\n");
for(z=0;z<=20;z++)//x+2*y+5*z=100,即x+5*z为偶数
{
for(y=100-5*z;y>=0;y-=2)
{
if(2*y+5*z<=100)
{
x=100-2*y-5*z;
printf("1*%d+2*%d+5*%d=100\t",x,y,z);
count+=1;
if(count==5)//5个为一行输出
{
printf("\n");
count=0;
}
}
}
}
return 0;
}
| [
"1182394023@qq.com"
] | 1182394023@qq.com |
5b8ec0672aba9876be4670068885db9bfd7fb5ea | e993fb1a77cf8df900e5da3c2062d5e3047d1940 | /Effective_Modern_Cpp/Item01-template_deduction/code.cc | ab6b39a96a764ccc10d01523ec574cec9a08c4fc | [] | no_license | activeion/Books_SourceCode | 2dba4e8d988106a902fc4bb7c084bda0c1a42ea3 | 7c6c23d4c22aa0ad3c8f01b0bba962527bdc599e | refs/heads/master | 2021-07-23T14:47:35.489523 | 2021-02-23T12:16:12 | 2021-02-23T12:16:12 | 100,842,985 | 19 | 11 | null | 2021-02-26T02:13:43 | 2017-08-20T06:28:48 | C++ | UTF-8 | C++ | false | false | 3,019 | cc |
template<typename T>
void f1(T& param)
{;}
template<typename T>
void f2(const T& param)
{;}
template<typename T>
void f3(T* param)
{;}
template<typename T>
void f4(T&& param)
{;}
template<typename T>
void f5(T param) //此处会有copy构造
{;}
#include <cstddef> //for size_t defination
template<typename T>
void f6(T& param)
{;}
template <typename T, std::size_t N>
constexpr std::size_t arraySize(T (&)[N]) noexcept
{
return N;
}
template<typename T>
void f10(T& param)
{;}
template<typename T>
void f20(T* param)
{;}
template<typename T>
void f30(T param)
{;}
void fun(int, double)
{;}
int main(void)
{
{// void f1(T& param)
int x = 27;
const int cx = x;
const int& rx = x;
f1(x); // T 的类型为int, ParamType的类型为int&
f1(cx); // T 的类型为const int, ParamType的类型为const int&
f1(rx); // T 的类型为const int, ParamType的类型为const int&
}
{// void f2(const T& param)
int x = 27;
const int cx = x;
const int& rx = x;
// 一样调用模板函数
f2(x); // T 的类型为int, ParamType的类型为cont int&
f2(cx); // T 的类型为int, ParamType的类型为const int&
f2(rx); // T 的类型为int, ParamType的类型为const int&
}
{// void f3(T* param)
int x = 27;
const int* px = &x;
const int& rx = x;
// 一样调用模板函数
f3(&x); // T 的类型为int, ParamType的类型为int*
f3(px); // T 的类型为const int, ParamType的类型为const int*
}
{// void f4(T&& param)
int x = 27;
const int cx = x;
const int& rx = x;
f4(x); // x是左值，所以T 和ParamType会被推断为int &类型，根据折叠规则 int& && = int&
f4(cx); // cx是左值，所以T和ParamType会被推断为const int &类型
f4(rx); // rx是左值，所以T和 ParamType会被推断为const int &类型
f4(27); // 27是右值，根据情况1，T的类型会被推断为int、ParamType会被推断为int &&
}
{// void f5(T param) //此处会有copy构造
int x = 27;
const int cx = x;
const int &rx = x;
f5(x); // 易知T和ParamType的类型都是int
f5(cx); // 忽略const，T和ParamType的类型都是int
f5(rx); // 忽略了引用后再忽略const,T和ParamType的类型都是int
}
{// void f6(T& param)
const char name[] = "J. R. Briggs"; // name = const char[13]
f6(name); // T = const char*
int size = arraySize(name);
}
{// void f10(T& param); void f20(T* param); void f30(T param). void fun(int, double)
f10(fun); // pt param = void (&)(int, double); pt T = void (int, double)
f20(fun); // pt param = void (*)(int, double); pt T = void (int, double)
f30(fun); // pt param = void (*)(int, double); pt T = void (*)(int, double)
return 0;
}
return 0;
}
| [
"ji.zhonghua@qq.com"
] | ji.zhonghua@qq.com |
b636c5826d25e60e2a3de97203bb12da9d3b53b1 | b700a3a3c0ae47379e01594df54d61cc06c3a5af | /src/protocol.cpp | 6a91aa3cc4a62174961f86cd0489c3e35e02aa4a | [
"MIT"
] | permissive | cygnusxi/Test-Net-Hard-Fork | b951b9d5876c9bf8ae62d4fccb64c481277a6612 | 0b716226f4924e776f6e51c0eba9527b7a05f87d | refs/heads/master | 2020-03-16T17:52:16.493395 | 2018-05-14T14:42:35 | 2018-05-14T14:42:35 | 132,850,149 | 2 | 0 | MIT | 2018-05-11T04:33:20 | 2018-05-10T04:53:47 | C++ | UTF-8 | C++ | false | false | 3,401 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2013 The curecoin developer
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "protocol.h"
#include "util.h"
#include "netbase.h"
#ifndef WIN32
# include <arpa/inet.h>
#endif
static const char* ppszTypeName[] =
{
"ERROR",
"tx",
"block",
};
CMessageHeader::CMessageHeader()
{
memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
memset(pchCommand, 0, sizeof(pchCommand));
pchCommand[1] = 1;
nMessageSize = -1;
nChecksum = 0;
}
CMessageHeader::CMessageHeader(const char* pszCommand, unsigned int nMessageSizeIn)
{
memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
strncpy(pchCommand, pszCommand, COMMAND_SIZE);
nMessageSize = nMessageSizeIn;
nChecksum = 0;
}
std::string CMessageHeader::GetCommand() const
{
if (pchCommand[COMMAND_SIZE-1] == 0)
return std::string(pchCommand, pchCommand + strlen(pchCommand));
else
return std::string(pchCommand, pchCommand + COMMAND_SIZE);
}
bool CMessageHeader::IsValid() const
{
// Check start string
if (memcmp(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart)) != 0)
return false;
// Check the command string for errors
for (const char* p1 = pchCommand; p1 < pchCommand + COMMAND_SIZE; p1++)
{
if (*p1 == 0)
{
// Must be all zeros after the first zero
for (; p1 < pchCommand + COMMAND_SIZE; p1++)
if (*p1 != 0)
return false;
}
else if (*p1 < ' ' || *p1 > 0x7E)
return false;
}
// Message size
if (nMessageSize > MAX_SIZE)
{
printf("CMessageHeader::IsValid() : (%s, %u bytes) nMessageSize > MAX_SIZE\n", GetCommand().c_str(), nMessageSize);
return false;
}
return true;
}
CAddress::CAddress() : CService()
{
Init();
}
CAddress::CAddress(CService ipIn, uint64 nServicesIn) : CService(ipIn)
{
Init();
nServices = nServicesIn;
}
void CAddress::Init()
{
nServices = NODE_NETWORK;
nTime = 100000000;
nLastTry = 0;
}
CInv::CInv()
{
type = 0;
hash = 0;
}
CInv::CInv(int typeIn, const uint256& hashIn)
{
type = typeIn;
hash = hashIn;
}
CInv::CInv(const std::string& strType, const uint256& hashIn)
{
unsigned int i;
for (i = 1; i < ARRAYLEN(ppszTypeName); i++)
{
if (strType == ppszTypeName[i])
{
type = i;
break;
}
}
if (i == ARRAYLEN(ppszTypeName))
throw std::out_of_range(strprintf("CInv::CInv(string, uint256) : unknown type '%s'", strType.c_str()));
hash = hashIn;
}
bool operator<(const CInv& a, const CInv& b)
{
return (a.type < b.type || (a.type == b.type && a.hash < b.hash));
}
bool CInv::IsKnownType() const
{
return (type >= 1 && type < (int)ARRAYLEN(ppszTypeName));
}
const char* CInv::GetCommand() const
{
if (!IsKnownType())
throw std::out_of_range(strprintf("CInv::GetCommand() : type=%d unknown type", type));
return ppszTypeName[type];
}
std::string CInv::ToString() const
{
return strprintf("%s %s", GetCommand(), hash.ToString().substr(0,20).c_str());
}
void CInv::print() const
{
printf("CInv(%s)\n", ToString().c_str());
}
| [
"racingoblivious@gmail.com"
] | racingoblivious@gmail.com |
d21d91061621b987102f739764d6f5f0b7f8d4dd | 847cccd728e768dc801d541a2d1169ef562311cd | /externalLibs/Box2D/Source/Box2D/Dynamics/Contacts/b2Contact.h | 118c38293707a82cb84ecc9044acd48b767219db | [] | no_license | aadarshasubedi/Ocerus | 1bea105de9c78b741f3de445601f7dee07987b96 | 4920b99a89f52f991125c9ecfa7353925ea9603c | refs/heads/master | 2021-01-17T17:50:00.472657 | 2011-03-25T13:26:12 | 2011-03-25T13:26:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,776 | h | /*
* Copyright (c) 2006-2009 Erin Catto http://www.gphysics.com
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
#ifndef B2_CONTACT_H
#define B2_CONTACT_H
#include <Box2D/Common/b2Math.h>
#include <Box2D/Collision/b2Collision.h>
#include <Box2D/Collision/Shapes/b2Shape.h>
#include <Box2D/Dynamics/Contacts/b2Contact.h>
#include <Box2D/Dynamics/b2Fixture.h>
class b2Body;
class b2Contact;
class b2Fixture;
class b2World;
class b2BlockAllocator;
class b2StackAllocator;
class b2ContactListener;
typedef b2Contact* b2ContactCreateFcn(b2Fixture* fixtureA, b2Fixture* fixtureB, b2BlockAllocator* allocator);
typedef void b2ContactDestroyFcn(b2Contact* contact, b2BlockAllocator* allocator);
struct b2ContactRegister
{
b2ContactCreateFcn* createFcn;
b2ContactDestroyFcn* destroyFcn;
bool primary;
};
/// A contact edge is used to connect bodies and contacts together
/// in a contact graph where each body is a node and each contact
/// is an edge. A contact edge belongs to a doubly linked list
/// maintained in each attached body. Each contact has two contact
/// nodes, one for each attached body.
struct b2ContactEdge
{
b2Body* other; ///< provides quick access to the other body attached.
b2Contact* contact; ///< the contact
b2ContactEdge* prev; ///< the previous contact edge in the body's contact list
b2ContactEdge* next; ///< the next contact edge in the body's contact list
};
/// The class manages contact between two shapes. A contact exists for each overlapping
/// AABB in the broad-phase (except if filtered). Therefore a contact object may exist
/// that has no contact points.
class b2Contact
{
public:
/// Get the contact manifold. Do not modify the manifold unless you understand the
/// internals of Box2D.
b2Manifold* GetManifold();
const b2Manifold* GetManifold() const;
/// Get the world manifold.
void GetWorldManifold(b2WorldManifold* worldManifold) const;
/// Is this contact touching?
bool IsTouching() const;
/// Enable/disable this contact. This can be used inside the pre-solve
/// contact listener. The contact is only disabled for the current
/// time step (or sub-step in continuous collisions).
void SetEnabled(bool flag);
/// Has this contact been disabled?
bool IsEnabled() const;
/// Get the next contact in the world's contact list.
b2Contact* GetNext();
const b2Contact* GetNext() const;
/// Get the first fixture in this contact.
b2Fixture* GetFixtureA();
const b2Fixture* GetFixtureA() const;
/// Get the second fixture in this contact.
b2Fixture* GetFixtureB();
const b2Fixture* GetFixtureB() const;
/// Flag this contact for filtering. Filtering will occur the next time step.
void FlagForFiltering();
/// Evaluate this contact with your own manifold and transforms.
virtual void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) = 0;
protected:
friend class b2ContactManager;
friend class b2World;
friend class b2ContactSolver;
// Flags stored in m_flags
enum
{
// Used when crawling contact graph when forming islands.
e_islandFlag = 0x0001,
// Set when the shapes are touching.
e_touchingFlag = 0x0002,
// This contact can be disabled (by user)
e_enabledFlag = 0x0004,
// This contact needs filtering because a fixture filter was changed.
e_filterFlag = 0x0008
};
static void AddType(b2ContactCreateFcn* createFcn, b2ContactDestroyFcn* destroyFcn,
b2Shape::Type typeA, b2Shape::Type typeB);
static void InitializeRegisters();
static b2Contact* Create(b2Fixture* fixtureA, b2Fixture* fixtureB, b2BlockAllocator* allocator);
static void Destroy(b2Contact* contact, b2Shape::Type typeA, b2Shape::Type typeB, b2BlockAllocator* allocator);
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
b2Contact() : m_fixtureA(NULL), m_fixtureB(NULL) {}
b2Contact(b2Fixture* fixtureA, b2Fixture* fixtureB);
virtual ~b2Contact() {}
void Update(b2ContactListener* listener);
static b2ContactRegister s_registers[b2Shape::e_typeCount][b2Shape::e_typeCount];
static bool s_initialized;
uint32 m_flags;
// World pool and list pointers.
b2Contact* m_prev;
b2Contact* m_next;
// Nodes for connecting bodies.
b2ContactEdge m_nodeA;
b2ContactEdge m_nodeB;
b2Fixture* m_fixtureA;
b2Fixture* m_fixtureB;
b2Manifold m_manifold;
int32 m_toiCount;
// float32 m_toi;
};
inline b2Manifold* b2Contact::GetManifold()
{
return &m_manifold;
}
inline const b2Manifold* b2Contact::GetManifold() const
{
return &m_manifold;
}
inline void b2Contact::GetWorldManifold(b2WorldManifold* worldManifold) const
{
const b2Body* bodyA = m_fixtureA->GetBody();
const b2Body* bodyB = m_fixtureB->GetBody();
const b2Shape* shapeA = m_fixtureA->GetShape();
const b2Shape* shapeB = m_fixtureB->GetShape();
worldManifold->Initialize(&m_manifold, bodyA->GetTransform(), shapeA->m_radius, bodyB->GetTransform(), shapeB->m_radius);
}
inline void b2Contact::SetEnabled(bool flag)
{
if (flag)
{
m_flags |= e_enabledFlag;
}
else
{
m_flags &= ~e_enabledFlag;
}
}
inline bool b2Contact::IsEnabled() const
{
return (m_flags & e_enabledFlag) == e_enabledFlag;
}
inline bool b2Contact::IsTouching() const
{
return (m_flags & e_touchingFlag) == e_touchingFlag;
}
inline b2Contact* b2Contact::GetNext()
{
return m_next;
}
inline const b2Contact* b2Contact::GetNext() const
{
return m_next;
}
inline b2Fixture* b2Contact::GetFixtureA()
{
return m_fixtureA;
}
inline const b2Fixture* b2Contact::GetFixtureA() const
{
return m_fixtureA;
}
inline b2Fixture* b2Contact::GetFixtureB()
{
return m_fixtureB;
}
inline const b2Fixture* b2Contact::GetFixtureB() const
{
return m_fixtureB;
}
inline void b2Contact::FlagForFiltering()
{
m_flags |= e_filterFlag;
}
#endif
| [
"MacJariel@gmail.com"
] | MacJariel@gmail.com |
e1a35e9d0ae3cf17d28819418db598bba270a26a | 129699935f0d5cc1131328fba922351941a08517 | /extras/EDSDKv0308W/Windows/Sample/VC/RAWDevelop/RAWDevelop.cpp | f9d5c62fc8b13b3146fff82250c64868424e3200 | [] | no_license | ollietb/EDSDKLib-1.1.2-nodeBindings | 9b9251f5a8ff30e694013650644ae3ae55f3867f | 4353ec33edb14516cd4821120202d865fdf795a6 | refs/heads/master | 2020-03-12T21:18:09.650581 | 2018-07-19T15:11:40 | 2018-07-19T15:11:40 | 130,825,442 | 1 | 0 | null | 2018-04-24T08:56:00 | 2018-04-24T08:55:59 | null | UTF-8 | C++ | false | false | 3,437 | cpp | /******************************************************************************
* *
* PROJECT : EOS Digital Software Development Kit EDSDK *
* NAME : RAWDevelop.cpp *
* *
* Description: This is the Sample code to show the usage of EDSDK. *
* *
* *
*******************************************************************************
* *
* Written and developed by Camera Design Dept.53 *
* Copyright Canon Inc. 2006 All Rights Reserved *
* *
*******************************************************************************
* File Update Information: *
* DATE Identify Comment *
* ----------------------------------------------------------------------- *
* 06-03-22 F-001 create first version. *
* *
******************************************************************************/
// RAWDevelop.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include "RAWDevelop.h"
#include "RAWDevelopDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
// CRAWDevelopApp
BEGIN_MESSAGE_MAP(CRAWDevelopApp, CWinApp)
ON_COMMAND(ID_HELP, CWinApp::OnHelp)
END_MESSAGE_MAP()
// CRAWDevelopApp construction
CRAWDevelopApp::CRAWDevelopApp()
{
// TODO: add construction code here,
// Place all significant initialization in InitInstance
}
// The one and only CRAWDevelopApp object
CRAWDevelopApp theApp;
// CRAWDevelopApp initialization
BOOL CRAWDevelopApp::InitInstance()
{
// InitCommonControls() is required on Windows XP if an application
// manifest specifies use of ComCtl32.dll version 6 or later to enable
// visual styles. Otherwise, any window creation will fail.
InitCommonControls();
CWinApp::InitInstance();
AfxEnableControlContainer();
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need
// Change the registry key under which our settings are stored
// TODO: You should modify this string to be something appropriate
// such as the name of your company or organization
SetRegistryKey(_T("Local AppWizard-Generated Applications"));
CRAWDevelopDlg dlg;
m_pMainWnd = &dlg;
INT_PTR nResponse = dlg.DoModal();
if (nResponse == IDOK)
{
// TODO: Place code here to handle when the dialog is
// dismissed with OK
}
else if (nResponse == IDCANCEL)
{
// TODO: Place code here to handle when the dialog is
// dismissed with Cancel
}
// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}
| [
"ufidstudios@gmail.com"
] | ufidstudios@gmail.com |
fe765e07e01a22987d90c1fd98b85a2b08c4099c | 8e9d7749e5b2737151371a9c34f4528d4322b1d5 | /wxLua/modules/wxbind/src/wxadv_bind.cpp | 6ede310bf8c93981b798b4adde16a94d0a47ad53 | [] | no_license | muhkuh-sys/wxlua | 9bc556c936ba2119d891e7a94d9fd5ad15d2b7e7 | e80dfb090bf9122c672c22eedbbc918bb8de9594 | refs/heads/master | 2020-06-26T22:31:22.093543 | 2015-07-02T20:25:22 | 2015-07-02T20:25:22 | 30,452,287 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 883,602 | cpp | // ---------------------------------------------------------------------------
// ../modules/wxbind/src/wxadv_adv.cpp was generated by genwxbind.lua
//
// Any changes made to this file will be lost when the file is regenerated.
// ---------------------------------------------------------------------------
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include "wxlua/wxlstate.h"
#include "wxbind/include/wxadv_bind.h"
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wunused-variable"
#endif // __GNUC__
#if wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
// ---------------------------------------------------------------------------
// Bind class wxAboutDialogInfo
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxAboutDialogInfo'
int wxluatype_wxAboutDialogInfo = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_AddArtist[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_AddArtist(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_AddArtist[1] = {{ wxLua_wxAboutDialogInfo_AddArtist, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_AddArtist }};
// void AddArtist(const wxString& artist );
static int LUACALL wxLua_wxAboutDialogInfo_AddArtist(lua_State *L)
{
// const wxString artist
const wxString artist = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call AddArtist
self->AddArtist(artist);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_AddDeveloper[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_AddDeveloper(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_AddDeveloper[1] = {{ wxLua_wxAboutDialogInfo_AddDeveloper, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_AddDeveloper }};
// void AddDeveloper(const wxString& developer );
static int LUACALL wxLua_wxAboutDialogInfo_AddDeveloper(lua_State *L)
{
// const wxString developer
const wxString developer = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call AddDeveloper
self->AddDeveloper(developer);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_AddDocWriter[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_AddDocWriter(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_AddDocWriter[1] = {{ wxLua_wxAboutDialogInfo_AddDocWriter, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_AddDocWriter }};
// void AddDocWriter(const wxString& docwriter );
static int LUACALL wxLua_wxAboutDialogInfo_AddDocWriter(lua_State *L)
{
// const wxString docwriter
const wxString docwriter = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call AddDocWriter
self->AddDocWriter(docwriter);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_AddTranslator[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_AddTranslator(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_AddTranslator[1] = {{ wxLua_wxAboutDialogInfo_AddTranslator, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_AddTranslator }};
// void AddTranslator(const wxString& translator );
static int LUACALL wxLua_wxAboutDialogInfo_AddTranslator(lua_State *L)
{
// const wxString translator
const wxString translator = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call AddTranslator
self->AddTranslator(translator);
return 0;
}
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetArtists[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetArtists(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetArtists[1] = {{ wxLua_wxAboutDialogInfo_GetArtists, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetArtists }};
// wxArrayString GetArtists() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetArtists(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetArtists
// allocate a new object using the copy constructor
wxArrayString* returns = new wxArrayString(self->GetArtists());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxArrayString);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxArrayString);
return 1;
}
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetCopyright[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetCopyright(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetCopyright[1] = {{ wxLua_wxAboutDialogInfo_GetCopyright, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetCopyright }};
// wxString GetCopyright() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetCopyright(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetCopyright
wxString returns = (self->GetCopyright());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetDescription[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetDescription(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetDescription[1] = {{ wxLua_wxAboutDialogInfo_GetDescription, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetDescription }};
// wxString GetDescription() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetDescription(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetDescription
wxString returns = (self->GetDescription());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetDescriptionAndCredits[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetDescriptionAndCredits(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetDescriptionAndCredits[1] = {{ wxLua_wxAboutDialogInfo_GetDescriptionAndCredits, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetDescriptionAndCredits }};
// wxString GetDescriptionAndCredits() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetDescriptionAndCredits(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetDescriptionAndCredits
wxString returns = (self->GetDescriptionAndCredits());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetDevelopers[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetDevelopers(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetDevelopers[1] = {{ wxLua_wxAboutDialogInfo_GetDevelopers, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetDevelopers }};
// const wxArrayString& GetDevelopers() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetDevelopers(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetDevelopers
const wxArrayString* returns = (const wxArrayString*)&self->GetDevelopers();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxArrayString);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetDocWriters[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetDocWriters(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetDocWriters[1] = {{ wxLua_wxAboutDialogInfo_GetDocWriters, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetDocWriters }};
// wxArrayString GetDocWriters() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetDocWriters(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetDocWriters
// allocate a new object using the copy constructor
wxArrayString* returns = new wxArrayString(self->GetDocWriters());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxArrayString);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxArrayString);
return 1;
}
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
#if (wxLUA_USE_wxIcon) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetIcon[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetIcon(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetIcon[1] = {{ wxLua_wxAboutDialogInfo_GetIcon, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetIcon }};
// wxIcon GetIcon() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetIcon(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetIcon
// allocate a new object using the copy constructor
wxIcon* returns = new wxIcon(self->GetIcon());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxIcon);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxIcon);
return 1;
}
#endif // (wxLUA_USE_wxIcon) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetLicence[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetLicence(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetLicence[1] = {{ wxLua_wxAboutDialogInfo_GetLicence, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetLicence }};
// wxString GetLicence() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetLicence(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetLicence
wxString returns = (self->GetLicence());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetName[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetName(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetName[1] = {{ wxLua_wxAboutDialogInfo_GetName, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetName }};
// wxString GetName() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetName(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetName
wxString returns = (self->GetName());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetTranslators[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetTranslators(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetTranslators[1] = {{ wxLua_wxAboutDialogInfo_GetTranslators, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetTranslators }};
// wxArrayString GetTranslators() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetTranslators(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetTranslators
// allocate a new object using the copy constructor
wxArrayString* returns = new wxArrayString(self->GetTranslators());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxArrayString);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxArrayString);
return 1;
}
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetVersion[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetVersion(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetVersion[1] = {{ wxLua_wxAboutDialogInfo_GetVersion, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetVersion }};
// wxString GetVersion() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetVersion(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetVersion
wxString returns = (self->GetVersion());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetWebSiteDescription[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetWebSiteDescription(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetWebSiteDescription[1] = {{ wxLua_wxAboutDialogInfo_GetWebSiteDescription, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetWebSiteDescription }};
// wxString GetWebSiteDescription() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetWebSiteDescription(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetWebSiteDescription
wxString returns = (self->GetWebSiteDescription());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetWebSiteURL[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_GetWebSiteURL(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_GetWebSiteURL[1] = {{ wxLua_wxAboutDialogInfo_GetWebSiteURL, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_GetWebSiteURL }};
// wxString GetWebSiteURL() const;
static int LUACALL wxLua_wxAboutDialogInfo_GetWebSiteURL(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call GetWebSiteURL
wxString returns = (self->GetWebSiteURL());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasArtists[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_HasArtists(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_HasArtists[1] = {{ wxLua_wxAboutDialogInfo_HasArtists, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasArtists }};
// bool HasArtists() const;
static int LUACALL wxLua_wxAboutDialogInfo_HasArtists(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call HasArtists
bool returns = (self->HasArtists());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasCopyright[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_HasCopyright(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_HasCopyright[1] = {{ wxLua_wxAboutDialogInfo_HasCopyright, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasCopyright }};
// bool HasCopyright() const;
static int LUACALL wxLua_wxAboutDialogInfo_HasCopyright(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call HasCopyright
bool returns = (self->HasCopyright());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasDescription[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_HasDescription(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_HasDescription[1] = {{ wxLua_wxAboutDialogInfo_HasDescription, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasDescription }};
// bool HasDescription() const;
static int LUACALL wxLua_wxAboutDialogInfo_HasDescription(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call HasDescription
bool returns = (self->HasDescription());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasDevelopers[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_HasDevelopers(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_HasDevelopers[1] = {{ wxLua_wxAboutDialogInfo_HasDevelopers, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasDevelopers }};
// bool HasDevelopers() const;
static int LUACALL wxLua_wxAboutDialogInfo_HasDevelopers(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call HasDevelopers
bool returns = (self->HasDevelopers());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasDocWriters[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_HasDocWriters(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_HasDocWriters[1] = {{ wxLua_wxAboutDialogInfo_HasDocWriters, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasDocWriters }};
// bool HasDocWriters() const;
static int LUACALL wxLua_wxAboutDialogInfo_HasDocWriters(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call HasDocWriters
bool returns = (self->HasDocWriters());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasIcon[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_HasIcon(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_HasIcon[1] = {{ wxLua_wxAboutDialogInfo_HasIcon, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasIcon }};
// bool HasIcon() const;
static int LUACALL wxLua_wxAboutDialogInfo_HasIcon(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call HasIcon
bool returns = (self->HasIcon());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasLicence[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_HasLicence(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_HasLicence[1] = {{ wxLua_wxAboutDialogInfo_HasLicence, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasLicence }};
// bool HasLicence() const;
static int LUACALL wxLua_wxAboutDialogInfo_HasLicence(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call HasLicence
bool returns = (self->HasLicence());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasTranslators[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_HasTranslators(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_HasTranslators[1] = {{ wxLua_wxAboutDialogInfo_HasTranslators, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasTranslators }};
// bool HasTranslators() const;
static int LUACALL wxLua_wxAboutDialogInfo_HasTranslators(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call HasTranslators
bool returns = (self->HasTranslators());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasVersion[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_HasVersion(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_HasVersion[1] = {{ wxLua_wxAboutDialogInfo_HasVersion, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasVersion }};
// bool HasVersion() const;
static int LUACALL wxLua_wxAboutDialogInfo_HasVersion(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call HasVersion
bool returns = (self->HasVersion());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasWebSite[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_HasWebSite(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_HasWebSite[1] = {{ wxLua_wxAboutDialogInfo_HasWebSite, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_HasWebSite }};
// bool HasWebSite() const;
static int LUACALL wxLua_wxAboutDialogInfo_HasWebSite(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call HasWebSite
bool returns = (self->HasWebSite());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_IsSimple[] = { &wxluatype_wxAboutDialogInfo, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_IsSimple(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_IsSimple[1] = {{ wxLua_wxAboutDialogInfo_IsSimple, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_IsSimple }};
// bool IsSimple() const;
static int LUACALL wxLua_wxAboutDialogInfo_IsSimple(lua_State *L)
{
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call IsSimple
bool returns = (self->IsSimple());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetArtists[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_wxArrayString, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetArtists(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetArtists[1] = {{ wxLua_wxAboutDialogInfo_SetArtists, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetArtists }};
// void SetArtists(const wxArrayString& artists );
static int LUACALL wxLua_wxAboutDialogInfo_SetArtists(lua_State *L)
{
// const wxArrayString artists
wxLuaSmartwxArrayString artists = wxlua_getwxArrayString(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetArtists
self->SetArtists(artists);
return 0;
}
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetCopyright[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetCopyright(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetCopyright[1] = {{ wxLua_wxAboutDialogInfo_SetCopyright, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetCopyright }};
// void SetCopyright(const wxString& copyright );
static int LUACALL wxLua_wxAboutDialogInfo_SetCopyright(lua_State *L)
{
// const wxString copyright
const wxString copyright = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetCopyright
self->SetCopyright(copyright);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetDescription[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetDescription(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetDescription[1] = {{ wxLua_wxAboutDialogInfo_SetDescription, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetDescription }};
// void SetDescription(const wxString& desc );
static int LUACALL wxLua_wxAboutDialogInfo_SetDescription(lua_State *L)
{
// const wxString desc
const wxString desc = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetDescription
self->SetDescription(desc);
return 0;
}
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetDevelopers[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_wxArrayString, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetDevelopers(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetDevelopers[1] = {{ wxLua_wxAboutDialogInfo_SetDevelopers, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetDevelopers }};
// void SetDevelopers(const wxArrayString& developers );
static int LUACALL wxLua_wxAboutDialogInfo_SetDevelopers(lua_State *L)
{
// const wxArrayString developers
wxLuaSmartwxArrayString developers = wxlua_getwxArrayString(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetDevelopers
self->SetDevelopers(developers);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetDocWriters[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_wxArrayString, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetDocWriters(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetDocWriters[1] = {{ wxLua_wxAboutDialogInfo_SetDocWriters, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetDocWriters }};
// void SetDocWriters(const wxArrayString& docwriters );
static int LUACALL wxLua_wxAboutDialogInfo_SetDocWriters(lua_State *L)
{
// const wxArrayString docwriters
wxLuaSmartwxArrayString docwriters = wxlua_getwxArrayString(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetDocWriters
self->SetDocWriters(docwriters);
return 0;
}
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
#if (wxLUA_USE_wxIcon) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetIcon[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_wxIcon, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetIcon(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetIcon[1] = {{ wxLua_wxAboutDialogInfo_SetIcon, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetIcon }};
// void SetIcon(const wxIcon& icon );
static int LUACALL wxLua_wxAboutDialogInfo_SetIcon(lua_State *L)
{
// const wxIcon icon
const wxIcon * icon = (const wxIcon *)wxluaT_getuserdatatype(L, 2, wxluatype_wxIcon);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetIcon
self->SetIcon(*icon);
return 0;
}
#endif // (wxLUA_USE_wxIcon) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetLicence[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetLicence(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetLicence[1] = {{ wxLua_wxAboutDialogInfo_SetLicence, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetLicence }};
// void SetLicence(const wxString& licence );
static int LUACALL wxLua_wxAboutDialogInfo_SetLicence(lua_State *L)
{
// const wxString licence
const wxString licence = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetLicence
self->SetLicence(licence);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetLicense[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetLicense(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetLicense[1] = {{ wxLua_wxAboutDialogInfo_SetLicense, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetLicense }};
// void SetLicense(const wxString& licence );
static int LUACALL wxLua_wxAboutDialogInfo_SetLicense(lua_State *L)
{
// const wxString licence
const wxString licence = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetLicense
self->SetLicense(licence);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetName[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetName(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetName[1] = {{ wxLua_wxAboutDialogInfo_SetName, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetName }};
// void SetName(const wxString& name );
static int LUACALL wxLua_wxAboutDialogInfo_SetName(lua_State *L)
{
// const wxString name
const wxString name = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetName
self->SetName(name);
return 0;
}
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetTranslators[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_wxArrayString, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetTranslators(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetTranslators[1] = {{ wxLua_wxAboutDialogInfo_SetTranslators, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetTranslators }};
// void SetTranslators(const wxArrayString& translators );
static int LUACALL wxLua_wxAboutDialogInfo_SetTranslators(lua_State *L)
{
// const wxArrayString translators
wxLuaSmartwxArrayString translators = wxlua_getwxArrayString(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetTranslators
self->SetTranslators(translators);
return 0;
}
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetVersion[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetVersion(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetVersion[1] = {{ wxLua_wxAboutDialogInfo_SetVersion, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetVersion }};
// void SetVersion(const wxString& version );
static int LUACALL wxLua_wxAboutDialogInfo_SetVersion(lua_State *L)
{
// const wxString version
const wxString version = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetVersion
self->SetVersion(version);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetWebSite[] = { &wxluatype_wxAboutDialogInfo, &wxluatype_TSTRING, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAboutDialogInfo_SetWebSite(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_SetWebSite[1] = {{ wxLua_wxAboutDialogInfo_SetWebSite, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxAboutDialogInfo_SetWebSite }};
// void SetWebSite(const wxString& url, const wxString& desc = "" );
static int LUACALL wxLua_wxAboutDialogInfo_SetWebSite(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString desc = ""
const wxString desc = (argCount >= 3 ? wxlua_getwxStringtype(L, 3) : wxString(wxEmptyString));
// const wxString url
const wxString url = wxlua_getwxStringtype(L, 2);
// get this
wxAboutDialogInfo * self = (wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call SetWebSite
self->SetWebSite(url, desc);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAboutDialogInfo_delete[] = { &wxluatype_wxAboutDialogInfo, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxAboutDialogInfo_delete }};
static int LUACALL wxLua_wxAboutDialogInfo_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAboutDialogInfo_constructor[1] = {{ wxLua_wxAboutDialogInfo_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxAboutDialogInfo( );
static int LUACALL wxLua_wxAboutDialogInfo_constructor(lua_State *L)
{
// call constructor
wxAboutDialogInfo* returns = new wxAboutDialogInfo();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxAboutDialogInfo);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxAboutDialogInfo);
return 1;
}
void wxLua_wxAboutDialogInfo_delete_function(void** p)
{
wxAboutDialogInfo* o = (wxAboutDialogInfo*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxAboutDialogInfo_methods[] = {
{ "AddArtist", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_AddArtist, 1, NULL },
{ "AddDeveloper", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_AddDeveloper, 1, NULL },
{ "AddDocWriter", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_AddDocWriter, 1, NULL },
{ "AddTranslator", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_AddTranslator, 1, NULL },
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "GetArtists", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetArtists, 1, NULL },
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "GetCopyright", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetCopyright, 1, NULL },
{ "GetDescription", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetDescription, 1, NULL },
{ "GetDescriptionAndCredits", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetDescriptionAndCredits, 1, NULL },
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "GetDevelopers", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetDevelopers, 1, NULL },
{ "GetDocWriters", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetDocWriters, 1, NULL },
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
#if (wxLUA_USE_wxIcon) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "GetIcon", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetIcon, 1, NULL },
#endif // (wxLUA_USE_wxIcon) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "GetLicence", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetLicence, 1, NULL },
{ "GetName", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetName, 1, NULL },
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "GetTranslators", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetTranslators, 1, NULL },
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "GetVersion", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetVersion, 1, NULL },
{ "GetWebSiteDescription", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetWebSiteDescription, 1, NULL },
{ "GetWebSiteURL", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_GetWebSiteURL, 1, NULL },
{ "HasArtists", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_HasArtists, 1, NULL },
{ "HasCopyright", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_HasCopyright, 1, NULL },
{ "HasDescription", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_HasDescription, 1, NULL },
{ "HasDevelopers", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_HasDevelopers, 1, NULL },
{ "HasDocWriters", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_HasDocWriters, 1, NULL },
{ "HasIcon", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_HasIcon, 1, NULL },
{ "HasLicence", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_HasLicence, 1, NULL },
{ "HasTranslators", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_HasTranslators, 1, NULL },
{ "HasVersion", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_HasVersion, 1, NULL },
{ "HasWebSite", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_HasWebSite, 1, NULL },
{ "IsSimple", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_IsSimple, 1, NULL },
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "SetArtists", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetArtists, 1, NULL },
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "SetCopyright", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetCopyright, 1, NULL },
{ "SetDescription", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetDescription, 1, NULL },
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "SetDevelopers", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetDevelopers, 1, NULL },
{ "SetDocWriters", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetDocWriters, 1, NULL },
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
#if (wxLUA_USE_wxIcon) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "SetIcon", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetIcon, 1, NULL },
#endif // (wxLUA_USE_wxIcon) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "SetLicence", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetLicence, 1, NULL },
{ "SetLicense", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetLicense, 1, NULL },
{ "SetName", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetName, 1, NULL },
#if (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "SetTranslators", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetTranslators, 1, NULL },
#endif // (wxLUA_USE_wxArrayString) && (wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog)
{ "SetVersion", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetVersion, 1, NULL },
{ "SetWebSite", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAboutDialogInfo_SetWebSite, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxAboutDialogInfo_delete, 1, NULL },
{ "wxAboutDialogInfo", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxAboutDialogInfo_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxAboutDialogInfo_methodCount = sizeof(wxAboutDialogInfo_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
#if wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
// ---------------------------------------------------------------------------
// Bind class wxAnimation
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxAnimation'
int wxluatype_wxAnimation = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimation_GetDelay[] = { &wxluatype_wxAnimation, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxAnimation_GetDelay(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_GetDelay[1] = {{ wxLua_wxAnimation_GetDelay, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAnimation_GetDelay }};
// virtual int GetDelay(unsigned int frame) const; // can be -1
static int LUACALL wxLua_wxAnimation_GetDelay(lua_State *L)
{
// unsigned int frame
unsigned int frame = (unsigned int)wxlua_getuintegertype(L, 2);
// get this
wxAnimation * self = (wxAnimation *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimation);
// call GetDelay
int returns = (self->GetDelay(frame));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxImage && wxUSE_IMAGE)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimation_GetFrame[] = { &wxluatype_wxAnimation, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxAnimation_GetFrame(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_GetFrame[1] = {{ wxLua_wxAnimation_GetFrame, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAnimation_GetFrame }};
// virtual wxImage GetFrame(unsigned int frame) const;
static int LUACALL wxLua_wxAnimation_GetFrame(lua_State *L)
{
// unsigned int frame
unsigned int frame = (unsigned int)wxlua_getuintegertype(L, 2);
// get this
wxAnimation * self = (wxAnimation *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimation);
// call GetFrame
// allocate a new object using the copy constructor
wxImage* returns = new wxImage(self->GetFrame(frame));
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxImage);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxImage);
return 1;
}
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxImage && wxUSE_IMAGE)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimation_GetFrameCount[] = { &wxluatype_wxAnimation, NULL };
static int LUACALL wxLua_wxAnimation_GetFrameCount(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_GetFrameCount[1] = {{ wxLua_wxAnimation_GetFrameCount, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAnimation_GetFrameCount }};
// virtual unsigned int GetFrameCount() const;
static int LUACALL wxLua_wxAnimation_GetFrameCount(lua_State *L)
{
// get this
wxAnimation * self = (wxAnimation *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimation);
// call GetFrameCount
unsigned int returns = (self->GetFrameCount());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimation_GetSize[] = { &wxluatype_wxAnimation, NULL };
static int LUACALL wxLua_wxAnimation_GetSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_GetSize[1] = {{ wxLua_wxAnimation_GetSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAnimation_GetSize }};
// virtual wxSize GetSize() const;
static int LUACALL wxLua_wxAnimation_GetSize(lua_State *L)
{
// get this
wxAnimation * self = (wxAnimation *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimation);
// call GetSize
// allocate a new object using the copy constructor
wxSize* returns = new wxSize(self->GetSize());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxSize);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSize);
return 1;
}
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimation_IsOk[] = { &wxluatype_wxAnimation, NULL };
static int LUACALL wxLua_wxAnimation_IsOk(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_IsOk[1] = {{ wxLua_wxAnimation_IsOk, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAnimation_IsOk }};
// virtual bool IsOk() const;
static int LUACALL wxLua_wxAnimation_IsOk(lua_State *L)
{
// get this
wxAnimation * self = (wxAnimation *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimation);
// call IsOk
bool returns = (self->IsOk());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxUSE_STREAMS)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimation_Load[] = { &wxluatype_wxAnimation, &wxluatype_wxInputStream, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxAnimation_Load(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_Load[1] = {{ wxLua_wxAnimation_Load, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxAnimation_Load }};
// virtual bool Load(wxInputStream& stream, wxAnimationType type = wxANIMATION_TYPE_ANY );
static int LUACALL wxLua_wxAnimation_Load(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxAnimationType type = wxANIMATION_TYPE_ANY
wxAnimationType type = (argCount >= 3 ? (wxAnimationType)wxlua_getenumtype(L, 3) : wxANIMATION_TYPE_ANY);
// wxInputStream stream
wxInputStream * stream = (wxInputStream *)wxluaT_getuserdatatype(L, 2, wxluatype_wxInputStream);
// get this
wxAnimation * self = (wxAnimation *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimation);
// call Load
bool returns = (self->Load(*stream, type));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxUSE_STREAMS)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimation_LoadFile[] = { &wxluatype_wxAnimation, &wxluatype_TSTRING, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxAnimation_LoadFile(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_LoadFile[1] = {{ wxLua_wxAnimation_LoadFile, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxAnimation_LoadFile }};
// virtual bool LoadFile(const wxString& name, wxAnimationType type = wxANIMATION_TYPE_ANY );
static int LUACALL wxLua_wxAnimation_LoadFile(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxAnimationType type = wxANIMATION_TYPE_ANY
wxAnimationType type = (argCount >= 3 ? (wxAnimationType)wxlua_getenumtype(L, 3) : wxANIMATION_TYPE_ANY);
// const wxString name
const wxString name = wxlua_getwxStringtype(L, 2);
// get this
wxAnimation * self = (wxAnimation *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimation);
// call LoadFile
bool returns = (self->LoadFile(name, type));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimation_delete[] = { &wxluatype_wxAnimation, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxAnimation_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimation_constructor1[] = { &wxluatype_wxAnimation, NULL };
static int LUACALL wxLua_wxAnimation_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_constructor1[1] = {{ wxLua_wxAnimation_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 1, s_wxluatypeArray_wxLua_wxAnimation_constructor1 }};
// wxAnimation(const wxAnimation& anim );
static int LUACALL wxLua_wxAnimation_constructor1(lua_State *L)
{
// const wxAnimation anim
const wxAnimation * anim = (const wxAnimation *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimation);
// call constructor
wxAnimation* returns = new wxAnimation(*anim);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxAnimation);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxAnimation);
return 1;
}
static int LUACALL wxLua_wxAnimation_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_constructor[1] = {{ wxLua_wxAnimation_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxAnimation( );
static int LUACALL wxLua_wxAnimation_constructor(lua_State *L)
{
// call constructor
wxAnimation* returns = new wxAnimation();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxAnimation);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxAnimation);
return 1;
}
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimation_constructor_overload[] =
{
{ wxLua_wxAnimation_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 1, s_wxluatypeArray_wxLua_wxAnimation_constructor1 },
{ wxLua_wxAnimation_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxAnimation_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxAnimation_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
void wxLua_wxAnimation_delete_function(void** p)
{
wxAnimation* o = (wxAnimation*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxAnimation_methods[] = {
{ "GetDelay", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimation_GetDelay, 1, NULL },
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxImage && wxUSE_IMAGE)
{ "GetFrame", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimation_GetFrame, 1, NULL },
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxImage && wxUSE_IMAGE)
{ "GetFrameCount", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimation_GetFrameCount, 1, NULL },
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
{ "GetSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimation_GetSize, 1, NULL },
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
{ "IsOk", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimation_IsOk, 1, NULL },
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxUSE_STREAMS)
{ "Load", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimation_Load, 1, NULL },
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxUSE_STREAMS)
{ "LoadFile", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimation_LoadFile, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxAnimation_delete, 1, NULL },
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
{ "wxAnimation", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxAnimation_constructor_overload, s_wxluafunc_wxLua_wxAnimation_constructor_overload_count, 0 },
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
{ 0, 0, 0, 0 },
};
int wxAnimation_methodCount = sizeof(wxAnimation_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
#if wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
// ---------------------------------------------------------------------------
// Bind class wxAnimationCtrl
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxAnimationCtrl'
int wxluatype_wxAnimationCtrl = WXLUA_TUNKNOWN;
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_Create[] = { &wxluatype_wxAnimationCtrl, &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_wxAnimation, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAnimationCtrl_Create(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_Create[1] = {{ wxLua_wxAnimationCtrl_Create, WXLUAMETHOD_METHOD, 4, 8, s_wxluatypeArray_wxLua_wxAnimationCtrl_Create }};
// bool Create(wxWindow *parent, wxWindowID id, const wxAnimation& anim, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxAC_DEFAULT_STYLE, const wxString& name = "wxAnimationCtrl" );
static int LUACALL wxLua_wxAnimationCtrl_Create(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxAnimationCtrl"
const wxString name = (argCount >= 8 ? wxlua_getwxStringtype(L, 8) : wxString(wxT("wxAnimationCtrl")));
// long style = wxAC_DEFAULT_STYLE
long style = (argCount >= 7 ? (long)wxlua_getnumbertype(L, 7) : wxAC_DEFAULT_STYLE);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 6 ? (const wxSize *)wxluaT_getuserdatatype(L, 6, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 5 ? (const wxPoint *)wxluaT_getuserdatatype(L, 5, wxluatype_wxPoint) : &wxDefaultPosition);
// const wxAnimation anim
const wxAnimation * anim = (const wxAnimation *)wxluaT_getuserdatatype(L, 4, wxluatype_wxAnimation);
// wxWindowID id
wxWindowID id = (wxWindowID)wxlua_getnumbertype(L, 3);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWindow);
// get this
wxAnimationCtrl * self = (wxAnimationCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimationCtrl);
// call Create
bool returns = (self->Create(parent, id, *anim, *pos, *size, style, name));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_GetAnimation[] = { &wxluatype_wxAnimationCtrl, NULL };
static int LUACALL wxLua_wxAnimationCtrl_GetAnimation(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_GetAnimation[1] = {{ wxLua_wxAnimationCtrl_GetAnimation, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAnimationCtrl_GetAnimation }};
// wxAnimation GetAnimation() const;
static int LUACALL wxLua_wxAnimationCtrl_GetAnimation(lua_State *L)
{
// get this
wxAnimationCtrl * self = (wxAnimationCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimationCtrl);
// call GetAnimation
// allocate a new object using the copy constructor
wxAnimation* returns = new wxAnimation(self->GetAnimation());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxAnimation);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxAnimation);
return 1;
}
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_GetInactiveBitmap[] = { &wxluatype_wxAnimationCtrl, NULL };
static int LUACALL wxLua_wxAnimationCtrl_GetInactiveBitmap(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_GetInactiveBitmap[1] = {{ wxLua_wxAnimationCtrl_GetInactiveBitmap, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAnimationCtrl_GetInactiveBitmap }};
// wxBitmap GetInactiveBitmap() const;
static int LUACALL wxLua_wxAnimationCtrl_GetInactiveBitmap(lua_State *L)
{
// get this
wxAnimationCtrl * self = (wxAnimationCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimationCtrl);
// call GetInactiveBitmap
// allocate a new object using the copy constructor
wxBitmap* returns = new wxBitmap(self->GetInactiveBitmap());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxBitmap);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxBitmap);
return 1;
}
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_IsPlaying[] = { &wxluatype_wxAnimationCtrl, NULL };
static int LUACALL wxLua_wxAnimationCtrl_IsPlaying(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_IsPlaying[1] = {{ wxLua_wxAnimationCtrl_IsPlaying, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAnimationCtrl_IsPlaying }};
// virtual bool IsPlaying() const;
static int LUACALL wxLua_wxAnimationCtrl_IsPlaying(lua_State *L)
{
// get this
wxAnimationCtrl * self = (wxAnimationCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimationCtrl);
// call IsPlaying
bool returns = (self->IsPlaying());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_LoadFile1[] = { &wxluatype_wxAnimationCtrl, &wxluatype_TSTRING, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxAnimationCtrl_LoadFile1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_LoadFile1[1] = {{ wxLua_wxAnimationCtrl_LoadFile1, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxAnimationCtrl_LoadFile1 }};
// bool LoadFile(const wxString& file, wxAnimationType animType = wxANIMATION_TYPE_ANY );
static int LUACALL wxLua_wxAnimationCtrl_LoadFile1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxAnimationType animType = wxANIMATION_TYPE_ANY
wxAnimationType animType = (argCount >= 3 ? (wxAnimationType)wxlua_getenumtype(L, 3) : wxANIMATION_TYPE_ANY);
// const wxString file
const wxString file = wxlua_getwxStringtype(L, 2);
// get this
wxAnimationCtrl * self = (wxAnimationCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimationCtrl);
// call LoadFile
bool returns = (self->LoadFile(file, animType));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_LoadFile[] = { &wxluatype_wxAnimationCtrl, &wxluatype_TSTRING, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxAnimationCtrl_LoadFile(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_LoadFile[1] = {{ wxLua_wxAnimationCtrl_LoadFile, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxAnimationCtrl_LoadFile }};
// virtual bool LoadFile(const wxString& filename, wxAnimationType type = wxANIMATION_TYPE_ANY );
static int LUACALL wxLua_wxAnimationCtrl_LoadFile(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxAnimationType type = wxANIMATION_TYPE_ANY
wxAnimationType type = (argCount >= 3 ? (wxAnimationType)wxlua_getenumtype(L, 3) : wxANIMATION_TYPE_ANY);
// const wxString filename
const wxString filename = wxlua_getwxStringtype(L, 2);
// get this
wxAnimationCtrl * self = (wxAnimationCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimationCtrl);
// call LoadFile
bool returns = (self->LoadFile(filename, type));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_Play[] = { &wxluatype_wxAnimationCtrl, NULL };
static int LUACALL wxLua_wxAnimationCtrl_Play(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_Play[1] = {{ wxLua_wxAnimationCtrl_Play, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAnimationCtrl_Play }};
// virtual bool Play( );
static int LUACALL wxLua_wxAnimationCtrl_Play(lua_State *L)
{
// get this
wxAnimationCtrl * self = (wxAnimationCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimationCtrl);
// call Play
bool returns = (self->Play());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_SetAnimation[] = { &wxluatype_wxAnimationCtrl, &wxluatype_wxAnimation, NULL };
static int LUACALL wxLua_wxAnimationCtrl_SetAnimation(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_SetAnimation[1] = {{ wxLua_wxAnimationCtrl_SetAnimation, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAnimationCtrl_SetAnimation }};
// virtual void SetAnimation(const wxAnimation &anim );
static int LUACALL wxLua_wxAnimationCtrl_SetAnimation(lua_State *L)
{
// const wxAnimation anim
const wxAnimation * anim = (const wxAnimation *)wxluaT_getuserdatatype(L, 2, wxluatype_wxAnimation);
// get this
wxAnimationCtrl * self = (wxAnimationCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimationCtrl);
// call SetAnimation
self->SetAnimation(*anim);
return 0;
}
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_SetInactiveBitmap[] = { &wxluatype_wxAnimationCtrl, &wxluatype_wxBitmap, NULL };
static int LUACALL wxLua_wxAnimationCtrl_SetInactiveBitmap(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_SetInactiveBitmap[1] = {{ wxLua_wxAnimationCtrl_SetInactiveBitmap, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxAnimationCtrl_SetInactiveBitmap }};
// virtual void SetInactiveBitmap(const wxBitmap &bmp );
static int LUACALL wxLua_wxAnimationCtrl_SetInactiveBitmap(lua_State *L)
{
// const wxBitmap bmp
const wxBitmap * bmp = (const wxBitmap *)wxluaT_getuserdatatype(L, 2, wxluatype_wxBitmap);
// get this
wxAnimationCtrl * self = (wxAnimationCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimationCtrl);
// call SetInactiveBitmap
self->SetInactiveBitmap(*bmp);
return 0;
}
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_Stop[] = { &wxluatype_wxAnimationCtrl, NULL };
static int LUACALL wxLua_wxAnimationCtrl_Stop(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_Stop[1] = {{ wxLua_wxAnimationCtrl_Stop, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxAnimationCtrl_Stop }};
// virtual void Stop( );
static int LUACALL wxLua_wxAnimationCtrl_Stop(lua_State *L)
{
// get this
wxAnimationCtrl * self = (wxAnimationCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAnimationCtrl);
// call Stop
self->Stop();
return 0;
}
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxAnimationCtrl_constructor1[] = { &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_wxAnimation, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxAnimationCtrl_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_constructor1[1] = {{ wxLua_wxAnimationCtrl_constructor1, WXLUAMETHOD_CONSTRUCTOR, 3, 7, s_wxluatypeArray_wxLua_wxAnimationCtrl_constructor1 }};
// wxAnimationCtrl(wxWindow *parent, wxWindowID id, const wxAnimation& anim, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxAC_DEFAULT_STYLE, const wxString& name = "wxAnimationCtrl" );
static int LUACALL wxLua_wxAnimationCtrl_constructor1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxAnimationCtrl"
const wxString name = (argCount >= 7 ? wxlua_getwxStringtype(L, 7) : wxString(wxT("wxAnimationCtrl")));
// long style = wxAC_DEFAULT_STYLE
long style = (argCount >= 6 ? (long)wxlua_getnumbertype(L, 6) : wxAC_DEFAULT_STYLE);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 5 ? (const wxSize *)wxluaT_getuserdatatype(L, 5, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 4 ? (const wxPoint *)wxluaT_getuserdatatype(L, 4, wxluatype_wxPoint) : &wxDefaultPosition);
// const wxAnimation anim
const wxAnimation * anim = (const wxAnimation *)wxluaT_getuserdatatype(L, 3, wxluatype_wxAnimation);
// wxWindowID id
wxWindowID id = (wxWindowID)wxlua_getnumbertype(L, 2);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWindow);
// call constructor
wxAnimationCtrl* returns = new wxAnimationCtrl(parent, id, *anim, *pos, *size, style, name);
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxAnimationCtrl);
return 1;
}
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
static int LUACALL wxLua_wxAnimationCtrl_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_constructor[1] = {{ wxLua_wxAnimationCtrl_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxAnimationCtrl( );
static int LUACALL wxLua_wxAnimationCtrl_constructor(lua_State *L)
{
// call constructor
wxAnimationCtrl* returns = new wxAnimationCtrl();
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxAnimationCtrl);
return 1;
}
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_LoadFile_overload[] =
{
{ wxLua_wxAnimationCtrl_LoadFile1, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxAnimationCtrl_LoadFile1 },
{ wxLua_wxAnimationCtrl_LoadFile, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxAnimationCtrl_LoadFile },
};
static int s_wxluafunc_wxLua_wxAnimationCtrl_LoadFile_overload_count = sizeof(s_wxluafunc_wxLua_wxAnimationCtrl_LoadFile_overload)/sizeof(wxLuaBindCFunc);
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
#if ((wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect))||(wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxAnimationCtrl_constructor_overload[] =
{
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
{ wxLua_wxAnimationCtrl_constructor1, WXLUAMETHOD_CONSTRUCTOR, 3, 7, s_wxluatypeArray_wxLua_wxAnimationCtrl_constructor1 },
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
{ wxLua_wxAnimationCtrl_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxAnimationCtrl_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxAnimationCtrl_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect))||(wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
void wxLua_wxAnimationCtrl_delete_function(void** p)
{
wxAnimationCtrl* o = (wxAnimationCtrl*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxAnimationCtrl_methods[] = {
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
{ "Create", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimationCtrl_Create, 1, NULL },
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect)
{ "GetAnimation", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimationCtrl_GetAnimation, 1, NULL },
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxBitmap)
{ "GetInactiveBitmap", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimationCtrl_GetInactiveBitmap, 1, NULL },
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxBitmap)
{ "IsPlaying", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimationCtrl_IsPlaying, 1, NULL },
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
{ "LoadFile", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimationCtrl_LoadFile_overload, s_wxluafunc_wxLua_wxAnimationCtrl_LoadFile_overload_count, 0 },
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
{ "Play", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimationCtrl_Play, 1, NULL },
{ "SetAnimation", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimationCtrl_SetAnimation, 1, NULL },
#if (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxBitmap)
{ "SetInactiveBitmap", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimationCtrl_SetInactiveBitmap, 1, NULL },
#endif // (wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxBitmap)
{ "Stop", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxAnimationCtrl_Stop, 1, NULL },
#if ((wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect))||(wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
{ "wxAnimationCtrl", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxAnimationCtrl_constructor_overload, s_wxluafunc_wxLua_wxAnimationCtrl_constructor_overload_count, 0 },
#endif // ((wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL) && (wxLUA_USE_wxPointSizeRect))||(wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL)
{ 0, 0, 0, 0 },
};
int wxAnimationCtrl_methodCount = sizeof(wxAnimationCtrl_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
#if wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX
// ---------------------------------------------------------------------------
// Bind class wxBitmapComboBox
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxBitmapComboBox'
int wxluatype_wxBitmapComboBox = WXLUA_TUNKNOWN;
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_Append2[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TSTRING, &wxluatype_wxBitmap, &wxluatype_wxClientData, NULL };
static int LUACALL wxLua_wxBitmapComboBox_Append2(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Append2[1] = {{ wxLua_wxBitmapComboBox_Append2, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxBitmapComboBox_Append2 }};
// int Append(const wxString& item, const wxBitmap& bitmap, wxClientData *clientData );
static int LUACALL wxLua_wxBitmapComboBox_Append2(lua_State *L)
{
// wxClientData clientData
wxClientData * clientData = (wxClientData *)wxluaT_getuserdatatype(L, 4, wxluatype_wxClientData);
// const wxBitmap bitmap
const wxBitmap * bitmap = (const wxBitmap *)wxluaT_getuserdatatype(L, 3, wxluatype_wxBitmap);
// const wxString item
const wxString item = wxlua_getwxStringtype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call Append
int returns = (self->Append(item, *bitmap, clientData));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_Append1[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TSTRING, &wxluatype_wxBitmap, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxBitmapComboBox_Append1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Append1[1] = {{ wxLua_wxBitmapComboBox_Append1, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxBitmapComboBox_Append1 }};
// int Append(const wxString& item, const wxBitmap& bitmap, voidptr_long data ); // C++ is (void *clientData) You can put a number here
static int LUACALL wxLua_wxBitmapComboBox_Append1(lua_State *L)
{
// voidptr_long data
long data = (long)wxlua_getnumbertype(L, 4);
// const wxBitmap bitmap
const wxBitmap * bitmap = (const wxBitmap *)wxluaT_getuserdatatype(L, 3, wxluatype_wxBitmap);
// const wxString item
const wxString item = wxlua_getwxStringtype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call Append
int returns = (self->Append(item, *bitmap, (void*)data));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_Append[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TSTRING, &wxluatype_wxBitmap, NULL };
static int LUACALL wxLua_wxBitmapComboBox_Append(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Append[1] = {{ wxLua_wxBitmapComboBox_Append, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxBitmapComboBox_Append }};
// int Append(const wxString& item, const wxBitmap& bitmap = wxNullBitmap );
static int LUACALL wxLua_wxBitmapComboBox_Append(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxBitmap bitmap = wxNullBitmap
const wxBitmap * bitmap = (argCount >= 3 ? (const wxBitmap *)wxluaT_getuserdatatype(L, 3, wxluatype_wxBitmap) : &wxNullBitmap);
// const wxString item
const wxString item = wxlua_getwxStringtype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call Append
int returns = (self->Append(item, *bitmap));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_Clear[] = { &wxluatype_wxBitmapComboBox, NULL };
static int LUACALL wxLua_wxBitmapComboBox_Clear(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Clear[1] = {{ wxLua_wxBitmapComboBox_Clear, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxBitmapComboBox_Clear }};
// void Clear( );
static int LUACALL wxLua_wxBitmapComboBox_Clear(lua_State *L)
{
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call Clear
self->Clear();
return 0;
}
#if (((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_Create[] = { &wxluatype_wxBitmapComboBox, &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_TSTRING, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_wxArrayString, &wxluatype_TNUMBER, &wxluatype_wxValidator, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxBitmapComboBox_Create(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Create[1] = {{ wxLua_wxBitmapComboBox_Create, WXLUAMETHOD_METHOD, 4, 10, s_wxluatypeArray_wxLua_wxBitmapComboBox_Create }};
// bool Create(wxWindow* parent, wxWindowID id, const wxString& value, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxBitmapComboBox" );
static int LUACALL wxLua_wxBitmapComboBox_Create(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxBitmapComboBox"
const wxString name = (argCount >= 10 ? wxlua_getwxStringtype(L, 10) : wxString(wxT("wxBitmapComboBox")));
// const wxValidator validator = wxDefaultValidator
const wxValidator * validator = (argCount >= 9 ? (const wxValidator *)wxluaT_getuserdatatype(L, 9, wxluatype_wxValidator) : &wxDefaultValidator);
// long style = 0
long style = (argCount >= 8 ? (long)wxlua_getnumbertype(L, 8) : 0);
// const wxArrayString choices = wxLuaNullSmartwxArrayString
wxLuaSmartwxArrayString choices = (argCount >= 7 ? wxlua_getwxArrayString(L, 7) : wxLuaNullSmartwxArrayString);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 6 ? (const wxSize *)wxluaT_getuserdatatype(L, 6, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 5 ? (const wxPoint *)wxluaT_getuserdatatype(L, 5, wxluatype_wxPoint) : &wxDefaultPosition);
// const wxString value
const wxString value = wxlua_getwxStringtype(L, 4);
// wxWindowID id
wxWindowID id = (wxWindowID)wxlua_getnumbertype(L, 3);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWindow);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call Create
bool returns = (self->Create(parent, id, value, *pos, *size, choices, style, *validator, name));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_Delete[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxBitmapComboBox_Delete(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Delete[1] = {{ wxLua_wxBitmapComboBox_Delete, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxBitmapComboBox_Delete }};
// void Delete(unsigned int n );
static int LUACALL wxLua_wxBitmapComboBox_Delete(lua_State *L)
{
// unsigned int n
unsigned int n = (unsigned int)wxlua_getuintegertype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call Delete
self->Delete(n);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_FindString[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TSTRING, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxBitmapComboBox_FindString(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_FindString[1] = {{ wxLua_wxBitmapComboBox_FindString, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxBitmapComboBox_FindString }};
// int FindString(const wxString& s, bool bCase = false) const;
static int LUACALL wxLua_wxBitmapComboBox_FindString(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool bCase = false
bool bCase = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : false);
// const wxString s
const wxString s = wxlua_getwxStringtype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call FindString
int returns = (self->FindString(s, bCase));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_GetBitmapSize[] = { &wxluatype_wxBitmapComboBox, NULL };
static int LUACALL wxLua_wxBitmapComboBox_GetBitmapSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_GetBitmapSize[1] = {{ wxLua_wxBitmapComboBox_GetBitmapSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxBitmapComboBox_GetBitmapSize }};
// wxSize GetBitmapSize() const;
static int LUACALL wxLua_wxBitmapComboBox_GetBitmapSize(lua_State *L)
{
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call GetBitmapSize
// allocate a new object using the copy constructor
wxSize* returns = new wxSize(self->GetBitmapSize());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxSize);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSize);
return 1;
}
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_GetCount[] = { &wxluatype_wxBitmapComboBox, NULL };
static int LUACALL wxLua_wxBitmapComboBox_GetCount(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_GetCount[1] = {{ wxLua_wxBitmapComboBox_GetCount, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxBitmapComboBox_GetCount }};
// unsigned int GetCount() const;
static int LUACALL wxLua_wxBitmapComboBox_GetCount(lua_State *L)
{
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call GetCount
unsigned int returns = (self->GetCount());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_GetItemBitmap[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxBitmapComboBox_GetItemBitmap(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_GetItemBitmap[1] = {{ wxLua_wxBitmapComboBox_GetItemBitmap, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxBitmapComboBox_GetItemBitmap }};
// wxBitmap GetItemBitmap(unsigned int n) const;
static int LUACALL wxLua_wxBitmapComboBox_GetItemBitmap(lua_State *L)
{
// unsigned int n
unsigned int n = (unsigned int)wxlua_getuintegertype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call GetItemBitmap
// allocate a new object using the copy constructor
wxBitmap* returns = new wxBitmap(self->GetItemBitmap(n));
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxBitmap);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxBitmap);
return 1;
}
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_GetSelection[] = { &wxluatype_wxBitmapComboBox, NULL };
static int LUACALL wxLua_wxBitmapComboBox_GetSelection(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_GetSelection[1] = {{ wxLua_wxBitmapComboBox_GetSelection, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxBitmapComboBox_GetSelection }};
// int GetSelection() const;
static int LUACALL wxLua_wxBitmapComboBox_GetSelection(lua_State *L)
{
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call GetSelection
int returns = (self->GetSelection());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_GetString[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxBitmapComboBox_GetString(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_GetString[1] = {{ wxLua_wxBitmapComboBox_GetString, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxBitmapComboBox_GetString }};
// wxString GetString(unsigned int n) const;
static int LUACALL wxLua_wxBitmapComboBox_GetString(lua_State *L)
{
// unsigned int n
unsigned int n = (unsigned int)wxlua_getuintegertype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call GetString
wxString returns = (self->GetString(n));
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_Insert2[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TSTRING, &wxluatype_wxBitmap, &wxluatype_TINTEGER, &wxluatype_wxClientData, NULL };
static int LUACALL wxLua_wxBitmapComboBox_Insert2(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Insert2[1] = {{ wxLua_wxBitmapComboBox_Insert2, WXLUAMETHOD_METHOD, 5, 5, s_wxluatypeArray_wxLua_wxBitmapComboBox_Insert2 }};
// int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int pos, wxClientData *clientData );
static int LUACALL wxLua_wxBitmapComboBox_Insert2(lua_State *L)
{
// wxClientData clientData
wxClientData * clientData = (wxClientData *)wxluaT_getuserdatatype(L, 5, wxluatype_wxClientData);
// unsigned int pos
unsigned int pos = (unsigned int)wxlua_getuintegertype(L, 4);
// const wxBitmap bitmap
const wxBitmap * bitmap = (const wxBitmap *)wxluaT_getuserdatatype(L, 3, wxluatype_wxBitmap);
// const wxString item
const wxString item = wxlua_getwxStringtype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call Insert
int returns = (self->Insert(item, *bitmap, pos, clientData));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
#if ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (!wxCHECK_VERSION(2,9,0) || wxCHECK_VERSION(2,9,5))) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_Insert1[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TSTRING, &wxluatype_wxBitmap, &wxluatype_TINTEGER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxBitmapComboBox_Insert1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Insert1[1] = {{ wxLua_wxBitmapComboBox_Insert1, WXLUAMETHOD_METHOD, 5, 5, s_wxluatypeArray_wxLua_wxBitmapComboBox_Insert1 }};
// int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int pos, voidptr_long data ); // C++ is (void *clientData) You can put a number here
static int LUACALL wxLua_wxBitmapComboBox_Insert1(lua_State *L)
{
// voidptr_long data
long data = (long)wxlua_getnumbertype(L, 5);
// unsigned int pos
unsigned int pos = (unsigned int)wxlua_getuintegertype(L, 4);
// const wxBitmap bitmap
const wxBitmap * bitmap = (const wxBitmap *)wxluaT_getuserdatatype(L, 3, wxluatype_wxBitmap);
// const wxString item
const wxString item = wxlua_getwxStringtype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call Insert
int returns = (self->Insert(item, *bitmap, pos, (void*)data));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#endif // ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (!wxCHECK_VERSION(2,9,0) || wxCHECK_VERSION(2,9,5))) && (wxLUA_USE_wxBitmap)
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_Insert[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TSTRING, &wxluatype_wxBitmap, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxBitmapComboBox_Insert(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Insert[1] = {{ wxLua_wxBitmapComboBox_Insert, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxBitmapComboBox_Insert }};
// int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int pos );
static int LUACALL wxLua_wxBitmapComboBox_Insert(lua_State *L)
{
// unsigned int pos
unsigned int pos = (unsigned int)wxlua_getuintegertype(L, 4);
// const wxBitmap bitmap
const wxBitmap * bitmap = (const wxBitmap *)wxluaT_getuserdatatype(L, 3, wxluatype_wxBitmap);
// const wxString item
const wxString item = wxlua_getwxStringtype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call Insert
int returns = (self->Insert(item, *bitmap, pos));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_Select[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxBitmapComboBox_Select(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Select[1] = {{ wxLua_wxBitmapComboBox_Select, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxBitmapComboBox_Select }};
// void Select(int n );
static int LUACALL wxLua_wxBitmapComboBox_Select(lua_State *L)
{
// int n
int n = (int)wxlua_getnumbertype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call Select
self->Select(n);
return 0;
}
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_SetItemBitmap[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TINTEGER, &wxluatype_wxBitmap, NULL };
static int LUACALL wxLua_wxBitmapComboBox_SetItemBitmap(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_SetItemBitmap[1] = {{ wxLua_wxBitmapComboBox_SetItemBitmap, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxBitmapComboBox_SetItemBitmap }};
// void SetItemBitmap(unsigned int n, const wxBitmap& bitmap );
static int LUACALL wxLua_wxBitmapComboBox_SetItemBitmap(lua_State *L)
{
// const wxBitmap bitmap
const wxBitmap * bitmap = (const wxBitmap *)wxluaT_getuserdatatype(L, 3, wxluatype_wxBitmap);
// unsigned int n
unsigned int n = (unsigned int)wxlua_getuintegertype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call SetItemBitmap
self->SetItemBitmap(n, *bitmap);
return 0;
}
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_SetSelection[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxBitmapComboBox_SetSelection(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_SetSelection[1] = {{ wxLua_wxBitmapComboBox_SetSelection, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxBitmapComboBox_SetSelection }};
// void SetSelection(int n );
static int LUACALL wxLua_wxBitmapComboBox_SetSelection(lua_State *L)
{
// int n
int n = (int)wxlua_getnumbertype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call SetSelection
self->SetSelection(n);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_SetString1[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TINTEGER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxBitmapComboBox_SetString1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_SetString1[1] = {{ wxLua_wxBitmapComboBox_SetString1, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxBitmapComboBox_SetString1 }};
// void SetString(unsigned int n, const wxString& s );
static int LUACALL wxLua_wxBitmapComboBox_SetString1(lua_State *L)
{
// const wxString s
const wxString s = wxlua_getwxStringtype(L, 3);
// unsigned int n
unsigned int n = (unsigned int)wxlua_getuintegertype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call SetString
self->SetString(n, s);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_SetString[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TINTEGER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxBitmapComboBox_SetString(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_SetString[1] = {{ wxLua_wxBitmapComboBox_SetString, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxBitmapComboBox_SetString }};
// void SetString(unsigned int n, const wxString& s );
static int LUACALL wxLua_wxBitmapComboBox_SetString(lua_State *L)
{
// const wxString s
const wxString s = wxlua_getwxStringtype(L, 3);
// unsigned int n
unsigned int n = (unsigned int)wxlua_getuintegertype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call SetString
self->SetString(n, s);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_SetStringSelection[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxBitmapComboBox_SetStringSelection(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_SetStringSelection[1] = {{ wxLua_wxBitmapComboBox_SetStringSelection, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxBitmapComboBox_SetStringSelection }};
// bool SetStringSelection(const wxString& s );
static int LUACALL wxLua_wxBitmapComboBox_SetStringSelection(lua_State *L)
{
// const wxString s
const wxString s = wxlua_getwxStringtype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call SetStringSelection
bool returns = (self->SetStringSelection(s));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_SetValue[] = { &wxluatype_wxBitmapComboBox, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxBitmapComboBox_SetValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_SetValue[1] = {{ wxLua_wxBitmapComboBox_SetValue, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxBitmapComboBox_SetValue }};
// void SetValue(const wxString& value );
static int LUACALL wxLua_wxBitmapComboBox_SetValue(lua_State *L)
{
// const wxString value
const wxString value = wxlua_getwxStringtype(L, 2);
// get this
wxBitmapComboBox * self = (wxBitmapComboBox *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmapComboBox);
// call SetValue
self->SetValue(value);
return 0;
}
#if (((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxBitmapComboBox_constructor1[] = { &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_TSTRING, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_wxArrayString, &wxluatype_TNUMBER, &wxluatype_wxValidator, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxBitmapComboBox_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_constructor1[1] = {{ wxLua_wxBitmapComboBox_constructor1, WXLUAMETHOD_CONSTRUCTOR, 3, 9, s_wxluatypeArray_wxLua_wxBitmapComboBox_constructor1 }};
// wxBitmapComboBox(wxWindow* parent, wxWindowID id, const wxString& value, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxBitmapComboBox" );
static int LUACALL wxLua_wxBitmapComboBox_constructor1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxBitmapComboBox"
const wxString name = (argCount >= 9 ? wxlua_getwxStringtype(L, 9) : wxString(wxT("wxBitmapComboBox")));
// const wxValidator validator = wxDefaultValidator
const wxValidator * validator = (argCount >= 8 ? (const wxValidator *)wxluaT_getuserdatatype(L, 8, wxluatype_wxValidator) : &wxDefaultValidator);
// long style = 0
long style = (argCount >= 7 ? (long)wxlua_getnumbertype(L, 7) : 0);
// const wxArrayString choices = wxLuaNullSmartwxArrayString
wxLuaSmartwxArrayString choices = (argCount >= 6 ? wxlua_getwxArrayString(L, 6) : wxLuaNullSmartwxArrayString);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 5 ? (const wxSize *)wxluaT_getuserdatatype(L, 5, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 4 ? (const wxPoint *)wxluaT_getuserdatatype(L, 4, wxluatype_wxPoint) : &wxDefaultPosition);
// const wxString value
const wxString value = wxlua_getwxStringtype(L, 3);
// wxWindowID id
wxWindowID id = (wxWindowID)wxlua_getnumbertype(L, 2);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWindow);
// call constructor
wxBitmapComboBox* returns = new wxBitmapComboBox(parent, id, value, *pos, *size, choices, style, *validator, name);
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxBitmapComboBox);
return 1;
}
#endif // (((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect)
static int LUACALL wxLua_wxBitmapComboBox_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_constructor[1] = {{ wxLua_wxBitmapComboBox_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxBitmapComboBox( );
static int LUACALL wxLua_wxBitmapComboBox_constructor(lua_State *L)
{
// call constructor
wxBitmapComboBox* returns = new wxBitmapComboBox();
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxBitmapComboBox);
return 1;
}
#if ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap))
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Append_overload[] =
{
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
{ wxLua_wxBitmapComboBox_Append2, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxBitmapComboBox_Append2 },
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
{ wxLua_wxBitmapComboBox_Append1, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxBitmapComboBox_Append1 },
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
{ wxLua_wxBitmapComboBox_Append, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxBitmapComboBox_Append },
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
};
static int s_wxluafunc_wxLua_wxBitmapComboBox_Append_overload_count = sizeof(s_wxluafunc_wxLua_wxBitmapComboBox_Append_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap))
#if ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap))||(((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (!wxCHECK_VERSION(2,9,0) || wxCHECK_VERSION(2,9,5))) && (wxLUA_USE_wxBitmap))
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_Insert_overload[] =
{
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
{ wxLua_wxBitmapComboBox_Insert2, WXLUAMETHOD_METHOD, 5, 5, s_wxluatypeArray_wxLua_wxBitmapComboBox_Insert2 },
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
#if ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (!wxCHECK_VERSION(2,9,0) || wxCHECK_VERSION(2,9,5))) && (wxLUA_USE_wxBitmap)
{ wxLua_wxBitmapComboBox_Insert1, WXLUAMETHOD_METHOD, 5, 5, s_wxluatypeArray_wxLua_wxBitmapComboBox_Insert1 },
#endif // ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (!wxCHECK_VERSION(2,9,0) || wxCHECK_VERSION(2,9,5))) && (wxLUA_USE_wxBitmap)
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
{ wxLua_wxBitmapComboBox_Insert, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxBitmapComboBox_Insert },
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
};
static int s_wxluafunc_wxLua_wxBitmapComboBox_Insert_overload_count = sizeof(s_wxluafunc_wxLua_wxBitmapComboBox_Insert_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap))||(((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (!wxCHECK_VERSION(2,9,0) || wxCHECK_VERSION(2,9,5))) && (wxLUA_USE_wxBitmap))
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_SetString_overload[] =
{
{ wxLua_wxBitmapComboBox_SetString1, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxBitmapComboBox_SetString1 },
{ wxLua_wxBitmapComboBox_SetString, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxBitmapComboBox_SetString },
};
static int s_wxluafunc_wxLua_wxBitmapComboBox_SetString_overload_count = sizeof(s_wxluafunc_wxLua_wxBitmapComboBox_SetString_overload)/sizeof(wxLuaBindCFunc);
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX)
#if ((((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxBitmapComboBox_constructor_overload[] =
{
#if (((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect)
{ wxLua_wxBitmapComboBox_constructor1, WXLUAMETHOD_CONSTRUCTOR, 3, 9, s_wxluatypeArray_wxLua_wxBitmapComboBox_constructor1 },
#endif // (((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect)
{ wxLua_wxBitmapComboBox_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxBitmapComboBox_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxBitmapComboBox_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // ((((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX)
void wxLua_wxBitmapComboBox_delete_function(void** p)
{
wxBitmapComboBox* o = (wxBitmapComboBox*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxBitmapComboBox_methods[] = {
#if ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap))
{ "Append", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_Append_overload, s_wxluafunc_wxLua_wxBitmapComboBox_Append_overload_count, 0 },
#endif // ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap))
{ "Clear", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_Clear, 1, NULL },
#if (((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect)
{ "Create", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_Create, 1, NULL },
#endif // (((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect)
{ "Delete", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_Delete, 1, NULL },
{ "FindString", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_FindString, 1, NULL },
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxPointSizeRect)
{ "GetBitmapSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_GetBitmapSize, 1, NULL },
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxPointSizeRect)
{ "GetCount", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_GetCount, 1, NULL },
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
{ "GetItemBitmap", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_GetItemBitmap, 1, NULL },
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
{ "GetSelection", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_GetSelection, 1, NULL },
{ "GetString", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_GetString, 1, NULL },
#if ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap))||(((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (!wxCHECK_VERSION(2,9,0) || wxCHECK_VERSION(2,9,5))) && (wxLUA_USE_wxBitmap))
{ "Insert", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_Insert_overload, s_wxluafunc_wxLua_wxBitmapComboBox_Insert_overload_count, 0 },
#endif // ((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap))||(((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (!wxCHECK_VERSION(2,9,0) || wxCHECK_VERSION(2,9,5))) && (wxLUA_USE_wxBitmap))
{ "Select", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_Select, 1, NULL },
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
{ "SetItemBitmap", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_SetItemBitmap, 1, NULL },
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxBitmap)
{ "SetSelection", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_SetSelection, 1, NULL },
#if (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX)
{ "SetString", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_SetString_overload, s_wxluafunc_wxLua_wxBitmapComboBox_SetString_overload_count, 0 },
#endif // (wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX)
{ "SetStringSelection", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_SetStringSelection, 1, NULL },
{ "SetValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxBitmapComboBox_SetValue, 1, NULL },
#if ((((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX)
{ "wxBitmapComboBox", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxBitmapComboBox_constructor_overload, s_wxluafunc_wxLua_wxBitmapComboBox_constructor_overload_count, 0 },
#endif // ((((wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxValidator && wxUSE_VALIDATORS)) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX)
{ 0, 0, 0, 0 },
};
int wxBitmapComboBox_methodCount = sizeof(wxBitmapComboBox_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX
#if wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
// ---------------------------------------------------------------------------
// Bind class wxCalendarCtrl
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxCalendarCtrl'
int wxluatype_wxCalendarCtrl = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_EnableHolidayDisplay[] = { &wxluatype_wxCalendarCtrl, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxCalendarCtrl_EnableHolidayDisplay(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_EnableHolidayDisplay[1] = {{ wxLua_wxCalendarCtrl_EnableHolidayDisplay, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxCalendarCtrl_EnableHolidayDisplay }};
// void EnableHolidayDisplay(bool display = true );
static int LUACALL wxLua_wxCalendarCtrl_EnableHolidayDisplay(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool display = true
bool display = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call EnableHolidayDisplay
self->EnableHolidayDisplay(display);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_EnableMonthChange[] = { &wxluatype_wxCalendarCtrl, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxCalendarCtrl_EnableMonthChange(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_EnableMonthChange[1] = {{ wxLua_wxCalendarCtrl_EnableMonthChange, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxCalendarCtrl_EnableMonthChange }};
// void EnableMonthChange(bool enable = true );
static int LUACALL wxLua_wxCalendarCtrl_EnableMonthChange(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool enable = true
bool enable = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call EnableMonthChange
self->EnableMonthChange(enable);
return 0;
}
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (!wxCHECK_VERSION(2,9,2))
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_EnableYearChange[] = { &wxluatype_wxCalendarCtrl, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxCalendarCtrl_EnableYearChange(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_EnableYearChange[1] = {{ wxLua_wxCalendarCtrl_EnableYearChange, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxCalendarCtrl_EnableYearChange }};
// void EnableYearChange(bool enable = true );
static int LUACALL wxLua_wxCalendarCtrl_EnableYearChange(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool enable = true
bool enable = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call EnableYearChange
self->EnableYearChange(enable);
return 0;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (!wxCHECK_VERSION(2,9,2))
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_GetAttr[] = { &wxluatype_wxCalendarCtrl, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxCalendarCtrl_GetAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_GetAttr[1] = {{ wxLua_wxCalendarCtrl_GetAttr, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarCtrl_GetAttr }};
// wxCalendarDateAttr* GetAttr(size_t day) const;
static int LUACALL wxLua_wxCalendarCtrl_GetAttr(lua_State *L)
{
// size_t day
size_t day = (size_t)wxlua_getuintegertype(L, 2);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call GetAttr
wxCalendarDateAttr* returns = (wxCalendarDateAttr*)self->GetAttr(day);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxCalendarDateAttr);
return 1;
}
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_GetDate[] = { &wxluatype_wxCalendarCtrl, NULL };
static int LUACALL wxLua_wxCalendarCtrl_GetDate(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_GetDate[1] = {{ wxLua_wxCalendarCtrl_GetDate, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarCtrl_GetDate }};
// wxDateTime GetDate() const;
static int LUACALL wxLua_wxCalendarCtrl_GetDate(lua_State *L)
{
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call GetDate
// allocate a new object using the copy constructor
wxDateTime* returns = new wxDateTime(self->GetDate());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxDateTime);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxDateTime);
return 1;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHeaderColourBg[] = { &wxluatype_wxCalendarCtrl, NULL };
static int LUACALL wxLua_wxCalendarCtrl_GetHeaderColourBg(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_GetHeaderColourBg[1] = {{ wxLua_wxCalendarCtrl_GetHeaderColourBg, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHeaderColourBg }};
// wxColour GetHeaderColourBg() const;
static int LUACALL wxLua_wxCalendarCtrl_GetHeaderColourBg(lua_State *L)
{
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call GetHeaderColourBg
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetHeaderColourBg());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHeaderColourFg[] = { &wxluatype_wxCalendarCtrl, NULL };
static int LUACALL wxLua_wxCalendarCtrl_GetHeaderColourFg(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_GetHeaderColourFg[1] = {{ wxLua_wxCalendarCtrl_GetHeaderColourFg, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHeaderColourFg }};
// wxColour GetHeaderColourFg() const;
static int LUACALL wxLua_wxCalendarCtrl_GetHeaderColourFg(lua_State *L)
{
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call GetHeaderColourFg
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetHeaderColourFg());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHighlightColourBg[] = { &wxluatype_wxCalendarCtrl, NULL };
static int LUACALL wxLua_wxCalendarCtrl_GetHighlightColourBg(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_GetHighlightColourBg[1] = {{ wxLua_wxCalendarCtrl_GetHighlightColourBg, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHighlightColourBg }};
// wxColour GetHighlightColourBg() const;
static int LUACALL wxLua_wxCalendarCtrl_GetHighlightColourBg(lua_State *L)
{
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call GetHighlightColourBg
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetHighlightColourBg());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHighlightColourFg[] = { &wxluatype_wxCalendarCtrl, NULL };
static int LUACALL wxLua_wxCalendarCtrl_GetHighlightColourFg(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_GetHighlightColourFg[1] = {{ wxLua_wxCalendarCtrl_GetHighlightColourFg, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHighlightColourFg }};
// wxColour GetHighlightColourFg() const;
static int LUACALL wxLua_wxCalendarCtrl_GetHighlightColourFg(lua_State *L)
{
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call GetHighlightColourFg
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetHighlightColourFg());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHolidayColourBg[] = { &wxluatype_wxCalendarCtrl, NULL };
static int LUACALL wxLua_wxCalendarCtrl_GetHolidayColourBg(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_GetHolidayColourBg[1] = {{ wxLua_wxCalendarCtrl_GetHolidayColourBg, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHolidayColourBg }};
// wxColour GetHolidayColourBg() const;
static int LUACALL wxLua_wxCalendarCtrl_GetHolidayColourBg(lua_State *L)
{
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call GetHolidayColourBg
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetHolidayColourBg());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHolidayColourFg[] = { &wxluatype_wxCalendarCtrl, NULL };
static int LUACALL wxLua_wxCalendarCtrl_GetHolidayColourFg(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_GetHolidayColourFg[1] = {{ wxLua_wxCalendarCtrl_GetHolidayColourFg, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarCtrl_GetHolidayColourFg }};
// wxColour GetHolidayColourFg() const;
static int LUACALL wxLua_wxCalendarCtrl_GetHolidayColourFg(lua_State *L)
{
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call GetHolidayColourFg
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetHolidayColourFg());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_HitTest[] = { &wxluatype_wxCalendarCtrl, &wxluatype_wxPoint, NULL };
static int LUACALL wxLua_wxCalendarCtrl_HitTest(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_HitTest[1] = {{ wxLua_wxCalendarCtrl_HitTest, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarCtrl_HitTest }};
// %override wxLua_wxCalendarCtrl_HitTest
// wxCalendarHitTestResult HitTest(const wxPoint& pos) //, wxDateTime* date = NULL, wxDateTime::WeekDay* wd = NULL)
static int LUACALL wxLua_wxCalendarCtrl_HitTest(lua_State *L)
{
// const wxPoint pos
const wxPoint * pos = (const wxPoint *)wxluaT_getuserdatatype(L, 2, wxluatype_wxPoint);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call HitTest
wxDateTime* date = new wxDateTime();
wxDateTime::WeekDay wd = wxDateTime::Inv_WeekDay;
wxCalendarHitTestResult returns = self->HitTest(*pos, date, &wd);
// push the result number
lua_pushnumber(L, returns);
wxluaT_pushuserdatatype(L, date, wxluatype_wxDateTime);
lua_pushnumber(L, wd);
return 3;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_ResetAttr[] = { &wxluatype_wxCalendarCtrl, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxCalendarCtrl_ResetAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_ResetAttr[1] = {{ wxLua_wxCalendarCtrl_ResetAttr, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarCtrl_ResetAttr }};
// void ResetAttr(size_t day );
static int LUACALL wxLua_wxCalendarCtrl_ResetAttr(lua_State *L)
{
// size_t day
size_t day = (size_t)wxlua_getuintegertype(L, 2);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call ResetAttr
self->ResetAttr(day);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_SetAttr[] = { &wxluatype_wxCalendarCtrl, &wxluatype_TINTEGER, &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarCtrl_SetAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_SetAttr[1] = {{ wxLua_wxCalendarCtrl_SetAttr, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxCalendarCtrl_SetAttr }};
// void SetAttr(size_t day, %ungc wxCalendarDateAttr* attr); // will delete previously set attr as well
static int LUACALL wxLua_wxCalendarCtrl_SetAttr(lua_State *L)
{
// wxCalendarDateAttr attr
wxCalendarDateAttr * attr = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 3, wxluatype_wxCalendarDateAttr);
// size_t day
size_t day = (size_t)wxlua_getuintegertype(L, 2);
if (wxluaO_isgcobject(L, attr)) wxluaO_undeletegcobject(L, attr);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call SetAttr
self->SetAttr(day, attr);
return 0;
}
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_SetDate[] = { &wxluatype_wxCalendarCtrl, &wxluatype_wxDateTime, NULL };
static int LUACALL wxLua_wxCalendarCtrl_SetDate(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_SetDate[1] = {{ wxLua_wxCalendarCtrl_SetDate, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarCtrl_SetDate }};
// void SetDate(const wxDateTime& date );
static int LUACALL wxLua_wxCalendarCtrl_SetDate(lua_State *L)
{
// const wxDateTime date
const wxDateTime * date = (const wxDateTime *)wxluaT_getuserdatatype(L, 2, wxluatype_wxDateTime);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call SetDate
self->SetDate(*date);
return 0;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_SetHeaderColours[] = { &wxluatype_wxCalendarCtrl, &wxluatype_wxColour, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxCalendarCtrl_SetHeaderColours(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_SetHeaderColours[1] = {{ wxLua_wxCalendarCtrl_SetHeaderColours, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxCalendarCtrl_SetHeaderColours }};
// void SetHeaderColours(const wxColour& colFg, const wxColour& colBg );
static int LUACALL wxLua_wxCalendarCtrl_SetHeaderColours(lua_State *L)
{
// const wxColour colBg
const wxColour * colBg = (const wxColour *)wxluaT_getuserdatatype(L, 3, wxluatype_wxColour);
// const wxColour colFg
const wxColour * colFg = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call SetHeaderColours
self->SetHeaderColours(*colFg, *colBg);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_SetHighlightColours[] = { &wxluatype_wxCalendarCtrl, &wxluatype_wxColour, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxCalendarCtrl_SetHighlightColours(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_SetHighlightColours[1] = {{ wxLua_wxCalendarCtrl_SetHighlightColours, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxCalendarCtrl_SetHighlightColours }};
// void SetHighlightColours(const wxColour& colFg, const wxColour& colBg );
static int LUACALL wxLua_wxCalendarCtrl_SetHighlightColours(lua_State *L)
{
// const wxColour colBg
const wxColour * colBg = (const wxColour *)wxluaT_getuserdatatype(L, 3, wxluatype_wxColour);
// const wxColour colFg
const wxColour * colFg = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call SetHighlightColours
self->SetHighlightColours(*colFg, *colBg);
return 0;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_SetHoliday[] = { &wxluatype_wxCalendarCtrl, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxCalendarCtrl_SetHoliday(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_SetHoliday[1] = {{ wxLua_wxCalendarCtrl_SetHoliday, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarCtrl_SetHoliday }};
// void SetHoliday(size_t day );
static int LUACALL wxLua_wxCalendarCtrl_SetHoliday(lua_State *L)
{
// size_t day
size_t day = (size_t)wxlua_getuintegertype(L, 2);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call SetHoliday
self->SetHoliday(day);
return 0;
}
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_SetHolidayColours[] = { &wxluatype_wxCalendarCtrl, &wxluatype_wxColour, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxCalendarCtrl_SetHolidayColours(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_SetHolidayColours[1] = {{ wxLua_wxCalendarCtrl_SetHolidayColours, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxCalendarCtrl_SetHolidayColours }};
// void SetHolidayColours(const wxColour& colFg, const wxColour& colBg );
static int LUACALL wxLua_wxCalendarCtrl_SetHolidayColours(lua_State *L)
{
// const wxColour colBg
const wxColour * colBg = (const wxColour *)wxluaT_getuserdatatype(L, 3, wxluatype_wxColour);
// const wxColour colFg
const wxColour * colFg = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxCalendarCtrl * self = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call SetHolidayColours
self->SetHolidayColours(*colFg, *colBg);
return 0;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
#if ((wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarCtrl_constructor[] = { &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_wxDateTime, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxCalendarCtrl_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarCtrl_constructor[1] = {{ wxLua_wxCalendarCtrl_constructor, WXLUAMETHOD_CONSTRUCTOR, 2, 7, s_wxluatypeArray_wxLua_wxCalendarCtrl_constructor }};
// wxCalendarCtrl(wxWindow* parent, wxWindowID id, const wxDateTime& date = wxDefaultDateTime, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxCAL_SHOW_HOLIDAYS, const wxString& name = "wxCalendarCtrl" );
static int LUACALL wxLua_wxCalendarCtrl_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxCalendarCtrl"
const wxString name = (argCount >= 7 ? wxlua_getwxStringtype(L, 7) : wxString(wxT("wxCalendarCtrl")));
// long style = wxCAL_SHOW_HOLIDAYS
long style = (argCount >= 6 ? (long)wxlua_getnumbertype(L, 6) : wxCAL_SHOW_HOLIDAYS);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 5 ? (const wxSize *)wxluaT_getuserdatatype(L, 5, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 4 ? (const wxPoint *)wxluaT_getuserdatatype(L, 4, wxluatype_wxPoint) : &wxDefaultPosition);
// const wxDateTime date = wxDefaultDateTime
const wxDateTime * date = (argCount >= 3 ? (const wxDateTime *)wxluaT_getuserdatatype(L, 3, wxluatype_wxDateTime) : &wxDefaultDateTime);
// wxWindowID id
wxWindowID id = (wxWindowID)wxlua_getnumbertype(L, 2);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWindow);
// call constructor
wxCalendarCtrl* returns = new wxCalendarCtrl(parent, id, *date, *pos, *size, style, name);
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxCalendarCtrl);
return 1;
}
#endif // ((wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)) && (wxLUA_USE_wxPointSizeRect)
void wxLua_wxCalendarCtrl_delete_function(void** p)
{
wxCalendarCtrl* o = (wxCalendarCtrl*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxCalendarCtrl_methods[] = {
{ "EnableHolidayDisplay", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_EnableHolidayDisplay, 1, NULL },
{ "EnableMonthChange", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_EnableMonthChange, 1, NULL },
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (!wxCHECK_VERSION(2,9,2))
{ "EnableYearChange", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_EnableYearChange, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (!wxCHECK_VERSION(2,9,2))
{ "GetAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_GetAttr, 1, NULL },
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
{ "GetDate", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_GetDate, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "GetHeaderColourBg", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_GetHeaderColourBg, 1, NULL },
{ "GetHeaderColourFg", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_GetHeaderColourFg, 1, NULL },
{ "GetHighlightColourBg", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_GetHighlightColourBg, 1, NULL },
{ "GetHighlightColourFg", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_GetHighlightColourFg, 1, NULL },
{ "GetHolidayColourBg", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_GetHolidayColourBg, 1, NULL },
{ "GetHolidayColourFg", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_GetHolidayColourFg, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxPointSizeRect)
{ "HitTest", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_HitTest, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxPointSizeRect)
{ "ResetAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_ResetAttr, 1, NULL },
{ "SetAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_SetAttr, 1, NULL },
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
{ "SetDate", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_SetDate, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "SetHeaderColours", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_SetHeaderColours, 1, NULL },
{ "SetHighlightColours", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_SetHighlightColours, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "SetHoliday", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_SetHoliday, 1, NULL },
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "SetHolidayColours", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarCtrl_SetHolidayColours, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
#if ((wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)) && (wxLUA_USE_wxPointSizeRect)
{ "wxCalendarCtrl", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxCalendarCtrl_constructor, 1, NULL },
#endif // ((wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)) && (wxLUA_USE_wxPointSizeRect)
{ 0, 0, 0, 0 },
};
int wxCalendarCtrl_methodCount = sizeof(wxCalendarCtrl_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
#if wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
// ---------------------------------------------------------------------------
// Bind class wxCalendarDateAttr
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxCalendarDateAttr'
int wxluatype_wxCalendarDateAttr = WXLUA_TUNKNOWN;
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_GetBackgroundColour[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_GetBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_GetBackgroundColour[1] = {{ wxLua_wxCalendarDateAttr_GetBackgroundColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_GetBackgroundColour }};
// wxColour GetBackgroundColour( );
static int LUACALL wxLua_wxCalendarDateAttr_GetBackgroundColour(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call GetBackgroundColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetBackgroundColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_GetBorder[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_GetBorder(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_GetBorder[1] = {{ wxLua_wxCalendarDateAttr_GetBorder, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_GetBorder }};
// wxCalendarDateBorder GetBorder( );
static int LUACALL wxLua_wxCalendarDateAttr_GetBorder(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call GetBorder
wxCalendarDateBorder returns = (self->GetBorder());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_GetBorderColour[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_GetBorderColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_GetBorderColour[1] = {{ wxLua_wxCalendarDateAttr_GetBorderColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_GetBorderColour }};
// wxColour GetBorderColour() const;
static int LUACALL wxLua_wxCalendarDateAttr_GetBorderColour(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call GetBorderColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetBorderColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxFont)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_GetFont[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_GetFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_GetFont[1] = {{ wxLua_wxCalendarDateAttr_GetFont, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_GetFont }};
// wxFont GetFont() const;
static int LUACALL wxLua_wxCalendarDateAttr_GetFont(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call GetFont
// allocate a new object using the copy constructor
wxFont* returns = new wxFont(self->GetFont());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxFont);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxFont);
return 1;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxFont)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_GetTextColour[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_GetTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_GetTextColour[1] = {{ wxLua_wxCalendarDateAttr_GetTextColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_GetTextColour }};
// wxColour GetTextColour() const;
static int LUACALL wxLua_wxCalendarDateAttr_GetTextColour(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call GetTextColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetTextColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_HasBackgroundColour[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_HasBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_HasBackgroundColour[1] = {{ wxLua_wxCalendarDateAttr_HasBackgroundColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_HasBackgroundColour }};
// bool HasBackgroundColour() const;
static int LUACALL wxLua_wxCalendarDateAttr_HasBackgroundColour(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call HasBackgroundColour
bool returns = (self->HasBackgroundColour());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_HasBorder[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_HasBorder(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_HasBorder[1] = {{ wxLua_wxCalendarDateAttr_HasBorder, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_HasBorder }};
// bool HasBorder() const;
static int LUACALL wxLua_wxCalendarDateAttr_HasBorder(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call HasBorder
bool returns = (self->HasBorder());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_HasBorderColour[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_HasBorderColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_HasBorderColour[1] = {{ wxLua_wxCalendarDateAttr_HasBorderColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_HasBorderColour }};
// bool HasBorderColour() const;
static int LUACALL wxLua_wxCalendarDateAttr_HasBorderColour(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call HasBorderColour
bool returns = (self->HasBorderColour());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_HasFont[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_HasFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_HasFont[1] = {{ wxLua_wxCalendarDateAttr_HasFont, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_HasFont }};
// bool HasFont() const;
static int LUACALL wxLua_wxCalendarDateAttr_HasFont(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call HasFont
bool returns = (self->HasFont());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_HasTextColour[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_HasTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_HasTextColour[1] = {{ wxLua_wxCalendarDateAttr_HasTextColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_HasTextColour }};
// bool HasTextColour() const;
static int LUACALL wxLua_wxCalendarDateAttr_HasTextColour(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call HasTextColour
bool returns = (self->HasTextColour());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_IsHoliday[] = { &wxluatype_wxCalendarDateAttr, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_IsHoliday(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_IsHoliday[1] = {{ wxLua_wxCalendarDateAttr_IsHoliday, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_IsHoliday }};
// bool IsHoliday() const;
static int LUACALL wxLua_wxCalendarDateAttr_IsHoliday(lua_State *L)
{
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call IsHoliday
bool returns = (self->IsHoliday());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetBackgroundColour[] = { &wxluatype_wxCalendarDateAttr, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_SetBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_SetBackgroundColour[1] = {{ wxLua_wxCalendarDateAttr_SetBackgroundColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetBackgroundColour }};
// void SetBackgroundColour(const wxColour& colBack );
static int LUACALL wxLua_wxCalendarDateAttr_SetBackgroundColour(lua_State *L)
{
// const wxColour colBack
const wxColour * colBack = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call SetBackgroundColour
self->SetBackgroundColour(*colBack);
return 0;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetBorder[] = { &wxluatype_wxCalendarDateAttr, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_SetBorder(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_SetBorder[1] = {{ wxLua_wxCalendarDateAttr_SetBorder, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetBorder }};
// void SetBorder(wxCalendarDateBorder border );
static int LUACALL wxLua_wxCalendarDateAttr_SetBorder(lua_State *L)
{
// wxCalendarDateBorder border
wxCalendarDateBorder border = (wxCalendarDateBorder)wxlua_getenumtype(L, 2);
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call SetBorder
self->SetBorder(border);
return 0;
}
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetBorderColour[] = { &wxluatype_wxCalendarDateAttr, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_SetBorderColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_SetBorderColour[1] = {{ wxLua_wxCalendarDateAttr_SetBorderColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetBorderColour }};
// void SetBorderColour(const wxColour& col );
static int LUACALL wxLua_wxCalendarDateAttr_SetBorderColour(lua_State *L)
{
// const wxColour col
const wxColour * col = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call SetBorderColour
self->SetBorderColour(*col);
return 0;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxFont)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetFont[] = { &wxluatype_wxCalendarDateAttr, &wxluatype_wxFont, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_SetFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_SetFont[1] = {{ wxLua_wxCalendarDateAttr_SetFont, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetFont }};
// void SetFont(const wxFont& font );
static int LUACALL wxLua_wxCalendarDateAttr_SetFont(lua_State *L)
{
// const wxFont font
const wxFont * font = (const wxFont *)wxluaT_getuserdatatype(L, 2, wxluatype_wxFont);
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call SetFont
self->SetFont(*font);
return 0;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxFont)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetHoliday[] = { &wxluatype_wxCalendarDateAttr, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_SetHoliday(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_SetHoliday[1] = {{ wxLua_wxCalendarDateAttr_SetHoliday, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetHoliday }};
// void SetHoliday(bool holiday );
static int LUACALL wxLua_wxCalendarDateAttr_SetHoliday(lua_State *L)
{
// bool holiday
bool holiday = wxlua_getbooleantype(L, 2);
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call SetHoliday
self->SetHoliday(holiday);
return 0;
}
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetTextColour[] = { &wxluatype_wxCalendarDateAttr, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_SetTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_SetTextColour[1] = {{ wxLua_wxCalendarDateAttr_SetTextColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarDateAttr_SetTextColour }};
// void SetTextColour(const wxColour& colText );
static int LUACALL wxLua_wxCalendarDateAttr_SetTextColour(lua_State *L)
{
// const wxColour colText
const wxColour * colText = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxCalendarDateAttr * self = (wxCalendarDateAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarDateAttr);
// call SetTextColour
self->SetTextColour(*colText);
return 0;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_delete[] = { &wxluatype_wxCalendarDateAttr, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxCalendarDateAttr_delete }};
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_constructor2[] = { &wxluatype_TINTEGER, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_constructor2(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_constructor2[1] = {{ wxLua_wxCalendarDateAttr_constructor2, WXLUAMETHOD_CONSTRUCTOR, 1, 2, s_wxluatypeArray_wxLua_wxCalendarDateAttr_constructor2 }};
// wxCalendarDateAttr(wxCalendarDateBorder border, const wxColour& colBorder = wxNullColour );
static int LUACALL wxLua_wxCalendarDateAttr_constructor2(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxColour colBorder = wxNullColour
const wxColour * colBorder = (argCount >= 2 ? (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour) : &wxNullColour);
// wxCalendarDateBorder border
wxCalendarDateBorder border = (wxCalendarDateBorder)wxlua_getenumtype(L, 1);
// call constructor
wxCalendarDateAttr* returns = new wxCalendarDateAttr(border, *colBorder);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxCalendarDateAttr);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxCalendarDateAttr);
return 1;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
#if ((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxFont)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarDateAttr_constructor1[] = { &wxluatype_wxColour, &wxluatype_wxColour, &wxluatype_wxColour, &wxluatype_wxFont, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxCalendarDateAttr_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_constructor1[1] = {{ wxLua_wxCalendarDateAttr_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 5, s_wxluatypeArray_wxLua_wxCalendarDateAttr_constructor1 }};
// wxCalendarDateAttr(const wxColour& colText, const wxColour& colBack = wxNullColour, const wxColour& colBorder = wxNullColour, const wxFont& font = wxNullFont, wxCalendarDateBorder border = wxCAL_BORDER_NONE );
static int LUACALL wxLua_wxCalendarDateAttr_constructor1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxCalendarDateBorder border = wxCAL_BORDER_NONE
wxCalendarDateBorder border = (argCount >= 5 ? (wxCalendarDateBorder)wxlua_getenumtype(L, 5) : wxCAL_BORDER_NONE);
// const wxFont font = wxNullFont
const wxFont * font = (argCount >= 4 ? (const wxFont *)wxluaT_getuserdatatype(L, 4, wxluatype_wxFont) : &wxNullFont);
// const wxColour colBorder = wxNullColour
const wxColour * colBorder = (argCount >= 3 ? (const wxColour *)wxluaT_getuserdatatype(L, 3, wxluatype_wxColour) : &wxNullColour);
// const wxColour colBack = wxNullColour
const wxColour * colBack = (argCount >= 2 ? (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour) : &wxNullColour);
// const wxColour colText
const wxColour * colText = (const wxColour *)wxluaT_getuserdatatype(L, 1, wxluatype_wxColour);
// call constructor
wxCalendarDateAttr* returns = new wxCalendarDateAttr(*colText, *colBack, *colBorder, *font, border);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxCalendarDateAttr);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxCalendarDateAttr);
return 1;
}
#endif // ((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxFont)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
static int LUACALL wxLua_wxCalendarDateAttr_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_constructor[1] = {{ wxLua_wxCalendarDateAttr_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxCalendarDateAttr( );
static int LUACALL wxLua_wxCalendarDateAttr_constructor(lua_State *L)
{
// call constructor
wxCalendarDateAttr* returns = new wxCalendarDateAttr();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxCalendarDateAttr);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxCalendarDateAttr);
return 1;
}
#if ((wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush))||(((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxFont)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))||(wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarDateAttr_constructor_overload[] =
{
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ wxLua_wxCalendarDateAttr_constructor2, WXLUAMETHOD_CONSTRUCTOR, 1, 2, s_wxluatypeArray_wxLua_wxCalendarDateAttr_constructor2 },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
#if ((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxFont)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
{ wxLua_wxCalendarDateAttr_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 5, s_wxluatypeArray_wxLua_wxCalendarDateAttr_constructor1 },
#endif // ((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxFont)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
{ wxLua_wxCalendarDateAttr_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxCalendarDateAttr_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxCalendarDateAttr_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush))||(((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxFont)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))||(wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
void wxLua_wxCalendarDateAttr_delete_function(void** p)
{
wxCalendarDateAttr* o = (wxCalendarDateAttr*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxCalendarDateAttr_methods[] = {
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "GetBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_GetBackgroundColour, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "GetBorder", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_GetBorder, 1, NULL },
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "GetBorderColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_GetBorderColour, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxFont)
{ "GetFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_GetFont, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxFont)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "GetTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_GetTextColour, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "HasBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_HasBackgroundColour, 1, NULL },
{ "HasBorder", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_HasBorder, 1, NULL },
{ "HasBorderColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_HasBorderColour, 1, NULL },
{ "HasFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_HasFont, 1, NULL },
{ "HasTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_HasTextColour, 1, NULL },
{ "IsHoliday", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_IsHoliday, 1, NULL },
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "SetBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_SetBackgroundColour, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "SetBorder", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_SetBorder, 1, NULL },
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "SetBorderColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_SetBorderColour, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxFont)
{ "SetFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_SetFont, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxFont)
{ "SetHoliday", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_SetHoliday, 1, NULL },
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "SetTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarDateAttr_SetTextColour, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush)
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxCalendarDateAttr_delete, 1, NULL },
#if ((wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush))||(((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxFont)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))||(wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
{ "wxCalendarDateAttr", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxCalendarDateAttr_constructor_overload, s_wxluafunc_wxLua_wxCalendarDateAttr_constructor_overload_count, 0 },
#endif // ((wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxColourPenBrush))||(((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxFont)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))||(wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
{ 0, 0, 0, 0 },
};
int wxCalendarDateAttr_methodCount = sizeof(wxCalendarDateAttr_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
#if wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
// ---------------------------------------------------------------------------
// Bind class wxDateEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxDateEvent'
int wxluatype_wxDateEvent = WXLUA_TUNKNOWN;
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
static wxLuaArgType s_wxluatypeArray_wxLua_wxDateEvent_GetDate[] = { &wxluatype_wxDateEvent, NULL };
static int LUACALL wxLua_wxDateEvent_GetDate(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxDateEvent_GetDate[1] = {{ wxLua_wxDateEvent_GetDate, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxDateEvent_GetDate }};
// wxDateTime GetDate() const;
static int LUACALL wxLua_wxDateEvent_GetDate(lua_State *L)
{
// get this
wxDateEvent * self = (wxDateEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxDateEvent);
// call GetDate
// allocate a new object using the copy constructor
wxDateTime* returns = new wxDateTime(self->GetDate());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxDateTime);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxDateTime);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxDateEvent_SetDate[] = { &wxluatype_wxDateEvent, &wxluatype_wxDateTime, NULL };
static int LUACALL wxLua_wxDateEvent_SetDate(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxDateEvent_SetDate[1] = {{ wxLua_wxDateEvent_SetDate, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxDateEvent_SetDate }};
// void SetDate(const wxDateTime &date );
static int LUACALL wxLua_wxDateEvent_SetDate(lua_State *L)
{
// const wxDateTime date
const wxDateTime * date = (const wxDateTime *)wxluaT_getuserdatatype(L, 2, wxluatype_wxDateTime);
// get this
wxDateEvent * self = (wxDateEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxDateEvent);
// call SetDate
self->SetDate(*date);
return 0;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
static wxLuaArgType s_wxluatypeArray_wxLua_wxDateEvent_delete[] = { &wxluatype_wxDateEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxDateEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxDateEvent_delete }};
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
static wxLuaArgType s_wxluatypeArray_wxLua_wxDateEvent_constructor[] = { &wxluatype_wxWindow, &wxluatype_wxDateTime, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxDateEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxDateEvent_constructor[1] = {{ wxLua_wxDateEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 3, 3, s_wxluatypeArray_wxLua_wxDateEvent_constructor }};
// wxDateEvent(wxWindow *win, const wxDateTime& dt, wxEventType type );
static int LUACALL wxLua_wxDateEvent_constructor(lua_State *L)
{
// wxEventType type
wxEventType type = (wxEventType)wxlua_getnumbertype(L, 3);
// const wxDateTime dt
const wxDateTime * dt = (const wxDateTime *)wxluaT_getuserdatatype(L, 2, wxluatype_wxDateTime);
// wxWindow win
wxWindow * win = (wxWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWindow);
// call constructor
wxDateEvent* returns = new wxDateEvent(win, *dt, type);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxDateEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxDateEvent);
return 1;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
void wxLua_wxDateEvent_delete_function(void** p)
{
wxDateEvent* o = (wxDateEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxDateEvent_methods[] = {
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
{ "GetDate", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxDateEvent_GetDate, 1, NULL },
{ "SetDate", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxDateEvent_SetDate, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxDateEvent_delete, 1, NULL },
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
{ "wxDateEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxDateEvent_constructor, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
{ 0, 0, 0, 0 },
};
int wxDateEvent_methodCount = sizeof(wxDateEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
#if wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
// ---------------------------------------------------------------------------
// Bind class wxCalendarEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxCalendarEvent'
int wxluatype_wxCalendarEvent = WXLUA_TUNKNOWN;
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarEvent_GetWeekDay[] = { &wxluatype_wxCalendarEvent, NULL };
static int LUACALL wxLua_wxCalendarEvent_GetWeekDay(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarEvent_GetWeekDay[1] = {{ wxLua_wxCalendarEvent_GetWeekDay, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalendarEvent_GetWeekDay }};
// wxDateTime::WeekDay GetWeekDay() const;
static int LUACALL wxLua_wxCalendarEvent_GetWeekDay(lua_State *L)
{
// get this
wxCalendarEvent * self = (wxCalendarEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarEvent);
// call GetWeekDay
wxDateTime::WeekDay returns = (self->GetWeekDay());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarEvent_SetWeekDay[] = { &wxluatype_wxCalendarEvent, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxCalendarEvent_SetWeekDay(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarEvent_SetWeekDay[1] = {{ wxLua_wxCalendarEvent_SetWeekDay, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalendarEvent_SetWeekDay }};
// void SetWeekDay(const wxDateTime::WeekDay wd );
static int LUACALL wxLua_wxCalendarEvent_SetWeekDay(lua_State *L)
{
// const wxDateTime::WeekDay wd
const wxDateTime::WeekDay wd = (const wxDateTime::WeekDay)wxlua_getenumtype(L, 2);
// get this
wxCalendarEvent * self = (wxCalendarEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarEvent);
// call SetWeekDay
self->SetWeekDay(wd);
return 0;
}
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarEvent_delete[] = { &wxluatype_wxCalendarEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxCalendarEvent_delete }};
#if (((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarEvent_constructor2[] = { &wxluatype_wxWindow, &wxluatype_wxDateTime, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxCalendarEvent_constructor2(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarEvent_constructor2[1] = {{ wxLua_wxCalendarEvent_constructor2, WXLUAMETHOD_CONSTRUCTOR, 3, 3, s_wxluatypeArray_wxLua_wxCalendarEvent_constructor2 }};
// %wxchkver_2_9_2 wxCalendarEvent(wxWindow *win, const wxDateTime& dt, wxEventType type );
static int LUACALL wxLua_wxCalendarEvent_constructor2(lua_State *L)
{
// wxEventType type
wxEventType type = (wxEventType)wxlua_getnumbertype(L, 3);
// const wxDateTime dt
const wxDateTime * dt = (const wxDateTime *)wxluaT_getuserdatatype(L, 2, wxluatype_wxDateTime);
// wxWindow win
wxWindow * win = (wxWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWindow);
// call constructor
wxCalendarEvent* returns = new wxCalendarEvent(win, *dt, type);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxCalendarEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxCalendarEvent);
return 1;
}
#endif // (((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
#if ((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarEvent_constructor1[] = { &wxluatype_wxCalendarCtrl, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxCalendarEvent_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarEvent_constructor1[1] = {{ wxLua_wxCalendarEvent_constructor1, WXLUAMETHOD_CONSTRUCTOR, 2, 2, s_wxluatypeArray_wxLua_wxCalendarEvent_constructor1 }};
// !%wxchkver_2_9_2 wxCalendarEvent(wxCalendarCtrl *cal, wxEventType type );
static int LUACALL wxLua_wxCalendarEvent_constructor1(lua_State *L)
{
// wxEventType type
wxEventType type = (wxEventType)wxlua_getnumbertype(L, 2);
// wxCalendarCtrl cal
wxCalendarCtrl * cal = (wxCalendarCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarCtrl);
// call constructor
wxCalendarEvent* returns = new wxCalendarEvent(cal, type);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxCalendarEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxCalendarEvent);
return 1;
}
#endif // ((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
#if ((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalendarEvent_constructor[] = { &wxluatype_wxCalendarEvent, NULL };
static int LUACALL wxLua_wxCalendarEvent_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarEvent_constructor[1] = {{ wxLua_wxCalendarEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 1, 1, s_wxluatypeArray_wxLua_wxCalendarEvent_constructor }};
// %wxchkver_2_9_2 wxCalendarEvent(const wxCalendarEvent& event );
static int LUACALL wxLua_wxCalendarEvent_constructor(lua_State *L)
{
// const wxCalendarEvent event
const wxCalendarEvent * event = (const wxCalendarEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalendarEvent);
// call constructor
wxCalendarEvent* returns = new wxCalendarEvent(*event);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxCalendarEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxCalendarEvent);
return 1;
}
#endif // ((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
#if ((((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME))||(((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))||(((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalendarEvent_constructor_overload[] =
{
#if (((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
{ wxLua_wxCalendarEvent_constructor2, WXLUAMETHOD_CONSTRUCTOR, 3, 3, s_wxluatypeArray_wxLua_wxCalendarEvent_constructor2 },
#endif // (((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
#if ((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
{ wxLua_wxCalendarEvent_constructor1, WXLUAMETHOD_CONSTRUCTOR, 2, 2, s_wxluatypeArray_wxLua_wxCalendarEvent_constructor1 },
#endif // ((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
#if ((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
{ wxLua_wxCalendarEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 1, 1, s_wxluatypeArray_wxLua_wxCalendarEvent_constructor },
#endif // ((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)
};
static int s_wxluafunc_wxLua_wxCalendarEvent_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxCalendarEvent_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // ((((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME))||(((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))||(((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))
void wxLua_wxCalendarEvent_delete_function(void** p)
{
wxCalendarEvent* o = (wxCalendarEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxCalendarEvent_methods[] = {
#if (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
{ "GetWeekDay", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarEvent_GetWeekDay, 1, NULL },
{ "SetWeekDay", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalendarEvent_SetWeekDay, 1, NULL },
#endif // (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME)
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxCalendarEvent_delete, 1, NULL },
#if ((((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME))||(((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))||(((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))
{ "wxCalendarEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxCalendarEvent_constructor_overload, s_wxluafunc_wxLua_wxCalendarEvent_constructor_overload_count, 0 },
#endif // ((((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxDateTime && wxUSE_DATETIME))||(((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))||(((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL)) && (wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL))
{ 0, 0, 0, 0 },
};
int wxCalendarEvent_methodCount = sizeof(wxCalendarEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
#if wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
// ---------------------------------------------------------------------------
// Bind class wxHyperlinkCtrl
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxHyperlinkCtrl'
int wxluatype_wxHyperlinkCtrl = WXLUA_TUNKNOWN;
#if (wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_Create[] = { &wxluatype_wxHyperlinkCtrl, &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_TSTRING, &wxluatype_TSTRING, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_Create(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_Create[1] = {{ wxLua_wxHyperlinkCtrl_Create, WXLUAMETHOD_METHOD, 5, 9, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_Create }};
// bool Create(wxWindow *parent, wxWindowID id, const wxString& label, const wxString& url, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxHL_DEFAULT_STYLE, const wxString& name = "wxHyperlinkCtrl");
static int LUACALL wxLua_wxHyperlinkCtrl_Create(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxHyperlinkCtrl"
const wxString name = (argCount >= 9 ? wxlua_getwxStringtype(L, 9) : wxString(wxT("wxHyperlinkCtrl")));
// long style = wxHL_DEFAULT_STYLE
long style = (argCount >= 8 ? (long)wxlua_getnumbertype(L, 8) : wxHL_DEFAULT_STYLE);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 7 ? (const wxSize *)wxluaT_getuserdatatype(L, 7, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 6 ? (const wxPoint *)wxluaT_getuserdatatype(L, 6, wxluatype_wxPoint) : &wxDefaultPosition);
// const wxString url
const wxString url = wxlua_getwxStringtype(L, 5);
// const wxString label
const wxString label = wxlua_getwxStringtype(L, 4);
// wxWindowID id
wxWindowID id = (wxWindowID)wxlua_getnumbertype(L, 3);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWindow);
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call Create
bool returns = (self->Create(parent, id, label, url, *pos, *size, style, name));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
#if (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_GetHoverColour[] = { &wxluatype_wxHyperlinkCtrl, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_GetHoverColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_GetHoverColour[1] = {{ wxLua_wxHyperlinkCtrl_GetHoverColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_GetHoverColour }};
// wxColour GetHoverColour() const;
static int LUACALL wxLua_wxHyperlinkCtrl_GetHoverColour(lua_State *L)
{
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call GetHoverColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetHoverColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_GetNormalColour[] = { &wxluatype_wxHyperlinkCtrl, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_GetNormalColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_GetNormalColour[1] = {{ wxLua_wxHyperlinkCtrl_GetNormalColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_GetNormalColour }};
// wxColour GetNormalColour() const;
static int LUACALL wxLua_wxHyperlinkCtrl_GetNormalColour(lua_State *L)
{
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call GetNormalColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetNormalColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_GetURL[] = { &wxluatype_wxHyperlinkCtrl, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_GetURL(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_GetURL[1] = {{ wxLua_wxHyperlinkCtrl_GetURL, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_GetURL }};
// wxString GetURL() const;
static int LUACALL wxLua_wxHyperlinkCtrl_GetURL(lua_State *L)
{
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call GetURL
wxString returns = (self->GetURL());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_GetVisited[] = { &wxluatype_wxHyperlinkCtrl, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_GetVisited(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_GetVisited[1] = {{ wxLua_wxHyperlinkCtrl_GetVisited, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_GetVisited }};
// bool GetVisited() const;
static int LUACALL wxLua_wxHyperlinkCtrl_GetVisited(lua_State *L)
{
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call GetVisited
bool returns = (self->GetVisited());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_GetVisitedColour[] = { &wxluatype_wxHyperlinkCtrl, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_GetVisitedColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_GetVisitedColour[1] = {{ wxLua_wxHyperlinkCtrl_GetVisitedColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_GetVisitedColour }};
// wxColour GetVisitedColour() const;
static int LUACALL wxLua_wxHyperlinkCtrl_GetVisitedColour(lua_State *L)
{
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call GetVisitedColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetVisitedColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_SetHoverColour[] = { &wxluatype_wxHyperlinkCtrl, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_SetHoverColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_SetHoverColour[1] = {{ wxLua_wxHyperlinkCtrl_SetHoverColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_SetHoverColour }};
// void SetHoverColour(const wxColour &colour );
static int LUACALL wxLua_wxHyperlinkCtrl_SetHoverColour(lua_State *L)
{
// const wxColour colour
const wxColour * colour = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call SetHoverColour
self->SetHoverColour(*colour);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_SetNormalColour[] = { &wxluatype_wxHyperlinkCtrl, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_SetNormalColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_SetNormalColour[1] = {{ wxLua_wxHyperlinkCtrl_SetNormalColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_SetNormalColour }};
// void SetNormalColour(const wxColour &colour);
static int LUACALL wxLua_wxHyperlinkCtrl_SetNormalColour(lua_State *L)
{
// const wxColour colour
const wxColour * colour = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call SetNormalColour
self->SetNormalColour(*colour);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_SetURL[] = { &wxluatype_wxHyperlinkCtrl, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_SetURL(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_SetURL[1] = {{ wxLua_wxHyperlinkCtrl_SetURL, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_SetURL }};
// void SetURL (const wxString &url );
static int LUACALL wxLua_wxHyperlinkCtrl_SetURL(lua_State *L)
{
// const wxString url
const wxString url = wxlua_getwxStringtype(L, 2);
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call SetURL
self->SetURL(url);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_SetVisited[] = { &wxluatype_wxHyperlinkCtrl, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_SetVisited(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_SetVisited[1] = {{ wxLua_wxHyperlinkCtrl_SetVisited, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_SetVisited }};
// void SetVisited(bool visited = true );
static int LUACALL wxLua_wxHyperlinkCtrl_SetVisited(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool visited = true
bool visited = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call SetVisited
self->SetVisited(visited);
return 0;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_SetVisitedColour[] = { &wxluatype_wxHyperlinkCtrl, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_SetVisitedColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_SetVisitedColour[1] = {{ wxLua_wxHyperlinkCtrl_SetVisitedColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_SetVisitedColour }};
// void SetVisitedColour(const wxColour &colour);
static int LUACALL wxLua_wxHyperlinkCtrl_SetVisitedColour(lua_State *L)
{
// const wxColour colour
const wxColour * colour = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxHyperlinkCtrl * self = (wxHyperlinkCtrl *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkCtrl);
// call SetVisitedColour
self->SetVisitedColour(*colour);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
#if (wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkCtrl_constructor1[] = { &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_TSTRING, &wxluatype_TSTRING, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxHyperlinkCtrl_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_constructor1[1] = {{ wxLua_wxHyperlinkCtrl_constructor1, WXLUAMETHOD_CONSTRUCTOR, 4, 8, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_constructor1 }};
// wxHyperlinkCtrl(wxWindow *parent, wxWindowID id, const wxString& label, const wxString& url, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxHL_DEFAULT_STYLE, const wxString& name = "wxHyperlinkCtrl" );
static int LUACALL wxLua_wxHyperlinkCtrl_constructor1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxHyperlinkCtrl"
const wxString name = (argCount >= 8 ? wxlua_getwxStringtype(L, 8) : wxString(wxT("wxHyperlinkCtrl")));
// long style = wxHL_DEFAULT_STYLE
long style = (argCount >= 7 ? (long)wxlua_getnumbertype(L, 7) : wxHL_DEFAULT_STYLE);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 6 ? (const wxSize *)wxluaT_getuserdatatype(L, 6, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 5 ? (const wxPoint *)wxluaT_getuserdatatype(L, 5, wxluatype_wxPoint) : &wxDefaultPosition);
// const wxString url
const wxString url = wxlua_getwxStringtype(L, 4);
// const wxString label
const wxString label = wxlua_getwxStringtype(L, 3);
// wxWindowID id
wxWindowID id = (wxWindowID)wxlua_getnumbertype(L, 2);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWindow);
// call constructor
wxHyperlinkCtrl* returns = new wxHyperlinkCtrl(parent, id, label, url, *pos, *size, style, name);
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxHyperlinkCtrl);
return 1;
}
#endif // (wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
static int LUACALL wxLua_wxHyperlinkCtrl_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_constructor[1] = {{ wxLua_wxHyperlinkCtrl_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxHyperlinkCtrl( );
static int LUACALL wxLua_wxHyperlinkCtrl_constructor(lua_State *L)
{
// call constructor
wxHyperlinkCtrl* returns = new wxHyperlinkCtrl();
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxHyperlinkCtrl);
return 1;
}
#if ((wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl))||(wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkCtrl_constructor_overload[] =
{
#if (wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ wxLua_wxHyperlinkCtrl_constructor1, WXLUAMETHOD_CONSTRUCTOR, 4, 8, s_wxluatypeArray_wxLua_wxHyperlinkCtrl_constructor1 },
#endif // (wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ wxLua_wxHyperlinkCtrl_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxHyperlinkCtrl_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxHyperlinkCtrl_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl))||(wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
void wxLua_wxHyperlinkCtrl_delete_function(void** p)
{
wxHyperlinkCtrl* o = (wxHyperlinkCtrl*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxHyperlinkCtrl_methods[] = {
#if (wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ "Create", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_Create, 1, NULL },
#endif // (wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
#if (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ "GetHoverColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_GetHoverColour, 1, NULL },
{ "GetNormalColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_GetNormalColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ "GetURL", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_GetURL, 1, NULL },
{ "GetVisited", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_GetVisited, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ "GetVisitedColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_GetVisitedColour, 1, NULL },
{ "SetHoverColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_SetHoverColour, 1, NULL },
{ "SetNormalColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_SetNormalColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ "SetURL", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_SetURL, 1, NULL },
{ "SetVisited", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_SetVisited, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ "SetVisitedColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkCtrl_SetVisitedColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
#if ((wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl))||(wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ "wxHyperlinkCtrl", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxHyperlinkCtrl_constructor_overload, s_wxluafunc_wxLua_wxHyperlinkCtrl_constructor_overload_count, 0 },
#endif // ((wxLUA_USE_wxPointSizeRect) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl))||(wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ 0, 0, 0, 0 },
};
int wxHyperlinkCtrl_methodCount = sizeof(wxHyperlinkCtrl_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
#if wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
// ---------------------------------------------------------------------------
// Bind class wxHyperlinkEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxHyperlinkEvent'
int wxluatype_wxHyperlinkEvent = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkEvent_GetURL[] = { &wxluatype_wxHyperlinkEvent, NULL };
static int LUACALL wxLua_wxHyperlinkEvent_GetURL(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkEvent_GetURL[1] = {{ wxLua_wxHyperlinkEvent_GetURL, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxHyperlinkEvent_GetURL }};
// wxString GetURL() const;
static int LUACALL wxLua_wxHyperlinkEvent_GetURL(lua_State *L)
{
// get this
wxHyperlinkEvent * self = (wxHyperlinkEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkEvent);
// call GetURL
wxString returns = (self->GetURL());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkEvent_SetURL[] = { &wxluatype_wxHyperlinkEvent, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxHyperlinkEvent_SetURL(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkEvent_SetURL[1] = {{ wxLua_wxHyperlinkEvent_SetURL, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxHyperlinkEvent_SetURL }};
// void SetURL(const wxString &url );
static int LUACALL wxLua_wxHyperlinkEvent_SetURL(lua_State *L)
{
// const wxString url
const wxString url = wxlua_getwxStringtype(L, 2);
// get this
wxHyperlinkEvent * self = (wxHyperlinkEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxHyperlinkEvent);
// call SetURL
self->SetURL(url);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkEvent_delete[] = { &wxluatype_wxHyperlinkEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxHyperlinkEvent_delete }};
#if (wxLUA_USE_wxObject) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
static wxLuaArgType s_wxluatypeArray_wxLua_wxHyperlinkEvent_constructor[] = { &wxluatype_wxObject, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxHyperlinkEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxHyperlinkEvent_constructor[1] = {{ wxLua_wxHyperlinkEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 3, 3, s_wxluatypeArray_wxLua_wxHyperlinkEvent_constructor }};
// wxHyperlinkEvent(wxObject *generator, wxWindowID id, const wxString& url );
static int LUACALL wxLua_wxHyperlinkEvent_constructor(lua_State *L)
{
// const wxString url
const wxString url = wxlua_getwxStringtype(L, 3);
// wxWindowID id
wxWindowID id = (wxWindowID)wxlua_getnumbertype(L, 2);
// wxObject generator
wxObject * generator = (wxObject *)wxluaT_getuserdatatype(L, 1, wxluatype_wxObject);
// call constructor
wxHyperlinkEvent* returns = new wxHyperlinkEvent(generator, id, url);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxHyperlinkEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxHyperlinkEvent);
return 1;
}
#endif // (wxLUA_USE_wxObject) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
void wxLua_wxHyperlinkEvent_delete_function(void** p)
{
wxHyperlinkEvent* o = (wxHyperlinkEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxHyperlinkEvent_methods[] = {
{ "GetURL", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkEvent_GetURL, 1, NULL },
{ "SetURL", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxHyperlinkEvent_SetURL, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxHyperlinkEvent_delete, 1, NULL },
#if (wxLUA_USE_wxObject) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ "wxHyperlinkEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxHyperlinkEvent_constructor, 1, NULL },
#endif // (wxLUA_USE_wxObject) && (wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl)
{ 0, 0, 0, 0 },
};
int wxHyperlinkEvent_methodCount = sizeof(wxHyperlinkEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
// ---------------------------------------------------------------------------
// Bind class wxSashWindow
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxSashWindow'
int wxluatype_wxSashWindow = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_GetMaximumSizeX[] = { &wxluatype_wxSashWindow, NULL };
static int LUACALL wxLua_wxSashWindow_GetMaximumSizeX(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_GetMaximumSizeX[1] = {{ wxLua_wxSashWindow_GetMaximumSizeX, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSashWindow_GetMaximumSizeX }};
// int GetMaximumSizeX() const;
static int LUACALL wxLua_wxSashWindow_GetMaximumSizeX(lua_State *L)
{
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call GetMaximumSizeX
int returns = (self->GetMaximumSizeX());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_GetMaximumSizeY[] = { &wxluatype_wxSashWindow, NULL };
static int LUACALL wxLua_wxSashWindow_GetMaximumSizeY(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_GetMaximumSizeY[1] = {{ wxLua_wxSashWindow_GetMaximumSizeY, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSashWindow_GetMaximumSizeY }};
// int GetMaximumSizeY() const;
static int LUACALL wxLua_wxSashWindow_GetMaximumSizeY(lua_State *L)
{
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call GetMaximumSizeY
int returns = (self->GetMaximumSizeY());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_GetMinimumSizeX[] = { &wxluatype_wxSashWindow, NULL };
static int LUACALL wxLua_wxSashWindow_GetMinimumSizeX(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_GetMinimumSizeX[1] = {{ wxLua_wxSashWindow_GetMinimumSizeX, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSashWindow_GetMinimumSizeX }};
// int GetMinimumSizeX() const;
static int LUACALL wxLua_wxSashWindow_GetMinimumSizeX(lua_State *L)
{
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call GetMinimumSizeX
int returns = (self->GetMinimumSizeX());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_GetMinimumSizeY[] = { &wxluatype_wxSashWindow, NULL };
static int LUACALL wxLua_wxSashWindow_GetMinimumSizeY(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_GetMinimumSizeY[1] = {{ wxLua_wxSashWindow_GetMinimumSizeY, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSashWindow_GetMinimumSizeY }};
// int GetMinimumSizeY() const;
static int LUACALL wxLua_wxSashWindow_GetMinimumSizeY(lua_State *L)
{
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call GetMinimumSizeY
int returns = (self->GetMinimumSizeY());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_GetSashVisible[] = { &wxluatype_wxSashWindow, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxSashWindow_GetSashVisible(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_GetSashVisible[1] = {{ wxLua_wxSashWindow_GetSashVisible, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashWindow_GetSashVisible }};
// bool GetSashVisible(wxSashEdgePosition edge) const;
static int LUACALL wxLua_wxSashWindow_GetSashVisible(lua_State *L)
{
// wxSashEdgePosition edge
wxSashEdgePosition edge = (wxSashEdgePosition)wxlua_getenumtype(L, 2);
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call GetSashVisible
bool returns = (self->GetSashVisible(edge));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (((defined(WXWIN_COMPATIBILITY_2_6) && WXWIN_COMPATIBILITY_2_6)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_HasBorder[] = { &wxluatype_wxSashWindow, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxSashWindow_HasBorder(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_HasBorder[1] = {{ wxLua_wxSashWindow_HasBorder, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashWindow_HasBorder }};
// %wxcompat_2_6 bool HasBorder(wxSashEdgePosition edge) const;
static int LUACALL wxLua_wxSashWindow_HasBorder(lua_State *L)
{
// wxSashEdgePosition edge
wxSashEdgePosition edge = (wxSashEdgePosition)wxlua_getenumtype(L, 2);
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call HasBorder
bool returns = (self->HasBorder(edge));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (((defined(WXWIN_COMPATIBILITY_2_6) && WXWIN_COMPATIBILITY_2_6)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_SetMaximumSizeX[] = { &wxluatype_wxSashWindow, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxSashWindow_SetMaximumSizeX(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_SetMaximumSizeX[1] = {{ wxLua_wxSashWindow_SetMaximumSizeX, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashWindow_SetMaximumSizeX }};
// void SetMaximumSizeX(int min );
static int LUACALL wxLua_wxSashWindow_SetMaximumSizeX(lua_State *L)
{
// int min
int min = (int)wxlua_getnumbertype(L, 2);
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call SetMaximumSizeX
self->SetMaximumSizeX(min);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_SetMaximumSizeY[] = { &wxluatype_wxSashWindow, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxSashWindow_SetMaximumSizeY(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_SetMaximumSizeY[1] = {{ wxLua_wxSashWindow_SetMaximumSizeY, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashWindow_SetMaximumSizeY }};
// void SetMaximumSizeY(int min );
static int LUACALL wxLua_wxSashWindow_SetMaximumSizeY(lua_State *L)
{
// int min
int min = (int)wxlua_getnumbertype(L, 2);
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call SetMaximumSizeY
self->SetMaximumSizeY(min);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_SetMinimumSizeX[] = { &wxluatype_wxSashWindow, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxSashWindow_SetMinimumSizeX(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_SetMinimumSizeX[1] = {{ wxLua_wxSashWindow_SetMinimumSizeX, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashWindow_SetMinimumSizeX }};
// void SetMinimumSizeX(int min );
static int LUACALL wxLua_wxSashWindow_SetMinimumSizeX(lua_State *L)
{
// int min
int min = (int)wxlua_getnumbertype(L, 2);
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call SetMinimumSizeX
self->SetMinimumSizeX(min);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_SetMinimumSizeY[] = { &wxluatype_wxSashWindow, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxSashWindow_SetMinimumSizeY(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_SetMinimumSizeY[1] = {{ wxLua_wxSashWindow_SetMinimumSizeY, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashWindow_SetMinimumSizeY }};
// void SetMinimumSizeY(int min );
static int LUACALL wxLua_wxSashWindow_SetMinimumSizeY(lua_State *L)
{
// int min
int min = (int)wxlua_getnumbertype(L, 2);
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call SetMinimumSizeY
self->SetMinimumSizeY(min);
return 0;
}
#if (((defined(WXWIN_COMPATIBILITY_2_6) && WXWIN_COMPATIBILITY_2_6)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_SetSashBorder[] = { &wxluatype_wxSashWindow, &wxluatype_TINTEGER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxSashWindow_SetSashBorder(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_SetSashBorder[1] = {{ wxLua_wxSashWindow_SetSashBorder, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxSashWindow_SetSashBorder }};
// %wxcompat_2_6 void SetSashBorder(wxSashEdgePosition edge, bool hasBorder );
static int LUACALL wxLua_wxSashWindow_SetSashBorder(lua_State *L)
{
// bool hasBorder
bool hasBorder = wxlua_getbooleantype(L, 3);
// wxSashEdgePosition edge
wxSashEdgePosition edge = (wxSashEdgePosition)wxlua_getenumtype(L, 2);
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call SetSashBorder
self->SetSashBorder(edge, hasBorder);
return 0;
}
#endif // (((defined(WXWIN_COMPATIBILITY_2_6) && WXWIN_COMPATIBILITY_2_6)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_SetSashVisible[] = { &wxluatype_wxSashWindow, &wxluatype_TINTEGER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxSashWindow_SetSashVisible(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_SetSashVisible[1] = {{ wxLua_wxSashWindow_SetSashVisible, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxSashWindow_SetSashVisible }};
// void SetSashVisible(wxSashEdgePosition edge, bool visible );
static int LUACALL wxLua_wxSashWindow_SetSashVisible(lua_State *L)
{
// bool visible
bool visible = wxlua_getbooleantype(L, 3);
// wxSashEdgePosition edge
wxSashEdgePosition edge = (wxSashEdgePosition)wxlua_getenumtype(L, 2);
// get this
wxSashWindow * self = (wxSashWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashWindow);
// call SetSashVisible
self->SetSashVisible(edge, visible);
return 0;
}
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashWindow_constructor1[] = { &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxSashWindow_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_constructor1[1] = {{ wxLua_wxSashWindow_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 6, s_wxluatypeArray_wxLua_wxSashWindow_constructor1 }};
// wxSashWindow(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSW_3D|wxCLIP_CHILDREN, const wxString& name = "wxSashWindow" );
static int LUACALL wxLua_wxSashWindow_constructor1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxSashWindow"
const wxString name = (argCount >= 6 ? wxlua_getwxStringtype(L, 6) : wxString(wxT("wxSashWindow")));
// long style = wxSW_3D | wxCLIP_CHILDREN
long style = (argCount >= 5 ? (long)wxlua_getnumbertype(L, 5) : wxSW_3D | wxCLIP_CHILDREN);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 4 ? (const wxSize *)wxluaT_getuserdatatype(L, 4, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 3 ? (const wxPoint *)wxluaT_getuserdatatype(L, 3, wxluatype_wxPoint) : &wxDefaultPosition);
// wxWindowID id = -1
wxWindowID id = (argCount >= 2 ? (wxWindowID)wxlua_getnumbertype(L, 2) : -1);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWindow);
// call constructor
wxSashWindow* returns = new wxSashWindow(parent, id, *pos, *size, style, name);
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSashWindow);
return 1;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static int LUACALL wxLua_wxSashWindow_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_constructor[1] = {{ wxLua_wxSashWindow_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxSashWindow( );
static int LUACALL wxLua_wxSashWindow_constructor(lua_State *L)
{
// call constructor
wxSashWindow* returns = new wxSashWindow();
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSashWindow);
return 1;
}
#if ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxSashWindow && wxUSE_SASH)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashWindow_constructor_overload[] =
{
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ wxLua_wxSashWindow_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 6, s_wxluatypeArray_wxLua_wxSashWindow_constructor1 },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ wxLua_wxSashWindow_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxSashWindow_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxSashWindow_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxSashWindow && wxUSE_SASH)
void wxLua_wxSashWindow_delete_function(void** p)
{
wxSashWindow* o = (wxSashWindow*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxSashWindow_methods[] = {
{ "GetMaximumSizeX", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_GetMaximumSizeX, 1, NULL },
{ "GetMaximumSizeY", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_GetMaximumSizeY, 1, NULL },
{ "GetMinimumSizeX", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_GetMinimumSizeX, 1, NULL },
{ "GetMinimumSizeY", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_GetMinimumSizeY, 1, NULL },
{ "GetSashVisible", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_GetSashVisible, 1, NULL },
#if (((defined(WXWIN_COMPATIBILITY_2_6) && WXWIN_COMPATIBILITY_2_6)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)
{ "HasBorder", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_HasBorder, 1, NULL },
#endif // (((defined(WXWIN_COMPATIBILITY_2_6) && WXWIN_COMPATIBILITY_2_6)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)
{ "SetMaximumSizeX", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_SetMaximumSizeX, 1, NULL },
{ "SetMaximumSizeY", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_SetMaximumSizeY, 1, NULL },
{ "SetMinimumSizeX", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_SetMinimumSizeX, 1, NULL },
{ "SetMinimumSizeY", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_SetMinimumSizeY, 1, NULL },
#if (((defined(WXWIN_COMPATIBILITY_2_6) && WXWIN_COMPATIBILITY_2_6)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)
{ "SetSashBorder", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_SetSashBorder, 1, NULL },
#endif // (((defined(WXWIN_COMPATIBILITY_2_6) && WXWIN_COMPATIBILITY_2_6)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)) && (wxLUA_USE_wxSashWindow && wxUSE_SASH)
{ "SetSashVisible", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashWindow_SetSashVisible, 1, NULL },
#if ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxSashWindow && wxUSE_SASH)
{ "wxSashWindow", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxSashWindow_constructor_overload, s_wxluafunc_wxLua_wxSashWindow_constructor_overload_count, 0 },
#endif // ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxSashWindow && wxUSE_SASH)
{ 0, 0, 0, 0 },
};
int wxSashWindow_methodCount = sizeof(wxSashWindow_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
// ---------------------------------------------------------------------------
// Bind class wxSashLayoutWindow
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxSashLayoutWindow'
int wxluatype_wxSashLayoutWindow = WXLUA_TUNKNOWN;
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashLayoutWindow_Create[] = { &wxluatype_wxSashLayoutWindow, &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxSashLayoutWindow_Create(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashLayoutWindow_Create[1] = {{ wxLua_wxSashLayoutWindow_Create, WXLUAMETHOD_METHOD, 2, 7, s_wxluatypeArray_wxLua_wxSashLayoutWindow_Create }};
// bool Create(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSW_3D|wxCLIP_CHILDREN, const wxString& name = "wxSashLayoutWindow" );
static int LUACALL wxLua_wxSashLayoutWindow_Create(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxSashLayoutWindow"
const wxString name = (argCount >= 7 ? wxlua_getwxStringtype(L, 7) : wxString(wxT("wxSashLayoutWindow")));
// long style = wxSW_3D | wxCLIP_CHILDREN
long style = (argCount >= 6 ? (long)wxlua_getnumbertype(L, 6) : wxSW_3D | wxCLIP_CHILDREN);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 5 ? (const wxSize *)wxluaT_getuserdatatype(L, 5, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 4 ? (const wxPoint *)wxluaT_getuserdatatype(L, 4, wxluatype_wxPoint) : &wxDefaultPosition);
// wxWindowID id = -1
wxWindowID id = (argCount >= 3 ? (wxWindowID)wxlua_getnumbertype(L, 3) : -1);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWindow);
// get this
wxSashLayoutWindow * self = (wxSashLayoutWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashLayoutWindow);
// call Create
bool returns = (self->Create(parent, id, *pos, *size, style, name));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashLayoutWindow_GetAlignment[] = { &wxluatype_wxSashLayoutWindow, NULL };
static int LUACALL wxLua_wxSashLayoutWindow_GetAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashLayoutWindow_GetAlignment[1] = {{ wxLua_wxSashLayoutWindow_GetAlignment, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSashLayoutWindow_GetAlignment }};
// wxLayoutAlignment GetAlignment() const;
static int LUACALL wxLua_wxSashLayoutWindow_GetAlignment(lua_State *L)
{
// get this
wxSashLayoutWindow * self = (wxSashLayoutWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashLayoutWindow);
// call GetAlignment
wxLayoutAlignment returns = (self->GetAlignment());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashLayoutWindow_GetOrientation[] = { &wxluatype_wxSashLayoutWindow, NULL };
static int LUACALL wxLua_wxSashLayoutWindow_GetOrientation(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashLayoutWindow_GetOrientation[1] = {{ wxLua_wxSashLayoutWindow_GetOrientation, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSashLayoutWindow_GetOrientation }};
// wxLayoutOrientation GetOrientation() const;
static int LUACALL wxLua_wxSashLayoutWindow_GetOrientation(lua_State *L)
{
// get this
wxSashLayoutWindow * self = (wxSashLayoutWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashLayoutWindow);
// call GetOrientation
wxLayoutOrientation returns = (self->GetOrientation());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashLayoutWindow_SetAlignment[] = { &wxluatype_wxSashLayoutWindow, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxSashLayoutWindow_SetAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashLayoutWindow_SetAlignment[1] = {{ wxLua_wxSashLayoutWindow_SetAlignment, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashLayoutWindow_SetAlignment }};
// void SetAlignment(wxLayoutAlignment alignment );
static int LUACALL wxLua_wxSashLayoutWindow_SetAlignment(lua_State *L)
{
// wxLayoutAlignment alignment
wxLayoutAlignment alignment = (wxLayoutAlignment)wxlua_getenumtype(L, 2);
// get this
wxSashLayoutWindow * self = (wxSashLayoutWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashLayoutWindow);
// call SetAlignment
self->SetAlignment(alignment);
return 0;
}
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashLayoutWindow_SetDefaultSize[] = { &wxluatype_wxSashLayoutWindow, &wxluatype_wxSize, NULL };
static int LUACALL wxLua_wxSashLayoutWindow_SetDefaultSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashLayoutWindow_SetDefaultSize[1] = {{ wxLua_wxSashLayoutWindow_SetDefaultSize, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashLayoutWindow_SetDefaultSize }};
// void SetDefaultSize(const wxSize& size );
static int LUACALL wxLua_wxSashLayoutWindow_SetDefaultSize(lua_State *L)
{
// const wxSize size
const wxSize * size = (const wxSize *)wxluaT_getuserdatatype(L, 2, wxluatype_wxSize);
// get this
wxSashLayoutWindow * self = (wxSashLayoutWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashLayoutWindow);
// call SetDefaultSize
self->SetDefaultSize(*size);
return 0;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashLayoutWindow_SetOrientation[] = { &wxluatype_wxSashLayoutWindow, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxSashLayoutWindow_SetOrientation(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashLayoutWindow_SetOrientation[1] = {{ wxLua_wxSashLayoutWindow_SetOrientation, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashLayoutWindow_SetOrientation }};
// void SetOrientation(wxLayoutOrientation orientation );
static int LUACALL wxLua_wxSashLayoutWindow_SetOrientation(lua_State *L)
{
// wxLayoutOrientation orientation
wxLayoutOrientation orientation = (wxLayoutOrientation)wxlua_getenumtype(L, 2);
// get this
wxSashLayoutWindow * self = (wxSashLayoutWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashLayoutWindow);
// call SetOrientation
self->SetOrientation(orientation);
return 0;
}
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashLayoutWindow_constructor1[] = { &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxSashLayoutWindow_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashLayoutWindow_constructor1[1] = {{ wxLua_wxSashLayoutWindow_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 6, s_wxluatypeArray_wxLua_wxSashLayoutWindow_constructor1 }};
// wxSashLayoutWindow(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSW_3D|wxCLIP_CHILDREN, const wxString& name = "wxSashLayoutWindow" );
static int LUACALL wxLua_wxSashLayoutWindow_constructor1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxSashLayoutWindow"
const wxString name = (argCount >= 6 ? wxlua_getwxStringtype(L, 6) : wxString(wxT("wxSashLayoutWindow")));
// long style = wxSW_3D | wxCLIP_CHILDREN
long style = (argCount >= 5 ? (long)wxlua_getnumbertype(L, 5) : wxSW_3D | wxCLIP_CHILDREN);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 4 ? (const wxSize *)wxluaT_getuserdatatype(L, 4, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 3 ? (const wxPoint *)wxluaT_getuserdatatype(L, 3, wxluatype_wxPoint) : &wxDefaultPosition);
// wxWindowID id = -1
wxWindowID id = (argCount >= 2 ? (wxWindowID)wxlua_getnumbertype(L, 2) : -1);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWindow);
// call constructor
wxSashLayoutWindow* returns = new wxSashLayoutWindow(parent, id, *pos, *size, style, name);
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSashLayoutWindow);
return 1;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static int LUACALL wxLua_wxSashLayoutWindow_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashLayoutWindow_constructor[1] = {{ wxLua_wxSashLayoutWindow_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxSashLayoutWindow( );
static int LUACALL wxLua_wxSashLayoutWindow_constructor(lua_State *L)
{
// call constructor
wxSashLayoutWindow* returns = new wxSashLayoutWindow();
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSashLayoutWindow);
return 1;
}
#if ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxSashWindow && wxUSE_SASH)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashLayoutWindow_constructor_overload[] =
{
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ wxLua_wxSashLayoutWindow_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 6, s_wxluatypeArray_wxLua_wxSashLayoutWindow_constructor1 },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ wxLua_wxSashLayoutWindow_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxSashLayoutWindow_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxSashLayoutWindow_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxSashWindow && wxUSE_SASH)
void wxLua_wxSashLayoutWindow_delete_function(void** p)
{
wxSashLayoutWindow* o = (wxSashLayoutWindow*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxSashLayoutWindow_methods[] = {
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "Create", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashLayoutWindow_Create, 1, NULL },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "GetAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashLayoutWindow_GetAlignment, 1, NULL },
{ "GetOrientation", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashLayoutWindow_GetOrientation, 1, NULL },
{ "SetAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashLayoutWindow_SetAlignment, 1, NULL },
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "SetDefaultSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashLayoutWindow_SetDefaultSize, 1, NULL },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "SetOrientation", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashLayoutWindow_SetOrientation, 1, NULL },
#if ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxSashWindow && wxUSE_SASH)
{ "wxSashLayoutWindow", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxSashLayoutWindow_constructor_overload, s_wxluafunc_wxLua_wxSashLayoutWindow_constructor_overload_count, 0 },
#endif // ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect))||(wxLUA_USE_wxSashWindow && wxUSE_SASH)
{ 0, 0, 0, 0 },
};
int wxSashLayoutWindow_methodCount = sizeof(wxSashLayoutWindow_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
// ---------------------------------------------------------------------------
// Bind class wxLayoutAlgorithm
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxLayoutAlgorithm'
int wxluatype_wxLayoutAlgorithm = WXLUA_TUNKNOWN;
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxFrame)
static wxLuaArgType s_wxluatypeArray_wxLua_wxLayoutAlgorithm_LayoutFrame[] = { &wxluatype_wxLayoutAlgorithm, &wxluatype_wxFrame, &wxluatype_wxWindow, NULL };
static int LUACALL wxLua_wxLayoutAlgorithm_LayoutFrame(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLayoutAlgorithm_LayoutFrame[1] = {{ wxLua_wxLayoutAlgorithm_LayoutFrame, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxLayoutAlgorithm_LayoutFrame }};
// bool LayoutFrame(wxFrame* frame, wxWindow* mainWindow = NULL) const;
static int LUACALL wxLua_wxLayoutAlgorithm_LayoutFrame(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxWindow mainWindow = NULL
wxWindow * mainWindow = (argCount >= 3 ? (wxWindow *)wxluaT_getuserdatatype(L, 3, wxluatype_wxWindow) : NULL);
// wxFrame frame
wxFrame * frame = (wxFrame *)wxluaT_getuserdatatype(L, 2, wxluatype_wxFrame);
// get this
wxLayoutAlgorithm * self = (wxLayoutAlgorithm *)wxluaT_getuserdatatype(L, 1, wxluatype_wxLayoutAlgorithm);
// call LayoutFrame
bool returns = (self->LayoutFrame(frame, mainWindow));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxFrame)
#if ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_MDI && wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxLayoutAlgorithm_LayoutMDIFrame[] = { &wxluatype_wxLayoutAlgorithm, &wxluatype_wxMDIParentFrame, &wxluatype_wxRect, NULL };
static int LUACALL wxLua_wxLayoutAlgorithm_LayoutMDIFrame(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLayoutAlgorithm_LayoutMDIFrame[1] = {{ wxLua_wxLayoutAlgorithm_LayoutMDIFrame, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxLayoutAlgorithm_LayoutMDIFrame }};
// bool LayoutMDIFrame(wxMDIParentFrame* frame, wxRect* rect = NULL );
static int LUACALL wxLua_wxLayoutAlgorithm_LayoutMDIFrame(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxRect rect = NULL
wxRect * rect = (argCount >= 3 ? (wxRect *)wxluaT_getuserdatatype(L, 3, wxluatype_wxRect) : NULL);
// wxMDIParentFrame frame
wxMDIParentFrame * frame = (wxMDIParentFrame *)wxluaT_getuserdatatype(L, 2, wxluatype_wxMDIParentFrame);
// get this
wxLayoutAlgorithm * self = (wxLayoutAlgorithm *)wxluaT_getuserdatatype(L, 1, wxluatype_wxLayoutAlgorithm);
// call LayoutMDIFrame
bool returns = (self->LayoutMDIFrame(frame, rect));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_MDI && wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxLayoutAlgorithm_LayoutWindow[] = { &wxluatype_wxLayoutAlgorithm, &wxluatype_wxWindow, &wxluatype_wxWindow, NULL };
static int LUACALL wxLua_wxLayoutAlgorithm_LayoutWindow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLayoutAlgorithm_LayoutWindow[1] = {{ wxLua_wxLayoutAlgorithm_LayoutWindow, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxLayoutAlgorithm_LayoutWindow }};
// bool LayoutWindow(wxWindow* frame, wxWindow* mainWindow = NULL );
static int LUACALL wxLua_wxLayoutAlgorithm_LayoutWindow(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxWindow mainWindow = NULL
wxWindow * mainWindow = (argCount >= 3 ? (wxWindow *)wxluaT_getuserdatatype(L, 3, wxluatype_wxWindow) : NULL);
// wxWindow frame
wxWindow * frame = (wxWindow *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWindow);
// get this
wxLayoutAlgorithm * self = (wxLayoutAlgorithm *)wxluaT_getuserdatatype(L, 1, wxluatype_wxLayoutAlgorithm);
// call LayoutWindow
bool returns = (self->LayoutWindow(frame, mainWindow));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxLayoutAlgorithm_delete[] = { &wxluatype_wxLayoutAlgorithm, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLayoutAlgorithm_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxLayoutAlgorithm_delete }};
static int LUACALL wxLua_wxLayoutAlgorithm_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLayoutAlgorithm_constructor[1] = {{ wxLua_wxLayoutAlgorithm_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxLayoutAlgorithm( );
static int LUACALL wxLua_wxLayoutAlgorithm_constructor(lua_State *L)
{
// call constructor
wxLayoutAlgorithm* returns = new wxLayoutAlgorithm();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxLayoutAlgorithm);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxLayoutAlgorithm);
return 1;
}
void wxLua_wxLayoutAlgorithm_delete_function(void** p)
{
wxLayoutAlgorithm* o = (wxLayoutAlgorithm*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxLayoutAlgorithm_methods[] = {
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxFrame)
{ "LayoutFrame", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxLayoutAlgorithm_LayoutFrame, 1, NULL },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxFrame)
#if ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_MDI && wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE)) && (wxLUA_USE_wxPointSizeRect)
{ "LayoutMDIFrame", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxLayoutAlgorithm_LayoutMDIFrame, 1, NULL },
#endif // ((wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_MDI && wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE)) && (wxLUA_USE_wxPointSizeRect)
{ "LayoutWindow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxLayoutAlgorithm_LayoutWindow, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxLayoutAlgorithm_delete, 1, NULL },
{ "wxLayoutAlgorithm", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxLayoutAlgorithm_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxLayoutAlgorithm_methodCount = sizeof(wxLayoutAlgorithm_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
// ---------------------------------------------------------------------------
// Bind class wxQueryLayoutInfoEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxQueryLayoutInfoEvent'
int wxluatype_wxQueryLayoutInfoEvent = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_GetAlignment[] = { &wxluatype_wxQueryLayoutInfoEvent, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_GetAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_GetAlignment[1] = {{ wxLua_wxQueryLayoutInfoEvent_GetAlignment, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_GetAlignment }};
// wxLayoutAlignment GetAlignment() const;
static int LUACALL wxLua_wxQueryLayoutInfoEvent_GetAlignment(lua_State *L)
{
// get this
wxQueryLayoutInfoEvent * self = (wxQueryLayoutInfoEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxQueryLayoutInfoEvent);
// call GetAlignment
wxLayoutAlignment returns = (self->GetAlignment());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_GetFlags[] = { &wxluatype_wxQueryLayoutInfoEvent, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_GetFlags(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_GetFlags[1] = {{ wxLua_wxQueryLayoutInfoEvent_GetFlags, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_GetFlags }};
// int GetFlags() const;
static int LUACALL wxLua_wxQueryLayoutInfoEvent_GetFlags(lua_State *L)
{
// get this
wxQueryLayoutInfoEvent * self = (wxQueryLayoutInfoEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxQueryLayoutInfoEvent);
// call GetFlags
int returns = (self->GetFlags());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_GetOrientation[] = { &wxluatype_wxQueryLayoutInfoEvent, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_GetOrientation(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_GetOrientation[1] = {{ wxLua_wxQueryLayoutInfoEvent_GetOrientation, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_GetOrientation }};
// wxLayoutOrientation GetOrientation() const;
static int LUACALL wxLua_wxQueryLayoutInfoEvent_GetOrientation(lua_State *L)
{
// get this
wxQueryLayoutInfoEvent * self = (wxQueryLayoutInfoEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxQueryLayoutInfoEvent);
// call GetOrientation
wxLayoutOrientation returns = (self->GetOrientation());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_GetRequestedLength[] = { &wxluatype_wxQueryLayoutInfoEvent, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_GetRequestedLength(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_GetRequestedLength[1] = {{ wxLua_wxQueryLayoutInfoEvent_GetRequestedLength, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_GetRequestedLength }};
// int GetRequestedLength() const;
static int LUACALL wxLua_wxQueryLayoutInfoEvent_GetRequestedLength(lua_State *L)
{
// get this
wxQueryLayoutInfoEvent * self = (wxQueryLayoutInfoEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxQueryLayoutInfoEvent);
// call GetRequestedLength
int returns = (self->GetRequestedLength());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_GetSize[] = { &wxluatype_wxQueryLayoutInfoEvent, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_GetSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_GetSize[1] = {{ wxLua_wxQueryLayoutInfoEvent_GetSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_GetSize }};
// wxSize GetSize() const;
static int LUACALL wxLua_wxQueryLayoutInfoEvent_GetSize(lua_State *L)
{
// get this
wxQueryLayoutInfoEvent * self = (wxQueryLayoutInfoEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxQueryLayoutInfoEvent);
// call GetSize
// allocate a new object using the copy constructor
wxSize* returns = new wxSize(self->GetSize());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxSize);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSize);
return 1;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_SetAlignment[] = { &wxluatype_wxQueryLayoutInfoEvent, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_SetAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_SetAlignment[1] = {{ wxLua_wxQueryLayoutInfoEvent_SetAlignment, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_SetAlignment }};
// void SetAlignment(wxLayoutAlignment alignment );
static int LUACALL wxLua_wxQueryLayoutInfoEvent_SetAlignment(lua_State *L)
{
// wxLayoutAlignment alignment
wxLayoutAlignment alignment = (wxLayoutAlignment)wxlua_getenumtype(L, 2);
// get this
wxQueryLayoutInfoEvent * self = (wxQueryLayoutInfoEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxQueryLayoutInfoEvent);
// call SetAlignment
self->SetAlignment(alignment);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_SetFlags[] = { &wxluatype_wxQueryLayoutInfoEvent, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_SetFlags(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_SetFlags[1] = {{ wxLua_wxQueryLayoutInfoEvent_SetFlags, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_SetFlags }};
// void SetFlags(int flags );
static int LUACALL wxLua_wxQueryLayoutInfoEvent_SetFlags(lua_State *L)
{
// int flags
int flags = (int)wxlua_getnumbertype(L, 2);
// get this
wxQueryLayoutInfoEvent * self = (wxQueryLayoutInfoEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxQueryLayoutInfoEvent);
// call SetFlags
self->SetFlags(flags);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_SetOrientation[] = { &wxluatype_wxQueryLayoutInfoEvent, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_SetOrientation(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_SetOrientation[1] = {{ wxLua_wxQueryLayoutInfoEvent_SetOrientation, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_SetOrientation }};
// void SetOrientation(wxLayoutOrientation orientation );
static int LUACALL wxLua_wxQueryLayoutInfoEvent_SetOrientation(lua_State *L)
{
// wxLayoutOrientation orientation
wxLayoutOrientation orientation = (wxLayoutOrientation)wxlua_getenumtype(L, 2);
// get this
wxQueryLayoutInfoEvent * self = (wxQueryLayoutInfoEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxQueryLayoutInfoEvent);
// call SetOrientation
self->SetOrientation(orientation);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_SetRequestedLength[] = { &wxluatype_wxQueryLayoutInfoEvent, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_SetRequestedLength(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_SetRequestedLength[1] = {{ wxLua_wxQueryLayoutInfoEvent_SetRequestedLength, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_SetRequestedLength }};
// void SetRequestedLength(int length );
static int LUACALL wxLua_wxQueryLayoutInfoEvent_SetRequestedLength(lua_State *L)
{
// int length
int length = (int)wxlua_getnumbertype(L, 2);
// get this
wxQueryLayoutInfoEvent * self = (wxQueryLayoutInfoEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxQueryLayoutInfoEvent);
// call SetRequestedLength
self->SetRequestedLength(length);
return 0;
}
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_SetSize[] = { &wxluatype_wxQueryLayoutInfoEvent, &wxluatype_wxSize, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_SetSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_SetSize[1] = {{ wxLua_wxQueryLayoutInfoEvent_SetSize, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_SetSize }};
// void SetSize(const wxSize& size );
static int LUACALL wxLua_wxQueryLayoutInfoEvent_SetSize(lua_State *L)
{
// const wxSize size
const wxSize * size = (const wxSize *)wxluaT_getuserdatatype(L, 2, wxluatype_wxSize);
// get this
wxQueryLayoutInfoEvent * self = (wxQueryLayoutInfoEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxQueryLayoutInfoEvent);
// call SetSize
self->SetSize(*size);
return 0;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_delete[] = { &wxluatype_wxQueryLayoutInfoEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_constructor[] = { &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxQueryLayoutInfoEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_constructor[1] = {{ wxLua_wxQueryLayoutInfoEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 1, s_wxluatypeArray_wxLua_wxQueryLayoutInfoEvent_constructor }};
// wxQueryLayoutInfoEvent(wxWindowID id = 0 );
static int LUACALL wxLua_wxQueryLayoutInfoEvent_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxWindowID id = 0
wxWindowID id = (argCount >= 1 ? (wxWindowID)wxlua_getnumbertype(L, 1) : 0);
// call constructor
wxQueryLayoutInfoEvent* returns = new wxQueryLayoutInfoEvent(id);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxQueryLayoutInfoEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxQueryLayoutInfoEvent);
return 1;
}
void wxLua_wxQueryLayoutInfoEvent_delete_function(void** p)
{
wxQueryLayoutInfoEvent* o = (wxQueryLayoutInfoEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxQueryLayoutInfoEvent_methods[] = {
{ "GetAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_GetAlignment, 1, NULL },
{ "GetFlags", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_GetFlags, 1, NULL },
{ "GetOrientation", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_GetOrientation, 1, NULL },
{ "GetRequestedLength", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_GetRequestedLength, 1, NULL },
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "GetSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_GetSize, 1, NULL },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "SetAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_SetAlignment, 1, NULL },
{ "SetFlags", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_SetFlags, 1, NULL },
{ "SetOrientation", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_SetOrientation, 1, NULL },
{ "SetRequestedLength", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_SetRequestedLength, 1, NULL },
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "SetSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_SetSize, 1, NULL },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_delete, 1, NULL },
{ "wxQueryLayoutInfoEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxQueryLayoutInfoEvent_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxQueryLayoutInfoEvent_methodCount = sizeof(wxQueryLayoutInfoEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
// ---------------------------------------------------------------------------
// Bind class wxCalculateLayoutEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxCalculateLayoutEvent'
int wxluatype_wxCalculateLayoutEvent = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_GetFlags[] = { &wxluatype_wxCalculateLayoutEvent, NULL };
static int LUACALL wxLua_wxCalculateLayoutEvent_GetFlags(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalculateLayoutEvent_GetFlags[1] = {{ wxLua_wxCalculateLayoutEvent_GetFlags, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_GetFlags }};
// int GetFlags() const;
static int LUACALL wxLua_wxCalculateLayoutEvent_GetFlags(lua_State *L)
{
// get this
wxCalculateLayoutEvent * self = (wxCalculateLayoutEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalculateLayoutEvent);
// call GetFlags
int returns = (self->GetFlags());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_GetRect[] = { &wxluatype_wxCalculateLayoutEvent, NULL };
static int LUACALL wxLua_wxCalculateLayoutEvent_GetRect(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalculateLayoutEvent_GetRect[1] = {{ wxLua_wxCalculateLayoutEvent_GetRect, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_GetRect }};
// wxRect GetRect() const;
static int LUACALL wxLua_wxCalculateLayoutEvent_GetRect(lua_State *L)
{
// get this
wxCalculateLayoutEvent * self = (wxCalculateLayoutEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalculateLayoutEvent);
// call GetRect
// allocate a new object using the copy constructor
wxRect* returns = new wxRect(self->GetRect());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxRect);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxRect);
return 1;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_SetFlags[] = { &wxluatype_wxCalculateLayoutEvent, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxCalculateLayoutEvent_SetFlags(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalculateLayoutEvent_SetFlags[1] = {{ wxLua_wxCalculateLayoutEvent_SetFlags, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_SetFlags }};
// void SetFlags(int flags );
static int LUACALL wxLua_wxCalculateLayoutEvent_SetFlags(lua_State *L)
{
// int flags
int flags = (int)wxlua_getnumbertype(L, 2);
// get this
wxCalculateLayoutEvent * self = (wxCalculateLayoutEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalculateLayoutEvent);
// call SetFlags
self->SetFlags(flags);
return 0;
}
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_SetRect[] = { &wxluatype_wxCalculateLayoutEvent, &wxluatype_wxRect, NULL };
static int LUACALL wxLua_wxCalculateLayoutEvent_SetRect(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalculateLayoutEvent_SetRect[1] = {{ wxLua_wxCalculateLayoutEvent_SetRect, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_SetRect }};
// void SetRect(const wxRect& rect );
static int LUACALL wxLua_wxCalculateLayoutEvent_SetRect(lua_State *L)
{
// const wxRect rect
const wxRect * rect = (const wxRect *)wxluaT_getuserdatatype(L, 2, wxluatype_wxRect);
// get this
wxCalculateLayoutEvent * self = (wxCalculateLayoutEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxCalculateLayoutEvent);
// call SetRect
self->SetRect(*rect);
return 0;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_delete[] = { &wxluatype_wxCalculateLayoutEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalculateLayoutEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_constructor[] = { &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxCalculateLayoutEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxCalculateLayoutEvent_constructor[1] = {{ wxLua_wxCalculateLayoutEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 1, s_wxluatypeArray_wxLua_wxCalculateLayoutEvent_constructor }};
// wxCalculateLayoutEvent(wxWindowID id = 0 );
static int LUACALL wxLua_wxCalculateLayoutEvent_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxWindowID id = 0
wxWindowID id = (argCount >= 1 ? (wxWindowID)wxlua_getnumbertype(L, 1) : 0);
// call constructor
wxCalculateLayoutEvent* returns = new wxCalculateLayoutEvent(id);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxCalculateLayoutEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxCalculateLayoutEvent);
return 1;
}
void wxLua_wxCalculateLayoutEvent_delete_function(void** p)
{
wxCalculateLayoutEvent* o = (wxCalculateLayoutEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxCalculateLayoutEvent_methods[] = {
{ "GetFlags", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalculateLayoutEvent_GetFlags, 1, NULL },
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "GetRect", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalculateLayoutEvent_GetRect, 1, NULL },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "SetFlags", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalculateLayoutEvent_SetFlags, 1, NULL },
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "SetRect", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxCalculateLayoutEvent_SetRect, 1, NULL },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxCalculateLayoutEvent_delete, 1, NULL },
{ "wxCalculateLayoutEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxCalculateLayoutEvent_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxCalculateLayoutEvent_methodCount = sizeof(wxCalculateLayoutEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
// ---------------------------------------------------------------------------
// Bind class wxSashEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxSashEvent'
int wxluatype_wxSashEvent = WXLUA_TUNKNOWN;
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashEvent_GetDragRect[] = { &wxluatype_wxSashEvent, NULL };
static int LUACALL wxLua_wxSashEvent_GetDragRect(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashEvent_GetDragRect[1] = {{ wxLua_wxSashEvent_GetDragRect, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSashEvent_GetDragRect }};
// wxRect GetDragRect( );
static int LUACALL wxLua_wxSashEvent_GetDragRect(lua_State *L)
{
// get this
wxSashEvent * self = (wxSashEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashEvent);
// call GetDragRect
// allocate a new object using the copy constructor
wxRect* returns = new wxRect(self->GetDragRect());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxRect);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxRect);
return 1;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashEvent_GetDragStatus[] = { &wxluatype_wxSashEvent, NULL };
static int LUACALL wxLua_wxSashEvent_GetDragStatus(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashEvent_GetDragStatus[1] = {{ wxLua_wxSashEvent_GetDragStatus, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSashEvent_GetDragStatus }};
// int GetDragStatus( );
static int LUACALL wxLua_wxSashEvent_GetDragStatus(lua_State *L)
{
// get this
wxSashEvent * self = (wxSashEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashEvent);
// call GetDragStatus
int returns = (self->GetDragStatus());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashEvent_GetEdge[] = { &wxluatype_wxSashEvent, NULL };
static int LUACALL wxLua_wxSashEvent_GetEdge(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashEvent_GetEdge[1] = {{ wxLua_wxSashEvent_GetEdge, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSashEvent_GetEdge }};
// int GetEdge( );
static int LUACALL wxLua_wxSashEvent_GetEdge(lua_State *L)
{
// get this
wxSashEvent * self = (wxSashEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashEvent);
// call GetEdge
int returns = (self->GetEdge());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashEvent_SetDragRect[] = { &wxluatype_wxSashEvent, &wxluatype_wxRect, NULL };
static int LUACALL wxLua_wxSashEvent_SetDragRect(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashEvent_SetDragRect[1] = {{ wxLua_wxSashEvent_SetDragRect, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashEvent_SetDragRect }};
// void SetDragRect(const wxRect& rect );
static int LUACALL wxLua_wxSashEvent_SetDragRect(lua_State *L)
{
// const wxRect rect
const wxRect * rect = (const wxRect *)wxluaT_getuserdatatype(L, 2, wxluatype_wxRect);
// get this
wxSashEvent * self = (wxSashEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashEvent);
// call SetDragRect
self->SetDragRect(*rect);
return 0;
}
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashEvent_SetDragStatus[] = { &wxluatype_wxSashEvent, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxSashEvent_SetDragStatus(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashEvent_SetDragStatus[1] = {{ wxLua_wxSashEvent_SetDragStatus, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashEvent_SetDragStatus }};
// void SetDragStatus(wxSashDragStatus status );
static int LUACALL wxLua_wxSashEvent_SetDragStatus(lua_State *L)
{
// wxSashDragStatus status
wxSashDragStatus status = (wxSashDragStatus)wxlua_getenumtype(L, 2);
// get this
wxSashEvent * self = (wxSashEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashEvent);
// call SetDragStatus
self->SetDragStatus(status);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashEvent_SetEdge[] = { &wxluatype_wxSashEvent, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxSashEvent_SetEdge(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashEvent_SetEdge[1] = {{ wxLua_wxSashEvent_SetEdge, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSashEvent_SetEdge }};
// void SetEdge(wxSashEdgePosition edge );
static int LUACALL wxLua_wxSashEvent_SetEdge(lua_State *L)
{
// wxSashEdgePosition edge
wxSashEdgePosition edge = (wxSashEdgePosition)wxlua_getenumtype(L, 2);
// get this
wxSashEvent * self = (wxSashEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSashEvent);
// call SetEdge
self->SetEdge(edge);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashEvent_delete[] = { &wxluatype_wxSashEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxSashEvent_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxSashEvent_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxSashEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSashEvent_constructor[1] = {{ wxLua_wxSashEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 2, s_wxluatypeArray_wxLua_wxSashEvent_constructor }};
// wxSashEvent(int id = 0, wxSashEdgePosition edge = wxSASH_NONE );
static int LUACALL wxLua_wxSashEvent_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxSashEdgePosition edge = wxSASH_NONE
wxSashEdgePosition edge = (argCount >= 2 ? (wxSashEdgePosition)wxlua_getenumtype(L, 2) : wxSASH_NONE);
// int id = 0
int id = (argCount >= 1 ? (int)wxlua_getnumbertype(L, 1) : 0);
// call constructor
wxSashEvent* returns = new wxSashEvent(id, edge);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxSashEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSashEvent);
return 1;
}
void wxLua_wxSashEvent_delete_function(void** p)
{
wxSashEvent* o = (wxSashEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxSashEvent_methods[] = {
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "GetDragRect", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashEvent_GetDragRect, 1, NULL },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "GetDragStatus", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashEvent_GetDragStatus, 1, NULL },
{ "GetEdge", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashEvent_GetEdge, 1, NULL },
#if (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "SetDragRect", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashEvent_SetDragRect, 1, NULL },
#endif // (wxLUA_USE_wxSashWindow && wxUSE_SASH) && (wxLUA_USE_wxPointSizeRect)
{ "SetDragStatus", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashEvent_SetDragStatus, 1, NULL },
{ "SetEdge", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSashEvent_SetEdge, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxSashEvent_delete, 1, NULL },
{ "wxSashEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxSashEvent_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxSashEvent_methodCount = sizeof(wxSashEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxSplashScreen
// ---------------------------------------------------------------------------
// Bind class wxSplashScreen
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxSplashScreen'
int wxluatype_wxSplashScreen = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxSplashScreen_GetSplashStyle[] = { &wxluatype_wxSplashScreen, NULL };
static int LUACALL wxLua_wxSplashScreen_GetSplashStyle(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSplashScreen_GetSplashStyle[1] = {{ wxLua_wxSplashScreen_GetSplashStyle, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSplashScreen_GetSplashStyle }};
// long GetSplashStyle() const;
static int LUACALL wxLua_wxSplashScreen_GetSplashStyle(lua_State *L)
{
// get this
wxSplashScreen * self = (wxSplashScreen *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSplashScreen);
// call GetSplashStyle
long returns = (self->GetSplashStyle());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSplashScreen_GetSplashWindow[] = { &wxluatype_wxSplashScreen, NULL };
static int LUACALL wxLua_wxSplashScreen_GetSplashWindow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSplashScreen_GetSplashWindow[1] = {{ wxLua_wxSplashScreen_GetSplashWindow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSplashScreen_GetSplashWindow }};
// wxSplashScreenWindow* GetSplashWindow() const;
static int LUACALL wxLua_wxSplashScreen_GetSplashWindow(lua_State *L)
{
// get this
wxSplashScreen * self = (wxSplashScreen *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSplashScreen);
// call GetSplashWindow
wxSplashScreenWindow* returns = (wxSplashScreenWindow*)self->GetSplashWindow();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSplashScreenWindow);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSplashScreen_GetTimeout[] = { &wxluatype_wxSplashScreen, NULL };
static int LUACALL wxLua_wxSplashScreen_GetTimeout(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSplashScreen_GetTimeout[1] = {{ wxLua_wxSplashScreen_GetTimeout, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSplashScreen_GetTimeout }};
// int GetTimeout() const;
static int LUACALL wxLua_wxSplashScreen_GetTimeout(lua_State *L)
{
// get this
wxSplashScreen * self = (wxSplashScreen *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSplashScreen);
// call GetTimeout
int returns = (self->GetTimeout());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if ((wxLUA_USE_wxSplashScreen) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSplashScreen_constructor[] = { &wxluatype_wxBitmap, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxSplashScreen_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSplashScreen_constructor[1] = {{ wxLua_wxSplashScreen_constructor, WXLUAMETHOD_CONSTRUCTOR, 5, 8, s_wxluatypeArray_wxLua_wxSplashScreen_constructor }};
// wxSplashScreen(const wxBitmap& bitmap, long splashStyle, int milliseconds, wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSIMPLE_BORDER|wxFRAME_NO_TASKBAR|wxSTAY_ON_TOP );
static int LUACALL wxLua_wxSplashScreen_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// long style = wxSIMPLE_BORDER | wxFRAME_NO_TASKBAR | wxSTAY_ON_TOP
long style = (argCount >= 8 ? (long)wxlua_getnumbertype(L, 8) : wxSIMPLE_BORDER | wxFRAME_NO_TASKBAR | wxSTAY_ON_TOP);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 7 ? (const wxSize *)wxluaT_getuserdatatype(L, 7, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 6 ? (const wxPoint *)wxluaT_getuserdatatype(L, 6, wxluatype_wxPoint) : &wxDefaultPosition);
// wxWindowID id
wxWindowID id = (wxWindowID)wxlua_getnumbertype(L, 5);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 4, wxluatype_wxWindow);
// int milliseconds
int milliseconds = (int)wxlua_getnumbertype(L, 3);
// long splashStyle
long splashStyle = (long)wxlua_getnumbertype(L, 2);
// const wxBitmap bitmap
const wxBitmap * bitmap = (const wxBitmap *)wxluaT_getuserdatatype(L, 1, wxluatype_wxBitmap);
// call constructor
wxSplashScreen* returns = new wxSplashScreen(*bitmap, splashStyle, milliseconds, parent, id, *pos, *size, style);
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSplashScreen);
return 1;
}
#endif // ((wxLUA_USE_wxSplashScreen) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
void wxLua_wxSplashScreen_delete_function(void** p)
{
wxSplashScreen* o = (wxSplashScreen*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxSplashScreen_methods[] = {
{ "GetSplashStyle", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSplashScreen_GetSplashStyle, 1, NULL },
{ "GetSplashWindow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSplashScreen_GetSplashWindow, 1, NULL },
{ "GetTimeout", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSplashScreen_GetTimeout, 1, NULL },
#if ((wxLUA_USE_wxSplashScreen) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
{ "wxSplashScreen", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxSplashScreen_constructor, 1, NULL },
#endif // ((wxLUA_USE_wxSplashScreen) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
{ 0, 0, 0, 0 },
};
int wxSplashScreen_methodCount = sizeof(wxSplashScreen_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxSplashScreen
#if wxLUA_USE_wxSplashScreen
// ---------------------------------------------------------------------------
// Bind class wxSplashScreenWindow
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxSplashScreenWindow'
int wxluatype_wxSplashScreenWindow = WXLUA_TUNKNOWN;
#if (wxLUA_USE_wxBitmap) && (wxLUA_USE_wxSplashScreen)
static wxLuaArgType s_wxluatypeArray_wxLua_wxSplashScreenWindow_GetBitmap[] = { &wxluatype_wxSplashScreenWindow, NULL };
static int LUACALL wxLua_wxSplashScreenWindow_GetBitmap(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSplashScreenWindow_GetBitmap[1] = {{ wxLua_wxSplashScreenWindow_GetBitmap, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSplashScreenWindow_GetBitmap }};
// wxBitmap& GetBitmap( );
static int LUACALL wxLua_wxSplashScreenWindow_GetBitmap(lua_State *L)
{
// get this
wxSplashScreenWindow * self = (wxSplashScreenWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSplashScreenWindow);
// call GetBitmap
wxBitmap* returns = (wxBitmap*)&self->GetBitmap();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxBitmap);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSplashScreenWindow_SetBitmap[] = { &wxluatype_wxSplashScreenWindow, &wxluatype_wxBitmap, NULL };
static int LUACALL wxLua_wxSplashScreenWindow_SetBitmap(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSplashScreenWindow_SetBitmap[1] = {{ wxLua_wxSplashScreenWindow_SetBitmap, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxSplashScreenWindow_SetBitmap }};
// void SetBitmap(const wxBitmap& bitmap );
static int LUACALL wxLua_wxSplashScreenWindow_SetBitmap(lua_State *L)
{
// const wxBitmap bitmap
const wxBitmap * bitmap = (const wxBitmap *)wxluaT_getuserdatatype(L, 2, wxluatype_wxBitmap);
// get this
wxSplashScreenWindow * self = (wxSplashScreenWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSplashScreenWindow);
// call SetBitmap
self->SetBitmap(*bitmap);
return 0;
}
#endif // (wxLUA_USE_wxBitmap) && (wxLUA_USE_wxSplashScreen)
void wxLua_wxSplashScreenWindow_delete_function(void** p)
{
wxSplashScreenWindow* o = (wxSplashScreenWindow*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxSplashScreenWindow_methods[] = {
#if (wxLUA_USE_wxBitmap) && (wxLUA_USE_wxSplashScreen)
{ "GetBitmap", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSplashScreenWindow_GetBitmap, 1, NULL },
{ "SetBitmap", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSplashScreenWindow_SetBitmap, 1, NULL },
#endif // (wxLUA_USE_wxBitmap) && (wxLUA_USE_wxSplashScreen)
{ 0, 0, 0, 0 },
};
int wxSplashScreenWindow_methodCount = sizeof(wxSplashScreenWindow_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxSplashScreen
#if wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
// ---------------------------------------------------------------------------
// Bind class wxWizard
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxWizard'
int wxluatype_wxWizard = WXLUA_TUNKNOWN;
#if ((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizard_Create[] = { &wxluatype_wxWizard, &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_TSTRING, &wxluatype_wxBitmap, &wxluatype_wxPoint, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxWizard_Create(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_Create[1] = {{ wxLua_wxWizard_Create, WXLUAMETHOD_METHOD, 2, 7, s_wxluatypeArray_wxLua_wxWizard_Create }};
// bool Create(wxWindow* parent, int id = -1, const wxString& title = "", const wxBitmap& bitmap = wxNullBitmap, const wxPoint& pos = wxDefaultPosition, long style = wxDEFAULT_DIALOG_STYLE );
static int LUACALL wxLua_wxWizard_Create(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// long style = wxDEFAULT_DIALOG_STYLE
long style = (argCount >= 7 ? (long)wxlua_getnumbertype(L, 7) : wxDEFAULT_DIALOG_STYLE);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 6 ? (const wxPoint *)wxluaT_getuserdatatype(L, 6, wxluatype_wxPoint) : &wxDefaultPosition);
// const wxBitmap bitmap = wxNullBitmap
const wxBitmap * bitmap = (argCount >= 5 ? (const wxBitmap *)wxluaT_getuserdatatype(L, 5, wxluatype_wxBitmap) : &wxNullBitmap);
// const wxString title = ""
const wxString title = (argCount >= 4 ? wxlua_getwxStringtype(L, 4) : wxString(wxEmptyString));
// int id = -1
int id = (argCount >= 3 ? (int)wxlua_getnumbertype(L, 3) : -1);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWindow);
// get this
wxWizard * self = (wxWizard *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizard);
// call Create
bool returns = (self->Create(parent, id, title, *bitmap, *pos, style));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // ((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizard_GetCurrentPage[] = { &wxluatype_wxWizard, NULL };
static int LUACALL wxLua_wxWizard_GetCurrentPage(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_GetCurrentPage[1] = {{ wxLua_wxWizard_GetCurrentPage, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxWizard_GetCurrentPage }};
// wxWizardPage* GetCurrentPage() const;
static int LUACALL wxLua_wxWizard_GetCurrentPage(lua_State *L)
{
// get this
wxWizard * self = (wxWizard *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizard);
// call GetCurrentPage
wxWizardPage* returns = (wxWizardPage*)self->GetCurrentPage();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWizardPage);
return 1;
}
#if ((wxLUA_USE_wxSizer) && (wxCHECK_VERSION(2,8,0))) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizard_GetPageAreaSizer[] = { &wxluatype_wxWizard, NULL };
static int LUACALL wxLua_wxWizard_GetPageAreaSizer(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_GetPageAreaSizer[1] = {{ wxLua_wxWizard_GetPageAreaSizer, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxWizard_GetPageAreaSizer }};
// virtual wxSizer* GetPageAreaSizer() const;
static int LUACALL wxLua_wxWizard_GetPageAreaSizer(lua_State *L)
{
// get this
wxWizard * self = (wxWizard *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizard);
// call GetPageAreaSizer
wxSizer* returns = (wxSizer*)self->GetPageAreaSizer();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSizer);
return 1;
}
#endif // ((wxLUA_USE_wxSizer) && (wxCHECK_VERSION(2,8,0))) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
#if (wxLUA_USE_wxPointSizeRect) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizard_GetPageSize[] = { &wxluatype_wxWizard, NULL };
static int LUACALL wxLua_wxWizard_GetPageSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_GetPageSize[1] = {{ wxLua_wxWizard_GetPageSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxWizard_GetPageSize }};
// wxSize GetPageSize() const;
static int LUACALL wxLua_wxWizard_GetPageSize(lua_State *L)
{
// get this
wxWizard * self = (wxWizard *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizard);
// call GetPageSize
// allocate a new object using the copy constructor
wxSize* returns = new wxSize(self->GetPageSize());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxSize);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSize);
return 1;
}
#endif // (wxLUA_USE_wxPointSizeRect) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizard_HasNextPage[] = { &wxluatype_wxWizard, &wxluatype_wxWizardPage, NULL };
static int LUACALL wxLua_wxWizard_HasNextPage(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_HasNextPage[1] = {{ wxLua_wxWizard_HasNextPage, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxWizard_HasNextPage }};
// virtual bool HasNextPage(wxWizardPage *page );
static int LUACALL wxLua_wxWizard_HasNextPage(lua_State *L)
{
// wxWizardPage page
wxWizardPage * page = (wxWizardPage *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWizardPage);
// get this
wxWizard * self = (wxWizard *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizard);
// call HasNextPage
bool returns = (self->HasNextPage(page));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizard_HasPrevPage[] = { &wxluatype_wxWizard, &wxluatype_wxWizardPage, NULL };
static int LUACALL wxLua_wxWizard_HasPrevPage(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_HasPrevPage[1] = {{ wxLua_wxWizard_HasPrevPage, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxWizard_HasPrevPage }};
// virtual bool HasPrevPage(wxWizardPage *page );
static int LUACALL wxLua_wxWizard_HasPrevPage(lua_State *L)
{
// wxWizardPage page
wxWizardPage * page = (wxWizardPage *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWizardPage);
// get this
wxWizard * self = (wxWizard *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizard);
// call HasPrevPage
bool returns = (self->HasPrevPage(page));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizard_RunWizard[] = { &wxluatype_wxWizard, &wxluatype_wxWizardPage, NULL };
static int LUACALL wxLua_wxWizard_RunWizard(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_RunWizard[1] = {{ wxLua_wxWizard_RunWizard, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxWizard_RunWizard }};
// bool RunWizard(wxWizardPage* firstPage );
static int LUACALL wxLua_wxWizard_RunWizard(lua_State *L)
{
// wxWizardPage firstPage
wxWizardPage * firstPage = (wxWizardPage *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWizardPage);
// get this
wxWizard * self = (wxWizard *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizard);
// call RunWizard
bool returns = (self->RunWizard(firstPage));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizard_SetBorder[] = { &wxluatype_wxWizard, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxWizard_SetBorder(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_SetBorder[1] = {{ wxLua_wxWizard_SetBorder, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxWizard_SetBorder }};
// void SetBorder(int border );
static int LUACALL wxLua_wxWizard_SetBorder(lua_State *L)
{
// int border
int border = (int)wxlua_getnumbertype(L, 2);
// get this
wxWizard * self = (wxWizard *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizard);
// call SetBorder
self->SetBorder(border);
return 0;
}
#if (wxLUA_USE_wxPointSizeRect) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizard_SetPageSize[] = { &wxluatype_wxWizard, &wxluatype_wxSize, NULL };
static int LUACALL wxLua_wxWizard_SetPageSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_SetPageSize[1] = {{ wxLua_wxWizard_SetPageSize, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxWizard_SetPageSize }};
// void SetPageSize(const wxSize& sizePage );
static int LUACALL wxLua_wxWizard_SetPageSize(lua_State *L)
{
// const wxSize sizePage
const wxSize * sizePage = (const wxSize *)wxluaT_getuserdatatype(L, 2, wxluatype_wxSize);
// get this
wxWizard * self = (wxWizard *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizard);
// call SetPageSize
self->SetPageSize(*sizePage);
return 0;
}
#endif // (wxLUA_USE_wxPointSizeRect) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
#if ((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizard_constructor1[] = { &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_TSTRING, &wxluatype_wxBitmap, &wxluatype_wxPoint, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxWizard_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_constructor1[1] = {{ wxLua_wxWizard_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 6, s_wxluatypeArray_wxLua_wxWizard_constructor1 }};
// wxWizard(wxWindow* parent, int id = -1, const wxString& title = "", const wxBitmap& bitmap = wxNullBitmap, const wxPoint& pos = wxDefaultPosition, long style = wxDEFAULT_DIALOG_STYLE );
static int LUACALL wxLua_wxWizard_constructor1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// long style = wxDEFAULT_DIALOG_STYLE
long style = (argCount >= 6 ? (long)wxlua_getnumbertype(L, 6) : wxDEFAULT_DIALOG_STYLE);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 5 ? (const wxPoint *)wxluaT_getuserdatatype(L, 5, wxluatype_wxPoint) : &wxDefaultPosition);
// const wxBitmap bitmap = wxNullBitmap
const wxBitmap * bitmap = (argCount >= 4 ? (const wxBitmap *)wxluaT_getuserdatatype(L, 4, wxluatype_wxBitmap) : &wxNullBitmap);
// const wxString title = ""
const wxString title = (argCount >= 3 ? wxlua_getwxStringtype(L, 3) : wxString(wxEmptyString));
// int id = -1
int id = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : -1);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWindow);
// call constructor
wxWizard* returns = new wxWizard(parent, id, title, *bitmap, *pos, style);
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWizard);
return 1;
}
#endif // ((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
static int LUACALL wxLua_wxWizard_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_constructor[1] = {{ wxLua_wxWizard_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxWizard( );
static int LUACALL wxLua_wxWizard_constructor(lua_State *L)
{
// call constructor
wxWizard* returns = new wxWizard();
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWizard);
return 1;
}
#if (((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect))||(wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizard_constructor_overload[] =
{
#if ((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
{ wxLua_wxWizard_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 6, s_wxluatypeArray_wxLua_wxWizard_constructor1 },
#endif // ((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
{ wxLua_wxWizard_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxWizard_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxWizard_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // (((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect))||(wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
void wxLua_wxWizard_delete_function(void** p)
{
wxWizard* o = (wxWizard*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxWizard_methods[] = {
#if ((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
{ "Create", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizard_Create, 1, NULL },
#endif // ((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect)
{ "GetCurrentPage", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizard_GetCurrentPage, 1, NULL },
#if ((wxLUA_USE_wxSizer) && (wxCHECK_VERSION(2,8,0))) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
{ "GetPageAreaSizer", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizard_GetPageAreaSizer, 1, NULL },
#endif // ((wxLUA_USE_wxSizer) && (wxCHECK_VERSION(2,8,0))) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
#if (wxLUA_USE_wxPointSizeRect) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
{ "GetPageSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizard_GetPageSize, 1, NULL },
#endif // (wxLUA_USE_wxPointSizeRect) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
{ "HasNextPage", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizard_HasNextPage, 1, NULL },
{ "HasPrevPage", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizard_HasPrevPage, 1, NULL },
{ "RunWizard", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizard_RunWizard, 1, NULL },
{ "SetBorder", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizard_SetBorder, 1, NULL },
#if (wxLUA_USE_wxPointSizeRect) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
{ "SetPageSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizard_SetPageSize, 1, NULL },
#endif // (wxLUA_USE_wxPointSizeRect) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
#if (((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect))||(wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
{ "wxWizard", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxWizard_constructor_overload, s_wxluafunc_wxLua_wxWizard_constructor_overload_count, 0 },
#endif // (((wxUSE_WIZARDDLG && wxLUA_USE_wxWizard) && (wxLUA_USE_wxBitmap)) && (wxLUA_USE_wxPointSizeRect))||(wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
{ 0, 0, 0, 0 },
};
int wxWizard_methodCount = sizeof(wxWizard_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
#if wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
// ---------------------------------------------------------------------------
// Bind class wxWizardPage
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxWizardPage'
int wxluatype_wxWizardPage = WXLUA_TUNKNOWN;
#if (wxLUA_USE_wxBitmap) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardPage_GetBitmap[] = { &wxluatype_wxWizardPage, NULL };
static int LUACALL wxLua_wxWizardPage_GetBitmap(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardPage_GetBitmap[1] = {{ wxLua_wxWizardPage_GetBitmap, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxWizardPage_GetBitmap }};
// wxBitmap GetBitmap() const;
static int LUACALL wxLua_wxWizardPage_GetBitmap(lua_State *L)
{
// get this
wxWizardPage * self = (wxWizardPage *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizardPage);
// call GetBitmap
// allocate a new object using the copy constructor
wxBitmap* returns = new wxBitmap(self->GetBitmap());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxBitmap);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxBitmap);
return 1;
}
#endif // (wxLUA_USE_wxBitmap) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
void wxLua_wxWizardPage_delete_function(void** p)
{
wxWizardPage* o = (wxWizardPage*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxWizardPage_methods[] = {
#if (wxLUA_USE_wxBitmap) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
{ "GetBitmap", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizardPage_GetBitmap, 1, NULL },
#endif // (wxLUA_USE_wxBitmap) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
{ 0, 0, 0, 0 },
};
int wxWizardPage_methodCount = sizeof(wxWizardPage_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
#if wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
// ---------------------------------------------------------------------------
// Bind class wxWizardPageSimple
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxWizardPageSimple'
int wxluatype_wxWizardPageSimple = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardPageSimple_Chain[] = { &wxluatype_wxWizardPageSimple, &wxluatype_wxWizardPageSimple, NULL };
static int LUACALL wxLua_wxWizardPageSimple_Chain(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardPageSimple_Chain[1] = {{ wxLua_wxWizardPageSimple_Chain, WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, 2, 2, s_wxluatypeArray_wxLua_wxWizardPageSimple_Chain }};
// static void Chain(wxWizardPageSimple* first, wxWizardPageSimple* second );
static int LUACALL wxLua_wxWizardPageSimple_Chain(lua_State *L)
{
// wxWizardPageSimple second
wxWizardPageSimple * second = (wxWizardPageSimple *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWizardPageSimple);
// wxWizardPageSimple first
wxWizardPageSimple * first = (wxWizardPageSimple *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizardPageSimple);
// call Chain
wxWizardPageSimple::Chain(first, second);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardPageSimple_GetNext[] = { &wxluatype_wxWizardPageSimple, NULL };
static int LUACALL wxLua_wxWizardPageSimple_GetNext(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardPageSimple_GetNext[1] = {{ wxLua_wxWizardPageSimple_GetNext, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxWizardPageSimple_GetNext }};
// virtual wxWizardPage* GetNext() const;
static int LUACALL wxLua_wxWizardPageSimple_GetNext(lua_State *L)
{
// get this
wxWizardPageSimple * self = (wxWizardPageSimple *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizardPageSimple);
// call GetNext
wxWizardPage* returns = (wxWizardPage*)self->GetNext();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWizardPage);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardPageSimple_GetPrev[] = { &wxluatype_wxWizardPageSimple, NULL };
static int LUACALL wxLua_wxWizardPageSimple_GetPrev(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardPageSimple_GetPrev[1] = {{ wxLua_wxWizardPageSimple_GetPrev, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxWizardPageSimple_GetPrev }};
// virtual wxWizardPage* GetPrev() const;
static int LUACALL wxLua_wxWizardPageSimple_GetPrev(lua_State *L)
{
// get this
wxWizardPageSimple * self = (wxWizardPageSimple *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizardPageSimple);
// call GetPrev
wxWizardPage* returns = (wxWizardPage*)self->GetPrev();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWizardPage);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardPageSimple_SetNext[] = { &wxluatype_wxWizardPageSimple, &wxluatype_wxWizardPage, NULL };
static int LUACALL wxLua_wxWizardPageSimple_SetNext(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardPageSimple_SetNext[1] = {{ wxLua_wxWizardPageSimple_SetNext, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxWizardPageSimple_SetNext }};
// void SetNext(wxWizardPage* next );
static int LUACALL wxLua_wxWizardPageSimple_SetNext(lua_State *L)
{
// wxWizardPage next
wxWizardPage * next = (wxWizardPage *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWizardPage);
// get this
wxWizardPageSimple * self = (wxWizardPageSimple *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizardPageSimple);
// call SetNext
self->SetNext(next);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardPageSimple_SetPrev[] = { &wxluatype_wxWizardPageSimple, &wxluatype_wxWizardPage, NULL };
static int LUACALL wxLua_wxWizardPageSimple_SetPrev(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardPageSimple_SetPrev[1] = {{ wxLua_wxWizardPageSimple_SetPrev, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxWizardPageSimple_SetPrev }};
// void SetPrev(wxWizardPage* prev );
static int LUACALL wxLua_wxWizardPageSimple_SetPrev(lua_State *L)
{
// wxWizardPage prev
wxWizardPage * prev = (wxWizardPage *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWizardPage);
// get this
wxWizardPageSimple * self = (wxWizardPageSimple *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizardPageSimple);
// call SetPrev
self->SetPrev(prev);
return 0;
}
#if (wxLUA_USE_wxBitmap) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardPageSimple_constructor[] = { &wxluatype_wxWizard, &wxluatype_wxWizardPage, &wxluatype_wxWizardPage, &wxluatype_wxBitmap, NULL };
static int LUACALL wxLua_wxWizardPageSimple_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardPageSimple_constructor[1] = {{ wxLua_wxWizardPageSimple_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 4, s_wxluatypeArray_wxLua_wxWizardPageSimple_constructor }};
// wxWizardPageSimple(wxWizard* parent = NULL, wxWizardPage* prev = NULL, wxWizardPage* next = NULL, const wxBitmap& bitmap = wxNullBitmap );
static int LUACALL wxLua_wxWizardPageSimple_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxBitmap bitmap = wxNullBitmap
const wxBitmap * bitmap = (argCount >= 4 ? (const wxBitmap *)wxluaT_getuserdatatype(L, 4, wxluatype_wxBitmap) : &wxNullBitmap);
// wxWizardPage next = NULL
wxWizardPage * next = (argCount >= 3 ? (wxWizardPage *)wxluaT_getuserdatatype(L, 3, wxluatype_wxWizardPage) : NULL);
// wxWizardPage prev = NULL
wxWizardPage * prev = (argCount >= 2 ? (wxWizardPage *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWizardPage) : NULL);
// wxWizard parent = NULL
wxWizard * parent = (argCount >= 1 ? (wxWizard *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizard) : NULL);
// call constructor
wxWizardPageSimple* returns = new wxWizardPageSimple(parent, prev, next, *bitmap);
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWizardPageSimple);
return 1;
}
#endif // (wxLUA_USE_wxBitmap) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
void wxLua_wxWizardPageSimple_delete_function(void** p)
{
wxWizardPageSimple* o = (wxWizardPageSimple*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxWizardPageSimple_methods[] = {
{ "Chain", WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, s_wxluafunc_wxLua_wxWizardPageSimple_Chain, 1, NULL },
{ "GetNext", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizardPageSimple_GetNext, 1, NULL },
{ "GetPrev", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizardPageSimple_GetPrev, 1, NULL },
{ "SetNext", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizardPageSimple_SetNext, 1, NULL },
{ "SetPrev", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizardPageSimple_SetPrev, 1, NULL },
#if (wxLUA_USE_wxBitmap) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
{ "wxWizardPageSimple", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxWizardPageSimple_constructor, 1, NULL },
#endif // (wxLUA_USE_wxBitmap) && (wxUSE_WIZARDDLG && wxLUA_USE_wxWizard)
{ 0, 0, 0, 0 },
};
int wxWizardPageSimple_methodCount = sizeof(wxWizardPageSimple_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
#if wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
// ---------------------------------------------------------------------------
// Bind class wxWizardEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxWizardEvent'
int wxluatype_wxWizardEvent = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardEvent_GetDirection[] = { &wxluatype_wxWizardEvent, NULL };
static int LUACALL wxLua_wxWizardEvent_GetDirection(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardEvent_GetDirection[1] = {{ wxLua_wxWizardEvent_GetDirection, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxWizardEvent_GetDirection }};
// bool GetDirection() const;
static int LUACALL wxLua_wxWizardEvent_GetDirection(lua_State *L)
{
// get this
wxWizardEvent * self = (wxWizardEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizardEvent);
// call GetDirection
bool returns = (self->GetDirection());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardEvent_GetPage[] = { &wxluatype_wxWizardEvent, NULL };
static int LUACALL wxLua_wxWizardEvent_GetPage(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardEvent_GetPage[1] = {{ wxLua_wxWizardEvent_GetPage, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxWizardEvent_GetPage }};
// wxWizardPage* GetPage() const;
static int LUACALL wxLua_wxWizardEvent_GetPage(lua_State *L)
{
// get this
wxWizardEvent * self = (wxWizardEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWizardEvent);
// call GetPage
wxWizardPage* returns = (wxWizardPage*)self->GetPage();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWizardPage);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardEvent_delete[] = { &wxluatype_wxWizardEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxWizardEvent_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxWizardEvent_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxWizardEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWizardEvent_constructor[1] = {{ wxLua_wxWizardEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 3, s_wxluatypeArray_wxLua_wxWizardEvent_constructor }};
// wxWizardEvent(wxEventType type = wxEVT_NULL, int id = -1, bool direction = true );
static int LUACALL wxLua_wxWizardEvent_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool direction = true
bool direction = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : true);
// int id = -1
int id = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : -1);
// wxEventType type = wxEVT_NULL
wxEventType type = (argCount >= 1 ? (wxEventType)wxlua_getnumbertype(L, 1) : wxEVT_NULL);
// call constructor
wxWizardEvent* returns = new wxWizardEvent(type, id, direction);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxWizardEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWizardEvent);
return 1;
}
void wxLua_wxWizardEvent_delete_function(void** p)
{
wxWizardEvent* o = (wxWizardEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxWizardEvent_methods[] = {
{ "GetDirection", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizardEvent_GetDirection, 1, NULL },
{ "GetPage", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWizardEvent_GetPage, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxWizardEvent_delete, 1, NULL },
{ "wxWizardEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxWizardEvent_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxWizardEvent_methodCount = sizeof(wxWizardEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
#if wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON )
// ---------------------------------------------------------------------------
// Bind class wxTaskBarIcon
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxTaskBarIcon'
int wxluatype_wxTaskBarIcon = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxTaskBarIcon_IsIconInstalled[] = { &wxluatype_wxTaskBarIcon, NULL };
static int LUACALL wxLua_wxTaskBarIcon_IsIconInstalled(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxTaskBarIcon_IsIconInstalled[1] = {{ wxLua_wxTaskBarIcon_IsIconInstalled, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxTaskBarIcon_IsIconInstalled }};
// bool IsIconInstalled( );
static int LUACALL wxLua_wxTaskBarIcon_IsIconInstalled(lua_State *L)
{
// get this
wxTaskBarIcon * self = (wxTaskBarIcon *)wxluaT_getuserdatatype(L, 1, wxluatype_wxTaskBarIcon);
// call IsIconInstalled
bool returns = (self->IsIconInstalled());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxCHECK_VERSION(2,4,0)) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
static wxLuaArgType s_wxluatypeArray_wxLua_wxTaskBarIcon_IsOk[] = { &wxluatype_wxTaskBarIcon, NULL };
static int LUACALL wxLua_wxTaskBarIcon_IsOk(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxTaskBarIcon_IsOk[1] = {{ wxLua_wxTaskBarIcon_IsOk, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxTaskBarIcon_IsOk }};
// %wxchkver_2_4 bool IsOk( );
static int LUACALL wxLua_wxTaskBarIcon_IsOk(lua_State *L)
{
// get this
wxTaskBarIcon * self = (wxTaskBarIcon *)wxluaT_getuserdatatype(L, 1, wxluatype_wxTaskBarIcon);
// call IsOk
bool returns = (self->IsOk());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxCHECK_VERSION(2,4,0)) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
#if (wxLUA_USE_wxMenu && wxUSE_MENUS) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
static wxLuaArgType s_wxluatypeArray_wxLua_wxTaskBarIcon_PopupMenu[] = { &wxluatype_wxTaskBarIcon, &wxluatype_wxMenu, NULL };
static int LUACALL wxLua_wxTaskBarIcon_PopupMenu(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxTaskBarIcon_PopupMenu[1] = {{ wxLua_wxTaskBarIcon_PopupMenu, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxTaskBarIcon_PopupMenu }};
// virtual bool PopupMenu(wxMenu* menu );
static int LUACALL wxLua_wxTaskBarIcon_PopupMenu(lua_State *L)
{
// wxMenu menu
wxMenu * menu = (wxMenu *)wxluaT_getuserdatatype(L, 2, wxluatype_wxMenu);
// get this
wxTaskBarIcon * self = (wxTaskBarIcon *)wxluaT_getuserdatatype(L, 1, wxluatype_wxTaskBarIcon);
// call PopupMenu
bool returns = (self->PopupMenu(menu));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxMenu && wxUSE_MENUS) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
static wxLuaArgType s_wxluatypeArray_wxLua_wxTaskBarIcon_RemoveIcon[] = { &wxluatype_wxTaskBarIcon, NULL };
static int LUACALL wxLua_wxTaskBarIcon_RemoveIcon(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxTaskBarIcon_RemoveIcon[1] = {{ wxLua_wxTaskBarIcon_RemoveIcon, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxTaskBarIcon_RemoveIcon }};
// bool RemoveIcon( );
static int LUACALL wxLua_wxTaskBarIcon_RemoveIcon(lua_State *L)
{
// get this
wxTaskBarIcon * self = (wxTaskBarIcon *)wxluaT_getuserdatatype(L, 1, wxluatype_wxTaskBarIcon);
// call RemoveIcon
bool returns = (self->RemoveIcon());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxLUA_USE_wxIcon) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
static wxLuaArgType s_wxluatypeArray_wxLua_wxTaskBarIcon_SetIcon[] = { &wxluatype_wxTaskBarIcon, &wxluatype_wxIcon, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxTaskBarIcon_SetIcon(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxTaskBarIcon_SetIcon[1] = {{ wxLua_wxTaskBarIcon_SetIcon, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxTaskBarIcon_SetIcon }};
// bool SetIcon(const wxIcon& icon, const wxString& tooltip );
static int LUACALL wxLua_wxTaskBarIcon_SetIcon(lua_State *L)
{
// const wxString tooltip
const wxString tooltip = wxlua_getwxStringtype(L, 3);
// const wxIcon icon
const wxIcon * icon = (const wxIcon *)wxluaT_getuserdatatype(L, 2, wxluatype_wxIcon);
// get this
wxTaskBarIcon * self = (wxTaskBarIcon *)wxluaT_getuserdatatype(L, 1, wxluatype_wxTaskBarIcon);
// call SetIcon
bool returns = (self->SetIcon(*icon, tooltip));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxIcon) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
static wxLuaArgType s_wxluatypeArray_wxLua_wxTaskBarIcon_delete[] = { &wxluatype_wxTaskBarIcon, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxTaskBarIcon_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxTaskBarIcon_delete }};
static int LUACALL wxLua_wxTaskBarIcon_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxTaskBarIcon_constructor[1] = {{ wxLua_wxTaskBarIcon_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxTaskBarIcon( );
static int LUACALL wxLua_wxTaskBarIcon_constructor(lua_State *L)
{
// call constructor
wxTaskBarIcon* returns = new wxTaskBarIcon();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxTaskBarIcon);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxTaskBarIcon);
return 1;
}
void wxLua_wxTaskBarIcon_delete_function(void** p)
{
wxTaskBarIcon* o = (wxTaskBarIcon*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxTaskBarIcon_methods[] = {
{ "IsIconInstalled", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxTaskBarIcon_IsIconInstalled, 1, NULL },
#if (wxCHECK_VERSION(2,4,0)) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
{ "IsOk", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxTaskBarIcon_IsOk, 1, NULL },
#endif // (wxCHECK_VERSION(2,4,0)) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
#if (wxLUA_USE_wxMenu && wxUSE_MENUS) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
{ "PopupMenu", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxTaskBarIcon_PopupMenu, 1, NULL },
#endif // (wxLUA_USE_wxMenu && wxUSE_MENUS) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
{ "RemoveIcon", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxTaskBarIcon_RemoveIcon, 1, NULL },
#if (wxLUA_USE_wxIcon) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
{ "SetIcon", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxTaskBarIcon_SetIcon, 1, NULL },
#endif // (wxLUA_USE_wxIcon) && (wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON ))
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxTaskBarIcon_delete, 1, NULL },
{ "wxTaskBarIcon", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxTaskBarIcon_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxTaskBarIcon_methodCount = sizeof(wxTaskBarIcon_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON )
#if wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON )
// ---------------------------------------------------------------------------
// Bind class wxTaskBarIconEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxTaskBarIconEvent'
int wxluatype_wxTaskBarIconEvent = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxTaskBarIconEvent_delete[] = { &wxluatype_wxTaskBarIconEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxTaskBarIconEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxTaskBarIconEvent_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxTaskBarIconEvent_constructor[] = { &wxluatype_TNUMBER, &wxluatype_wxTaskBarIcon, NULL };
static int LUACALL wxLua_wxTaskBarIconEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxTaskBarIconEvent_constructor[1] = {{ wxLua_wxTaskBarIconEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 2, 2, s_wxluatypeArray_wxLua_wxTaskBarIconEvent_constructor }};
// wxTaskBarIconEvent(wxEventType evtType, wxTaskBarIcon *tbIcon );
static int LUACALL wxLua_wxTaskBarIconEvent_constructor(lua_State *L)
{
// wxTaskBarIcon tbIcon
wxTaskBarIcon * tbIcon = (wxTaskBarIcon *)wxluaT_getuserdatatype(L, 2, wxluatype_wxTaskBarIcon);
// wxEventType evtType
wxEventType evtType = (wxEventType)wxlua_getnumbertype(L, 1);
// call constructor
wxTaskBarIconEvent* returns = new wxTaskBarIconEvent(evtType, tbIcon);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxTaskBarIconEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxTaskBarIconEvent);
return 1;
}
void wxLua_wxTaskBarIconEvent_delete_function(void** p)
{
wxTaskBarIconEvent* o = (wxTaskBarIconEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxTaskBarIconEvent_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxTaskBarIconEvent_delete, 1, NULL },
{ "wxTaskBarIconEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxTaskBarIconEvent_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxTaskBarIconEvent_methodCount = sizeof(wxTaskBarIconEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON )
#if wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
// ---------------------------------------------------------------------------
// Bind class wxJoystick
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxJoystick'
int wxluatype_wxJoystick = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetButtonState[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetButtonState(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetButtonState[1] = {{ wxLua_wxJoystick_GetButtonState, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetButtonState }};
// int GetButtonState() const;
static int LUACALL wxLua_wxJoystick_GetButtonState(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetButtonState
int returns = (self->GetButtonState());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetManufacturerId[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetManufacturerId(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetManufacturerId[1] = {{ wxLua_wxJoystick_GetManufacturerId, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetManufacturerId }};
// int GetManufacturerId() const;
static int LUACALL wxLua_wxJoystick_GetManufacturerId(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetManufacturerId
int returns = (self->GetManufacturerId());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetMovementThreshold[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetMovementThreshold(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetMovementThreshold[1] = {{ wxLua_wxJoystick_GetMovementThreshold, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetMovementThreshold }};
// int GetMovementThreshold() const;
static int LUACALL wxLua_wxJoystick_GetMovementThreshold(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetMovementThreshold
int returns = (self->GetMovementThreshold());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetNumberAxes[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetNumberAxes(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetNumberAxes[1] = {{ wxLua_wxJoystick_GetNumberAxes, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetNumberAxes }};
// int GetNumberAxes() const;
static int LUACALL wxLua_wxJoystick_GetNumberAxes(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetNumberAxes
int returns = (self->GetNumberAxes());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetNumberButtons[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetNumberButtons(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetNumberButtons[1] = {{ wxLua_wxJoystick_GetNumberButtons, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetNumberButtons }};
// int GetNumberButtons() const;
static int LUACALL wxLua_wxJoystick_GetNumberButtons(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetNumberButtons
int returns = (self->GetNumberButtons());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (!wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK)
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetNumberJoysticks1[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetNumberJoysticks1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetNumberJoysticks1[1] = {{ wxLua_wxJoystick_GetNumberJoysticks1, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetNumberJoysticks1 }};
// !%wxchkver_2_8 int GetNumberJoysticks() const;
static int LUACALL wxLua_wxJoystick_GetNumberJoysticks1(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetNumberJoysticks
int returns = (self->GetNumberJoysticks());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#endif // (!wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK)
#if (wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK)
static int LUACALL wxLua_wxJoystick_GetNumberJoysticks(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetNumberJoysticks[1] = {{ wxLua_wxJoystick_GetNumberJoysticks, WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, 0, 0, g_wxluaargtypeArray_None }};
// %wxchkver_2_8 static int GetNumberJoysticks() const;
static int LUACALL wxLua_wxJoystick_GetNumberJoysticks(lua_State *L)
{
// call GetNumberJoysticks
int returns = (wxJoystick::GetNumberJoysticks());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#endif // (wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK)
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetPOVCTSPosition[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetPOVCTSPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetPOVCTSPosition[1] = {{ wxLua_wxJoystick_GetPOVCTSPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetPOVCTSPosition }};
// int GetPOVCTSPosition() const;
static int LUACALL wxLua_wxJoystick_GetPOVCTSPosition(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetPOVCTSPosition
int returns = (self->GetPOVCTSPosition());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetPOVPosition[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetPOVPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetPOVPosition[1] = {{ wxLua_wxJoystick_GetPOVPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetPOVPosition }};
// int GetPOVPosition() const;
static int LUACALL wxLua_wxJoystick_GetPOVPosition(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetPOVPosition
int returns = (self->GetPOVPosition());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetPollingMax[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetPollingMax(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetPollingMax[1] = {{ wxLua_wxJoystick_GetPollingMax, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetPollingMax }};
// int GetPollingMax() const;
static int LUACALL wxLua_wxJoystick_GetPollingMax(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetPollingMax
int returns = (self->GetPollingMax());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetPollingMin[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetPollingMin(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetPollingMin[1] = {{ wxLua_wxJoystick_GetPollingMin, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetPollingMin }};
// int GetPollingMin() const;
static int LUACALL wxLua_wxJoystick_GetPollingMin(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetPollingMin
int returns = (self->GetPollingMin());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetPosition[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetPosition[1] = {{ wxLua_wxJoystick_GetPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetPosition }};
// wxPoint GetPosition() const;
static int LUACALL wxLua_wxJoystick_GetPosition(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetPosition
// allocate a new object using the copy constructor
wxPoint* returns = new wxPoint(self->GetPosition());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxPoint);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxPoint);
return 1;
}
#endif // (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetProductId[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetProductId(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetProductId[1] = {{ wxLua_wxJoystick_GetProductId, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetProductId }};
// int GetProductId() const;
static int LUACALL wxLua_wxJoystick_GetProductId(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetProductId
int returns = (self->GetProductId());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetProductName[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetProductName(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetProductName[1] = {{ wxLua_wxJoystick_GetProductName, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetProductName }};
// wxString GetProductName() const;
static int LUACALL wxLua_wxJoystick_GetProductName(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetProductName
wxString returns = (self->GetProductName());
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetRudderMax[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetRudderMax(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetRudderMax[1] = {{ wxLua_wxJoystick_GetRudderMax, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetRudderMax }};
// int GetRudderMax() const;
static int LUACALL wxLua_wxJoystick_GetRudderMax(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetRudderMax
int returns = (self->GetRudderMax());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetRudderMin[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetRudderMin(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetRudderMin[1] = {{ wxLua_wxJoystick_GetRudderMin, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetRudderMin }};
// int GetRudderMin() const;
static int LUACALL wxLua_wxJoystick_GetRudderMin(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetRudderMin
int returns = (self->GetRudderMin());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetRudderPosition[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetRudderPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetRudderPosition[1] = {{ wxLua_wxJoystick_GetRudderPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetRudderPosition }};
// int GetRudderPosition() const;
static int LUACALL wxLua_wxJoystick_GetRudderPosition(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetRudderPosition
int returns = (self->GetRudderPosition());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetUMax[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetUMax(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetUMax[1] = {{ wxLua_wxJoystick_GetUMax, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetUMax }};
// int GetUMax() const;
static int LUACALL wxLua_wxJoystick_GetUMax(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetUMax
int returns = (self->GetUMax());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetUMin[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetUMin(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetUMin[1] = {{ wxLua_wxJoystick_GetUMin, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetUMin }};
// int GetUMin() const;
static int LUACALL wxLua_wxJoystick_GetUMin(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetUMin
int returns = (self->GetUMin());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetUPosition[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetUPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetUPosition[1] = {{ wxLua_wxJoystick_GetUPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetUPosition }};
// int GetUPosition() const;
static int LUACALL wxLua_wxJoystick_GetUPosition(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetUPosition
int returns = (self->GetUPosition());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetVMax[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetVMax(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetVMax[1] = {{ wxLua_wxJoystick_GetVMax, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetVMax }};
// int GetVMax() const;
static int LUACALL wxLua_wxJoystick_GetVMax(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetVMax
int returns = (self->GetVMax());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetVMin[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetVMin(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetVMin[1] = {{ wxLua_wxJoystick_GetVMin, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetVMin }};
// int GetVMin() const;
static int LUACALL wxLua_wxJoystick_GetVMin(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetVMin
int returns = (self->GetVMin());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetVPosition[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetVPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetVPosition[1] = {{ wxLua_wxJoystick_GetVPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetVPosition }};
// int GetVPosition() const;
static int LUACALL wxLua_wxJoystick_GetVPosition(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetVPosition
int returns = (self->GetVPosition());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetXMax[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetXMax(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetXMax[1] = {{ wxLua_wxJoystick_GetXMax, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetXMax }};
// int GetXMax() const;
static int LUACALL wxLua_wxJoystick_GetXMax(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetXMax
int returns = (self->GetXMax());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetXMin[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetXMin(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetXMin[1] = {{ wxLua_wxJoystick_GetXMin, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetXMin }};
// int GetXMin() const;
static int LUACALL wxLua_wxJoystick_GetXMin(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetXMin
int returns = (self->GetXMin());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetYMax[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetYMax(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetYMax[1] = {{ wxLua_wxJoystick_GetYMax, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetYMax }};
// int GetYMax() const;
static int LUACALL wxLua_wxJoystick_GetYMax(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetYMax
int returns = (self->GetYMax());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetYMin[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetYMin(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetYMin[1] = {{ wxLua_wxJoystick_GetYMin, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetYMin }};
// int GetYMin() const;
static int LUACALL wxLua_wxJoystick_GetYMin(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetYMin
int returns = (self->GetYMin());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetZMax[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetZMax(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetZMax[1] = {{ wxLua_wxJoystick_GetZMax, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetZMax }};
// int GetZMax() const;
static int LUACALL wxLua_wxJoystick_GetZMax(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetZMax
int returns = (self->GetZMax());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetZMin[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetZMin(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetZMin[1] = {{ wxLua_wxJoystick_GetZMin, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetZMin }};
// int GetZMin() const;
static int LUACALL wxLua_wxJoystick_GetZMin(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetZMin
int returns = (self->GetZMin());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_GetZPosition[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_GetZPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetZPosition[1] = {{ wxLua_wxJoystick_GetZPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetZPosition }};
// int GetZPosition() const;
static int LUACALL wxLua_wxJoystick_GetZPosition(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call GetZPosition
int returns = (self->GetZPosition());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_HasPOV[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_HasPOV(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_HasPOV[1] = {{ wxLua_wxJoystick_HasPOV, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_HasPOV }};
// bool HasPOV() const;
static int LUACALL wxLua_wxJoystick_HasPOV(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call HasPOV
bool returns = (self->HasPOV());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_HasPOV4Dir[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_HasPOV4Dir(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_HasPOV4Dir[1] = {{ wxLua_wxJoystick_HasPOV4Dir, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_HasPOV4Dir }};
// bool HasPOV4Dir() const;
static int LUACALL wxLua_wxJoystick_HasPOV4Dir(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call HasPOV4Dir
bool returns = (self->HasPOV4Dir());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_HasPOVCTS[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_HasPOVCTS(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_HasPOVCTS[1] = {{ wxLua_wxJoystick_HasPOVCTS, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_HasPOVCTS }};
// bool HasPOVCTS() const;
static int LUACALL wxLua_wxJoystick_HasPOVCTS(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call HasPOVCTS
bool returns = (self->HasPOVCTS());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_HasRudder[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_HasRudder(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_HasRudder[1] = {{ wxLua_wxJoystick_HasRudder, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_HasRudder }};
// bool HasRudder() const;
static int LUACALL wxLua_wxJoystick_HasRudder(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call HasRudder
bool returns = (self->HasRudder());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_HasU[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_HasU(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_HasU[1] = {{ wxLua_wxJoystick_HasU, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_HasU }};
// bool HasU() const;
static int LUACALL wxLua_wxJoystick_HasU(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call HasU
bool returns = (self->HasU());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_HasV[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_HasV(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_HasV[1] = {{ wxLua_wxJoystick_HasV, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_HasV }};
// bool HasV() const;
static int LUACALL wxLua_wxJoystick_HasV(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call HasV
bool returns = (self->HasV());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_HasZ[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_HasZ(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_HasZ[1] = {{ wxLua_wxJoystick_HasZ, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_HasZ }};
// bool HasZ() const;
static int LUACALL wxLua_wxJoystick_HasZ(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call HasZ
bool returns = (self->HasZ());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_IsOk[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_IsOk(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_IsOk[1] = {{ wxLua_wxJoystick_IsOk, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_IsOk }};
// bool IsOk() const;
static int LUACALL wxLua_wxJoystick_IsOk(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call IsOk
bool returns = (self->IsOk());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_ReleaseCapture[] = { &wxluatype_wxJoystick, NULL };
static int LUACALL wxLua_wxJoystick_ReleaseCapture(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_ReleaseCapture[1] = {{ wxLua_wxJoystick_ReleaseCapture, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_ReleaseCapture }};
// bool ReleaseCapture( );
static int LUACALL wxLua_wxJoystick_ReleaseCapture(lua_State *L)
{
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call ReleaseCapture
bool returns = (self->ReleaseCapture());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_SetCapture[] = { &wxluatype_wxJoystick, &wxluatype_wxWindow, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxJoystick_SetCapture(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_SetCapture[1] = {{ wxLua_wxJoystick_SetCapture, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxJoystick_SetCapture }};
// bool SetCapture(wxWindow* win, int pollingFreq = 0 );
static int LUACALL wxLua_wxJoystick_SetCapture(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int pollingFreq = 0
int pollingFreq = (argCount >= 3 ? (int)wxlua_getnumbertype(L, 3) : 0);
// wxWindow win
wxWindow * win = (wxWindow *)wxluaT_getuserdatatype(L, 2, wxluatype_wxWindow);
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call SetCapture
bool returns = (self->SetCapture(win, pollingFreq));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_SetMovementThreshold[] = { &wxluatype_wxJoystick, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxJoystick_SetMovementThreshold(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_SetMovementThreshold[1] = {{ wxLua_wxJoystick_SetMovementThreshold, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxJoystick_SetMovementThreshold }};
// void SetMovementThreshold(int threshold );
static int LUACALL wxLua_wxJoystick_SetMovementThreshold(lua_State *L)
{
// int threshold
int threshold = (int)wxlua_getnumbertype(L, 2);
// get this
wxJoystick * self = (wxJoystick *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystick);
// call SetMovementThreshold
self->SetMovementThreshold(threshold);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_delete[] = { &wxluatype_wxJoystick, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystick_constructor[] = { &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxJoystick_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_constructor[1] = {{ wxLua_wxJoystick_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 1, s_wxluatypeArray_wxLua_wxJoystick_constructor }};
// wxJoystick(int joystick = wxJOYSTICK1 );
static int LUACALL wxLua_wxJoystick_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int joystick = wxJOYSTICK1
int joystick = (argCount >= 1 ? (int)wxlua_getnumbertype(L, 1) : wxJOYSTICK1);
// call constructor
wxJoystick* returns = new wxJoystick(joystick);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxJoystick);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxJoystick);
return 1;
}
#if ((!wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK))||((wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK))
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystick_GetNumberJoysticks_overload[] =
{
#if (!wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK)
{ wxLua_wxJoystick_GetNumberJoysticks1, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystick_GetNumberJoysticks1 },
#endif // (!wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK)
#if (wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK)
{ wxLua_wxJoystick_GetNumberJoysticks, WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, 0, 0, g_wxluaargtypeArray_None },
#endif // (wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK)
};
static int s_wxluafunc_wxLua_wxJoystick_GetNumberJoysticks_overload_count = sizeof(s_wxluafunc_wxLua_wxJoystick_GetNumberJoysticks_overload)/sizeof(wxLuaBindCFunc);
#endif // ((!wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK))||((wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK))
void wxLua_wxJoystick_delete_function(void** p)
{
wxJoystick* o = (wxJoystick*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxJoystick_methods[] = {
{ "GetButtonState", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetButtonState, 1, NULL },
{ "GetManufacturerId", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetManufacturerId, 1, NULL },
{ "GetMovementThreshold", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetMovementThreshold, 1, NULL },
{ "GetNumberAxes", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetNumberAxes, 1, NULL },
{ "GetNumberButtons", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetNumberButtons, 1, NULL },
#if ((!wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK))||((wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK))
{ "GetNumberJoysticks", WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, s_wxluafunc_wxLua_wxJoystick_GetNumberJoysticks_overload, s_wxluafunc_wxLua_wxJoystick_GetNumberJoysticks_overload_count, 0 },
#endif // ((!wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK))||((wxCHECK_VERSION(2,8,0)) && (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK))
{ "GetPOVCTSPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetPOVCTSPosition, 1, NULL },
{ "GetPOVPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetPOVPosition, 1, NULL },
{ "GetPollingMax", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetPollingMax, 1, NULL },
{ "GetPollingMin", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetPollingMin, 1, NULL },
#if (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK) && (wxLUA_USE_wxPointSizeRect)
{ "GetPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetPosition, 1, NULL },
#endif // (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK) && (wxLUA_USE_wxPointSizeRect)
{ "GetProductId", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetProductId, 1, NULL },
{ "GetProductName", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetProductName, 1, NULL },
{ "GetRudderMax", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetRudderMax, 1, NULL },
{ "GetRudderMin", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetRudderMin, 1, NULL },
{ "GetRudderPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetRudderPosition, 1, NULL },
{ "GetUMax", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetUMax, 1, NULL },
{ "GetUMin", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetUMin, 1, NULL },
{ "GetUPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetUPosition, 1, NULL },
{ "GetVMax", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetVMax, 1, NULL },
{ "GetVMin", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetVMin, 1, NULL },
{ "GetVPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetVPosition, 1, NULL },
{ "GetXMax", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetXMax, 1, NULL },
{ "GetXMin", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetXMin, 1, NULL },
{ "GetYMax", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetYMax, 1, NULL },
{ "GetYMin", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetYMin, 1, NULL },
{ "GetZMax", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetZMax, 1, NULL },
{ "GetZMin", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetZMin, 1, NULL },
{ "GetZPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_GetZPosition, 1, NULL },
{ "HasPOV", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_HasPOV, 1, NULL },
{ "HasPOV4Dir", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_HasPOV4Dir, 1, NULL },
{ "HasPOVCTS", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_HasPOVCTS, 1, NULL },
{ "HasRudder", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_HasRudder, 1, NULL },
{ "HasU", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_HasU, 1, NULL },
{ "HasV", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_HasV, 1, NULL },
{ "HasZ", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_HasZ, 1, NULL },
{ "IsOk", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_IsOk, 1, NULL },
{ "ReleaseCapture", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_ReleaseCapture, 1, NULL },
{ "SetCapture", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_SetCapture, 1, NULL },
{ "SetMovementThreshold", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystick_SetMovementThreshold, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxJoystick_delete, 1, NULL },
{ "wxJoystick", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxJoystick_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxJoystick_methodCount = sizeof(wxJoystick_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
#if wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
// ---------------------------------------------------------------------------
// Bind class wxJoystickEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxJoystickEvent'
int wxluatype_wxJoystickEvent = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_ButtonDown[] = { &wxluatype_wxJoystickEvent, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxJoystickEvent_ButtonDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_ButtonDown[1] = {{ wxLua_wxJoystickEvent_ButtonDown, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxJoystickEvent_ButtonDown }};
// bool ButtonDown(int button = wxJOY_BUTTON_ANY) const;
static int LUACALL wxLua_wxJoystickEvent_ButtonDown(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int button = wxJOY_BUTTON_ANY
int button = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : wxJOY_BUTTON_ANY);
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call ButtonDown
bool returns = (self->ButtonDown(button));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_ButtonIsDown[] = { &wxluatype_wxJoystickEvent, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxJoystickEvent_ButtonIsDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_ButtonIsDown[1] = {{ wxLua_wxJoystickEvent_ButtonIsDown, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxJoystickEvent_ButtonIsDown }};
// bool ButtonIsDown(int button = wxJOY_BUTTON_ANY) const;
static int LUACALL wxLua_wxJoystickEvent_ButtonIsDown(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int button = wxJOY_BUTTON_ANY
int button = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : wxJOY_BUTTON_ANY);
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call ButtonIsDown
bool returns = (self->ButtonIsDown(button));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_ButtonUp[] = { &wxluatype_wxJoystickEvent, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxJoystickEvent_ButtonUp(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_ButtonUp[1] = {{ wxLua_wxJoystickEvent_ButtonUp, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxJoystickEvent_ButtonUp }};
// bool ButtonUp(int button = wxJOY_BUTTON_ANY) const;
static int LUACALL wxLua_wxJoystickEvent_ButtonUp(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int button = wxJOY_BUTTON_ANY
int button = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : wxJOY_BUTTON_ANY);
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call ButtonUp
bool returns = (self->ButtonUp(button));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_GetButtonChange[] = { &wxluatype_wxJoystickEvent, NULL };
static int LUACALL wxLua_wxJoystickEvent_GetButtonChange(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_GetButtonChange[1] = {{ wxLua_wxJoystickEvent_GetButtonChange, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystickEvent_GetButtonChange }};
// int GetButtonChange() const;
static int LUACALL wxLua_wxJoystickEvent_GetButtonChange(lua_State *L)
{
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call GetButtonChange
int returns = (self->GetButtonChange());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_GetButtonState[] = { &wxluatype_wxJoystickEvent, NULL };
static int LUACALL wxLua_wxJoystickEvent_GetButtonState(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_GetButtonState[1] = {{ wxLua_wxJoystickEvent_GetButtonState, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystickEvent_GetButtonState }};
// int GetButtonState() const;
static int LUACALL wxLua_wxJoystickEvent_GetButtonState(lua_State *L)
{
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call GetButtonState
int returns = (self->GetButtonState());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_GetJoystick[] = { &wxluatype_wxJoystickEvent, NULL };
static int LUACALL wxLua_wxJoystickEvent_GetJoystick(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_GetJoystick[1] = {{ wxLua_wxJoystickEvent_GetJoystick, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystickEvent_GetJoystick }};
// int GetJoystick() const;
static int LUACALL wxLua_wxJoystickEvent_GetJoystick(lua_State *L)
{
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call GetJoystick
int returns = (self->GetJoystick());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_GetPosition[] = { &wxluatype_wxJoystickEvent, NULL };
static int LUACALL wxLua_wxJoystickEvent_GetPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_GetPosition[1] = {{ wxLua_wxJoystickEvent_GetPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystickEvent_GetPosition }};
// wxPoint GetPosition() const;
static int LUACALL wxLua_wxJoystickEvent_GetPosition(lua_State *L)
{
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call GetPosition
// allocate a new object using the copy constructor
wxPoint* returns = new wxPoint(self->GetPosition());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxPoint);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxPoint);
return 1;
}
#endif // (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_GetZPosition[] = { &wxluatype_wxJoystickEvent, NULL };
static int LUACALL wxLua_wxJoystickEvent_GetZPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_GetZPosition[1] = {{ wxLua_wxJoystickEvent_GetZPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystickEvent_GetZPosition }};
// int GetZPosition() const;
static int LUACALL wxLua_wxJoystickEvent_GetZPosition(lua_State *L)
{
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call GetZPosition
int returns = (self->GetZPosition());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_IsButton[] = { &wxluatype_wxJoystickEvent, NULL };
static int LUACALL wxLua_wxJoystickEvent_IsButton(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_IsButton[1] = {{ wxLua_wxJoystickEvent_IsButton, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystickEvent_IsButton }};
// bool IsButton() const;
static int LUACALL wxLua_wxJoystickEvent_IsButton(lua_State *L)
{
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call IsButton
bool returns = (self->IsButton());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_IsMove[] = { &wxluatype_wxJoystickEvent, NULL };
static int LUACALL wxLua_wxJoystickEvent_IsMove(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_IsMove[1] = {{ wxLua_wxJoystickEvent_IsMove, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystickEvent_IsMove }};
// bool IsMove() const;
static int LUACALL wxLua_wxJoystickEvent_IsMove(lua_State *L)
{
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call IsMove
bool returns = (self->IsMove());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_IsZMove[] = { &wxluatype_wxJoystickEvent, NULL };
static int LUACALL wxLua_wxJoystickEvent_IsZMove(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_IsZMove[1] = {{ wxLua_wxJoystickEvent_IsZMove, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxJoystickEvent_IsZMove }};
// bool IsZMove() const;
static int LUACALL wxLua_wxJoystickEvent_IsZMove(lua_State *L)
{
// get this
wxJoystickEvent * self = (wxJoystickEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxJoystickEvent);
// call IsZMove
bool returns = (self->IsZMove());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_delete[] = { &wxluatype_wxJoystickEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxJoystickEvent_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxJoystickEvent_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxJoystickEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxJoystickEvent_constructor[1] = {{ wxLua_wxJoystickEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 4, s_wxluatypeArray_wxLua_wxJoystickEvent_constructor }};
// wxJoystickEvent(wxEventType eventType = wxEVT_NULL, int state = 0, int joystick = wxJOYSTICK1, int change = 0 );
static int LUACALL wxLua_wxJoystickEvent_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int change = 0
int change = (argCount >= 4 ? (int)wxlua_getnumbertype(L, 4) : 0);
// int joystick = wxJOYSTICK1
int joystick = (argCount >= 3 ? (int)wxlua_getnumbertype(L, 3) : wxJOYSTICK1);
// int state = 0
int state = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : 0);
// wxEventType eventType = wxEVT_NULL
wxEventType eventType = (argCount >= 1 ? (wxEventType)wxlua_getnumbertype(L, 1) : wxEVT_NULL);
// call constructor
wxJoystickEvent* returns = new wxJoystickEvent(eventType, state, joystick, change);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxJoystickEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxJoystickEvent);
return 1;
}
void wxLua_wxJoystickEvent_delete_function(void** p)
{
wxJoystickEvent* o = (wxJoystickEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxJoystickEvent_methods[] = {
{ "ButtonDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_ButtonDown, 1, NULL },
{ "ButtonIsDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_ButtonIsDown, 1, NULL },
{ "ButtonUp", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_ButtonUp, 1, NULL },
{ "GetButtonChange", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_GetButtonChange, 1, NULL },
{ "GetButtonState", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_GetButtonState, 1, NULL },
{ "GetJoystick", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_GetJoystick, 1, NULL },
#if (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK) && (wxLUA_USE_wxPointSizeRect)
{ "GetPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_GetPosition, 1, NULL },
#endif // (wxLUA_USE_wxJoystick && wxUSE_JOYSTICK) && (wxLUA_USE_wxPointSizeRect)
{ "GetZPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_GetZPosition, 1, NULL },
{ "IsButton", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_IsButton, 1, NULL },
{ "IsMove", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_IsMove, 1, NULL },
{ "IsZMove", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxJoystickEvent_IsZMove, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxJoystickEvent_delete, 1, NULL },
{ "wxJoystickEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxJoystickEvent_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxJoystickEvent_methodCount = sizeof(wxJoystickEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
#if (wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND)
// ---------------------------------------------------------------------------
// Bind class wxSound
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxSound'
int wxluatype_wxSound = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxSound_Create[] = { &wxluatype_wxSound, &wxluatype_TSTRING, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxSound_Create(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_Create[1] = {{ wxLua_wxSound_Create, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxSound_Create }};
// bool Create(const wxString& fileName, bool isResource = false );
static int LUACALL wxLua_wxSound_Create(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool isResource = false
bool isResource = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : false);
// const wxString fileName
const wxString fileName = wxlua_getwxStringtype(L, 2);
// get this
wxSound * self = (wxSound *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSound);
// call Create
bool returns = (self->Create(fileName, isResource));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSound_IsOk[] = { &wxluatype_wxSound, NULL };
static int LUACALL wxLua_wxSound_IsOk(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_IsOk[1] = {{ wxLua_wxSound_IsOk, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxSound_IsOk }};
// bool IsOk() const;
static int LUACALL wxLua_wxSound_IsOk(lua_State *L)
{
// get this
wxSound * self = (wxSound *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSound);
// call IsOk
bool returns = (self->IsOk());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (!defined(__WXMSW__)) && ((wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND))
static int LUACALL wxLua_wxSound_IsPlaying(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_IsPlaying[1] = {{ wxLua_wxSound_IsPlaying, WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, 0, 0, g_wxluaargtypeArray_None }};
// !%win static bool IsPlaying() const;
static int LUACALL wxLua_wxSound_IsPlaying(lua_State *L)
{
// call IsPlaying
bool returns = (wxSound::IsPlaying());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (!defined(__WXMSW__)) && ((wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND))
static wxLuaArgType s_wxluatypeArray_wxLua_wxSound_Play1[] = { &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxSound_Play1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_Play1[1] = {{ wxLua_wxSound_Play1, WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, 1, 1, s_wxluatypeArray_wxLua_wxSound_Play1 }};
// static bool Play(const wxString& filename, unsigned flags = wxSOUND_ASYNC );
static int LUACALL wxLua_wxSound_Play1(lua_State *L)
{
// const wxString filename
const wxString filename = wxlua_getwxStringtype(L, 1);
// call Play
bool returns = (wxSound::Play(filename));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSound_Play[] = { &wxluatype_wxSound, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxSound_Play(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_Play[1] = {{ wxLua_wxSound_Play, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxSound_Play }};
// bool Play(unsigned int flags = wxSOUND_ASYNC) const;
static int LUACALL wxLua_wxSound_Play(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// unsigned int flags = wxSOUND_ASYNC
unsigned int flags = (argCount >= 2 ? (unsigned int)wxlua_getuintegertype(L, 2) : wxSOUND_ASYNC);
// get this
wxSound * self = (wxSound *)wxluaT_getuserdatatype(L, 1, wxluatype_wxSound);
// call Play
bool returns = (self->Play(flags));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static int LUACALL wxLua_wxSound_Stop(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_Stop[1] = {{ wxLua_wxSound_Stop, WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, 0, 0, g_wxluaargtypeArray_None }};
// static void Stop( );
static int LUACALL wxLua_wxSound_Stop(lua_State *L)
{
// call Stop
wxSound::Stop();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxSound_delete[] = { &wxluatype_wxSound, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxSound_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxSound_constructor1[] = { &wxluatype_TSTRING, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxSound_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_constructor1[1] = {{ wxLua_wxSound_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 2, s_wxluatypeArray_wxLua_wxSound_constructor1 }};
// wxSound(const wxString& fileName, bool isResource = false );
static int LUACALL wxLua_wxSound_constructor1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool isResource = false
bool isResource = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : false);
// const wxString fileName
const wxString fileName = wxlua_getwxStringtype(L, 1);
// call constructor
wxSound* returns = new wxSound(fileName, isResource);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxSound);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSound);
return 1;
}
static int LUACALL wxLua_wxSound_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_constructor[1] = {{ wxLua_wxSound_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxSound( );
static int LUACALL wxLua_wxSound_constructor(lua_State *L)
{
// call constructor
wxSound* returns = new wxSound();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxSound);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSound);
return 1;
}
#if ((wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND))
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_Play_overload[] =
{
{ wxLua_wxSound_Play1, WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, 1, 1, s_wxluatypeArray_wxLua_wxSound_Play1 },
{ wxLua_wxSound_Play, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxSound_Play },
};
static int s_wxluafunc_wxLua_wxSound_Play_overload_count = sizeof(s_wxluafunc_wxLua_wxSound_Play_overload)/sizeof(wxLuaBindCFunc);
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxSound_constructor_overload[] =
{
{ wxLua_wxSound_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 2, s_wxluatypeArray_wxLua_wxSound_constructor1 },
{ wxLua_wxSound_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxSound_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxSound_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND))
void wxLua_wxSound_delete_function(void** p)
{
wxSound* o = (wxSound*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxSound_methods[] = {
{ "Create", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSound_Create, 1, NULL },
{ "IsOk", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxSound_IsOk, 1, NULL },
#if (!defined(__WXMSW__)) && ((wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND))
{ "IsPlaying", WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, s_wxluafunc_wxLua_wxSound_IsPlaying, 1, NULL },
#endif // (!defined(__WXMSW__)) && ((wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND))
#if ((wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND))
{ "Play", WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, s_wxluafunc_wxLua_wxSound_Play_overload, s_wxluafunc_wxLua_wxSound_Play_overload_count, 0 },
#endif // ((wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND))
{ "Stop", WXLUAMETHOD_METHOD|WXLUAMETHOD_STATIC, s_wxluafunc_wxLua_wxSound_Stop, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxSound_delete, 1, NULL },
#if ((wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND))
{ "wxSound", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxSound_constructor_overload, s_wxluafunc_wxLua_wxSound_constructor_overload_count, 0 },
#endif // ((wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND))
{ 0, 0, 0, 0 },
};
int wxSound_methodCount = sizeof(wxSound_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // (wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND)
#if (wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)
// ---------------------------------------------------------------------------
// Bind class wxWave
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxWave'
int wxluatype_wxWave = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxWave_Create[] = { &wxluatype_wxWave, &wxluatype_TSTRING, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxWave_Create(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWave_Create[1] = {{ wxLua_wxWave_Create, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxWave_Create }};
// bool Create(const wxString& fileName, bool isResource = false );
static int LUACALL wxLua_wxWave_Create(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool isResource = false
bool isResource = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : false);
// const wxString fileName
const wxString fileName = wxlua_getwxStringtype(L, 2);
// get this
wxWave * self = (wxWave *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWave);
// call Create
bool returns = (self->Create(fileName, isResource));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxWave_IsOk[] = { &wxluatype_wxWave, NULL };
static int LUACALL wxLua_wxWave_IsOk(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWave_IsOk[1] = {{ wxLua_wxWave_IsOk, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxWave_IsOk }};
// bool IsOk() const;
static int LUACALL wxLua_wxWave_IsOk(lua_State *L)
{
// get this
wxWave * self = (wxWave *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWave);
// call IsOk
bool returns = (self->IsOk());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
static wxLuaArgType s_wxluatypeArray_wxLua_wxWave_Play1[] = { &wxluatype_wxWave, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxWave_Play1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxWave_Play1[1] = {{ wxLua_wxWave_Play1, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxWave_Play1 }};
// %wxchkver_2_6 bool Play(unsigned int flags = wxSOUND_ASYNC) const;
static int LUACALL wxLua_wxWave_Play1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// unsigned int flags = wxSOUND_ASYNC
unsigned int flags = (argCount >= 2 ? (unsigned int)wxlua_getuintegertype(L, 2) : wxSOUND_ASYNC);
// get this
wxWave * self = (wxWave *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWave);
// call Play
bool returns = (self->Play(flags));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
#if (!wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
static wxLuaArgType s_wxluatypeArray_wxLua_wxWave_Play[] = { &wxluatype_wxWave, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxWave_Play(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxWave_Play[1] = {{ wxLua_wxWave_Play, WXLUAMETHOD_METHOD, 1, 3, s_wxluatypeArray_wxLua_wxWave_Play }};
// !%wxchkver_2_6 bool Play(bool async = true, bool looped = false) const;
static int LUACALL wxLua_wxWave_Play(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool looped = false
bool looped = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : false);
// bool async = true
bool async = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxWave * self = (wxWave *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWave);
// call Play
bool returns = (self->Play(async, looped));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (!wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
static wxLuaArgType s_wxluatypeArray_wxLua_wxWave_delete[] = { &wxluatype_wxWave, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWave_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxWave_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxWave_constructor1[] = { &wxluatype_TSTRING, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxWave_constructor1(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxWave_constructor1[1] = {{ wxLua_wxWave_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 2, s_wxluatypeArray_wxLua_wxWave_constructor1 }};
// wxWave(const wxString& fileName, bool isResource = false );
static int LUACALL wxLua_wxWave_constructor1(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool isResource = false
bool isResource = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : false);
// const wxString fileName
const wxString fileName = wxlua_getwxStringtype(L, 1);
// call constructor
wxWave* returns = new wxWave(fileName, isResource);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxWave);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWave);
return 1;
}
static int LUACALL wxLua_wxWave_constructor(lua_State *L);
// // static wxLuaBindCFunc s_wxluafunc_wxLua_wxWave_constructor[1] = {{ wxLua_wxWave_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxWave( );
static int LUACALL wxLua_wxWave_constructor(lua_State *L)
{
// call constructor
wxWave* returns = new wxWave();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxWave);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWave);
return 1;
}
#if ((wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)))||((!wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)))
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWave_Play_overload[] =
{
#if (wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
{ wxLua_wxWave_Play1, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxWave_Play1 },
#endif // (wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
#if (!wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
{ wxLua_wxWave_Play, WXLUAMETHOD_METHOD, 1, 3, s_wxluatypeArray_wxLua_wxWave_Play },
#endif // (!wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
};
static int s_wxluafunc_wxLua_wxWave_Play_overload_count = sizeof(s_wxluafunc_wxLua_wxWave_Play_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)))||((!wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)))
#if ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxWave_constructor_overload[] =
{
{ wxLua_wxWave_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 2, s_wxluatypeArray_wxLua_wxWave_constructor1 },
{ wxLua_wxWave_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxWave_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxWave_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
void wxLua_wxWave_delete_function(void** p)
{
wxWave* o = (wxWave*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxWave_methods[] = {
{ "Create", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWave_Create, 1, NULL },
{ "IsOk", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWave_IsOk, 1, NULL },
#if ((wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)))||((!wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)))
{ "Play", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxWave_Play_overload, s_wxluafunc_wxLua_wxWave_Play_overload_count, 0 },
#endif // ((wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)))||((!wxCHECK_VERSION(2,6,0)) && ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)))
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxWave_delete, 1, NULL },
#if ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
{ "wxWave", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxWave_constructor_overload, s_wxluafunc_wxLua_wxWave_constructor_overload_count, 0 },
#endif // ((wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE))
{ 0, 0, 0, 0 },
};
int wxWave_methodCount = sizeof(wxWave_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // (wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)
// ---------------------------------------------------------------------------
// ../modules/wxbind/src/wxadv_grid.cpp was generated by genwxbind.lua
//
// Any changes made to this file will be lost when the file is regenerated.
// ---------------------------------------------------------------------------
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellWorker
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellWorker'
int wxluatype_wxGridCellWorker = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellWorker_DecRef[] = { &wxluatype_wxGridCellWorker, NULL };
static int LUACALL wxLua_wxGridCellWorker_DecRef(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellWorker_DecRef[1] = {{ wxLua_wxGridCellWorker_DecRef, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellWorker_DecRef }};
// void DecRef( );
static int LUACALL wxLua_wxGridCellWorker_DecRef(lua_State *L)
{
// get this
wxGridCellWorker * self = (wxGridCellWorker *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellWorker);
// call DecRef
self->DecRef();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellWorker_IncRef[] = { &wxluatype_wxGridCellWorker, NULL };
static int LUACALL wxLua_wxGridCellWorker_IncRef(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellWorker_IncRef[1] = {{ wxLua_wxGridCellWorker_IncRef, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellWorker_IncRef }};
// void IncRef( );
static int LUACALL wxLua_wxGridCellWorker_IncRef(lua_State *L)
{
// get this
wxGridCellWorker * self = (wxGridCellWorker *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellWorker);
// call IncRef
self->IncRef();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellWorker_SetParameters[] = { &wxluatype_wxGridCellWorker, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGridCellWorker_SetParameters(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellWorker_SetParameters[1] = {{ wxLua_wxGridCellWorker_SetParameters, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellWorker_SetParameters }};
// virtual void SetParameters(const wxString& params );
static int LUACALL wxLua_wxGridCellWorker_SetParameters(lua_State *L)
{
// const wxString params
const wxString params = wxlua_getwxStringtype(L, 2);
// get this
wxGridCellWorker * self = (wxGridCellWorker *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellWorker);
// call SetParameters
self->SetParameters(params);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellWorker_delete[] = { &wxluatype_wxGridCellWorker, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellWorker_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellWorker_delete }};
// %override wxLua_wxGridCellWorker_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellWorker_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellWorker>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellWorker_methods[] = {
{ "DecRef", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellWorker_DecRef, 1, NULL },
{ "IncRef", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellWorker_IncRef, 1, NULL },
{ "SetParameters", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellWorker_SetParameters, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellWorker_delete, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellWorker_methodCount = sizeof(wxGridCellWorker_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellRenderer
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellRenderer'
int wxluatype_wxGridCellRenderer = WXLUA_TUNKNOWN;
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxDC)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellRenderer_GetBestSize[] = { &wxluatype_wxGridCellRenderer, &wxluatype_wxGrid, &wxluatype_wxGridCellAttr, &wxluatype_wxDC, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellRenderer_GetBestSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellRenderer_GetBestSize[1] = {{ wxLua_wxGridCellRenderer_GetBestSize, WXLUAMETHOD_METHOD, 6, 6, s_wxluatypeArray_wxLua_wxGridCellRenderer_GetBestSize }};
// virtual wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, int row, int col );
static int LUACALL wxLua_wxGridCellRenderer_GetBestSize(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 6);
// int row
int row = (int)wxlua_getnumbertype(L, 5);
// wxDC dc
wxDC * dc = (wxDC *)wxluaT_getuserdatatype(L, 4, wxluatype_wxDC);
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 3, wxluatype_wxGridCellAttr);
// wxGrid grid
wxGrid * grid = (wxGrid *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGrid);
// get this
wxGridCellRenderer * self = (wxGridCellRenderer *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellRenderer);
// call GetBestSize
// allocate a new object using the copy constructor
wxSize* returns = new wxSize(self->GetBestSize(*grid, *attr, *dc, row, col));
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxSize);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxSize);
return 1;
}
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxDC)) && (wxLUA_USE_wxPointSizeRect)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellRenderer_delete[] = { &wxluatype_wxGridCellRenderer, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellRenderer_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellRenderer_delete }};
// %override wxLua_wxGridCellRenderer_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellRenderer_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellRenderer>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellRenderer_methods[] = {
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxDC)) && (wxLUA_USE_wxPointSizeRect)
{ "GetBestSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellRenderer_GetBestSize, 1, NULL },
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxDC)) && (wxLUA_USE_wxPointSizeRect)
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellRenderer_delete, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellRenderer_methodCount = sizeof(wxGridCellRenderer_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellStringRenderer
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellStringRenderer'
int wxluatype_wxGridCellStringRenderer = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellStringRenderer_delete[] = { &wxluatype_wxGridCellStringRenderer, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellStringRenderer_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellStringRenderer_delete }};
static int LUACALL wxLua_wxGridCellStringRenderer_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellStringRenderer_constructor[1] = {{ wxLua_wxGridCellStringRenderer_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxGridCellStringRenderer( );
static int LUACALL wxLua_wxGridCellStringRenderer_constructor(lua_State *L)
{
// call constructor
wxGridCellStringRenderer* returns = new wxGridCellStringRenderer();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellStringRenderer);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellStringRenderer);
return 1;
}
// %override wxLua_wxGridCellStringRenderer_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellStringRenderer_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellStringRenderer>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellStringRenderer_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellStringRenderer_delete, 1, NULL },
{ "wxGridCellStringRenderer", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellStringRenderer_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellStringRenderer_methodCount = sizeof(wxGridCellStringRenderer_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellNumberRenderer
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellNumberRenderer'
int wxluatype_wxGridCellNumberRenderer = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellNumberRenderer_delete[] = { &wxluatype_wxGridCellNumberRenderer, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellNumberRenderer_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellNumberRenderer_delete }};
static int LUACALL wxLua_wxGridCellNumberRenderer_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellNumberRenderer_constructor[1] = {{ wxLua_wxGridCellNumberRenderer_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxGridCellNumberRenderer( );
static int LUACALL wxLua_wxGridCellNumberRenderer_constructor(lua_State *L)
{
// call constructor
wxGridCellNumberRenderer* returns = new wxGridCellNumberRenderer();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellNumberRenderer);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellNumberRenderer);
return 1;
}
// %override wxLua_wxGridCellNumberRenderer_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellNumberRenderer_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellNumberRenderer>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellNumberRenderer_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellNumberRenderer_delete, 1, NULL },
{ "wxGridCellNumberRenderer", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellNumberRenderer_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellNumberRenderer_methodCount = sizeof(wxGridCellNumberRenderer_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellFloatRenderer
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellFloatRenderer'
int wxluatype_wxGridCellFloatRenderer = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_GetPrecision[] = { &wxluatype_wxGridCellFloatRenderer, NULL };
static int LUACALL wxLua_wxGridCellFloatRenderer_GetPrecision(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellFloatRenderer_GetPrecision[1] = {{ wxLua_wxGridCellFloatRenderer_GetPrecision, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_GetPrecision }};
// int GetPrecision() const;
static int LUACALL wxLua_wxGridCellFloatRenderer_GetPrecision(lua_State *L)
{
// get this
wxGridCellFloatRenderer * self = (wxGridCellFloatRenderer *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellFloatRenderer);
// call GetPrecision
int returns = (self->GetPrecision());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_GetWidth[] = { &wxluatype_wxGridCellFloatRenderer, NULL };
static int LUACALL wxLua_wxGridCellFloatRenderer_GetWidth(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellFloatRenderer_GetWidth[1] = {{ wxLua_wxGridCellFloatRenderer_GetWidth, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_GetWidth }};
// int GetWidth() const;
static int LUACALL wxLua_wxGridCellFloatRenderer_GetWidth(lua_State *L)
{
// get this
wxGridCellFloatRenderer * self = (wxGridCellFloatRenderer *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellFloatRenderer);
// call GetWidth
int returns = (self->GetWidth());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_SetPrecision[] = { &wxluatype_wxGridCellFloatRenderer, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellFloatRenderer_SetPrecision(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellFloatRenderer_SetPrecision[1] = {{ wxLua_wxGridCellFloatRenderer_SetPrecision, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_SetPrecision }};
// void SetPrecision(int precision );
static int LUACALL wxLua_wxGridCellFloatRenderer_SetPrecision(lua_State *L)
{
// int precision
int precision = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellFloatRenderer * self = (wxGridCellFloatRenderer *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellFloatRenderer);
// call SetPrecision
self->SetPrecision(precision);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_SetWidth[] = { &wxluatype_wxGridCellFloatRenderer, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellFloatRenderer_SetWidth(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellFloatRenderer_SetWidth[1] = {{ wxLua_wxGridCellFloatRenderer_SetWidth, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_SetWidth }};
// void SetWidth(int width );
static int LUACALL wxLua_wxGridCellFloatRenderer_SetWidth(lua_State *L)
{
// int width
int width = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellFloatRenderer * self = (wxGridCellFloatRenderer *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellFloatRenderer);
// call SetWidth
self->SetWidth(width);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_delete[] = { &wxluatype_wxGridCellFloatRenderer, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellFloatRenderer_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellFloatRenderer_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellFloatRenderer_constructor[1] = {{ wxLua_wxGridCellFloatRenderer_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 2, s_wxluatypeArray_wxLua_wxGridCellFloatRenderer_constructor }};
// wxGridCellFloatRenderer(int width = -1, int precision = -1 );
static int LUACALL wxLua_wxGridCellFloatRenderer_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int precision = -1
int precision = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : -1);
// int width = -1
int width = (argCount >= 1 ? (int)wxlua_getnumbertype(L, 1) : -1);
// call constructor
wxGridCellFloatRenderer* returns = new wxGridCellFloatRenderer(width, precision);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellFloatRenderer);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellFloatRenderer);
return 1;
}
// %override wxLua_wxGridCellFloatRenderer_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellFloatRenderer_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellFloatRenderer>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellFloatRenderer_methods[] = {
{ "GetPrecision", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellFloatRenderer_GetPrecision, 1, NULL },
{ "GetWidth", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellFloatRenderer_GetWidth, 1, NULL },
{ "SetPrecision", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellFloatRenderer_SetPrecision, 1, NULL },
{ "SetWidth", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellFloatRenderer_SetWidth, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellFloatRenderer_delete, 1, NULL },
{ "wxGridCellFloatRenderer", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellFloatRenderer_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellFloatRenderer_methodCount = sizeof(wxGridCellFloatRenderer_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellBoolRenderer
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellBoolRenderer'
int wxluatype_wxGridCellBoolRenderer = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellBoolRenderer_delete[] = { &wxluatype_wxGridCellBoolRenderer, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellBoolRenderer_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellBoolRenderer_delete }};
static int LUACALL wxLua_wxGridCellBoolRenderer_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellBoolRenderer_constructor[1] = {{ wxLua_wxGridCellBoolRenderer_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxGridCellBoolRenderer( );
static int LUACALL wxLua_wxGridCellBoolRenderer_constructor(lua_State *L)
{
// call constructor
wxGridCellBoolRenderer* returns = new wxGridCellBoolRenderer();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellBoolRenderer);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellBoolRenderer);
return 1;
}
// %override wxLua_wxGridCellBoolRenderer_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellBoolRenderer_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellBoolRenderer>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellBoolRenderer_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellBoolRenderer_delete, 1, NULL },
{ "wxGridCellBoolRenderer", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellBoolRenderer_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellBoolRenderer_methodCount = sizeof(wxGridCellBoolRenderer_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellDateTimeRenderer
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellDateTimeRenderer'
int wxluatype_wxGridCellDateTimeRenderer = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellDateTimeRenderer_delete[] = { &wxluatype_wxGridCellDateTimeRenderer, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellDateTimeRenderer_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellDateTimeRenderer_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellDateTimeRenderer_constructor[] = { &wxluatype_TSTRING, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGridCellDateTimeRenderer_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellDateTimeRenderer_constructor[1] = {{ wxLua_wxGridCellDateTimeRenderer_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 2, s_wxluatypeArray_wxLua_wxGridCellDateTimeRenderer_constructor }};
// wxGridCellDateTimeRenderer(const wxString& outformat = wxDefaultDateTimeFormat, const wxString& informat = wxDefaultDateTimeFormat );
static int LUACALL wxLua_wxGridCellDateTimeRenderer_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString informat = wxDefaultDateTimeFormat
const wxString informat = (argCount >= 2 ? wxlua_getwxStringtype(L, 2) : wxString(wxDefaultDateTimeFormat));
// const wxString outformat = wxDefaultDateTimeFormat
const wxString outformat = (argCount >= 1 ? wxlua_getwxStringtype(L, 1) : wxString(wxDefaultDateTimeFormat));
// call constructor
wxGridCellDateTimeRenderer* returns = new wxGridCellDateTimeRenderer(outformat, informat);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellDateTimeRenderer);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellDateTimeRenderer);
return 1;
}
// %override wxLua_wxGridCellDateTimeRenderer_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellDateTimeRenderer_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellDateTimeRenderer>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellDateTimeRenderer_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellDateTimeRenderer_delete, 1, NULL },
{ "wxGridCellDateTimeRenderer", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellDateTimeRenderer_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellDateTimeRenderer_methodCount = sizeof(wxGridCellDateTimeRenderer_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellEnumRenderer
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellEnumRenderer'
int wxluatype_wxGridCellEnumRenderer = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEnumRenderer_delete[] = { &wxluatype_wxGridCellEnumRenderer, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEnumRenderer_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellEnumRenderer_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEnumRenderer_constructor[] = { &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGridCellEnumRenderer_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEnumRenderer_constructor[1] = {{ wxLua_wxGridCellEnumRenderer_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 1, s_wxluatypeArray_wxLua_wxGridCellEnumRenderer_constructor }};
// wxGridCellEnumRenderer( const wxString& choices = "" );
static int LUACALL wxLua_wxGridCellEnumRenderer_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString choices = ""
const wxString choices = (argCount >= 1 ? wxlua_getwxStringtype(L, 1) : wxString(wxEmptyString));
// call constructor
wxGridCellEnumRenderer* returns = new wxGridCellEnumRenderer(choices);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellEnumRenderer);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellEnumRenderer);
return 1;
}
// %override wxLua_wxGridCellEnumRenderer_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellEnumRenderer_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellEnumRenderer>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellEnumRenderer_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellEnumRenderer_delete, 1, NULL },
{ "wxGridCellEnumRenderer", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellEnumRenderer_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellEnumRenderer_methodCount = sizeof(wxGridCellEnumRenderer_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellAutoWrapStringRenderer
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellAutoWrapStringRenderer'
int wxluatype_wxGridCellAutoWrapStringRenderer = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAutoWrapStringRenderer_delete[] = { &wxluatype_wxGridCellAutoWrapStringRenderer, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAutoWrapStringRenderer_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAutoWrapStringRenderer_delete }};
static int LUACALL wxLua_wxGridCellAutoWrapStringRenderer_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAutoWrapStringRenderer_constructor[1] = {{ wxLua_wxGridCellAutoWrapStringRenderer_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxGridCellAutoWrapStringRenderer( );
static int LUACALL wxLua_wxGridCellAutoWrapStringRenderer_constructor(lua_State *L)
{
// call constructor
wxGridCellAutoWrapStringRenderer* returns = new wxGridCellAutoWrapStringRenderer();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellAutoWrapStringRenderer);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellAutoWrapStringRenderer);
return 1;
}
// %override wxLua_wxGridCellAutoWrapStringRenderer_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellAutoWrapStringRenderer_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellAutoWrapStringRenderer>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellAutoWrapStringRenderer_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellAutoWrapStringRenderer_delete, 1, NULL },
{ "wxGridCellAutoWrapStringRenderer", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellAutoWrapStringRenderer_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellAutoWrapStringRenderer_methodCount = sizeof(wxGridCellAutoWrapStringRenderer_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellEditor
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellEditor'
int wxluatype_wxGridCellEditor = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_BeginEdit[] = { &wxluatype_wxGridCellEditor, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGridCellEditor_BeginEdit(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_BeginEdit[1] = {{ wxLua_wxGridCellEditor_BeginEdit, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridCellEditor_BeginEdit }};
// virtual void BeginEdit(int row, int col, wxGrid* grid );
static int LUACALL wxLua_wxGridCellEditor_BeginEdit(lua_State *L)
{
// wxGrid grid
wxGrid * grid = (wxGrid *)wxluaT_getuserdatatype(L, 4, wxluatype_wxGrid);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call BeginEdit
self->BeginEdit(row, col, grid);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_Destroy[] = { &wxluatype_wxGridCellEditor, NULL };
static int LUACALL wxLua_wxGridCellEditor_Destroy(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_Destroy[1] = {{ wxLua_wxGridCellEditor_Destroy, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellEditor_Destroy }};
// virtual void Destroy( );
static int LUACALL wxLua_wxGridCellEditor_Destroy(lua_State *L)
{
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call Destroy
self->Destroy();
return 0;
}
#if ((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_EndEdit1[] = { &wxluatype_wxGridCellEditor, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxGrid, &wxluatype_TSTRING, &wxluatype_TLIGHTUSERDATA, NULL };
static int LUACALL wxLua_wxGridCellEditor_EndEdit1(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_EndEdit1[1] = {{ wxLua_wxGridCellEditor_EndEdit1, WXLUAMETHOD_METHOD, 6, 6, s_wxluatypeArray_wxLua_wxGridCellEditor_EndEdit1 }};
// %wxchkver_2_9_2 virtual bool EndEdit(int row, int col, const wxGrid *grid, const wxString& oldval, wxString *newval );
static int LUACALL wxLua_wxGridCellEditor_EndEdit1(lua_State *L)
{
// wxString newval
wxString * newval = (wxString *)wxlua_touserdata(L, 6);
// const wxString oldval
const wxString oldval = wxlua_getwxStringtype(L, 5);
// const wxGrid grid
const wxGrid * grid = (const wxGrid *)wxluaT_getuserdatatype(L, 4, wxluatype_wxGrid);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call EndEdit
bool returns = (self->EndEdit(row, col, grid, oldval, newval));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // ((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if ((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_EndEdit[] = { &wxluatype_wxGridCellEditor, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGridCellEditor_EndEdit(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_EndEdit[1] = {{ wxLua_wxGridCellEditor_EndEdit, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridCellEditor_EndEdit }};
// !%wxchkver_2_9_2 virtual bool EndEdit(int row, int col, wxGrid* grid );
static int LUACALL wxLua_wxGridCellEditor_EndEdit(lua_State *L)
{
// wxGrid grid
wxGrid * grid = (wxGrid *)wxluaT_getuserdatatype(L, 4, wxluatype_wxGrid);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call EndEdit
bool returns = (self->EndEdit(row, col, grid));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // ((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_GetCellAttr[] = { &wxluatype_wxGridCellEditor, NULL };
static int LUACALL wxLua_wxGridCellEditor_GetCellAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_GetCellAttr[1] = {{ wxLua_wxGridCellEditor_GetCellAttr, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellEditor_GetCellAttr }};
// wxGridCellAttr* GetCellAttr( );
static int LUACALL wxLua_wxGridCellEditor_GetCellAttr(lua_State *L)
{
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call GetCellAttr
wxGridCellAttr* returns = (wxGridCellAttr*)self->GetCellAttr();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellAttr);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_GetControl[] = { &wxluatype_wxGridCellEditor, NULL };
static int LUACALL wxLua_wxGridCellEditor_GetControl(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_GetControl[1] = {{ wxLua_wxGridCellEditor_GetControl, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellEditor_GetControl }};
// wxControl* GetControl( );
static int LUACALL wxLua_wxGridCellEditor_GetControl(lua_State *L)
{
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call GetControl
wxControl* returns = (wxControl*)self->GetControl();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxControl);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_HandleReturn[] = { &wxluatype_wxGridCellEditor, &wxluatype_wxKeyEvent, NULL };
static int LUACALL wxLua_wxGridCellEditor_HandleReturn(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_HandleReturn[1] = {{ wxLua_wxGridCellEditor_HandleReturn, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellEditor_HandleReturn }};
// virtual void HandleReturn(wxKeyEvent& event );
static int LUACALL wxLua_wxGridCellEditor_HandleReturn(lua_State *L)
{
// wxKeyEvent event
wxKeyEvent * event = (wxKeyEvent *)wxluaT_getuserdatatype(L, 2, wxluatype_wxKeyEvent);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call HandleReturn
self->HandleReturn(*event);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_IsAcceptedKey[] = { &wxluatype_wxGridCellEditor, &wxluatype_wxKeyEvent, NULL };
static int LUACALL wxLua_wxGridCellEditor_IsAcceptedKey(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_IsAcceptedKey[1] = {{ wxLua_wxGridCellEditor_IsAcceptedKey, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellEditor_IsAcceptedKey }};
// virtual bool IsAcceptedKey(wxKeyEvent& event );
static int LUACALL wxLua_wxGridCellEditor_IsAcceptedKey(lua_State *L)
{
// wxKeyEvent event
wxKeyEvent * event = (wxKeyEvent *)wxluaT_getuserdatatype(L, 2, wxluatype_wxKeyEvent);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call IsAcceptedKey
bool returns = (self->IsAcceptedKey(*event));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_IsCreated[] = { &wxluatype_wxGridCellEditor, NULL };
static int LUACALL wxLua_wxGridCellEditor_IsCreated(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_IsCreated[1] = {{ wxLua_wxGridCellEditor_IsCreated, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellEditor_IsCreated }};
// bool IsCreated( );
static int LUACALL wxLua_wxGridCellEditor_IsCreated(lua_State *L)
{
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call IsCreated
bool returns = (self->IsCreated());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (((wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && ((wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))) && (wxLUA_USE_wxDC)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_PaintBackground1[] = { &wxluatype_wxGridCellEditor, &wxluatype_wxDC, &wxluatype_wxRect, &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellEditor_PaintBackground1(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_PaintBackground1[1] = {{ wxLua_wxGridCellEditor_PaintBackground1, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridCellEditor_PaintBackground1 }};
// %wxchkver_2_9_5 virtual void PaintBackground(wxDC& dc, const wxRect& rectCell, const wxGridCellAttr &attr );
static int LUACALL wxLua_wxGridCellEditor_PaintBackground1(lua_State *L)
{
// const wxGridCellAttr attr
const wxGridCellAttr * attr = (const wxGridCellAttr *)wxluaT_getuserdatatype(L, 4, wxluatype_wxGridCellAttr);
// const wxRect rectCell
const wxRect * rectCell = (const wxRect *)wxluaT_getuserdatatype(L, 3, wxluatype_wxRect);
// wxDC dc
wxDC * dc = (wxDC *)wxluaT_getuserdatatype(L, 2, wxluatype_wxDC);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call PaintBackground
self->PaintBackground(*dc, *rectCell, *attr);
return 0;
}
#endif // (((wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && ((wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))) && (wxLUA_USE_wxDC)
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && ((!wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_PaintBackground[] = { &wxluatype_wxGridCellEditor, &wxluatype_wxRect, &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellEditor_PaintBackground(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_PaintBackground[1] = {{ wxLua_wxGridCellEditor_PaintBackground, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridCellEditor_PaintBackground }};
// !%wxchkver_2_9_5 virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr );
static int LUACALL wxLua_wxGridCellEditor_PaintBackground(lua_State *L)
{
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 3, wxluatype_wxGridCellAttr);
// const wxRect rectCell
const wxRect * rectCell = (const wxRect *)wxluaT_getuserdatatype(L, 2, wxluatype_wxRect);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call PaintBackground
self->PaintBackground(*rectCell, attr);
return 0;
}
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && ((!wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_Reset[] = { &wxluatype_wxGridCellEditor, NULL };
static int LUACALL wxLua_wxGridCellEditor_Reset(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_Reset[1] = {{ wxLua_wxGridCellEditor_Reset, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellEditor_Reset }};
// virtual void Reset( );
static int LUACALL wxLua_wxGridCellEditor_Reset(lua_State *L)
{
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call Reset
self->Reset();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_SetCellAttr[] = { &wxluatype_wxGridCellEditor, &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellEditor_SetCellAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_SetCellAttr[1] = {{ wxLua_wxGridCellEditor_SetCellAttr, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellEditor_SetCellAttr }};
// void SetCellAttr(wxGridCellAttr* attr );
static int LUACALL wxLua_wxGridCellEditor_SetCellAttr(lua_State *L)
{
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellAttr);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call SetCellAttr
self->SetCellAttr(attr);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_SetControl[] = { &wxluatype_wxGridCellEditor, &wxluatype_wxControl, NULL };
static int LUACALL wxLua_wxGridCellEditor_SetControl(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_SetControl[1] = {{ wxLua_wxGridCellEditor_SetControl, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellEditor_SetControl }};
// void SetControl(%ungc wxControl* control );
static int LUACALL wxLua_wxGridCellEditor_SetControl(lua_State *L)
{
// wxControl control
wxControl * control = (wxControl *)wxluaT_getuserdatatype(L, 2, wxluatype_wxControl);
if (wxluaO_isgcobject(L, control)) wxluaO_undeletegcobject(L, control);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call SetControl
self->SetControl(control);
return 0;
}
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_SetSize[] = { &wxluatype_wxGridCellEditor, &wxluatype_wxRect, NULL };
static int LUACALL wxLua_wxGridCellEditor_SetSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_SetSize[1] = {{ wxLua_wxGridCellEditor_SetSize, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellEditor_SetSize }};
// virtual void SetSize(const wxRect& rect );
static int LUACALL wxLua_wxGridCellEditor_SetSize(lua_State *L)
{
// const wxRect rect
const wxRect * rect = (const wxRect *)wxluaT_getuserdatatype(L, 2, wxluatype_wxRect);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call SetSize
self->SetSize(*rect);
return 0;
}
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_Show[] = { &wxluatype_wxGridCellEditor, &wxluatype_TBOOLEAN, &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellEditor_Show(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_Show[1] = {{ wxLua_wxGridCellEditor_Show, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxGridCellEditor_Show }};
// virtual void Show(bool show, wxGridCellAttr *attr = NULL );
static int LUACALL wxLua_wxGridCellEditor_Show(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxGridCellAttr attr = NULL
wxGridCellAttr * attr = (argCount >= 3 ? (wxGridCellAttr *)wxluaT_getuserdatatype(L, 3, wxluatype_wxGridCellAttr) : NULL);
// bool show
bool show = wxlua_getbooleantype(L, 2);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call Show
self->Show(show, attr);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_StartingClick[] = { &wxluatype_wxGridCellEditor, NULL };
static int LUACALL wxLua_wxGridCellEditor_StartingClick(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_StartingClick[1] = {{ wxLua_wxGridCellEditor_StartingClick, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellEditor_StartingClick }};
// virtual void StartingClick( );
static int LUACALL wxLua_wxGridCellEditor_StartingClick(lua_State *L)
{
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call StartingClick
self->StartingClick();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_StartingKey[] = { &wxluatype_wxGridCellEditor, &wxluatype_wxKeyEvent, NULL };
static int LUACALL wxLua_wxGridCellEditor_StartingKey(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_StartingKey[1] = {{ wxLua_wxGridCellEditor_StartingKey, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellEditor_StartingKey }};
// virtual void StartingKey(wxKeyEvent& event );
static int LUACALL wxLua_wxGridCellEditor_StartingKey(lua_State *L)
{
// wxKeyEvent event
wxKeyEvent * event = (wxKeyEvent *)wxluaT_getuserdatatype(L, 2, wxluatype_wxKeyEvent);
// get this
wxGridCellEditor * self = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellEditor);
// call StartingKey
self->StartingKey(*event);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEditor_delete[] = { &wxluatype_wxGridCellEditor, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellEditor_delete }};
#if (((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID))||(((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID))
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_EndEdit_overload[] =
{
#if ((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ wxLua_wxGridCellEditor_EndEdit1, WXLUAMETHOD_METHOD, 6, 6, s_wxluatypeArray_wxLua_wxGridCellEditor_EndEdit1 },
#endif // ((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if ((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ wxLua_wxGridCellEditor_EndEdit, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridCellEditor_EndEdit },
#endif // ((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
};
static int s_wxluafunc_wxLua_wxGridCellEditor_EndEdit_overload_count = sizeof(s_wxluafunc_wxLua_wxGridCellEditor_EndEdit_overload)/sizeof(wxLuaBindCFunc);
#endif // (((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID))||(((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID))
#if ((((wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && ((wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))) && (wxLUA_USE_wxDC))||(((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && ((!wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID)))
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEditor_PaintBackground_overload[] =
{
#if (((wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && ((wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))) && (wxLUA_USE_wxDC)
{ wxLua_wxGridCellEditor_PaintBackground1, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridCellEditor_PaintBackground1 },
#endif // (((wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && ((wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))) && (wxLUA_USE_wxDC)
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && ((!wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))
{ wxLua_wxGridCellEditor_PaintBackground, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridCellEditor_PaintBackground },
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && ((!wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))
};
static int s_wxluafunc_wxLua_wxGridCellEditor_PaintBackground_overload_count = sizeof(s_wxluafunc_wxLua_wxGridCellEditor_PaintBackground_overload)/sizeof(wxLuaBindCFunc);
#endif // ((((wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && ((wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))) && (wxLUA_USE_wxDC))||(((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && ((!wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID)))
// %override wxLua_wxGridCellEditor_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellEditor_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellEditor>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellEditor_methods[] = {
{ "BeginEdit", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_BeginEdit, 1, NULL },
{ "Destroy", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_Destroy, 1, NULL },
#if (((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID))||(((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID))
{ "EndEdit", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_EndEdit_overload, s_wxluafunc_wxLua_wxGridCellEditor_EndEdit_overload_count, 0 },
#endif // (((wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID))||(((!wxCHECK_VERSION(2,9,2)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxGrid && wxUSE_GRID))
{ "GetCellAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_GetCellAttr, 1, NULL },
{ "GetControl", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_GetControl, 1, NULL },
{ "HandleReturn", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_HandleReturn, 1, NULL },
{ "IsAcceptedKey", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_IsAcceptedKey, 1, NULL },
{ "IsCreated", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_IsCreated, 1, NULL },
#if ((((wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && ((wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))) && (wxLUA_USE_wxDC))||(((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && ((!wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID)))
{ "PaintBackground", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_PaintBackground_overload, s_wxluafunc_wxLua_wxGridCellEditor_PaintBackground_overload_count, 0 },
#endif // ((((wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && ((wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID))) && (wxLUA_USE_wxDC))||(((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && ((!wxCHECK_VERSION(2,9,5)) && (wxLUA_USE_wxGrid && wxUSE_GRID)))
{ "Reset", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_Reset, 1, NULL },
{ "SetCellAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_SetCellAttr, 1, NULL },
{ "SetControl", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_SetControl, 1, NULL },
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_SetSize, 1, NULL },
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "Show", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_Show, 1, NULL },
{ "StartingClick", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_StartingClick, 1, NULL },
{ "StartingKey", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellEditor_StartingKey, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellEditor_delete, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellEditor_methodCount = sizeof(wxGridCellEditor_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellTextEditor
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellTextEditor'
int wxluatype_wxGridCellTextEditor = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellTextEditor_delete[] = { &wxluatype_wxGridCellTextEditor, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellTextEditor_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellTextEditor_delete }};
static int LUACALL wxLua_wxGridCellTextEditor_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellTextEditor_constructor[1] = {{ wxLua_wxGridCellTextEditor_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxGridCellTextEditor( );
static int LUACALL wxLua_wxGridCellTextEditor_constructor(lua_State *L)
{
// call constructor
wxGridCellTextEditor* returns = new wxGridCellTextEditor();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellTextEditor);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellTextEditor);
return 1;
}
// %override wxLua_wxGridCellTextEditor_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellTextEditor_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellTextEditor>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellTextEditor_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellTextEditor_delete, 1, NULL },
{ "wxGridCellTextEditor", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellTextEditor_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellTextEditor_methodCount = sizeof(wxGridCellTextEditor_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellNumberEditor
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellNumberEditor'
int wxluatype_wxGridCellNumberEditor = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellNumberEditor_delete[] = { &wxluatype_wxGridCellNumberEditor, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellNumberEditor_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellNumberEditor_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellNumberEditor_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellNumberEditor_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellNumberEditor_constructor[1] = {{ wxLua_wxGridCellNumberEditor_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 2, s_wxluatypeArray_wxLua_wxGridCellNumberEditor_constructor }};
// wxGridCellNumberEditor(int min = -1, int max = -1 );
static int LUACALL wxLua_wxGridCellNumberEditor_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int max = -1
int max = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : -1);
// int min = -1
int min = (argCount >= 1 ? (int)wxlua_getnumbertype(L, 1) : -1);
// call constructor
wxGridCellNumberEditor* returns = new wxGridCellNumberEditor(min, max);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellNumberEditor);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellNumberEditor);
return 1;
}
// %override wxLua_wxGridCellNumberEditor_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellNumberEditor_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellNumberEditor>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellNumberEditor_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellNumberEditor_delete, 1, NULL },
{ "wxGridCellNumberEditor", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellNumberEditor_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellNumberEditor_methodCount = sizeof(wxGridCellNumberEditor_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellFloatEditor
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellFloatEditor'
int wxluatype_wxGridCellFloatEditor = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellFloatEditor_delete[] = { &wxluatype_wxGridCellFloatEditor, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellFloatEditor_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellFloatEditor_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellFloatEditor_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellFloatEditor_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellFloatEditor_constructor[1] = {{ wxLua_wxGridCellFloatEditor_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 2, s_wxluatypeArray_wxLua_wxGridCellFloatEditor_constructor }};
// wxGridCellFloatEditor(int width = -1, int precision = -1 );
static int LUACALL wxLua_wxGridCellFloatEditor_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int precision = -1
int precision = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : -1);
// int width = -1
int width = (argCount >= 1 ? (int)wxlua_getnumbertype(L, 1) : -1);
// call constructor
wxGridCellFloatEditor* returns = new wxGridCellFloatEditor(width, precision);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellFloatEditor);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellFloatEditor);
return 1;
}
// %override wxLua_wxGridCellFloatEditor_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellFloatEditor_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellFloatEditor>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellFloatEditor_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellFloatEditor_delete, 1, NULL },
{ "wxGridCellFloatEditor", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellFloatEditor_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellFloatEditor_methodCount = sizeof(wxGridCellFloatEditor_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellBoolEditor
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellBoolEditor'
int wxluatype_wxGridCellBoolEditor = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellBoolEditor_delete[] = { &wxluatype_wxGridCellBoolEditor, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellBoolEditor_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellBoolEditor_delete }};
static int LUACALL wxLua_wxGridCellBoolEditor_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellBoolEditor_constructor[1] = {{ wxLua_wxGridCellBoolEditor_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxGridCellBoolEditor( );
static int LUACALL wxLua_wxGridCellBoolEditor_constructor(lua_State *L)
{
// call constructor
wxGridCellBoolEditor* returns = new wxGridCellBoolEditor();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellBoolEditor);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellBoolEditor);
return 1;
}
// %override wxLua_wxGridCellBoolEditor_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellBoolEditor_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellBoolEditor>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellBoolEditor_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellBoolEditor_delete, 1, NULL },
{ "wxGridCellBoolEditor", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellBoolEditor_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellBoolEditor_methodCount = sizeof(wxGridCellBoolEditor_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellChoiceEditor
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellChoiceEditor'
int wxluatype_wxGridCellChoiceEditor = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellChoiceEditor_delete[] = { &wxluatype_wxGridCellChoiceEditor, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellChoiceEditor_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellChoiceEditor_delete }};
#if (wxLUA_USE_wxArrayString) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellChoiceEditor_constructor[] = { &wxluatype_wxArrayString, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGridCellChoiceEditor_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellChoiceEditor_constructor[1] = {{ wxLua_wxGridCellChoiceEditor_constructor, WXLUAMETHOD_CONSTRUCTOR, 1, 2, s_wxluatypeArray_wxLua_wxGridCellChoiceEditor_constructor }};
// wxGridCellChoiceEditor(const wxArrayString& choices, bool allowOthers = false );
static int LUACALL wxLua_wxGridCellChoiceEditor_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool allowOthers = false
bool allowOthers = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : false);
// const wxArrayString choices
wxLuaSmartwxArrayString choices = wxlua_getwxArrayString(L, 1);
// call constructor
wxGridCellChoiceEditor* returns = new wxGridCellChoiceEditor(choices, allowOthers);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellChoiceEditor);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellChoiceEditor);
return 1;
}
#endif // (wxLUA_USE_wxArrayString) && (wxLUA_USE_wxGrid && wxUSE_GRID)
// %override wxLua_wxGridCellChoiceEditor_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellChoiceEditor_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellChoiceEditor>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellChoiceEditor_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellChoiceEditor_delete, 1, NULL },
#if (wxLUA_USE_wxArrayString) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "wxGridCellChoiceEditor", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellChoiceEditor_constructor, 1, NULL },
#endif // (wxLUA_USE_wxArrayString) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ 0, 0, 0, 0 },
};
int wxGridCellChoiceEditor_methodCount = sizeof(wxGridCellChoiceEditor_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellEnumEditor
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellEnumEditor'
int wxluatype_wxGridCellEnumEditor = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEnumEditor_delete[] = { &wxluatype_wxGridCellEnumEditor, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEnumEditor_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellEnumEditor_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellEnumEditor_constructor[] = { &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGridCellEnumEditor_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellEnumEditor_constructor[1] = {{ wxLua_wxGridCellEnumEditor_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 1, s_wxluatypeArray_wxLua_wxGridCellEnumEditor_constructor }};
// wxGridCellEnumEditor( const wxString& choices = "" );
static int LUACALL wxLua_wxGridCellEnumEditor_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString choices = ""
const wxString choices = (argCount >= 1 ? wxlua_getwxStringtype(L, 1) : wxString(wxEmptyString));
// call constructor
wxGridCellEnumEditor* returns = new wxGridCellEnumEditor(choices);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellEnumEditor);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellEnumEditor);
return 1;
}
// %override wxLua_wxGridCellEnumEditor_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellEnumEditor_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellEnumEditor>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellEnumEditor_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellEnumEditor_delete, 1, NULL },
{ "wxGridCellEnumEditor", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellEnumEditor_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellEnumEditor_methodCount = sizeof(wxGridCellEnumEditor_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellAutoWrapStringEditor
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellAutoWrapStringEditor'
int wxluatype_wxGridCellAutoWrapStringEditor = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAutoWrapStringEditor_delete[] = { &wxluatype_wxGridCellAutoWrapStringEditor, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAutoWrapStringEditor_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAutoWrapStringEditor_delete }};
static int LUACALL wxLua_wxGridCellAutoWrapStringEditor_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAutoWrapStringEditor_constructor[1] = {{ wxLua_wxGridCellAutoWrapStringEditor_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxGridCellAutoWrapStringEditor( );
static int LUACALL wxLua_wxGridCellAutoWrapStringEditor_constructor(lua_State *L)
{
// call constructor
wxGridCellAutoWrapStringEditor* returns = new wxGridCellAutoWrapStringEditor();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellAutoWrapStringEditor);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellAutoWrapStringEditor);
return 1;
}
// %override wxLua_wxGridCellAutoWrapStringEditor_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellAutoWrapStringEditor_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellAutoWrapStringEditor>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellAutoWrapStringEditor_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellAutoWrapStringEditor_delete, 1, NULL },
{ "wxGridCellAutoWrapStringEditor", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellAutoWrapStringEditor_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellAutoWrapStringEditor_methodCount = sizeof(wxGridCellAutoWrapStringEditor_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellAttr
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellAttr'
int wxluatype_wxGridCellAttr = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_DecRef[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_DecRef(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_DecRef[1] = {{ wxLua_wxGridCellAttr_DecRef, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_DecRef }};
// void DecRef( );
static int LUACALL wxLua_wxGridCellAttr_DecRef(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call DecRef
self->DecRef();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_GetAlignment[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_GetAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_GetAlignment[1] = {{ wxLua_wxGridCellAttr_GetAlignment, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_GetAlignment }};
// %override wxLua_wxGridCellAttr_GetAlignment
// void GetAlignment(int *horz, int *vert) const
static int LUACALL wxLua_wxGridCellAttr_GetAlignment(lua_State *L)
{
int horz;
int vert;
// get this
wxGridCellAttr *self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call GetAlignment
self->GetAlignment(&horz, &vert);
lua_pushnumber(L, horz);
lua_pushnumber(L, vert);
// return the number of parameters
return 2;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_GetBackgroundColour[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_GetBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_GetBackgroundColour[1] = {{ wxLua_wxGridCellAttr_GetBackgroundColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_GetBackgroundColour }};
// wxColour GetBackgroundColour() const;
static int LUACALL wxLua_wxGridCellAttr_GetBackgroundColour(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call GetBackgroundColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetBackgroundColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_GetEditor[] = { &wxluatype_wxGridCellAttr, &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellAttr_GetEditor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_GetEditor[1] = {{ wxLua_wxGridCellAttr_GetEditor, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridCellAttr_GetEditor }};
// %gc wxGridCellEditor *GetEditor(wxGrid* grid, int row, int col) const;
static int LUACALL wxLua_wxGridCellAttr_GetEditor(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 4);
// int row
int row = (int)wxlua_getnumbertype(L, 3);
// wxGrid grid
wxGrid * grid = (wxGrid *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGrid);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call GetEditor
wxGridCellEditor* returns = (wxGridCellEditor*)self->GetEditor(grid, row, col);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellEditor);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellEditor);
return 1;
}
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_GetFont[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_GetFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_GetFont[1] = {{ wxLua_wxGridCellAttr_GetFont, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_GetFont }};
// wxFont GetFont() const;
static int LUACALL wxLua_wxGridCellAttr_GetFont(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call GetFont
// allocate a new object using the copy constructor
wxFont* returns = new wxFont(self->GetFont());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxFont);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxFont);
return 1;
}
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_GetKind[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_GetKind(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_GetKind[1] = {{ wxLua_wxGridCellAttr_GetKind, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_GetKind }};
// wxGridCellAttr::wxAttrKind GetKind( );
static int LUACALL wxLua_wxGridCellAttr_GetKind(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call GetKind
wxGridCellAttr::wxAttrKind returns = (self->GetKind());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_GetOverflow[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_GetOverflow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_GetOverflow[1] = {{ wxLua_wxGridCellAttr_GetOverflow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_GetOverflow }};
// bool GetOverflow() const;
static int LUACALL wxLua_wxGridCellAttr_GetOverflow(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call GetOverflow
bool returns = (self->GetOverflow());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_GetRenderer[] = { &wxluatype_wxGridCellAttr, &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellAttr_GetRenderer(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_GetRenderer[1] = {{ wxLua_wxGridCellAttr_GetRenderer, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridCellAttr_GetRenderer }};
// %gc wxGridCellRenderer *GetRenderer(wxGrid* grid, int row, int col) const;
static int LUACALL wxLua_wxGridCellAttr_GetRenderer(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 4);
// int row
int row = (int)wxlua_getnumbertype(L, 3);
// wxGrid grid
wxGrid * grid = (wxGrid *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGrid);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call GetRenderer
wxGridCellRenderer* returns = (wxGridCellRenderer*)self->GetRenderer(grid, row, col);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellRenderer);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellRenderer);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_GetSize[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_GetSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_GetSize[1] = {{ wxLua_wxGridCellAttr_GetSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_GetSize }};
// %override wxLua_wxGridCellAttr_GetSize
// void GetSize(int *num_rows, int *num_cols) const
static int LUACALL wxLua_wxGridCellAttr_GetSize(lua_State *L)
{
int num_rows;
int num_cols;
// get this
wxGridCellAttr *self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call GetSize
self->GetSize(&num_rows, &num_cols);
lua_pushnumber(L, num_rows);
lua_pushnumber(L, num_cols);
// return the number of parameters
return 2;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_GetTextColour[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_GetTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_GetTextColour[1] = {{ wxLua_wxGridCellAttr_GetTextColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_GetTextColour }};
// wxColour GetTextColour() const;
static int LUACALL wxLua_wxGridCellAttr_GetTextColour(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call GetTextColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetTextColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_HasAlignment[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_HasAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_HasAlignment[1] = {{ wxLua_wxGridCellAttr_HasAlignment, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_HasAlignment }};
// bool HasAlignment() const;
static int LUACALL wxLua_wxGridCellAttr_HasAlignment(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call HasAlignment
bool returns = (self->HasAlignment());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_HasBackgroundColour[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_HasBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_HasBackgroundColour[1] = {{ wxLua_wxGridCellAttr_HasBackgroundColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_HasBackgroundColour }};
// bool HasBackgroundColour() const;
static int LUACALL wxLua_wxGridCellAttr_HasBackgroundColour(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call HasBackgroundColour
bool returns = (self->HasBackgroundColour());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_HasEditor[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_HasEditor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_HasEditor[1] = {{ wxLua_wxGridCellAttr_HasEditor, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_HasEditor }};
// bool HasEditor() const;
static int LUACALL wxLua_wxGridCellAttr_HasEditor(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call HasEditor
bool returns = (self->HasEditor());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_HasFont[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_HasFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_HasFont[1] = {{ wxLua_wxGridCellAttr_HasFont, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_HasFont }};
// bool HasFont() const;
static int LUACALL wxLua_wxGridCellAttr_HasFont(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call HasFont
bool returns = (self->HasFont());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_HasOverflowMode[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_HasOverflowMode(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_HasOverflowMode[1] = {{ wxLua_wxGridCellAttr_HasOverflowMode, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_HasOverflowMode }};
// bool HasOverflowMode() const;
static int LUACALL wxLua_wxGridCellAttr_HasOverflowMode(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call HasOverflowMode
bool returns = (self->HasOverflowMode());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_HasReadWriteMode[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_HasReadWriteMode(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_HasReadWriteMode[1] = {{ wxLua_wxGridCellAttr_HasReadWriteMode, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_HasReadWriteMode }};
// bool HasReadWriteMode() const;
static int LUACALL wxLua_wxGridCellAttr_HasReadWriteMode(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call HasReadWriteMode
bool returns = (self->HasReadWriteMode());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_HasRenderer[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_HasRenderer(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_HasRenderer[1] = {{ wxLua_wxGridCellAttr_HasRenderer, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_HasRenderer }};
// bool HasRenderer() const;
static int LUACALL wxLua_wxGridCellAttr_HasRenderer(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call HasRenderer
bool returns = (self->HasRenderer());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_HasSize[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_HasSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_HasSize[1] = {{ wxLua_wxGridCellAttr_HasSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_HasSize }};
// bool HasSize() const;
static int LUACALL wxLua_wxGridCellAttr_HasSize(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call HasSize
bool returns = (self->HasSize());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_HasTextColour[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_HasTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_HasTextColour[1] = {{ wxLua_wxGridCellAttr_HasTextColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_HasTextColour }};
// bool HasTextColour() const;
static int LUACALL wxLua_wxGridCellAttr_HasTextColour(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call HasTextColour
bool returns = (self->HasTextColour());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_IncRef[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_IncRef(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_IncRef[1] = {{ wxLua_wxGridCellAttr_IncRef, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_IncRef }};
// void IncRef( );
static int LUACALL wxLua_wxGridCellAttr_IncRef(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call IncRef
self->IncRef();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_IsReadOnly[] = { &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_IsReadOnly(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_IsReadOnly[1] = {{ wxLua_wxGridCellAttr_IsReadOnly, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_IsReadOnly }};
// bool IsReadOnly() const;
static int LUACALL wxLua_wxGridCellAttr_IsReadOnly(lua_State *L)
{
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call IsReadOnly
bool returns = (self->IsReadOnly());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_MergeWith[] = { &wxluatype_wxGridCellAttr, &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_MergeWith(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_MergeWith[1] = {{ wxLua_wxGridCellAttr_MergeWith, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellAttr_MergeWith }};
// void MergeWith(wxGridCellAttr *mergefrom );
static int LUACALL wxLua_wxGridCellAttr_MergeWith(lua_State *L)
{
// wxGridCellAttr mergefrom
wxGridCellAttr * mergefrom = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellAttr);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call MergeWith
self->MergeWith(mergefrom);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetAlignment[] = { &wxluatype_wxGridCellAttr, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetAlignment[1] = {{ wxLua_wxGridCellAttr_SetAlignment, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridCellAttr_SetAlignment }};
// void SetAlignment(int hAlign, int vAlign );
static int LUACALL wxLua_wxGridCellAttr_SetAlignment(lua_State *L)
{
// int vAlign
int vAlign = (int)wxlua_getnumbertype(L, 3);
// int hAlign
int hAlign = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetAlignment
self->SetAlignment(hAlign, vAlign);
return 0;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetBackgroundColour[] = { &wxluatype_wxGridCellAttr, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetBackgroundColour[1] = {{ wxLua_wxGridCellAttr_SetBackgroundColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellAttr_SetBackgroundColour }};
// void SetBackgroundColour(const wxColour& colBack );
static int LUACALL wxLua_wxGridCellAttr_SetBackgroundColour(lua_State *L)
{
// const wxColour colBack
const wxColour * colBack = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetBackgroundColour
self->SetBackgroundColour(*colBack);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetDefAttr[] = { &wxluatype_wxGridCellAttr, &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetDefAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetDefAttr[1] = {{ wxLua_wxGridCellAttr_SetDefAttr, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellAttr_SetDefAttr }};
// void SetDefAttr(wxGridCellAttr* defAttr );
static int LUACALL wxLua_wxGridCellAttr_SetDefAttr(lua_State *L)
{
// wxGridCellAttr defAttr
wxGridCellAttr * defAttr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellAttr);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetDefAttr
self->SetDefAttr(defAttr);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetEditor[] = { &wxluatype_wxGridCellAttr, &wxluatype_wxGridCellEditor, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetEditor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetEditor[1] = {{ wxLua_wxGridCellAttr_SetEditor, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellAttr_SetEditor }};
// void SetEditor(%IncRef wxGridCellEditor* editor );
static int LUACALL wxLua_wxGridCellAttr_SetEditor(lua_State *L)
{
// wxGridCellEditor editor
wxGridCellEditor * editor = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellEditor);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
editor->IncRef();
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetEditor
self->SetEditor(editor);
return 0;
}
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetFont[] = { &wxluatype_wxGridCellAttr, &wxluatype_wxFont, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetFont[1] = {{ wxLua_wxGridCellAttr_SetFont, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellAttr_SetFont }};
// void SetFont(const wxFont& font );
static int LUACALL wxLua_wxGridCellAttr_SetFont(lua_State *L)
{
// const wxFont font
const wxFont * font = (const wxFont *)wxluaT_getuserdatatype(L, 2, wxluatype_wxFont);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetFont
self->SetFont(*font);
return 0;
}
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetKind[] = { &wxluatype_wxGridCellAttr, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetKind(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetKind[1] = {{ wxLua_wxGridCellAttr_SetKind, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellAttr_SetKind }};
// void SetKind(wxGridCellAttr::wxAttrKind kind );
static int LUACALL wxLua_wxGridCellAttr_SetKind(lua_State *L)
{
// wxGridCellAttr::wxAttrKind kind
wxGridCellAttr::wxAttrKind kind = (wxGridCellAttr::wxAttrKind)wxlua_getenumtype(L, 2);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetKind
self->SetKind(kind);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetOverflow[] = { &wxluatype_wxGridCellAttr, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetOverflow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetOverflow[1] = {{ wxLua_wxGridCellAttr_SetOverflow, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGridCellAttr_SetOverflow }};
// void SetOverflow(bool allow = true );
static int LUACALL wxLua_wxGridCellAttr_SetOverflow(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool allow = true
bool allow = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetOverflow
self->SetOverflow(allow);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetReadOnly[] = { &wxluatype_wxGridCellAttr, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetReadOnly(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetReadOnly[1] = {{ wxLua_wxGridCellAttr_SetReadOnly, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGridCellAttr_SetReadOnly }};
// void SetReadOnly(bool isReadOnly = true );
static int LUACALL wxLua_wxGridCellAttr_SetReadOnly(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool isReadOnly = true
bool isReadOnly = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetReadOnly
self->SetReadOnly(isReadOnly);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetRenderer[] = { &wxluatype_wxGridCellAttr, &wxluatype_wxGridCellRenderer, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetRenderer(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetRenderer[1] = {{ wxLua_wxGridCellAttr_SetRenderer, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellAttr_SetRenderer }};
// void SetRenderer(%IncRef wxGridCellRenderer *renderer );
static int LUACALL wxLua_wxGridCellAttr_SetRenderer(lua_State *L)
{
// wxGridCellRenderer renderer
wxGridCellRenderer * renderer = (wxGridCellRenderer *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellRenderer);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
renderer->IncRef();
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetRenderer
self->SetRenderer(renderer);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetSize[] = { &wxluatype_wxGridCellAttr, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetSize[1] = {{ wxLua_wxGridCellAttr_SetSize, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridCellAttr_SetSize }};
// void SetSize(int num_rows, int num_cols );
static int LUACALL wxLua_wxGridCellAttr_SetSize(lua_State *L)
{
// int num_cols
int num_cols = (int)wxlua_getnumbertype(L, 3);
// int num_rows
int num_rows = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetSize
self->SetSize(num_rows, num_cols);
return 0;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_SetTextColour[] = { &wxluatype_wxGridCellAttr, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGridCellAttr_SetTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_SetTextColour[1] = {{ wxLua_wxGridCellAttr_SetTextColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellAttr_SetTextColour }};
// void SetTextColour(const wxColour& colText );
static int LUACALL wxLua_wxGridCellAttr_SetTextColour(lua_State *L)
{
// const wxColour colText
const wxColour * colText = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxGridCellAttr * self = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttr);
// call SetTextColour
self->SetTextColour(*colText);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_delete[] = { &wxluatype_wxGridCellAttr, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttr_delete }};
#if ((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxFont)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttr_constructor1[] = { &wxluatype_wxColour, &wxluatype_wxColour, &wxluatype_wxFont, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellAttr_constructor1(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_constructor1[1] = {{ wxLua_wxGridCellAttr_constructor1, WXLUAMETHOD_CONSTRUCTOR, 5, 5, s_wxluatypeArray_wxLua_wxGridCellAttr_constructor1 }};
// wxGridCellAttr(const wxColour& colText, const wxColour& colBack, const wxFont& font, int hAlign, int vAlign );
static int LUACALL wxLua_wxGridCellAttr_constructor1(lua_State *L)
{
// int vAlign
int vAlign = (int)wxlua_getnumbertype(L, 5);
// int hAlign
int hAlign = (int)wxlua_getnumbertype(L, 4);
// const wxFont font
const wxFont * font = (const wxFont *)wxluaT_getuserdatatype(L, 3, wxluatype_wxFont);
// const wxColour colBack
const wxColour * colBack = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// const wxColour colText
const wxColour * colText = (const wxColour *)wxluaT_getuserdatatype(L, 1, wxluatype_wxColour);
// call constructor
wxGridCellAttr* returns = new wxGridCellAttr(*colText, *colBack, *font, hAlign, vAlign);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellAttr);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellAttr);
return 1;
}
#endif // ((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxFont)
static int LUACALL wxLua_wxGridCellAttr_constructor(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_constructor[1] = {{ wxLua_wxGridCellAttr_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxGridCellAttr( );
static int LUACALL wxLua_wxGridCellAttr_constructor(lua_State *L)
{
// call constructor
wxGridCellAttr* returns = new wxGridCellAttr();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellAttr);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellAttr);
return 1;
}
#if (((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxFont))||(wxLUA_USE_wxGrid && wxUSE_GRID)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttr_constructor_overload[] =
{
#if ((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxFont)
{ wxLua_wxGridCellAttr_constructor1, WXLUAMETHOD_CONSTRUCTOR, 5, 5, s_wxluatypeArray_wxLua_wxGridCellAttr_constructor1 },
#endif // ((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxFont)
{ wxLua_wxGridCellAttr_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxGridCellAttr_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxGridCellAttr_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // (((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxFont))||(wxLUA_USE_wxGrid && wxUSE_GRID)
// %override wxLua_wxGridCellAttr_delete_function
// delete is private in wxGridCellWorker, DecRef() it in derived classes
void wxLua_wxGridCellAttr_delete_function(void** p)
{
wxLua_wxGrid_DecRef_delete_function<wxGridCellAttr>(p);
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellAttr_methods[] = {
{ "DecRef", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_DecRef, 1, NULL },
{ "GetAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_GetAlignment, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_GetBackgroundColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetEditor", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_GetEditor, 1, NULL },
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_GetFont, 1, NULL },
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetKind", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_GetKind, 1, NULL },
{ "GetOverflow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_GetOverflow, 1, NULL },
{ "GetRenderer", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_GetRenderer, 1, NULL },
{ "GetSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_GetSize, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_GetTextColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "HasAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_HasAlignment, 1, NULL },
{ "HasBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_HasBackgroundColour, 1, NULL },
{ "HasEditor", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_HasEditor, 1, NULL },
{ "HasFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_HasFont, 1, NULL },
{ "HasOverflowMode", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_HasOverflowMode, 1, NULL },
{ "HasReadWriteMode", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_HasReadWriteMode, 1, NULL },
{ "HasRenderer", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_HasRenderer, 1, NULL },
{ "HasSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_HasSize, 1, NULL },
{ "HasTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_HasTextColour, 1, NULL },
{ "IncRef", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_IncRef, 1, NULL },
{ "IsReadOnly", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_IsReadOnly, 1, NULL },
{ "MergeWith", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_MergeWith, 1, NULL },
{ "SetAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetAlignment, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetBackgroundColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetDefAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetDefAttr, 1, NULL },
{ "SetEditor", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetEditor, 1, NULL },
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetFont, 1, NULL },
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetKind", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetKind, 1, NULL },
{ "SetOverflow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetOverflow, 1, NULL },
{ "SetReadOnly", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetReadOnly, 1, NULL },
{ "SetRenderer", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetRenderer, 1, NULL },
{ "SetSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetSize, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttr_SetTextColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellAttr_delete, 1, NULL },
#if (((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxFont))||(wxLUA_USE_wxGrid && wxUSE_GRID)
{ "wxGridCellAttr", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellAttr_constructor_overload, s_wxluafunc_wxLua_wxGridCellAttr_constructor_overload_count, 0 },
#endif // (((wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxFont))||(wxLUA_USE_wxGrid && wxUSE_GRID)
{ 0, 0, 0, 0 },
};
int wxGridCellAttr_methodCount = sizeof(wxGridCellAttr_methods)/sizeof(wxLuaBindMethod) - 1;
wxLuaBindNumber wxGridCellAttr_enums[] = {
#if wxLUA_USE_wxGrid && wxUSE_GRID
{ "Any", wxGridCellAttr::Any },
{ "Cell", wxGridCellAttr::Cell },
{ "Col", wxGridCellAttr::Col },
{ "Default", wxGridCellAttr::Default },
{ "Merged", wxGridCellAttr::Merged },
{ "Row", wxGridCellAttr::Row },
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
{ NULL, 0, },
};
int wxGridCellAttr_enumCount = sizeof(wxGridCellAttr_enums)/sizeof(wxLuaBindNumber) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellAttrProvider
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellAttrProvider'
int wxluatype_wxGridCellAttrProvider = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttrProvider_GetAttr[] = { &wxluatype_wxGridCellAttrProvider, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridCellAttrProvider_GetAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttrProvider_GetAttr[1] = {{ wxLua_wxGridCellAttrProvider_GetAttr, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridCellAttrProvider_GetAttr }};
// %gc wxGridCellAttr *GetAttr(int row, int col, wxGridCellAttr::wxAttrKind kind) const;
static int LUACALL wxLua_wxGridCellAttrProvider_GetAttr(lua_State *L)
{
// wxGridCellAttr::wxAttrKind kind
wxGridCellAttr::wxAttrKind kind = (wxGridCellAttr::wxAttrKind)wxlua_getenumtype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellAttrProvider * self = (wxGridCellAttrProvider *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttrProvider);
// call GetAttr
wxGridCellAttr* returns = (wxGridCellAttr*)self->GetAttr(row, col, kind);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellAttr);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellAttr);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttrProvider_SetAttr[] = { &wxluatype_wxGridCellAttrProvider, &wxluatype_wxGridCellAttr, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellAttrProvider_SetAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttrProvider_SetAttr[1] = {{ wxLua_wxGridCellAttrProvider_SetAttr, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridCellAttrProvider_SetAttr }};
// void SetAttr(%IncRef wxGridCellAttr *attr, int row, int col );
static int LUACALL wxLua_wxGridCellAttrProvider_SetAttr(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 4);
// int row
int row = (int)wxlua_getnumbertype(L, 3);
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellAttr);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
attr->IncRef();
// get this
wxGridCellAttrProvider * self = (wxGridCellAttrProvider *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttrProvider);
// call SetAttr
self->SetAttr(attr, row, col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttrProvider_SetColAttr[] = { &wxluatype_wxGridCellAttrProvider, &wxluatype_wxGridCellAttr, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellAttrProvider_SetColAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttrProvider_SetColAttr[1] = {{ wxLua_wxGridCellAttrProvider_SetColAttr, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridCellAttrProvider_SetColAttr }};
// void SetColAttr(%IncRef wxGridCellAttr *attr, int col );
static int LUACALL wxLua_wxGridCellAttrProvider_SetColAttr(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellAttr);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
attr->IncRef();
// get this
wxGridCellAttrProvider * self = (wxGridCellAttrProvider *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttrProvider);
// call SetColAttr
self->SetColAttr(attr, col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttrProvider_SetRowAttr[] = { &wxluatype_wxGridCellAttrProvider, &wxluatype_wxGridCellAttr, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellAttrProvider_SetRowAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttrProvider_SetRowAttr[1] = {{ wxLua_wxGridCellAttrProvider_SetRowAttr, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridCellAttrProvider_SetRowAttr }};
// void SetRowAttr(%IncRef wxGridCellAttr *attr, int row );
static int LUACALL wxLua_wxGridCellAttrProvider_SetRowAttr(lua_State *L)
{
// int row
int row = (int)wxlua_getnumbertype(L, 3);
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellAttr);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
attr->IncRef();
// get this
wxGridCellAttrProvider * self = (wxGridCellAttrProvider *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttrProvider);
// call SetRowAttr
self->SetRowAttr(attr, row);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttrProvider_UpdateAttrCols[] = { &wxluatype_wxGridCellAttrProvider, &wxluatype_TINTEGER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellAttrProvider_UpdateAttrCols(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttrProvider_UpdateAttrCols[1] = {{ wxLua_wxGridCellAttrProvider_UpdateAttrCols, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridCellAttrProvider_UpdateAttrCols }};
// void UpdateAttrCols( size_t pos, int numCols );
static int LUACALL wxLua_wxGridCellAttrProvider_UpdateAttrCols(lua_State *L)
{
// int numCols
int numCols = (int)wxlua_getnumbertype(L, 3);
// size_t pos
size_t pos = (size_t)wxlua_getuintegertype(L, 2);
// get this
wxGridCellAttrProvider * self = (wxGridCellAttrProvider *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttrProvider);
// call UpdateAttrCols
self->UpdateAttrCols(pos, numCols);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttrProvider_UpdateAttrRows[] = { &wxluatype_wxGridCellAttrProvider, &wxluatype_TINTEGER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellAttrProvider_UpdateAttrRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttrProvider_UpdateAttrRows[1] = {{ wxLua_wxGridCellAttrProvider_UpdateAttrRows, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridCellAttrProvider_UpdateAttrRows }};
// void UpdateAttrRows( size_t pos, int numRows );
static int LUACALL wxLua_wxGridCellAttrProvider_UpdateAttrRows(lua_State *L)
{
// int numRows
int numRows = (int)wxlua_getnumbertype(L, 3);
// size_t pos
size_t pos = (size_t)wxlua_getuintegertype(L, 2);
// get this
wxGridCellAttrProvider * self = (wxGridCellAttrProvider *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellAttrProvider);
// call UpdateAttrRows
self->UpdateAttrRows(pos, numRows);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellAttrProvider_delete[] = { &wxluatype_wxGridCellAttrProvider, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttrProvider_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellAttrProvider_delete }};
static int LUACALL wxLua_wxGridCellAttrProvider_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellAttrProvider_constructor[1] = {{ wxLua_wxGridCellAttrProvider_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxGridCellAttrProvider( );
static int LUACALL wxLua_wxGridCellAttrProvider_constructor(lua_State *L)
{
// call constructor
wxGridCellAttrProvider* returns = new wxGridCellAttrProvider();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellAttrProvider);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellAttrProvider);
return 1;
}
void wxLua_wxGridCellAttrProvider_delete_function(void** p)
{
wxGridCellAttrProvider* o = (wxGridCellAttrProvider*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellAttrProvider_methods[] = {
{ "GetAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttrProvider_GetAttr, 1, NULL },
{ "SetAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttrProvider_SetAttr, 1, NULL },
{ "SetColAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttrProvider_SetColAttr, 1, NULL },
{ "SetRowAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttrProvider_SetRowAttr, 1, NULL },
{ "UpdateAttrCols", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttrProvider_UpdateAttrCols, 1, NULL },
{ "UpdateAttrRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellAttrProvider_UpdateAttrRows, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellAttrProvider_delete, 1, NULL },
{ "wxGridCellAttrProvider", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellAttrProvider_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellAttrProvider_methodCount = sizeof(wxGridCellAttrProvider_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridTableBase
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridTableBase'
int wxluatype_wxGridTableBase = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_AppendCols[] = { &wxluatype_wxGridTableBase, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridTableBase_AppendCols(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_AppendCols[1] = {{ wxLua_wxGridTableBase_AppendCols, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGridTableBase_AppendCols }};
// virtual bool AppendCols( size_t numCols = 1 );
static int LUACALL wxLua_wxGridTableBase_AppendCols(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// size_t numCols = 1
size_t numCols = (argCount >= 2 ? (size_t)wxlua_getuintegertype(L, 2) : 1);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call AppendCols
bool returns = (self->AppendCols(numCols));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_AppendRows[] = { &wxluatype_wxGridTableBase, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridTableBase_AppendRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_AppendRows[1] = {{ wxLua_wxGridTableBase_AppendRows, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGridTableBase_AppendRows }};
// virtual bool AppendRows( size_t numRows = 1 );
static int LUACALL wxLua_wxGridTableBase_AppendRows(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// size_t numRows = 1
size_t numRows = (argCount >= 2 ? (size_t)wxlua_getuintegertype(L, 2) : 1);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call AppendRows
bool returns = (self->AppendRows(numRows));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_CanGetValueAs[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGridTableBase_CanGetValueAs(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_CanGetValueAs[1] = {{ wxLua_wxGridTableBase_CanGetValueAs, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridTableBase_CanGetValueAs }};
// virtual bool CanGetValueAs( int row, int col, const wxString& typeName );
static int LUACALL wxLua_wxGridTableBase_CanGetValueAs(lua_State *L)
{
// const wxString typeName
const wxString typeName = wxlua_getwxStringtype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call CanGetValueAs
bool returns = (self->CanGetValueAs(row, col, typeName));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_CanHaveAttributes[] = { &wxluatype_wxGridTableBase, NULL };
static int LUACALL wxLua_wxGridTableBase_CanHaveAttributes(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_CanHaveAttributes[1] = {{ wxLua_wxGridTableBase_CanHaveAttributes, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridTableBase_CanHaveAttributes }};
// virtual bool CanHaveAttributes( );
static int LUACALL wxLua_wxGridTableBase_CanHaveAttributes(lua_State *L)
{
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call CanHaveAttributes
bool returns = (self->CanHaveAttributes());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_CanSetValueAs[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGridTableBase_CanSetValueAs(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_CanSetValueAs[1] = {{ wxLua_wxGridTableBase_CanSetValueAs, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridTableBase_CanSetValueAs }};
// virtual bool CanSetValueAs( int row, int col, const wxString& typeName );
static int LUACALL wxLua_wxGridTableBase_CanSetValueAs(lua_State *L)
{
// const wxString typeName
const wxString typeName = wxlua_getwxStringtype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call CanSetValueAs
bool returns = (self->CanSetValueAs(row, col, typeName));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_Clear[] = { &wxluatype_wxGridTableBase, NULL };
static int LUACALL wxLua_wxGridTableBase_Clear(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_Clear[1] = {{ wxLua_wxGridTableBase_Clear, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridTableBase_Clear }};
// virtual void Clear( );
static int LUACALL wxLua_wxGridTableBase_Clear(lua_State *L)
{
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call Clear
self->Clear();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_DeleteCols[] = { &wxluatype_wxGridTableBase, &wxluatype_TINTEGER, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridTableBase_DeleteCols(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_DeleteCols[1] = {{ wxLua_wxGridTableBase_DeleteCols, WXLUAMETHOD_METHOD, 1, 3, s_wxluatypeArray_wxLua_wxGridTableBase_DeleteCols }};
// virtual bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
static int LUACALL wxLua_wxGridTableBase_DeleteCols(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// size_t numCols = 1
size_t numCols = (argCount >= 3 ? (size_t)wxlua_getuintegertype(L, 3) : 1);
// size_t pos = 0
size_t pos = (argCount >= 2 ? (size_t)wxlua_getuintegertype(L, 2) : 0);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call DeleteCols
bool returns = (self->DeleteCols(pos, numCols));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_DeleteRows[] = { &wxluatype_wxGridTableBase, &wxluatype_TINTEGER, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridTableBase_DeleteRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_DeleteRows[1] = {{ wxLua_wxGridTableBase_DeleteRows, WXLUAMETHOD_METHOD, 1, 3, s_wxluatypeArray_wxLua_wxGridTableBase_DeleteRows }};
// virtual bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
static int LUACALL wxLua_wxGridTableBase_DeleteRows(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// size_t numRows = 1
size_t numRows = (argCount >= 3 ? (size_t)wxlua_getuintegertype(L, 3) : 1);
// size_t pos = 0
size_t pos = (argCount >= 2 ? (size_t)wxlua_getuintegertype(L, 2) : 0);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call DeleteRows
bool returns = (self->DeleteRows(pos, numRows));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetAttr[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridTableBase_GetAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetAttr[1] = {{ wxLua_wxGridTableBase_GetAttr, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridTableBase_GetAttr }};
// virtual %gc wxGridCellAttr* GetAttr( int row, int col, wxGridCellAttr::wxAttrKind kind );
static int LUACALL wxLua_wxGridTableBase_GetAttr(lua_State *L)
{
// wxGridCellAttr::wxAttrKind kind
wxGridCellAttr::wxAttrKind kind = (wxGridCellAttr::wxAttrKind)wxlua_getenumtype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetAttr
wxGridCellAttr* returns = (wxGridCellAttr*)self->GetAttr(row, col, kind);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellAttr);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellAttr);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetAttrProvider[] = { &wxluatype_wxGridTableBase, NULL };
static int LUACALL wxLua_wxGridTableBase_GetAttrProvider(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetAttrProvider[1] = {{ wxLua_wxGridTableBase_GetAttrProvider, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridTableBase_GetAttrProvider }};
// wxGridCellAttrProvider *GetAttrProvider() const;
static int LUACALL wxLua_wxGridTableBase_GetAttrProvider(lua_State *L)
{
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetAttrProvider
wxGridCellAttrProvider* returns = (wxGridCellAttrProvider*)self->GetAttrProvider();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellAttrProvider);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetColLabelValue[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_GetColLabelValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetColLabelValue[1] = {{ wxLua_wxGridTableBase_GetColLabelValue, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridTableBase_GetColLabelValue }};
// virtual wxString GetColLabelValue( int col );
static int LUACALL wxLua_wxGridTableBase_GetColLabelValue(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetColLabelValue
wxString returns = (self->GetColLabelValue(col));
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetNumberCols[] = { &wxluatype_wxGridTableBase, NULL };
static int LUACALL wxLua_wxGridTableBase_GetNumberCols(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetNumberCols[1] = {{ wxLua_wxGridTableBase_GetNumberCols, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridTableBase_GetNumberCols }};
// virtual int GetNumberCols( );
static int LUACALL wxLua_wxGridTableBase_GetNumberCols(lua_State *L)
{
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetNumberCols
int returns = (self->GetNumberCols());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetNumberRows[] = { &wxluatype_wxGridTableBase, NULL };
static int LUACALL wxLua_wxGridTableBase_GetNumberRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetNumberRows[1] = {{ wxLua_wxGridTableBase_GetNumberRows, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridTableBase_GetNumberRows }};
// virtual int GetNumberRows( );
static int LUACALL wxLua_wxGridTableBase_GetNumberRows(lua_State *L)
{
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetNumberRows
int returns = (self->GetNumberRows());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetRowLabelValue[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_GetRowLabelValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetRowLabelValue[1] = {{ wxLua_wxGridTableBase_GetRowLabelValue, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridTableBase_GetRowLabelValue }};
// virtual wxString GetRowLabelValue( int row );
static int LUACALL wxLua_wxGridTableBase_GetRowLabelValue(lua_State *L)
{
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetRowLabelValue
wxString returns = (self->GetRowLabelValue(row));
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetTypeName[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_GetTypeName(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetTypeName[1] = {{ wxLua_wxGridTableBase_GetTypeName, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridTableBase_GetTypeName }};
// virtual wxString GetTypeName( int row, int col );
static int LUACALL wxLua_wxGridTableBase_GetTypeName(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetTypeName
wxString returns = (self->GetTypeName(row, col));
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetValue[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_GetValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetValue[1] = {{ wxLua_wxGridTableBase_GetValue, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridTableBase_GetValue }};
// virtual wxString GetValue( int row, int col );
static int LUACALL wxLua_wxGridTableBase_GetValue(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetValue
wxString returns = (self->GetValue(row, col));
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetValueAsBool[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_GetValueAsBool(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetValueAsBool[1] = {{ wxLua_wxGridTableBase_GetValueAsBool, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridTableBase_GetValueAsBool }};
// virtual bool GetValueAsBool( int row, int col );
static int LUACALL wxLua_wxGridTableBase_GetValueAsBool(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetValueAsBool
bool returns = (self->GetValueAsBool(row, col));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetValueAsDouble[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_GetValueAsDouble(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetValueAsDouble[1] = {{ wxLua_wxGridTableBase_GetValueAsDouble, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridTableBase_GetValueAsDouble }};
// virtual double GetValueAsDouble( int row, int col );
static int LUACALL wxLua_wxGridTableBase_GetValueAsDouble(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetValueAsDouble
double returns = (self->GetValueAsDouble(row, col));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetValueAsLong[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_GetValueAsLong(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetValueAsLong[1] = {{ wxLua_wxGridTableBase_GetValueAsLong, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridTableBase_GetValueAsLong }};
// virtual long GetValueAsLong( int row, int col );
static int LUACALL wxLua_wxGridTableBase_GetValueAsLong(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetValueAsLong
long returns = (self->GetValueAsLong(row, col));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_GetView[] = { &wxluatype_wxGridTableBase, NULL };
static int LUACALL wxLua_wxGridTableBase_GetView(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_GetView[1] = {{ wxLua_wxGridTableBase_GetView, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridTableBase_GetView }};
// virtual wxGrid * GetView() const;
static int LUACALL wxLua_wxGridTableBase_GetView(lua_State *L)
{
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call GetView
wxGrid* returns = (wxGrid*)self->GetView();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGrid);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_InsertCols[] = { &wxluatype_wxGridTableBase, &wxluatype_TINTEGER, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridTableBase_InsertCols(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_InsertCols[1] = {{ wxLua_wxGridTableBase_InsertCols, WXLUAMETHOD_METHOD, 1, 3, s_wxluatypeArray_wxLua_wxGridTableBase_InsertCols }};
// virtual bool InsertCols( size_t pos = 0, size_t numCols = 1 );
static int LUACALL wxLua_wxGridTableBase_InsertCols(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// size_t numCols = 1
size_t numCols = (argCount >= 3 ? (size_t)wxlua_getuintegertype(L, 3) : 1);
// size_t pos = 0
size_t pos = (argCount >= 2 ? (size_t)wxlua_getuintegertype(L, 2) : 0);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call InsertCols
bool returns = (self->InsertCols(pos, numCols));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_InsertRows[] = { &wxluatype_wxGridTableBase, &wxluatype_TINTEGER, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridTableBase_InsertRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_InsertRows[1] = {{ wxLua_wxGridTableBase_InsertRows, WXLUAMETHOD_METHOD, 1, 3, s_wxluatypeArray_wxLua_wxGridTableBase_InsertRows }};
// virtual bool InsertRows( size_t pos = 0, size_t numRows = 1 );
static int LUACALL wxLua_wxGridTableBase_InsertRows(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// size_t numRows = 1
size_t numRows = (argCount >= 3 ? (size_t)wxlua_getuintegertype(L, 3) : 1);
// size_t pos = 0
size_t pos = (argCount >= 2 ? (size_t)wxlua_getuintegertype(L, 2) : 0);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call InsertRows
bool returns = (self->InsertRows(pos, numRows));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_IsEmptyCell[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_IsEmptyCell(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_IsEmptyCell[1] = {{ wxLua_wxGridTableBase_IsEmptyCell, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridTableBase_IsEmptyCell }};
// virtual bool IsEmptyCell( int row, int col );
static int LUACALL wxLua_wxGridTableBase_IsEmptyCell(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call IsEmptyCell
bool returns = (self->IsEmptyCell(row, col));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetAttr[] = { &wxluatype_wxGridTableBase, &wxluatype_wxGridCellAttr, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_SetAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetAttr[1] = {{ wxLua_wxGridTableBase_SetAttr, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridTableBase_SetAttr }};
// void SetAttr(%IncRef wxGridCellAttr* attr, int row, int col );
static int LUACALL wxLua_wxGridTableBase_SetAttr(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 4);
// int row
int row = (int)wxlua_getnumbertype(L, 3);
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellAttr);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
attr->IncRef();
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetAttr
self->SetAttr(attr, row, col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetAttrProvider[] = { &wxluatype_wxGridTableBase, &wxluatype_wxGridCellAttrProvider, NULL };
static int LUACALL wxLua_wxGridTableBase_SetAttrProvider(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetAttrProvider[1] = {{ wxLua_wxGridTableBase_SetAttrProvider, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridTableBase_SetAttrProvider }};
// void SetAttrProvider(wxGridCellAttrProvider *attrProvider );
static int LUACALL wxLua_wxGridTableBase_SetAttrProvider(lua_State *L)
{
// wxGridCellAttrProvider attrProvider
wxGridCellAttrProvider * attrProvider = (wxGridCellAttrProvider *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellAttrProvider);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetAttrProvider
self->SetAttrProvider(attrProvider);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetColAttr[] = { &wxluatype_wxGridTableBase, &wxluatype_wxGridCellAttr, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_SetColAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetColAttr[1] = {{ wxLua_wxGridTableBase_SetColAttr, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridTableBase_SetColAttr }};
// void SetColAttr(%IncRef wxGridCellAttr *attr, int col );
static int LUACALL wxLua_wxGridTableBase_SetColAttr(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellAttr);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
attr->IncRef();
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetColAttr
self->SetColAttr(attr, col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetColLabelValue[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGridTableBase_SetColLabelValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetColLabelValue[1] = {{ wxLua_wxGridTableBase_SetColLabelValue, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridTableBase_SetColLabelValue }};
// virtual void SetColLabelValue( int col, const wxString& value );
static int LUACALL wxLua_wxGridTableBase_SetColLabelValue(lua_State *L)
{
// const wxString value
const wxString value = wxlua_getwxStringtype(L, 3);
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetColLabelValue
self->SetColLabelValue(col, value);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetRowAttr[] = { &wxluatype_wxGridTableBase, &wxluatype_wxGridCellAttr, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_SetRowAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetRowAttr[1] = {{ wxLua_wxGridTableBase_SetRowAttr, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridTableBase_SetRowAttr }};
// void SetRowAttr(%IncRef wxGridCellAttr *attr, int row );
static int LUACALL wxLua_wxGridTableBase_SetRowAttr(lua_State *L)
{
// int row
int row = (int)wxlua_getnumbertype(L, 3);
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellAttr);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
attr->IncRef();
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetRowAttr
self->SetRowAttr(attr, row);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetRowLabelValue[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGridTableBase_SetRowLabelValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetRowLabelValue[1] = {{ wxLua_wxGridTableBase_SetRowLabelValue, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridTableBase_SetRowLabelValue }};
// virtual void SetRowLabelValue( int row, const wxString& value );
static int LUACALL wxLua_wxGridTableBase_SetRowLabelValue(lua_State *L)
{
// const wxString value
const wxString value = wxlua_getwxStringtype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetRowLabelValue
self->SetRowLabelValue(row, value);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetValue[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGridTableBase_SetValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetValue[1] = {{ wxLua_wxGridTableBase_SetValue, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridTableBase_SetValue }};
// virtual void SetValue( int row, int col, const wxString& value );
static int LUACALL wxLua_wxGridTableBase_SetValue(lua_State *L)
{
// const wxString value
const wxString value = wxlua_getwxStringtype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetValue
self->SetValue(row, col, value);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetValueAsBool[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGridTableBase_SetValueAsBool(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetValueAsBool[1] = {{ wxLua_wxGridTableBase_SetValueAsBool, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridTableBase_SetValueAsBool }};
// virtual void SetValueAsBool( int row, int col, bool value );
static int LUACALL wxLua_wxGridTableBase_SetValueAsBool(lua_State *L)
{
// bool value
bool value = wxlua_getbooleantype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetValueAsBool
self->SetValueAsBool(row, col, value);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetValueAsDouble[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_SetValueAsDouble(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetValueAsDouble[1] = {{ wxLua_wxGridTableBase_SetValueAsDouble, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridTableBase_SetValueAsDouble }};
// virtual void SetValueAsDouble( int row, int col, double value );
static int LUACALL wxLua_wxGridTableBase_SetValueAsDouble(lua_State *L)
{
// double value
double value = (double)wxlua_getnumbertype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetValueAsDouble
self->SetValueAsDouble(row, col, value);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetValueAsLong[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableBase_SetValueAsLong(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetValueAsLong[1] = {{ wxLua_wxGridTableBase_SetValueAsLong, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGridTableBase_SetValueAsLong }};
// virtual void SetValueAsLong( int row, int col, long value );
static int LUACALL wxLua_wxGridTableBase_SetValueAsLong(lua_State *L)
{
// long value
long value = (long)wxlua_getnumbertype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetValueAsLong
self->SetValueAsLong(row, col, value);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableBase_SetView[] = { &wxluatype_wxGridTableBase, &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGridTableBase_SetView(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableBase_SetView[1] = {{ wxLua_wxGridTableBase_SetView, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridTableBase_SetView }};
// virtual void SetView( wxGrid *grid );
static int LUACALL wxLua_wxGridTableBase_SetView(lua_State *L)
{
// wxGrid grid
wxGrid * grid = (wxGrid *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGrid);
// get this
wxGridTableBase * self = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call SetView
self->SetView(grid);
return 0;
}
void wxLua_wxGridTableBase_delete_function(void** p)
{
wxGridTableBase* o = (wxGridTableBase*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridTableBase_methods[] = {
{ "AppendCols", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_AppendCols, 1, NULL },
{ "AppendRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_AppendRows, 1, NULL },
{ "CanGetValueAs", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_CanGetValueAs, 1, NULL },
{ "CanHaveAttributes", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_CanHaveAttributes, 1, NULL },
{ "CanSetValueAs", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_CanSetValueAs, 1, NULL },
{ "Clear", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_Clear, 1, NULL },
{ "DeleteCols", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_DeleteCols, 1, NULL },
{ "DeleteRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_DeleteRows, 1, NULL },
{ "GetAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetAttr, 1, NULL },
{ "GetAttrProvider", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetAttrProvider, 1, NULL },
{ "GetColLabelValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetColLabelValue, 1, NULL },
{ "GetNumberCols", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetNumberCols, 1, NULL },
{ "GetNumberRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetNumberRows, 1, NULL },
{ "GetRowLabelValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetRowLabelValue, 1, NULL },
{ "GetTypeName", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetTypeName, 1, NULL },
{ "GetValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetValue, 1, NULL },
{ "GetValueAsBool", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetValueAsBool, 1, NULL },
{ "GetValueAsDouble", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetValueAsDouble, 1, NULL },
{ "GetValueAsLong", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetValueAsLong, 1, NULL },
{ "GetView", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_GetView, 1, NULL },
{ "InsertCols", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_InsertCols, 1, NULL },
{ "InsertRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_InsertRows, 1, NULL },
{ "IsEmptyCell", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_IsEmptyCell, 1, NULL },
{ "SetAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetAttr, 1, NULL },
{ "SetAttrProvider", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetAttrProvider, 1, NULL },
{ "SetColAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetColAttr, 1, NULL },
{ "SetColLabelValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetColLabelValue, 1, NULL },
{ "SetRowAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetRowAttr, 1, NULL },
{ "SetRowLabelValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetRowLabelValue, 1, NULL },
{ "SetValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetValue, 1, NULL },
{ "SetValueAsBool", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetValueAsBool, 1, NULL },
{ "SetValueAsDouble", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetValueAsDouble, 1, NULL },
{ "SetValueAsLong", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetValueAsLong, 1, NULL },
{ "SetView", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableBase_SetView, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridTableBase_methodCount = sizeof(wxGridTableBase_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxLuaGridTableBase
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxLuaGridTableBase'
int wxluatype_wxLuaGridTableBase = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxLuaGridTableBase_delete[] = { &wxluatype_wxLuaGridTableBase, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLuaGridTableBase_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxLuaGridTableBase_delete }};
static int LUACALL wxLua_wxLuaGridTableBase_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLuaGridTableBase_constructor[1] = {{ wxLua_wxLuaGridTableBase_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// %override wxLua_wxLuaGridTableBase_constructor
// wxLuaGridTableBase()
static int LUACALL wxLua_wxLuaGridTableBase_constructor(lua_State *L)
{
wxLuaState wxlState(L);
// call constructor
wxLuaGridTableBase *returns = new wxLuaGridTableBase(wxlState);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxLuaGridTableBase);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxLuaGridTableBase);
return 1;
}
void wxLua_wxLuaGridTableBase_delete_function(void** p)
{
wxLuaGridTableBase* o = (wxLuaGridTableBase*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxLuaGridTableBase_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxLuaGridTableBase_delete, 1, NULL },
{ "wxLuaGridTableBase", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxLuaGridTableBase_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxLuaGridTableBase_methodCount = sizeof(wxLuaGridTableBase_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridStringTable
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridStringTable'
int wxluatype_wxGridStringTable = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridStringTable_delete[] = { &wxluatype_wxGridStringTable, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridStringTable_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridStringTable_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridStringTable_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridStringTable_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridStringTable_constructor[1] = {{ wxLua_wxGridStringTable_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 2, s_wxluatypeArray_wxLua_wxGridStringTable_constructor }};
// wxGridStringTable( int numRows=0, int numCols=0 );
static int LUACALL wxLua_wxGridStringTable_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int numCols = 0
int numCols = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : 0);
// int numRows = 0
int numRows = (argCount >= 1 ? (int)wxlua_getnumbertype(L, 1) : 0);
// call constructor
wxGridStringTable* returns = new wxGridStringTable(numRows, numCols);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridStringTable);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridStringTable);
return 1;
}
void wxLua_wxGridStringTable_delete_function(void** p)
{
wxGridStringTable* o = (wxGridStringTable*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridStringTable_methods[] = {
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridStringTable_delete, 1, NULL },
{ "wxGridStringTable", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridStringTable_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridStringTable_methodCount = sizeof(wxGridStringTable_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridTableMessage
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridTableMessage'
int wxluatype_wxGridTableMessage = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableMessage_GetCommandInt[] = { &wxluatype_wxGridTableMessage, NULL };
static int LUACALL wxLua_wxGridTableMessage_GetCommandInt(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableMessage_GetCommandInt[1] = {{ wxLua_wxGridTableMessage_GetCommandInt, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridTableMessage_GetCommandInt }};
// int GetCommandInt( );
static int LUACALL wxLua_wxGridTableMessage_GetCommandInt(lua_State *L)
{
// get this
wxGridTableMessage * self = (wxGridTableMessage *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableMessage);
// call GetCommandInt
int returns = (self->GetCommandInt());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableMessage_GetCommandInt2[] = { &wxluatype_wxGridTableMessage, NULL };
static int LUACALL wxLua_wxGridTableMessage_GetCommandInt2(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableMessage_GetCommandInt2[1] = {{ wxLua_wxGridTableMessage_GetCommandInt2, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridTableMessage_GetCommandInt2 }};
// int GetCommandInt2( );
static int LUACALL wxLua_wxGridTableMessage_GetCommandInt2(lua_State *L)
{
// get this
wxGridTableMessage * self = (wxGridTableMessage *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableMessage);
// call GetCommandInt2
int returns = (self->GetCommandInt2());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableMessage_GetId[] = { &wxluatype_wxGridTableMessage, NULL };
static int LUACALL wxLua_wxGridTableMessage_GetId(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableMessage_GetId[1] = {{ wxLua_wxGridTableMessage_GetId, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridTableMessage_GetId }};
// int GetId( );
static int LUACALL wxLua_wxGridTableMessage_GetId(lua_State *L)
{
// get this
wxGridTableMessage * self = (wxGridTableMessage *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableMessage);
// call GetId
int returns = (self->GetId());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableMessage_GetTableObject[] = { &wxluatype_wxGridTableMessage, NULL };
static int LUACALL wxLua_wxGridTableMessage_GetTableObject(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableMessage_GetTableObject[1] = {{ wxLua_wxGridTableMessage_GetTableObject, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridTableMessage_GetTableObject }};
// wxGridTableBase * GetTableObject() const;
static int LUACALL wxLua_wxGridTableMessage_GetTableObject(lua_State *L)
{
// get this
wxGridTableMessage * self = (wxGridTableMessage *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableMessage);
// call GetTableObject
wxGridTableBase* returns = (wxGridTableBase*)self->GetTableObject();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridTableBase);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableMessage_SetCommandInt[] = { &wxluatype_wxGridTableMessage, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableMessage_SetCommandInt(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableMessage_SetCommandInt[1] = {{ wxLua_wxGridTableMessage_SetCommandInt, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridTableMessage_SetCommandInt }};
// void SetCommandInt( int comInt1 );
static int LUACALL wxLua_wxGridTableMessage_SetCommandInt(lua_State *L)
{
// int comInt1
int comInt1 = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableMessage * self = (wxGridTableMessage *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableMessage);
// call SetCommandInt
self->SetCommandInt(comInt1);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableMessage_SetCommandInt2[] = { &wxluatype_wxGridTableMessage, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableMessage_SetCommandInt2(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableMessage_SetCommandInt2[1] = {{ wxLua_wxGridTableMessage_SetCommandInt2, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridTableMessage_SetCommandInt2 }};
// void SetCommandInt2( int comInt2 );
static int LUACALL wxLua_wxGridTableMessage_SetCommandInt2(lua_State *L)
{
// int comInt2
int comInt2 = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableMessage * self = (wxGridTableMessage *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableMessage);
// call SetCommandInt2
self->SetCommandInt2(comInt2);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableMessage_SetId[] = { &wxluatype_wxGridTableMessage, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableMessage_SetId(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableMessage_SetId[1] = {{ wxLua_wxGridTableMessage_SetId, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridTableMessage_SetId }};
// void SetId( int id );
static int LUACALL wxLua_wxGridTableMessage_SetId(lua_State *L)
{
// int id
int id = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridTableMessage * self = (wxGridTableMessage *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableMessage);
// call SetId
self->SetId(id);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableMessage_SetTableObject[] = { &wxluatype_wxGridTableMessage, &wxluatype_wxGridTableBase, NULL };
static int LUACALL wxLua_wxGridTableMessage_SetTableObject(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableMessage_SetTableObject[1] = {{ wxLua_wxGridTableMessage_SetTableObject, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridTableMessage_SetTableObject }};
// void SetTableObject( wxGridTableBase *table );
static int LUACALL wxLua_wxGridTableMessage_SetTableObject(lua_State *L)
{
// wxGridTableBase table
wxGridTableBase * table = (wxGridTableBase *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridTableBase);
// get this
wxGridTableMessage * self = (wxGridTableMessage *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableMessage);
// call SetTableObject
self->SetTableObject(table);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableMessage_delete[] = { &wxluatype_wxGridTableMessage, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableMessage_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridTableMessage_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridTableMessage_constructor[] = { &wxluatype_wxGridTableBase, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridTableMessage_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridTableMessage_constructor[1] = {{ wxLua_wxGridTableMessage_constructor, WXLUAMETHOD_CONSTRUCTOR, 2, 4, s_wxluatypeArray_wxLua_wxGridTableMessage_constructor }};
// wxGridTableMessage( wxGridTableBase *table, int id, int comInt1 = -1, int comInt2 = -1 );
static int LUACALL wxLua_wxGridTableMessage_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int comInt2 = -1
int comInt2 = (argCount >= 4 ? (int)wxlua_getnumbertype(L, 4) : -1);
// int comInt1 = -1
int comInt1 = (argCount >= 3 ? (int)wxlua_getnumbertype(L, 3) : -1);
// int id
int id = (int)wxlua_getnumbertype(L, 2);
// wxGridTableBase table
wxGridTableBase * table = (wxGridTableBase *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridTableBase);
// call constructor
wxGridTableMessage* returns = new wxGridTableMessage(table, id, comInt1, comInt2);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridTableMessage);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridTableMessage);
return 1;
}
void wxLua_wxGridTableMessage_delete_function(void** p)
{
wxGridTableMessage* o = (wxGridTableMessage*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridTableMessage_methods[] = {
{ "GetCommandInt", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableMessage_GetCommandInt, 1, NULL },
{ "GetCommandInt2", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableMessage_GetCommandInt2, 1, NULL },
{ "GetId", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableMessage_GetId, 1, NULL },
{ "GetTableObject", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableMessage_GetTableObject, 1, NULL },
{ "SetCommandInt", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableMessage_SetCommandInt, 1, NULL },
{ "SetCommandInt2", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableMessage_SetCommandInt2, 1, NULL },
{ "SetId", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableMessage_SetId, 1, NULL },
{ "SetTableObject", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridTableMessage_SetTableObject, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridTableMessage_delete, 1, NULL },
{ "wxGridTableMessage", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridTableMessage_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridTableMessage_methodCount = sizeof(wxGridTableMessage_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellCoords
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellCoords'
int wxluatype_wxGridCellCoords = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoords_GetCol[] = { &wxluatype_wxGridCellCoords, NULL };
static int LUACALL wxLua_wxGridCellCoords_GetCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoords_GetCol[1] = {{ wxLua_wxGridCellCoords_GetCol, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoords_GetCol }};
// int GetCol() const;
static int LUACALL wxLua_wxGridCellCoords_GetCol(lua_State *L)
{
// get this
wxGridCellCoords * self = (wxGridCellCoords *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoords);
// call GetCol
int returns = (self->GetCol());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoords_GetRow[] = { &wxluatype_wxGridCellCoords, NULL };
static int LUACALL wxLua_wxGridCellCoords_GetRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoords_GetRow[1] = {{ wxLua_wxGridCellCoords_GetRow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoords_GetRow }};
// int GetRow() const;
static int LUACALL wxLua_wxGridCellCoords_GetRow(lua_State *L)
{
// get this
wxGridCellCoords * self = (wxGridCellCoords *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoords);
// call GetRow
int returns = (self->GetRow());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoords_Set[] = { &wxluatype_wxGridCellCoords, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellCoords_Set(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoords_Set[1] = {{ wxLua_wxGridCellCoords_Set, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGridCellCoords_Set }};
// void Set(int row, int col );
static int LUACALL wxLua_wxGridCellCoords_Set(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellCoords * self = (wxGridCellCoords *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoords);
// call Set
self->Set(row, col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoords_SetCol[] = { &wxluatype_wxGridCellCoords, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellCoords_SetCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoords_SetCol[1] = {{ wxLua_wxGridCellCoords_SetCol, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellCoords_SetCol }};
// void SetCol( int n );
static int LUACALL wxLua_wxGridCellCoords_SetCol(lua_State *L)
{
// int n
int n = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellCoords * self = (wxGridCellCoords *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoords);
// call SetCol
self->SetCol(n);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoords_SetRow[] = { &wxluatype_wxGridCellCoords, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellCoords_SetRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoords_SetRow[1] = {{ wxLua_wxGridCellCoords_SetRow, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellCoords_SetRow }};
// void SetRow( int n );
static int LUACALL wxLua_wxGridCellCoords_SetRow(lua_State *L)
{
// int n
int n = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellCoords * self = (wxGridCellCoords *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoords);
// call SetRow
self->SetRow(n);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoords_delete[] = { &wxluatype_wxGridCellCoords, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoords_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoords_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoords_op_eq[] = { &wxluatype_wxGridCellCoords, &wxluatype_wxGridCellCoords, NULL };
static int LUACALL wxLua_wxGridCellCoords_op_eq(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoords_op_eq[1] = {{ wxLua_wxGridCellCoords_op_eq, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellCoords_op_eq }};
// bool operator==( const wxGridCellCoords& other ) const;
static int LUACALL wxLua_wxGridCellCoords_op_eq(lua_State *L)
{
// const wxGridCellCoords other
const wxGridCellCoords * other = (const wxGridCellCoords *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellCoords);
// get this
wxGridCellCoords * self = (wxGridCellCoords *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoords);
// call op_eq
bool returns = ((*self)==(*other));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoords_op_not[] = { &wxluatype_wxGridCellCoords, NULL };
static int LUACALL wxLua_wxGridCellCoords_op_not(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoords_op_not[1] = {{ wxLua_wxGridCellCoords_op_not, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoords_op_not }};
// bool operator!() const;
static int LUACALL wxLua_wxGridCellCoords_op_not(lua_State *L)
{
// get this
wxGridCellCoords * self = (wxGridCellCoords *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoords);
// call op_not
bool returns = (!(*self));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoords_op_set[] = { &wxluatype_wxGridCellCoords, &wxluatype_wxGridCellCoords, NULL };
static int LUACALL wxLua_wxGridCellCoords_op_set(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoords_op_set[1] = {{ wxLua_wxGridCellCoords_op_set, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellCoords_op_set }};
// wxGridCellCoords& operator=( const wxGridCellCoords& other );
static int LUACALL wxLua_wxGridCellCoords_op_set(lua_State *L)
{
// const wxGridCellCoords other
const wxGridCellCoords * other = (const wxGridCellCoords *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellCoords);
// get this
wxGridCellCoords * self = (wxGridCellCoords *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoords);
// call op_set
(*self)=(*other);
wxGridCellCoords* returns = self;
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoords);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoords_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellCoords_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoords_constructor[1] = {{ wxLua_wxGridCellCoords_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 2, s_wxluatypeArray_wxLua_wxGridCellCoords_constructor }};
// wxGridCellCoords( int r = -1, int c = -1 );
static int LUACALL wxLua_wxGridCellCoords_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int c = -1
int c = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : -1);
// int r = -1
int r = (argCount >= 1 ? (int)wxlua_getnumbertype(L, 1) : -1);
// call constructor
wxGridCellCoords* returns = new wxGridCellCoords(r, c);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellCoords);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoords);
return 1;
}
void wxLua_wxGridCellCoords_delete_function(void** p)
{
wxGridCellCoords* o = (wxGridCellCoords*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellCoords_methods[] = {
{ "GetCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoords_GetCol, 1, NULL },
{ "GetRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoords_GetRow, 1, NULL },
{ "Set", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoords_Set, 1, NULL },
{ "SetCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoords_SetCol, 1, NULL },
{ "SetRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoords_SetRow, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellCoords_delete, 1, NULL },
{ "op_eq", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoords_op_eq, 1, NULL },
{ "op_not", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoords_op_not, 1, NULL },
{ "op_set", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoords_op_set, 1, NULL },
{ "wxGridCellCoords", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellCoords_constructor, 1, NULL },
{ 0, 0, 0, 0 },
};
int wxGridCellCoords_methodCount = sizeof(wxGridCellCoords_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridCellCoordsArray
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridCellCoordsArray'
int wxluatype_wxGridCellCoordsArray = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Add[] = { &wxluatype_wxGridCellCoordsArray, &wxluatype_wxGridCellCoords, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_Add(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_Add[1] = {{ wxLua_wxGridCellCoordsArray_Add, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Add }};
// void Add( const wxGridCellCoords& c );
static int LUACALL wxLua_wxGridCellCoordsArray_Add(lua_State *L)
{
// const wxGridCellCoords c
const wxGridCellCoords * c = (const wxGridCellCoords *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellCoords);
// get this
wxGridCellCoordsArray * self = (wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call Add
self->Add(*c);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Alloc[] = { &wxluatype_wxGridCellCoordsArray, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_Alloc(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_Alloc[1] = {{ wxLua_wxGridCellCoordsArray_Alloc, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Alloc }};
// void Alloc(size_t count );
static int LUACALL wxLua_wxGridCellCoordsArray_Alloc(lua_State *L)
{
// size_t count
size_t count = (size_t)wxlua_getuintegertype(L, 2);
// get this
wxGridCellCoordsArray * self = (wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call Alloc
self->Alloc(count);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Clear[] = { &wxluatype_wxGridCellCoordsArray, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_Clear(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_Clear[1] = {{ wxLua_wxGridCellCoordsArray_Clear, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Clear }};
// void Clear( );
static int LUACALL wxLua_wxGridCellCoordsArray_Clear(lua_State *L)
{
// get this
wxGridCellCoordsArray * self = (wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call Clear
self->Clear();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_GetCount[] = { &wxluatype_wxGridCellCoordsArray, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_GetCount(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_GetCount[1] = {{ wxLua_wxGridCellCoordsArray_GetCount, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_GetCount }};
// int GetCount() const;
static int LUACALL wxLua_wxGridCellCoordsArray_GetCount(lua_State *L)
{
// get this
wxGridCellCoordsArray * self = (wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call GetCount
int returns = (self->GetCount());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Insert[] = { &wxluatype_wxGridCellCoordsArray, &wxluatype_wxGridCellCoords, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_Insert(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_Insert[1] = {{ wxLua_wxGridCellCoordsArray_Insert, WXLUAMETHOD_METHOD, 3, 4, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Insert }};
// void Insert( const wxGridCellCoords& c, int n, int copies = 1 );
static int LUACALL wxLua_wxGridCellCoordsArray_Insert(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int copies = 1
int copies = (argCount >= 4 ? (int)wxlua_getnumbertype(L, 4) : 1);
// int n
int n = (int)wxlua_getnumbertype(L, 3);
// const wxGridCellCoords c
const wxGridCellCoords * c = (const wxGridCellCoords *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellCoords);
// get this
wxGridCellCoordsArray * self = (wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call Insert
self->Insert(*c, n, copies);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_IsEmpty[] = { &wxluatype_wxGridCellCoordsArray, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_IsEmpty(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_IsEmpty[1] = {{ wxLua_wxGridCellCoordsArray_IsEmpty, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_IsEmpty }};
// bool IsEmpty() const;
static int LUACALL wxLua_wxGridCellCoordsArray_IsEmpty(lua_State *L)
{
// get this
wxGridCellCoordsArray * self = (wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call IsEmpty
bool returns = (self->IsEmpty());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Item[] = { &wxluatype_wxGridCellCoordsArray, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_Item(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_Item[1] = {{ wxLua_wxGridCellCoordsArray_Item, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Item }};
// wxGridCellCoords Item( int n );
static int LUACALL wxLua_wxGridCellCoordsArray_Item(lua_State *L)
{
// int n
int n = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridCellCoordsArray * self = (wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call Item
// allocate a new object using the copy constructor
wxGridCellCoords* returns = new wxGridCellCoords(self->Item(n));
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellCoords);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoords);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_RemoveAt[] = { &wxluatype_wxGridCellCoordsArray, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_RemoveAt(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_RemoveAt[1] = {{ wxLua_wxGridCellCoordsArray_RemoveAt, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_RemoveAt }};
// void RemoveAt(size_t index );
static int LUACALL wxLua_wxGridCellCoordsArray_RemoveAt(lua_State *L)
{
// size_t index
size_t index = (size_t)wxlua_getuintegertype(L, 2);
// get this
wxGridCellCoordsArray * self = (wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call RemoveAt
self->RemoveAt(index);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Shrink[] = { &wxluatype_wxGridCellCoordsArray, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_Shrink(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_Shrink[1] = {{ wxLua_wxGridCellCoordsArray_Shrink, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_Shrink }};
// void Shrink( );
static int LUACALL wxLua_wxGridCellCoordsArray_Shrink(lua_State *L)
{
// get this
wxGridCellCoordsArray * self = (wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call Shrink
self->Shrink();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_delete[] = { &wxluatype_wxGridCellCoordsArray, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_delete }};
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_op_index[] = { &wxluatype_wxGridCellCoordsArray, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_op_index(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_op_index[1] = {{ wxLua_wxGridCellCoordsArray_op_index, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_op_index }};
// wxGridCellCoords operator[](size_t nIndex );
static int LUACALL wxLua_wxGridCellCoordsArray_op_index(lua_State *L)
{
// size_t nIndex
size_t nIndex = (size_t)wxlua_getuintegertype(L, 2);
// get this
wxGridCellCoordsArray * self = (wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call op_index
// allocate a new object using the copy constructor
wxGridCellCoords* returns = new wxGridCellCoords((*self)[(nIndex)]);
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellCoords);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoords);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridCellCoordsArray_constructor1[] = { &wxluatype_wxGridCellCoordsArray, NULL };
static int LUACALL wxLua_wxGridCellCoordsArray_constructor1(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_constructor1[1] = {{ wxLua_wxGridCellCoordsArray_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_constructor1 }};
// wxGridCellCoordsArray(const wxGridCellCoordsArray& array );
static int LUACALL wxLua_wxGridCellCoordsArray_constructor1(lua_State *L)
{
// const wxGridCellCoordsArray array
const wxGridCellCoordsArray * array = (const wxGridCellCoordsArray *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridCellCoordsArray);
// call constructor
wxGridCellCoordsArray* returns = new wxGridCellCoordsArray(*array);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellCoordsArray);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoordsArray);
return 1;
}
static int LUACALL wxLua_wxGridCellCoordsArray_constructor(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_constructor[1] = {{ wxLua_wxGridCellCoordsArray_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// wxGridCellCoordsArray( );
static int LUACALL wxLua_wxGridCellCoordsArray_constructor(lua_State *L)
{
// call constructor
wxGridCellCoordsArray* returns = new wxGridCellCoordsArray();
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellCoordsArray);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoordsArray);
return 1;
}
#if (wxLUA_USE_wxGrid && wxUSE_GRID)
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridCellCoordsArray_constructor_overload[] =
{
{ wxLua_wxGridCellCoordsArray_constructor1, WXLUAMETHOD_CONSTRUCTOR, 1, 1, s_wxluatypeArray_wxLua_wxGridCellCoordsArray_constructor1 },
{ wxLua_wxGridCellCoordsArray_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None },
};
static int s_wxluafunc_wxLua_wxGridCellCoordsArray_constructor_overload_count = sizeof(s_wxluafunc_wxLua_wxGridCellCoordsArray_constructor_overload)/sizeof(wxLuaBindCFunc);
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID)
void wxLua_wxGridCellCoordsArray_delete_function(void** p)
{
wxGridCellCoordsArray* o = (wxGridCellCoordsArray*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridCellCoordsArray_methods[] = {
{ "Add", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoordsArray_Add, 1, NULL },
{ "Alloc", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoordsArray_Alloc, 1, NULL },
{ "Clear", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoordsArray_Clear, 1, NULL },
{ "GetCount", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoordsArray_GetCount, 1, NULL },
{ "Insert", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoordsArray_Insert, 1, NULL },
{ "IsEmpty", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoordsArray_IsEmpty, 1, NULL },
{ "Item", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoordsArray_Item, 1, NULL },
{ "RemoveAt", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoordsArray_RemoveAt, 1, NULL },
{ "Shrink", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoordsArray_Shrink, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridCellCoordsArray_delete, 1, NULL },
{ "op_index", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridCellCoordsArray_op_index, 1, NULL },
#if (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "wxGridCellCoordsArray", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridCellCoordsArray_constructor_overload, s_wxluafunc_wxLua_wxGridCellCoordsArray_constructor_overload_count, 0 },
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID)
{ 0, 0, 0, 0 },
};
int wxGridCellCoordsArray_methodCount = sizeof(wxGridCellCoordsArray_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGrid
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGrid'
int wxluatype_wxGrid = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_AppendCols[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_AppendCols(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_AppendCols[1] = {{ wxLua_wxGrid_AppendCols, WXLUAMETHOD_METHOD, 1, 3, s_wxluatypeArray_wxLua_wxGrid_AppendCols }};
// bool AppendCols( int numCols = 1, bool updateLabels=true );
static int LUACALL wxLua_wxGrid_AppendCols(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool updateLabels = true
bool updateLabels = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : true);
// int numCols = 1
int numCols = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : 1);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call AppendCols
bool returns = (self->AppendCols(numCols, updateLabels));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_AppendRows[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_AppendRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_AppendRows[1] = {{ wxLua_wxGrid_AppendRows, WXLUAMETHOD_METHOD, 1, 3, s_wxluatypeArray_wxLua_wxGrid_AppendRows }};
// bool AppendRows( int numRows = 1, bool updateLabels=true );
static int LUACALL wxLua_wxGrid_AppendRows(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool updateLabels = true
bool updateLabels = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : true);
// int numRows = 1
int numRows = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : 1);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call AppendRows
bool returns = (self->AppendRows(numRows, updateLabels));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_AutoSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_AutoSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_AutoSize[1] = {{ wxLua_wxGrid_AutoSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_AutoSize }};
// void AutoSize( );
static int LUACALL wxLua_wxGrid_AutoSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call AutoSize
self->AutoSize();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_AutoSizeColLabelSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_AutoSizeColLabelSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_AutoSizeColLabelSize[1] = {{ wxLua_wxGrid_AutoSizeColLabelSize, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_AutoSizeColLabelSize }};
// void AutoSizeColLabelSize( int col );
static int LUACALL wxLua_wxGrid_AutoSizeColLabelSize(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call AutoSizeColLabelSize
self->AutoSizeColLabelSize(col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_AutoSizeColumn[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_AutoSizeColumn(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_AutoSizeColumn[1] = {{ wxLua_wxGrid_AutoSizeColumn, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxGrid_AutoSizeColumn }};
// void AutoSizeColumn( int col, bool setAsMin = true );
static int LUACALL wxLua_wxGrid_AutoSizeColumn(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool setAsMin = true
bool setAsMin = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : true);
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call AutoSizeColumn
self->AutoSizeColumn(col, setAsMin);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_AutoSizeColumns[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_AutoSizeColumns(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_AutoSizeColumns[1] = {{ wxLua_wxGrid_AutoSizeColumns, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGrid_AutoSizeColumns }};
// void AutoSizeColumns( bool setAsMin = true );
static int LUACALL wxLua_wxGrid_AutoSizeColumns(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool setAsMin = true
bool setAsMin = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call AutoSizeColumns
self->AutoSizeColumns(setAsMin);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_AutoSizeRow[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_AutoSizeRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_AutoSizeRow[1] = {{ wxLua_wxGrid_AutoSizeRow, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxGrid_AutoSizeRow }};
// void AutoSizeRow( int row, bool setAsMin = true );
static int LUACALL wxLua_wxGrid_AutoSizeRow(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool setAsMin = true
bool setAsMin = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : true);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call AutoSizeRow
self->AutoSizeRow(row, setAsMin);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_AutoSizeRowLabelSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_AutoSizeRowLabelSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_AutoSizeRowLabelSize[1] = {{ wxLua_wxGrid_AutoSizeRowLabelSize, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_AutoSizeRowLabelSize }};
// void AutoSizeRowLabelSize( int row );
static int LUACALL wxLua_wxGrid_AutoSizeRowLabelSize(lua_State *L)
{
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call AutoSizeRowLabelSize
self->AutoSizeRowLabelSize(row);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_AutoSizeRows[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_AutoSizeRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_AutoSizeRows[1] = {{ wxLua_wxGrid_AutoSizeRows, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGrid_AutoSizeRows }};
// void AutoSizeRows( bool setAsMin = true );
static int LUACALL wxLua_wxGrid_AutoSizeRows(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool setAsMin = true
bool setAsMin = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call AutoSizeRows
self->AutoSizeRows(setAsMin);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_BeginBatch[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_BeginBatch(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_BeginBatch[1] = {{ wxLua_wxGrid_BeginBatch, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_BeginBatch }};
// void BeginBatch( );
static int LUACALL wxLua_wxGrid_BeginBatch(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call BeginBatch
self->BeginBatch();
return 0;
}
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_BlockToDeviceRect[] = { &wxluatype_wxGrid, &wxluatype_wxGridCellCoords, &wxluatype_wxGridCellCoords, NULL };
static int LUACALL wxLua_wxGrid_BlockToDeviceRect(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_BlockToDeviceRect[1] = {{ wxLua_wxGrid_BlockToDeviceRect, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_BlockToDeviceRect }};
// wxRect BlockToDeviceRect( const wxGridCellCoords& topLeft, const wxGridCellCoords& bottomRight );
static int LUACALL wxLua_wxGrid_BlockToDeviceRect(lua_State *L)
{
// const wxGridCellCoords bottomRight
const wxGridCellCoords * bottomRight = (const wxGridCellCoords *)wxluaT_getuserdatatype(L, 3, wxluatype_wxGridCellCoords);
// const wxGridCellCoords topLeft
const wxGridCellCoords * topLeft = (const wxGridCellCoords *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellCoords);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call BlockToDeviceRect
// allocate a new object using the copy constructor
wxRect* returns = new wxRect(self->BlockToDeviceRect(*topLeft, *bottomRight));
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxRect);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxRect);
return 1;
}
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_CanDragCell[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_CanDragCell(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CanDragCell[1] = {{ wxLua_wxGrid_CanDragCell, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_CanDragCell }};
// bool CanDragCell( );
static int LUACALL wxLua_wxGrid_CanDragCell(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call CanDragCell
bool returns = (self->CanDragCell());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0))
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_CanDragColSize1[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_CanDragColSize1(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CanDragColSize1[1] = {{ wxLua_wxGrid_CanDragColSize1, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_CanDragColSize1 }};
// bool CanDragColSize( int col );
static int LUACALL wxLua_wxGrid_CanDragColSize1(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call CanDragColSize
bool returns = (self->CanDragColSize(col));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0))
#if (wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8))
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_CanDragColSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_CanDragColSize(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CanDragColSize[1] = {{ wxLua_wxGrid_CanDragColSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_CanDragColSize }};
// bool CanDragColSize( );
static int LUACALL wxLua_wxGrid_CanDragColSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call CanDragColSize
bool returns = (self->CanDragColSize());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8))
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_CanDragGridSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_CanDragGridSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CanDragGridSize[1] = {{ wxLua_wxGrid_CanDragGridSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_CanDragGridSize }};
// bool CanDragGridSize( );
static int LUACALL wxLua_wxGrid_CanDragGridSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call CanDragGridSize
bool returns = (self->CanDragGridSize());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0))
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_CanDragRowSize1[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_CanDragRowSize1(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CanDragRowSize1[1] = {{ wxLua_wxGrid_CanDragRowSize1, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_CanDragRowSize1 }};
// bool CanDragRowSize( int row );
static int LUACALL wxLua_wxGrid_CanDragRowSize1(lua_State *L)
{
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call CanDragRowSize
bool returns = (self->CanDragRowSize(row));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0))
#if (wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8))
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_CanDragRowSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_CanDragRowSize(lua_State *L);
// static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CanDragRowSize[1] = {{ wxLua_wxGrid_CanDragRowSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_CanDragRowSize }};
// bool CanDragRowSize( );
static int LUACALL wxLua_wxGrid_CanDragRowSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call CanDragRowSize
bool returns = (self->CanDragRowSize());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8))
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_CanEnableCellControl[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_CanEnableCellControl(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CanEnableCellControl[1] = {{ wxLua_wxGrid_CanEnableCellControl, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_CanEnableCellControl }};
// bool CanEnableCellControl() const;
static int LUACALL wxLua_wxGrid_CanEnableCellControl(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call CanEnableCellControl
bool returns = (self->CanEnableCellControl());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_CellToRect[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_CellToRect(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CellToRect[1] = {{ wxLua_wxGrid_CellToRect, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_CellToRect }};
// wxRect CellToRect( int row, int col );
static int LUACALL wxLua_wxGrid_CellToRect(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call CellToRect
// allocate a new object using the copy constructor
wxRect* returns = new wxRect(self->CellToRect(row, col));
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxRect);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxRect);
return 1;
}
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_ClearGrid[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_ClearGrid(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_ClearGrid[1] = {{ wxLua_wxGrid_ClearGrid, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_ClearGrid }};
// void ClearGrid( );
static int LUACALL wxLua_wxGrid_ClearGrid(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call ClearGrid
self->ClearGrid();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_ClearSelection[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_ClearSelection(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_ClearSelection[1] = {{ wxLua_wxGrid_ClearSelection, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_ClearSelection }};
// void ClearSelection( );
static int LUACALL wxLua_wxGrid_ClearSelection(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call ClearSelection
self->ClearSelection();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_CreateGrid[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGrid_CreateGrid(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CreateGrid[1] = {{ wxLua_wxGrid_CreateGrid, WXLUAMETHOD_METHOD, 3, 4, s_wxluatypeArray_wxLua_wxGrid_CreateGrid }};
// bool CreateGrid( int numRows, int numCols, wxGrid::wxGridSelectionModes selmode = wxGrid::wxGridSelectCells );
static int LUACALL wxLua_wxGrid_CreateGrid(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxGrid::wxGridSelectionModes selmode = wxGrid::wxGridSelectCells
wxGrid::wxGridSelectionModes selmode = (argCount >= 4 ? (wxGrid::wxGridSelectionModes)wxlua_getenumtype(L, 4) : wxGrid::wxGridSelectCells);
// int numCols
int numCols = (int)wxlua_getnumbertype(L, 3);
// int numRows
int numRows = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call CreateGrid
bool returns = (self->CreateGrid(numRows, numCols, selmode));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DeleteCols[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_DeleteCols(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DeleteCols[1] = {{ wxLua_wxGrid_DeleteCols, WXLUAMETHOD_METHOD, 1, 4, s_wxluatypeArray_wxLua_wxGrid_DeleteCols }};
// bool DeleteCols( int pos = 0, int numCols = 1, bool updateLabels=true );
static int LUACALL wxLua_wxGrid_DeleteCols(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool updateLabels = true
bool updateLabels = (argCount >= 4 ? wxlua_getbooleantype(L, 4) : true);
// int numCols = 1
int numCols = (argCount >= 3 ? (int)wxlua_getnumbertype(L, 3) : 1);
// int pos = 0
int pos = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : 0);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DeleteCols
bool returns = (self->DeleteCols(pos, numCols, updateLabels));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DeleteRows[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_DeleteRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DeleteRows[1] = {{ wxLua_wxGrid_DeleteRows, WXLUAMETHOD_METHOD, 1, 4, s_wxluatypeArray_wxLua_wxGrid_DeleteRows }};
// bool DeleteRows( int pos = 0, int numRows = 1, bool updateLabels=true );
static int LUACALL wxLua_wxGrid_DeleteRows(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool updateLabels = true
bool updateLabels = (argCount >= 4 ? wxlua_getbooleantype(L, 4) : true);
// int numRows = 1
int numRows = (argCount >= 3 ? (int)wxlua_getnumbertype(L, 3) : 1);
// int pos = 0
int pos = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : 0);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DeleteRows
bool returns = (self->DeleteRows(pos, numRows, updateLabels));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DeselectCell[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_DeselectCell(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DeselectCell[1] = {{ wxLua_wxGrid_DeselectCell, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_DeselectCell }};
// void DeselectCell( int row, int col );
static int LUACALL wxLua_wxGrid_DeselectCell(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DeselectCell
self->DeselectCell(row, col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DeselectCol[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_DeselectCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DeselectCol[1] = {{ wxLua_wxGrid_DeselectCol, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_DeselectCol }};
// void DeselectCol( int col );
static int LUACALL wxLua_wxGrid_DeselectCol(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DeselectCol
self->DeselectCol(col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DeselectRow[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_DeselectRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DeselectRow[1] = {{ wxLua_wxGrid_DeselectRow, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_DeselectRow }};
// void DeselectRow( int row );
static int LUACALL wxLua_wxGrid_DeselectRow(lua_State *L)
{
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DeselectRow
self->DeselectRow(row);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DisableCellEditControl[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_DisableCellEditControl(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DisableCellEditControl[1] = {{ wxLua_wxGrid_DisableCellEditControl, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_DisableCellEditControl }};
// void DisableCellEditControl( );
static int LUACALL wxLua_wxGrid_DisableCellEditControl(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DisableCellEditControl
self->DisableCellEditControl();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DisableDragCell[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_DisableDragCell(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DisableDragCell[1] = {{ wxLua_wxGrid_DisableDragCell, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_DisableDragCell }};
// void DisableDragCell( );
static int LUACALL wxLua_wxGrid_DisableDragCell(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DisableDragCell
self->DisableDragCell();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DisableDragColSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_DisableDragColSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DisableDragColSize[1] = {{ wxLua_wxGrid_DisableDragColSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_DisableDragColSize }};
// void DisableDragColSize( );
static int LUACALL wxLua_wxGrid_DisableDragColSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DisableDragColSize
self->DisableDragColSize();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DisableDragGridSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_DisableDragGridSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DisableDragGridSize[1] = {{ wxLua_wxGrid_DisableDragGridSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_DisableDragGridSize }};
// void DisableDragGridSize( );
static int LUACALL wxLua_wxGrid_DisableDragGridSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DisableDragGridSize
self->DisableDragGridSize();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DisableDragRowSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_DisableDragRowSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DisableDragRowSize[1] = {{ wxLua_wxGrid_DisableDragRowSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_DisableDragRowSize }};
// void DisableDragRowSize( );
static int LUACALL wxLua_wxGrid_DisableDragRowSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DisableDragRowSize
self->DisableDragRowSize();
return 0;
}
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && (wxLUA_USE_wxDC)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_DrawTextRectangle[] = { &wxluatype_wxGrid, &wxluatype_wxDC, &wxluatype_TSTRING, &wxluatype_wxRect, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_DrawTextRectangle(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_DrawTextRectangle[1] = {{ wxLua_wxGrid_DrawTextRectangle, WXLUAMETHOD_METHOD, 4, 7, s_wxluatypeArray_wxLua_wxGrid_DrawTextRectangle }};
// void DrawTextRectangle( wxDC& dc, const wxString&, const wxRect&, int horizontalAlignment = wxALIGN_LEFT, int verticalAlignment = wxALIGN_TOP, int textOrientation = wxHORIZONTAL );
static int LUACALL wxLua_wxGrid_DrawTextRectangle(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int textOrientation = wxHORIZONTAL
int textOrientation = (argCount >= 7 ? (int)wxlua_getnumbertype(L, 7) : wxHORIZONTAL);
// int verticalAlignment = wxALIGN_TOP
int verticalAlignment = (argCount >= 6 ? (int)wxlua_getnumbertype(L, 6) : wxALIGN_TOP);
// int horizontalAlignment = wxALIGN_LEFT
int horizontalAlignment = (argCount >= 5 ? (int)wxlua_getnumbertype(L, 5) : wxALIGN_LEFT);
// const wxRect arg3
const wxRect * arg3 = (const wxRect *)wxluaT_getuserdatatype(L, 4, wxluatype_wxRect);
// const wxString arg2
const wxString arg2 = wxlua_getwxStringtype(L, 3);
// wxDC dc
wxDC * dc = (wxDC *)wxluaT_getuserdatatype(L, 2, wxluatype_wxDC);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call DrawTextRectangle
self->DrawTextRectangle(*dc, arg2, *arg3, horizontalAlignment, verticalAlignment, textOrientation);
return 0;
}
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && (wxLUA_USE_wxDC)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_EnableCellEditControl[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_EnableCellEditControl(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_EnableCellEditControl[1] = {{ wxLua_wxGrid_EnableCellEditControl, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGrid_EnableCellEditControl }};
// void EnableCellEditControl( bool enable = true );
static int LUACALL wxLua_wxGrid_EnableCellEditControl(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool enable = true
bool enable = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call EnableCellEditControl
self->EnableCellEditControl(enable);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_EnableDragCell[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_EnableDragCell(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_EnableDragCell[1] = {{ wxLua_wxGrid_EnableDragCell, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGrid_EnableDragCell }};
// void EnableDragCell( bool enable = true );
static int LUACALL wxLua_wxGrid_EnableDragCell(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool enable = true
bool enable = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call EnableDragCell
self->EnableDragCell(enable);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_EnableDragColSize[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_EnableDragColSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_EnableDragColSize[1] = {{ wxLua_wxGrid_EnableDragColSize, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGrid_EnableDragColSize }};
// void EnableDragColSize( bool enable = true );
static int LUACALL wxLua_wxGrid_EnableDragColSize(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool enable = true
bool enable = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call EnableDragColSize
self->EnableDragColSize(enable);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_EnableDragGridSize[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_EnableDragGridSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_EnableDragGridSize[1] = {{ wxLua_wxGrid_EnableDragGridSize, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGrid_EnableDragGridSize }};
// void EnableDragGridSize(bool enable = true );
static int LUACALL wxLua_wxGrid_EnableDragGridSize(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool enable = true
bool enable = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call EnableDragGridSize
self->EnableDragGridSize(enable);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_EnableDragRowSize[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_EnableDragRowSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_EnableDragRowSize[1] = {{ wxLua_wxGrid_EnableDragRowSize, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGrid_EnableDragRowSize }};
// void EnableDragRowSize( bool enable = true );
static int LUACALL wxLua_wxGrid_EnableDragRowSize(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool enable = true
bool enable = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call EnableDragRowSize
self->EnableDragRowSize(enable);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_EnableEditing[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_EnableEditing(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_EnableEditing[1] = {{ wxLua_wxGrid_EnableEditing, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_EnableEditing }};
// void EnableEditing( bool edit );
static int LUACALL wxLua_wxGrid_EnableEditing(lua_State *L)
{
// bool edit
bool edit = wxlua_getbooleantype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call EnableEditing
self->EnableEditing(edit);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_EnableGridLines[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_EnableGridLines(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_EnableGridLines[1] = {{ wxLua_wxGrid_EnableGridLines, WXLUAMETHOD_METHOD, 1, 2, s_wxluatypeArray_wxLua_wxGrid_EnableGridLines }};
// void EnableGridLines( bool enable = true );
static int LUACALL wxLua_wxGrid_EnableGridLines(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool enable = true
bool enable = (argCount >= 2 ? wxlua_getbooleantype(L, 2) : true);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call EnableGridLines
self->EnableGridLines(enable);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_EndBatch[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_EndBatch(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_EndBatch[1] = {{ wxLua_wxGrid_EndBatch, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_EndBatch }};
// void EndBatch( );
static int LUACALL wxLua_wxGrid_EndBatch(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call EndBatch
self->EndBatch();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_ForceRefresh[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_ForceRefresh(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_ForceRefresh[1] = {{ wxLua_wxGrid_ForceRefresh, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_ForceRefresh }};
// void ForceRefresh( );
static int LUACALL wxLua_wxGrid_ForceRefresh(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call ForceRefresh
self->ForceRefresh();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetBatchCount[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetBatchCount(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetBatchCount[1] = {{ wxLua_wxGrid_GetBatchCount, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetBatchCount }};
// int GetBatchCount( );
static int LUACALL wxLua_wxGrid_GetBatchCount(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetBatchCount
int returns = (self->GetBatchCount());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellAlignment[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetCellAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellAlignment[1] = {{ wxLua_wxGrid_GetCellAlignment, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetCellAlignment }};
// %override wxLua_wxGrid_GetCellAlignment
// void GetCellAlignment( int row, int col, int *horiz, int *vert )
static int LUACALL wxLua_wxGrid_GetCellAlignment(lua_State *L)
{
int vert;
int horiz;
// int col
int col = (int)lua_tonumber(L, 3);
// int row
int row = (int)lua_tonumber(L, 2);
// get this
wxGrid *self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellAlignment
self->GetCellAlignment(row, col, &horiz, &vert);
// push results
lua_pushnumber(L, horiz);
lua_pushnumber(L, vert);
// return the number of parameters
return 2;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellBackgroundColour[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetCellBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellBackgroundColour[1] = {{ wxLua_wxGrid_GetCellBackgroundColour, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetCellBackgroundColour }};
// wxColour GetCellBackgroundColour( int row, int col );
static int LUACALL wxLua_wxGrid_GetCellBackgroundColour(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellBackgroundColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetCellBackgroundColour(row, col));
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellEditor[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetCellEditor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellEditor[1] = {{ wxLua_wxGrid_GetCellEditor, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetCellEditor }};
// %gc wxGridCellEditor* GetCellEditor(int row, int col );
static int LUACALL wxLua_wxGrid_GetCellEditor(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellEditor
wxGridCellEditor* returns = (wxGridCellEditor*)self->GetCellEditor(row, col);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellEditor);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellEditor);
return 1;
}
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellFont[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetCellFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellFont[1] = {{ wxLua_wxGrid_GetCellFont, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetCellFont }};
// wxFont GetCellFont( int row, int col );
static int LUACALL wxLua_wxGrid_GetCellFont(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellFont
// allocate a new object using the copy constructor
wxFont* returns = new wxFont(self->GetCellFont(row, col));
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxFont);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxFont);
return 1;
}
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellHighlightColour[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetCellHighlightColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellHighlightColour[1] = {{ wxLua_wxGrid_GetCellHighlightColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetCellHighlightColour }};
// wxColour GetCellHighlightColour( );
static int LUACALL wxLua_wxGrid_GetCellHighlightColour(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellHighlightColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetCellHighlightColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellHighlightPenWidth[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetCellHighlightPenWidth(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellHighlightPenWidth[1] = {{ wxLua_wxGrid_GetCellHighlightPenWidth, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetCellHighlightPenWidth }};
// int GetCellHighlightPenWidth( );
static int LUACALL wxLua_wxGrid_GetCellHighlightPenWidth(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellHighlightPenWidth
int returns = (self->GetCellHighlightPenWidth());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellHighlightROPenWidth[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetCellHighlightROPenWidth(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellHighlightROPenWidth[1] = {{ wxLua_wxGrid_GetCellHighlightROPenWidth, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetCellHighlightROPenWidth }};
// int GetCellHighlightROPenWidth( );
static int LUACALL wxLua_wxGrid_GetCellHighlightROPenWidth(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellHighlightROPenWidth
int returns = (self->GetCellHighlightROPenWidth());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellOverflow[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetCellOverflow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellOverflow[1] = {{ wxLua_wxGrid_GetCellOverflow, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetCellOverflow }};
// bool GetCellOverflow( int row, int col );
static int LUACALL wxLua_wxGrid_GetCellOverflow(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellOverflow
bool returns = (self->GetCellOverflow(row, col));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellRenderer[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetCellRenderer(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellRenderer[1] = {{ wxLua_wxGrid_GetCellRenderer, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetCellRenderer }};
// %gc wxGridCellRenderer* GetCellRenderer(int row, int col );
static int LUACALL wxLua_wxGrid_GetCellRenderer(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellRenderer
wxGridCellRenderer* returns = (wxGridCellRenderer*)self->GetCellRenderer(row, col);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellRenderer);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellRenderer);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetCellSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellSize[1] = {{ wxLua_wxGrid_GetCellSize, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetCellSize }};
// %override wxLua_wxGrid_GetCellSize
// void GetCellSize( int row, int col, int *num_rows, int *num_cols )
static int LUACALL wxLua_wxGrid_GetCellSize(lua_State *L)
{
int num_rows;
int num_cols;
// int col
int col = (int)lua_tonumber(L, 3);
// int row
int row = (int)lua_tonumber(L, 2);
// get this
wxGrid *self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellSize
self->GetCellSize(row, col, &num_rows, &num_cols);
// push results
lua_pushnumber(L, num_rows);
lua_pushnumber(L, num_cols);
// return the number of parameters
return 2;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellTextColour[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetCellTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellTextColour[1] = {{ wxLua_wxGrid_GetCellTextColour, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetCellTextColour }};
// wxColour GetCellTextColour( int row, int col );
static int LUACALL wxLua_wxGrid_GetCellTextColour(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellTextColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetCellTextColour(row, col));
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetCellValue[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetCellValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetCellValue[1] = {{ wxLua_wxGrid_GetCellValue, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetCellValue }};
// wxString GetCellValue( int row, int col );
static int LUACALL wxLua_wxGrid_GetCellValue(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetCellValue
wxString returns = (self->GetCellValue(row, col));
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetColLabelAlignment[] = { &wxluatype_wxGrid, &wxluatype_TLIGHTUSERDATA, &wxluatype_TLIGHTUSERDATA, NULL };
static int LUACALL wxLua_wxGrid_GetColLabelAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetColLabelAlignment[1] = {{ wxLua_wxGrid_GetColLabelAlignment, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetColLabelAlignment }};
// %override wxLua_wxGrid_GetColLabelAlignment
// void GetColLabelAlignment( int *horz, int *vert )
static int LUACALL wxLua_wxGrid_GetColLabelAlignment(lua_State *L)
{
int vert;
int horz;
// get this
wxGrid *self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetColLabelAlignment
self->GetColLabelAlignment(&horz, &vert);
// push results
lua_pushnumber(L, horz);
lua_pushnumber(L, vert);
// return the number of parameters
return 2;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetColLabelSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetColLabelSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetColLabelSize[1] = {{ wxLua_wxGrid_GetColLabelSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetColLabelSize }};
// int GetColLabelSize( );
static int LUACALL wxLua_wxGrid_GetColLabelSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetColLabelSize
int returns = (self->GetColLabelSize());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetColLabelTextOrientation[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetColLabelTextOrientation(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetColLabelTextOrientation[1] = {{ wxLua_wxGrid_GetColLabelTextOrientation, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetColLabelTextOrientation }};
// int GetColLabelTextOrientation( );
static int LUACALL wxLua_wxGrid_GetColLabelTextOrientation(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetColLabelTextOrientation
int returns = (self->GetColLabelTextOrientation());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetColLabelValue[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetColLabelValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetColLabelValue[1] = {{ wxLua_wxGrid_GetColLabelValue, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_GetColLabelValue }};
// wxString GetColLabelValue( int col );
static int LUACALL wxLua_wxGrid_GetColLabelValue(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetColLabelValue
wxString returns = (self->GetColLabelValue(col));
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetColMinimalAcceptableWidth[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetColMinimalAcceptableWidth(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetColMinimalAcceptableWidth[1] = {{ wxLua_wxGrid_GetColMinimalAcceptableWidth, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetColMinimalAcceptableWidth }};
// int GetColMinimalAcceptableWidth() const;
static int LUACALL wxLua_wxGrid_GetColMinimalAcceptableWidth(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetColMinimalAcceptableWidth
int returns = (self->GetColMinimalAcceptableWidth());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetColSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetColSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetColSize[1] = {{ wxLua_wxGrid_GetColSize, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_GetColSize }};
// int GetColSize( int col );
static int LUACALL wxLua_wxGrid_GetColSize(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetColSize
int returns = (self->GetColSize(col));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultCellAlignment[] = { &wxluatype_wxGrid, &wxluatype_TLIGHTUSERDATA, &wxluatype_TLIGHTUSERDATA, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultCellAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultCellAlignment[1] = {{ wxLua_wxGrid_GetDefaultCellAlignment, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetDefaultCellAlignment }};
// %override wxLua_wxGrid_GetDefaultCellAlignment
// void GetDefaultCellAlignment( int *horiz, int *vert )
static int LUACALL wxLua_wxGrid_GetDefaultCellAlignment(lua_State *L)
{
int vert;
int horiz;
// get this
wxGrid *self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultCellAlignment
self->GetDefaultCellAlignment(&horiz, &vert);
// push results
lua_pushnumber(L, horiz);
lua_pushnumber(L, vert);
// return the number of parameters
return 2;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultCellBackgroundColour[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultCellBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultCellBackgroundColour[1] = {{ wxLua_wxGrid_GetDefaultCellBackgroundColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetDefaultCellBackgroundColour }};
// wxColour GetDefaultCellBackgroundColour( );
static int LUACALL wxLua_wxGrid_GetDefaultCellBackgroundColour(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultCellBackgroundColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetDefaultCellBackgroundColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultCellFont[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultCellFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultCellFont[1] = {{ wxLua_wxGrid_GetDefaultCellFont, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetDefaultCellFont }};
// wxFont GetDefaultCellFont( );
static int LUACALL wxLua_wxGrid_GetDefaultCellFont(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultCellFont
// allocate a new object using the copy constructor
wxFont* returns = new wxFont(self->GetDefaultCellFont());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxFont);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxFont);
return 1;
}
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultCellOverflow[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultCellOverflow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultCellOverflow[1] = {{ wxLua_wxGrid_GetDefaultCellOverflow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetDefaultCellOverflow }};
// bool GetDefaultCellOverflow( );
static int LUACALL wxLua_wxGrid_GetDefaultCellOverflow(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultCellOverflow
bool returns = (self->GetDefaultCellOverflow());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultCellTextColour[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultCellTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultCellTextColour[1] = {{ wxLua_wxGrid_GetDefaultCellTextColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetDefaultCellTextColour }};
// wxColour GetDefaultCellTextColour( );
static int LUACALL wxLua_wxGrid_GetDefaultCellTextColour(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultCellTextColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetDefaultCellTextColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultColLabelSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultColLabelSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultColLabelSize[1] = {{ wxLua_wxGrid_GetDefaultColLabelSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetDefaultColLabelSize }};
// int GetDefaultColLabelSize( );
static int LUACALL wxLua_wxGrid_GetDefaultColLabelSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultColLabelSize
int returns = (self->GetDefaultColLabelSize());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultColSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultColSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultColSize[1] = {{ wxLua_wxGrid_GetDefaultColSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetDefaultColSize }};
// int GetDefaultColSize( );
static int LUACALL wxLua_wxGrid_GetDefaultColSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultColSize
int returns = (self->GetDefaultColSize());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultEditor[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultEditor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultEditor[1] = {{ wxLua_wxGrid_GetDefaultEditor, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetDefaultEditor }};
// %gc wxGridCellEditor* GetDefaultEditor() const;
static int LUACALL wxLua_wxGrid_GetDefaultEditor(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultEditor
wxGridCellEditor* returns = (wxGridCellEditor*)self->GetDefaultEditor();
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellEditor);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellEditor);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultEditorForCell[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultEditorForCell(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultEditorForCell[1] = {{ wxLua_wxGrid_GetDefaultEditorForCell, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetDefaultEditorForCell }};
// %gc wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
static int LUACALL wxLua_wxGrid_GetDefaultEditorForCell(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultEditorForCell
wxGridCellEditor* returns = (wxGridCellEditor*)self->GetDefaultEditorForCell(row, col);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellEditor);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellEditor);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultEditorForType[] = { &wxluatype_wxGrid, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultEditorForType(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultEditorForType[1] = {{ wxLua_wxGrid_GetDefaultEditorForType, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_GetDefaultEditorForType }};
// %gc wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
static int LUACALL wxLua_wxGrid_GetDefaultEditorForType(lua_State *L)
{
// const wxString typeName
const wxString typeName = wxlua_getwxStringtype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultEditorForType
wxGridCellEditor* returns = (wxGridCellEditor*)self->GetDefaultEditorForType(typeName);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellEditor);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellEditor);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultRenderer[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultRenderer(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultRenderer[1] = {{ wxLua_wxGrid_GetDefaultRenderer, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetDefaultRenderer }};
// %gc wxGridCellRenderer* GetDefaultRenderer() const;
static int LUACALL wxLua_wxGrid_GetDefaultRenderer(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultRenderer
wxGridCellRenderer* returns = (wxGridCellRenderer*)self->GetDefaultRenderer();
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellRenderer);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellRenderer);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultRendererForCell[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultRendererForCell(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultRendererForCell[1] = {{ wxLua_wxGrid_GetDefaultRendererForCell, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetDefaultRendererForCell }};
// %gc wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
static int LUACALL wxLua_wxGrid_GetDefaultRendererForCell(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultRendererForCell
wxGridCellRenderer* returns = (wxGridCellRenderer*)self->GetDefaultRendererForCell(row, col);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellRenderer);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellRenderer);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultRendererForType[] = { &wxluatype_wxGrid, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultRendererForType(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultRendererForType[1] = {{ wxLua_wxGrid_GetDefaultRendererForType, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_GetDefaultRendererForType }};
// %gc wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
static int LUACALL wxLua_wxGrid_GetDefaultRendererForType(lua_State *L)
{
// const wxString typeName
const wxString typeName = wxlua_getwxStringtype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultRendererForType
wxGridCellRenderer* returns = (wxGridCellRenderer*)self->GetDefaultRendererForType(typeName);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellRenderer);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellRenderer);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultRowLabelSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultRowLabelSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultRowLabelSize[1] = {{ wxLua_wxGrid_GetDefaultRowLabelSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetDefaultRowLabelSize }};
// int GetDefaultRowLabelSize( );
static int LUACALL wxLua_wxGrid_GetDefaultRowLabelSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultRowLabelSize
int returns = (self->GetDefaultRowLabelSize());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetDefaultRowSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetDefaultRowSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetDefaultRowSize[1] = {{ wxLua_wxGrid_GetDefaultRowSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetDefaultRowSize }};
// int GetDefaultRowSize( );
static int LUACALL wxLua_wxGrid_GetDefaultRowSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetDefaultRowSize
int returns = (self->GetDefaultRowSize());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetGridColLabelWindow[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetGridColLabelWindow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetGridColLabelWindow[1] = {{ wxLua_wxGrid_GetGridColLabelWindow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetGridColLabelWindow }};
// wxWindow* GetGridColLabelWindow( );
static int LUACALL wxLua_wxGrid_GetGridColLabelWindow(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetGridColLabelWindow
wxWindow* returns = (wxWindow*)self->GetGridColLabelWindow();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWindow);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetGridCornerLabelWindow[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetGridCornerLabelWindow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetGridCornerLabelWindow[1] = {{ wxLua_wxGrid_GetGridCornerLabelWindow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetGridCornerLabelWindow }};
// wxWindow* GetGridCornerLabelWindow( );
static int LUACALL wxLua_wxGrid_GetGridCornerLabelWindow(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetGridCornerLabelWindow
wxWindow* returns = (wxWindow*)self->GetGridCornerLabelWindow();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWindow);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetGridCursorCol[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetGridCursorCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetGridCursorCol[1] = {{ wxLua_wxGrid_GetGridCursorCol, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetGridCursorCol }};
// int GetGridCursorCol( );
static int LUACALL wxLua_wxGrid_GetGridCursorCol(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetGridCursorCol
int returns = (self->GetGridCursorCol());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetGridCursorRow[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetGridCursorRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetGridCursorRow[1] = {{ wxLua_wxGrid_GetGridCursorRow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetGridCursorRow }};
// int GetGridCursorRow( );
static int LUACALL wxLua_wxGrid_GetGridCursorRow(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetGridCursorRow
int returns = (self->GetGridCursorRow());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetGridLineColour[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetGridLineColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetGridLineColour[1] = {{ wxLua_wxGrid_GetGridLineColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetGridLineColour }};
// wxColour GetGridLineColour( );
static int LUACALL wxLua_wxGrid_GetGridLineColour(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetGridLineColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetGridLineColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetGridRowLabelWindow[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetGridRowLabelWindow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetGridRowLabelWindow[1] = {{ wxLua_wxGrid_GetGridRowLabelWindow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetGridRowLabelWindow }};
// wxWindow* GetGridRowLabelWindow( );
static int LUACALL wxLua_wxGrid_GetGridRowLabelWindow(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetGridRowLabelWindow
wxWindow* returns = (wxWindow*)self->GetGridRowLabelWindow();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWindow);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetGridWindow[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetGridWindow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetGridWindow[1] = {{ wxLua_wxGrid_GetGridWindow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetGridWindow }};
// wxWindow* GetGridWindow( );
static int LUACALL wxLua_wxGrid_GetGridWindow(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetGridWindow
wxWindow* returns = (wxWindow*)self->GetGridWindow();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxWindow);
return 1;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetLabelBackgroundColour[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetLabelBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetLabelBackgroundColour[1] = {{ wxLua_wxGrid_GetLabelBackgroundColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetLabelBackgroundColour }};
// wxColour GetLabelBackgroundColour( );
static int LUACALL wxLua_wxGrid_GetLabelBackgroundColour(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetLabelBackgroundColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetLabelBackgroundColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetLabelFont[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetLabelFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetLabelFont[1] = {{ wxLua_wxGrid_GetLabelFont, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetLabelFont }};
// wxFont GetLabelFont( );
static int LUACALL wxLua_wxGrid_GetLabelFont(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetLabelFont
// allocate a new object using the copy constructor
wxFont* returns = new wxFont(self->GetLabelFont());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxFont);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxFont);
return 1;
}
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetLabelTextColour[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetLabelTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetLabelTextColour[1] = {{ wxLua_wxGrid_GetLabelTextColour, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetLabelTextColour }};
// wxColour GetLabelTextColour( );
static int LUACALL wxLua_wxGrid_GetLabelTextColour(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetLabelTextColour
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetLabelTextColour());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetNumberCols[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetNumberCols(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetNumberCols[1] = {{ wxLua_wxGrid_GetNumberCols, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetNumberCols }};
// int GetNumberCols( );
static int LUACALL wxLua_wxGrid_GetNumberCols(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetNumberCols
int returns = (self->GetNumberCols());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetNumberRows[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetNumberRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetNumberRows[1] = {{ wxLua_wxGrid_GetNumberRows, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetNumberRows }};
// int GetNumberRows( );
static int LUACALL wxLua_wxGrid_GetNumberRows(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetNumberRows
int returns = (self->GetNumberRows());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetOrCreateCellAttr[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetOrCreateCellAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetOrCreateCellAttr[1] = {{ wxLua_wxGrid_GetOrCreateCellAttr, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetOrCreateCellAttr }};
// %gc wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
static int LUACALL wxLua_wxGrid_GetOrCreateCellAttr(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetOrCreateCellAttr
wxGridCellAttr* returns = (wxGridCellAttr*)self->GetOrCreateCellAttr(row, col);
if (!wxluaO_isgcobject(L, returns)) wxluaO_addgcobject(L, returns, wxluatype_wxGridCellAttr);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellAttr);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetRowLabelAlignment[] = { &wxluatype_wxGrid, &wxluatype_TLIGHTUSERDATA, &wxluatype_TLIGHTUSERDATA, NULL };
static int LUACALL wxLua_wxGrid_GetRowLabelAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetRowLabelAlignment[1] = {{ wxLua_wxGrid_GetRowLabelAlignment, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetRowLabelAlignment }};
// %override wxLua_wxGrid_GetRowLabelAlignment
// void GetRowLabelAlignment( int *horz, int *vert )
static int LUACALL wxLua_wxGrid_GetRowLabelAlignment(lua_State *L)
{
int vert;
int horz;
// get this
wxGrid *self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetRowLabelAlignment
self->GetRowLabelAlignment(&horz, &vert);
// push results
lua_pushnumber(L, horz);
lua_pushnumber(L, vert);
// return the number of parameters
return 2;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetRowLabelSize[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetRowLabelSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetRowLabelSize[1] = {{ wxLua_wxGrid_GetRowLabelSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetRowLabelSize }};
// int GetRowLabelSize( );
static int LUACALL wxLua_wxGrid_GetRowLabelSize(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetRowLabelSize
int returns = (self->GetRowLabelSize());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetRowLabelValue[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetRowLabelValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetRowLabelValue[1] = {{ wxLua_wxGrid_GetRowLabelValue, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_GetRowLabelValue }};
// wxString GetRowLabelValue( int row );
static int LUACALL wxLua_wxGrid_GetRowLabelValue(lua_State *L)
{
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetRowLabelValue
wxString returns = (self->GetRowLabelValue(row));
// push the result string
wxlua_pushwxString(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetRowMinimalAcceptableHeight[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetRowMinimalAcceptableHeight(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetRowMinimalAcceptableHeight[1] = {{ wxLua_wxGrid_GetRowMinimalAcceptableHeight, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetRowMinimalAcceptableHeight }};
// int GetRowMinimalAcceptableHeight() const;
static int LUACALL wxLua_wxGrid_GetRowMinimalAcceptableHeight(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetRowMinimalAcceptableHeight
int returns = (self->GetRowMinimalAcceptableHeight());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetRowSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_GetRowSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetRowSize[1] = {{ wxLua_wxGrid_GetRowSize, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_GetRowSize }};
// int GetRowSize( int row );
static int LUACALL wxLua_wxGrid_GetRowSize(lua_State *L)
{
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetRowSize
int returns = (self->GetRowSize(row));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetSelectedCells[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetSelectedCells(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetSelectedCells[1] = {{ wxLua_wxGrid_GetSelectedCells, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetSelectedCells }};
// wxGridCellCoordsArray GetSelectedCells() const;
static int LUACALL wxLua_wxGrid_GetSelectedCells(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetSelectedCells
// allocate a new object using the copy constructor
wxGridCellCoordsArray* returns = new wxGridCellCoordsArray(self->GetSelectedCells());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellCoordsArray);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoordsArray);
return 1;
}
#if (wxLUA_USE_wxArrayInt) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetSelectedCols[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetSelectedCols(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetSelectedCols[1] = {{ wxLua_wxGrid_GetSelectedCols, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetSelectedCols }};
// wxArrayInt GetSelectedCols() const;
static int LUACALL wxLua_wxGrid_GetSelectedCols(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetSelectedCols
// allocate a new object using the copy constructor
wxArrayInt* returns = new wxArrayInt(self->GetSelectedCols());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxArrayInt);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxArrayInt);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetSelectedRows[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetSelectedRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetSelectedRows[1] = {{ wxLua_wxGrid_GetSelectedRows, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetSelectedRows }};
// wxArrayInt GetSelectedRows() const;
static int LUACALL wxLua_wxGrid_GetSelectedRows(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetSelectedRows
// allocate a new object using the copy constructor
wxArrayInt* returns = new wxArrayInt(self->GetSelectedRows());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxArrayInt);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxArrayInt);
return 1;
}
#endif // (wxLUA_USE_wxArrayInt) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetSelectionBackground[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetSelectionBackground(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetSelectionBackground[1] = {{ wxLua_wxGrid_GetSelectionBackground, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetSelectionBackground }};
// wxColour GetSelectionBackground() const;
static int LUACALL wxLua_wxGrid_GetSelectionBackground(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetSelectionBackground
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetSelectionBackground());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetSelectionBlockBottomRight[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetSelectionBlockBottomRight(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetSelectionBlockBottomRight[1] = {{ wxLua_wxGrid_GetSelectionBlockBottomRight, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetSelectionBlockBottomRight }};
// wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
static int LUACALL wxLua_wxGrid_GetSelectionBlockBottomRight(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetSelectionBlockBottomRight
// allocate a new object using the copy constructor
wxGridCellCoordsArray* returns = new wxGridCellCoordsArray(self->GetSelectionBlockBottomRight());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellCoordsArray);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoordsArray);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetSelectionBlockTopLeft[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetSelectionBlockTopLeft(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetSelectionBlockTopLeft[1] = {{ wxLua_wxGrid_GetSelectionBlockTopLeft, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetSelectionBlockTopLeft }};
// wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
static int LUACALL wxLua_wxGrid_GetSelectionBlockTopLeft(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetSelectionBlockTopLeft
// allocate a new object using the copy constructor
wxGridCellCoordsArray* returns = new wxGridCellCoordsArray(self->GetSelectionBlockTopLeft());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellCoordsArray);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoordsArray);
return 1;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetSelectionForeground[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetSelectionForeground(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetSelectionForeground[1] = {{ wxLua_wxGrid_GetSelectionForeground, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetSelectionForeground }};
// wxColour GetSelectionForeground() const;
static int LUACALL wxLua_wxGrid_GetSelectionForeground(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetSelectionForeground
// allocate a new object using the copy constructor
wxColour* returns = new wxColour(self->GetSelectionForeground());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxColour);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxColour);
return 1;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetSelectionMode[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetSelectionMode(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetSelectionMode[1] = {{ wxLua_wxGrid_GetSelectionMode, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetSelectionMode }};
// wxGrid::wxGridSelectionModes GetSelectionMode() const;
static int LUACALL wxLua_wxGrid_GetSelectionMode(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetSelectionMode
wxGrid::wxGridSelectionModes returns = (self->GetSelectionMode());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetTable[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GetTable(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetTable[1] = {{ wxLua_wxGrid_GetTable, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GetTable }};
// wxGridTableBase * GetTable() const;
static int LUACALL wxLua_wxGrid_GetTable(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetTable
wxGridTableBase* returns = (wxGridTableBase*)self->GetTable();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridTableBase);
return 1;
}
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxDC)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GetTextBoxSize[] = { &wxluatype_wxGrid, &wxluatype_wxDC, &wxluatype_wxArrayString, NULL };
static int LUACALL wxLua_wxGrid_GetTextBoxSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GetTextBoxSize[1] = {{ wxLua_wxGrid_GetTextBoxSize, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_GetTextBoxSize }};
// %override wxLua_wxGrid_GetTextBoxSize
// void GetTextBoxSize(wxDC& dc, wxArrayString& lines, long * width, long * height)
static int LUACALL wxLua_wxGrid_GetTextBoxSize(lua_State *L)
{
long height;
long width;
// wxArrayString& lines
wxArrayString *lines = (wxArrayString *)wxluaT_getuserdatatype(L, 3, wxluatype_wxArrayString);
// wxDC& dc
wxDC *dc = (wxDC *)wxluaT_getuserdatatype(L, 2, wxluatype_wxDC);
// get this
wxGrid *self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GetTextBoxSize
self->GetTextBoxSize(*dc, *lines, &width, &height);
lua_pushnumber(L, width);
lua_pushnumber(L, height);
// return the number of parameters
return 2;
}
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxDC)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_GridLinesEnabled[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_GridLinesEnabled(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_GridLinesEnabled[1] = {{ wxLua_wxGrid_GridLinesEnabled, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_GridLinesEnabled }};
// bool GridLinesEnabled( );
static int LUACALL wxLua_wxGrid_GridLinesEnabled(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call GridLinesEnabled
bool returns = (self->GridLinesEnabled());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_HideCellEditControl[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_HideCellEditControl(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_HideCellEditControl[1] = {{ wxLua_wxGrid_HideCellEditControl, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_HideCellEditControl }};
// void HideCellEditControl( );
static int LUACALL wxLua_wxGrid_HideCellEditControl(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call HideCellEditControl
self->HideCellEditControl();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_InsertCols[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_InsertCols(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_InsertCols[1] = {{ wxLua_wxGrid_InsertCols, WXLUAMETHOD_METHOD, 1, 4, s_wxluatypeArray_wxLua_wxGrid_InsertCols }};
// bool InsertCols( int pos = 0, int numCols = 1, bool updateLabels=true );
static int LUACALL wxLua_wxGrid_InsertCols(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool updateLabels = true
bool updateLabels = (argCount >= 4 ? wxlua_getbooleantype(L, 4) : true);
// int numCols = 1
int numCols = (argCount >= 3 ? (int)wxlua_getnumbertype(L, 3) : 1);
// int pos = 0
int pos = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : 0);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call InsertCols
bool returns = (self->InsertCols(pos, numCols, updateLabels));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_InsertRows[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_InsertRows(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_InsertRows[1] = {{ wxLua_wxGrid_InsertRows, WXLUAMETHOD_METHOD, 1, 4, s_wxluatypeArray_wxLua_wxGrid_InsertRows }};
// bool InsertRows( int pos = 0, int numRows = 1, bool updateLabels=true );
static int LUACALL wxLua_wxGrid_InsertRows(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool updateLabels = true
bool updateLabels = (argCount >= 4 ? wxlua_getbooleantype(L, 4) : true);
// int numRows = 1
int numRows = (argCount >= 3 ? (int)wxlua_getnumbertype(L, 3) : 1);
// int pos = 0
int pos = (argCount >= 2 ? (int)wxlua_getnumbertype(L, 2) : 0);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call InsertRows
bool returns = (self->InsertRows(pos, numRows, updateLabels));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_IsCellEditControlEnabled[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_IsCellEditControlEnabled(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_IsCellEditControlEnabled[1] = {{ wxLua_wxGrid_IsCellEditControlEnabled, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_IsCellEditControlEnabled }};
// bool IsCellEditControlEnabled() const;
static int LUACALL wxLua_wxGrid_IsCellEditControlEnabled(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call IsCellEditControlEnabled
bool returns = (self->IsCellEditControlEnabled());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_IsCellEditControlShown[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_IsCellEditControlShown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_IsCellEditControlShown[1] = {{ wxLua_wxGrid_IsCellEditControlShown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_IsCellEditControlShown }};
// bool IsCellEditControlShown() const;
static int LUACALL wxLua_wxGrid_IsCellEditControlShown(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call IsCellEditControlShown
bool returns = (self->IsCellEditControlShown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_IsCurrentCellReadOnly[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_IsCurrentCellReadOnly(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_IsCurrentCellReadOnly[1] = {{ wxLua_wxGrid_IsCurrentCellReadOnly, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_IsCurrentCellReadOnly }};
// bool IsCurrentCellReadOnly() const;
static int LUACALL wxLua_wxGrid_IsCurrentCellReadOnly(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call IsCurrentCellReadOnly
bool returns = (self->IsCurrentCellReadOnly());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_IsEditable[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_IsEditable(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_IsEditable[1] = {{ wxLua_wxGrid_IsEditable, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_IsEditable }};
// bool IsEditable( );
static int LUACALL wxLua_wxGrid_IsEditable(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call IsEditable
bool returns = (self->IsEditable());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_IsInSelection[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_IsInSelection(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_IsInSelection[1] = {{ wxLua_wxGrid_IsInSelection, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_IsInSelection }};
// bool IsInSelection( int row, int col );
static int LUACALL wxLua_wxGrid_IsInSelection(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call IsInSelection
bool returns = (self->IsInSelection(row, col));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_IsReadOnly[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_IsReadOnly(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_IsReadOnly[1] = {{ wxLua_wxGrid_IsReadOnly, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_IsReadOnly }};
// bool IsReadOnly(int row, int col) const;
static int LUACALL wxLua_wxGrid_IsReadOnly(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call IsReadOnly
bool returns = (self->IsReadOnly(row, col));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_IsSelection[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_IsSelection(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_IsSelection[1] = {{ wxLua_wxGrid_IsSelection, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_IsSelection }};
// bool IsSelection( );
static int LUACALL wxLua_wxGrid_IsSelection(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call IsSelection
bool returns = (self->IsSelection());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_IsVisible[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_IsVisible(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_IsVisible[1] = {{ wxLua_wxGrid_IsVisible, WXLUAMETHOD_METHOD, 3, 4, s_wxluatypeArray_wxLua_wxGrid_IsVisible }};
// bool IsVisible( int row, int col, bool wholeCellVisible = true );
static int LUACALL wxLua_wxGrid_IsVisible(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool wholeCellVisible = true
bool wholeCellVisible = (argCount >= 4 ? wxlua_getbooleantype(L, 4) : true);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call IsVisible
bool returns = (self->IsVisible(row, col, wholeCellVisible));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MakeCellVisible[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_MakeCellVisible(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MakeCellVisible[1] = {{ wxLua_wxGrid_MakeCellVisible, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_MakeCellVisible }};
// void MakeCellVisible( int row, int col );
static int LUACALL wxLua_wxGrid_MakeCellVisible(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MakeCellVisible
self->MakeCellVisible(row, col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MoveCursorDown[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_MoveCursorDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MoveCursorDown[1] = {{ wxLua_wxGrid_MoveCursorDown, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_MoveCursorDown }};
// bool MoveCursorDown( bool expandSelection );
static int LUACALL wxLua_wxGrid_MoveCursorDown(lua_State *L)
{
// bool expandSelection
bool expandSelection = wxlua_getbooleantype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MoveCursorDown
bool returns = (self->MoveCursorDown(expandSelection));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MoveCursorDownBlock[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_MoveCursorDownBlock(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MoveCursorDownBlock[1] = {{ wxLua_wxGrid_MoveCursorDownBlock, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_MoveCursorDownBlock }};
// bool MoveCursorDownBlock( bool expandSelection );
static int LUACALL wxLua_wxGrid_MoveCursorDownBlock(lua_State *L)
{
// bool expandSelection
bool expandSelection = wxlua_getbooleantype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MoveCursorDownBlock
bool returns = (self->MoveCursorDownBlock(expandSelection));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MoveCursorLeft[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_MoveCursorLeft(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MoveCursorLeft[1] = {{ wxLua_wxGrid_MoveCursorLeft, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_MoveCursorLeft }};
// bool MoveCursorLeft( bool expandSelection );
static int LUACALL wxLua_wxGrid_MoveCursorLeft(lua_State *L)
{
// bool expandSelection
bool expandSelection = wxlua_getbooleantype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MoveCursorLeft
bool returns = (self->MoveCursorLeft(expandSelection));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MoveCursorLeftBlock[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_MoveCursorLeftBlock(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MoveCursorLeftBlock[1] = {{ wxLua_wxGrid_MoveCursorLeftBlock, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_MoveCursorLeftBlock }};
// bool MoveCursorLeftBlock( bool expandSelection );
static int LUACALL wxLua_wxGrid_MoveCursorLeftBlock(lua_State *L)
{
// bool expandSelection
bool expandSelection = wxlua_getbooleantype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MoveCursorLeftBlock
bool returns = (self->MoveCursorLeftBlock(expandSelection));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MoveCursorRight[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_MoveCursorRight(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MoveCursorRight[1] = {{ wxLua_wxGrid_MoveCursorRight, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_MoveCursorRight }};
// bool MoveCursorRight( bool expandSelection );
static int LUACALL wxLua_wxGrid_MoveCursorRight(lua_State *L)
{
// bool expandSelection
bool expandSelection = wxlua_getbooleantype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MoveCursorRight
bool returns = (self->MoveCursorRight(expandSelection));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MoveCursorRightBlock[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_MoveCursorRightBlock(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MoveCursorRightBlock[1] = {{ wxLua_wxGrid_MoveCursorRightBlock, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_MoveCursorRightBlock }};
// bool MoveCursorRightBlock( bool expandSelection );
static int LUACALL wxLua_wxGrid_MoveCursorRightBlock(lua_State *L)
{
// bool expandSelection
bool expandSelection = wxlua_getbooleantype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MoveCursorRightBlock
bool returns = (self->MoveCursorRightBlock(expandSelection));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MoveCursorUp[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_MoveCursorUp(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MoveCursorUp[1] = {{ wxLua_wxGrid_MoveCursorUp, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_MoveCursorUp }};
// bool MoveCursorUp( bool expandSelection );
static int LUACALL wxLua_wxGrid_MoveCursorUp(lua_State *L)
{
// bool expandSelection
bool expandSelection = wxlua_getbooleantype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MoveCursorUp
bool returns = (self->MoveCursorUp(expandSelection));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MoveCursorUpBlock[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_MoveCursorUpBlock(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MoveCursorUpBlock[1] = {{ wxLua_wxGrid_MoveCursorUpBlock, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_MoveCursorUpBlock }};
// bool MoveCursorUpBlock( bool expandSelection );
static int LUACALL wxLua_wxGrid_MoveCursorUpBlock(lua_State *L)
{
// bool expandSelection
bool expandSelection = wxlua_getbooleantype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MoveCursorUpBlock
bool returns = (self->MoveCursorUpBlock(expandSelection));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MovePageDown[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_MovePageDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MovePageDown[1] = {{ wxLua_wxGrid_MovePageDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_MovePageDown }};
// bool MovePageDown( );
static int LUACALL wxLua_wxGrid_MovePageDown(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MovePageDown
bool returns = (self->MovePageDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_MovePageUp[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_MovePageUp(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_MovePageUp[1] = {{ wxLua_wxGrid_MovePageUp, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_MovePageUp }};
// bool MovePageUp( );
static int LUACALL wxLua_wxGrid_MovePageUp(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call MovePageUp
bool returns = (self->MovePageUp());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_ProcessTableMessage[] = { &wxluatype_wxGrid, &wxluatype_wxGridTableMessage, NULL };
static int LUACALL wxLua_wxGrid_ProcessTableMessage(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_ProcessTableMessage[1] = {{ wxLua_wxGrid_ProcessTableMessage, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_ProcessTableMessage }};
// bool ProcessTableMessage( wxGridTableMessage& msg );
static int LUACALL wxLua_wxGrid_ProcessTableMessage(lua_State *L)
{
// wxGridTableMessage msg
wxGridTableMessage * msg = (wxGridTableMessage *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridTableMessage);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call ProcessTableMessage
bool returns = (self->ProcessTableMessage(*msg));
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_RegisterDataType[] = { &wxluatype_wxGrid, &wxluatype_TSTRING, &wxluatype_wxGridCellRenderer, &wxluatype_wxGridCellEditor, NULL };
static int LUACALL wxLua_wxGrid_RegisterDataType(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_RegisterDataType[1] = {{ wxLua_wxGrid_RegisterDataType, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGrid_RegisterDataType }};
// void RegisterDataType(const wxString& typeName, %IncRef wxGridCellRenderer* renderer, %IncRef wxGridCellEditor* editor );
static int LUACALL wxLua_wxGrid_RegisterDataType(lua_State *L)
{
// wxGridCellEditor editor
wxGridCellEditor * editor = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 4, wxluatype_wxGridCellEditor);
// wxGridCellRenderer renderer
wxGridCellRenderer * renderer = (wxGridCellRenderer *)wxluaT_getuserdatatype(L, 3, wxluatype_wxGridCellRenderer);
// const wxString typeName
const wxString typeName = wxlua_getwxStringtype(L, 2);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
renderer->IncRef();
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
editor->IncRef();
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call RegisterDataType
self->RegisterDataType(typeName, renderer, editor);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SaveEditControlValue[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_SaveEditControlValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SaveEditControlValue[1] = {{ wxLua_wxGrid_SaveEditControlValue, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_SaveEditControlValue }};
// void SaveEditControlValue( );
static int LUACALL wxLua_wxGrid_SaveEditControlValue(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SaveEditControlValue
self->SaveEditControlValue();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SelectAll[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_SelectAll(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SelectAll[1] = {{ wxLua_wxGrid_SelectAll, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_SelectAll }};
// void SelectAll( );
static int LUACALL wxLua_wxGrid_SelectAll(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SelectAll
self->SelectAll();
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SelectBlock[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_SelectBlock(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SelectBlock[1] = {{ wxLua_wxGrid_SelectBlock, WXLUAMETHOD_METHOD, 5, 6, s_wxluatypeArray_wxLua_wxGrid_SelectBlock }};
// void SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol, bool addToSelected = false );
static int LUACALL wxLua_wxGrid_SelectBlock(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool addToSelected = false
bool addToSelected = (argCount >= 6 ? wxlua_getbooleantype(L, 6) : false);
// int rightCol
int rightCol = (int)wxlua_getnumbertype(L, 5);
// int bottomRow
int bottomRow = (int)wxlua_getnumbertype(L, 4);
// int leftCol
int leftCol = (int)wxlua_getnumbertype(L, 3);
// int topRow
int topRow = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SelectBlock
self->SelectBlock(topRow, leftCol, bottomRow, rightCol, addToSelected);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SelectCol[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_SelectCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SelectCol[1] = {{ wxLua_wxGrid_SelectCol, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxGrid_SelectCol }};
// void SelectCol( int col, bool addToSelected = false );
static int LUACALL wxLua_wxGrid_SelectCol(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool addToSelected = false
bool addToSelected = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : false);
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SelectCol
self->SelectCol(col, addToSelected);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SelectRow[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_SelectRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SelectRow[1] = {{ wxLua_wxGrid_SelectRow, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxGrid_SelectRow }};
// void SelectRow( int row, bool addToSelected = false );
static int LUACALL wxLua_wxGrid_SelectRow(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool addToSelected = false
bool addToSelected = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : false);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SelectRow
self->SelectRow(row, addToSelected);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetAttr[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGrid_SetAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetAttr[1] = {{ wxLua_wxGrid_SetAttr, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGrid_SetAttr }};
// void SetAttr(int row, int col, %IncRef wxGridCellAttr *attr );
static int LUACALL wxLua_wxGrid_SetAttr(lua_State *L)
{
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 4, wxluatype_wxGridCellAttr);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
attr->IncRef();
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetAttr
self->SetAttr(row, col, attr);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellAlignment[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetCellAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellAlignment[1] = {{ wxLua_wxGrid_SetCellAlignment, WXLUAMETHOD_METHOD, 5, 5, s_wxluatypeArray_wxLua_wxGrid_SetCellAlignment }};
// void SetCellAlignment( int row, int col, int horiz, int vert );
static int LUACALL wxLua_wxGrid_SetCellAlignment(lua_State *L)
{
// int vert
int vert = (int)wxlua_getnumbertype(L, 5);
// int horiz
int horiz = (int)wxlua_getnumbertype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellAlignment
self->SetCellAlignment(row, col, horiz, vert);
return 0;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellBackgroundColour[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGrid_SetCellBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellBackgroundColour[1] = {{ wxLua_wxGrid_SetCellBackgroundColour, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGrid_SetCellBackgroundColour }};
// void SetCellBackgroundColour( int row, int col, const wxColour& backColour );
static int LUACALL wxLua_wxGrid_SetCellBackgroundColour(lua_State *L)
{
// const wxColour backColour
const wxColour * backColour = (const wxColour *)wxluaT_getuserdatatype(L, 4, wxluatype_wxColour);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellBackgroundColour
self->SetCellBackgroundColour(row, col, *backColour);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellEditor[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxGridCellEditor, NULL };
static int LUACALL wxLua_wxGrid_SetCellEditor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellEditor[1] = {{ wxLua_wxGrid_SetCellEditor, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGrid_SetCellEditor }};
// void SetCellEditor(int row, int col, %IncRef wxGridCellEditor *editor );
static int LUACALL wxLua_wxGrid_SetCellEditor(lua_State *L)
{
// wxGridCellEditor editor
wxGridCellEditor * editor = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 4, wxluatype_wxGridCellEditor);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
editor->IncRef();
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellEditor
self->SetCellEditor(row, col, editor);
return 0;
}
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellFont[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxFont, NULL };
static int LUACALL wxLua_wxGrid_SetCellFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellFont[1] = {{ wxLua_wxGrid_SetCellFont, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGrid_SetCellFont }};
// void SetCellFont( int row, int col, const wxFont& cellFont );
static int LUACALL wxLua_wxGrid_SetCellFont(lua_State *L)
{
// const wxFont cellFont
const wxFont * cellFont = (const wxFont *)wxluaT_getuserdatatype(L, 4, wxluatype_wxFont);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellFont
self->SetCellFont(row, col, *cellFont);
return 0;
}
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellHighlightColour[] = { &wxluatype_wxGrid, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGrid_SetCellHighlightColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellHighlightColour[1] = {{ wxLua_wxGrid_SetCellHighlightColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetCellHighlightColour }};
// void SetCellHighlightColour( const wxColour& highlightColour );
static int LUACALL wxLua_wxGrid_SetCellHighlightColour(lua_State *L)
{
// const wxColour highlightColour
const wxColour * highlightColour = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellHighlightColour
self->SetCellHighlightColour(*highlightColour);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellHighlightPenWidth[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetCellHighlightPenWidth(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellHighlightPenWidth[1] = {{ wxLua_wxGrid_SetCellHighlightPenWidth, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetCellHighlightPenWidth }};
// void SetCellHighlightPenWidth(int width );
static int LUACALL wxLua_wxGrid_SetCellHighlightPenWidth(lua_State *L)
{
// int width
int width = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellHighlightPenWidth
self->SetCellHighlightPenWidth(width);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellHighlightROPenWidth[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetCellHighlightROPenWidth(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellHighlightROPenWidth[1] = {{ wxLua_wxGrid_SetCellHighlightROPenWidth, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetCellHighlightROPenWidth }};
// void SetCellHighlightROPenWidth(int width );
static int LUACALL wxLua_wxGrid_SetCellHighlightROPenWidth(lua_State *L)
{
// int width
int width = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellHighlightROPenWidth
self->SetCellHighlightROPenWidth(width);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellOverflow[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_SetCellOverflow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellOverflow[1] = {{ wxLua_wxGrid_SetCellOverflow, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGrid_SetCellOverflow }};
// void SetCellOverflow( int row, int col, bool allow );
static int LUACALL wxLua_wxGrid_SetCellOverflow(lua_State *L)
{
// bool allow
bool allow = wxlua_getbooleantype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellOverflow
self->SetCellOverflow(row, col, allow);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellRenderer[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxGridCellRenderer, NULL };
static int LUACALL wxLua_wxGrid_SetCellRenderer(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellRenderer[1] = {{ wxLua_wxGrid_SetCellRenderer, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGrid_SetCellRenderer }};
// void SetCellRenderer(int row, int col, %IncRef wxGridCellRenderer *renderer );
static int LUACALL wxLua_wxGrid_SetCellRenderer(lua_State *L)
{
// wxGridCellRenderer renderer
wxGridCellRenderer * renderer = (wxGridCellRenderer *)wxluaT_getuserdatatype(L, 4, wxluatype_wxGridCellRenderer);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
renderer->IncRef();
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellRenderer
self->SetCellRenderer(row, col, renderer);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetCellSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellSize[1] = {{ wxLua_wxGrid_SetCellSize, WXLUAMETHOD_METHOD, 5, 5, s_wxluatypeArray_wxLua_wxGrid_SetCellSize }};
// void SetCellSize( int row, int col, int num_rows, int num_cols );
static int LUACALL wxLua_wxGrid_SetCellSize(lua_State *L)
{
// int num_cols
int num_cols = (int)wxlua_getnumbertype(L, 5);
// int num_rows
int num_rows = (int)wxlua_getnumbertype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellSize
self->SetCellSize(row, col, num_rows, num_cols);
return 0;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellTextColour[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGrid_SetCellTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellTextColour[1] = {{ wxLua_wxGrid_SetCellTextColour, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGrid_SetCellTextColour }};
// void SetCellTextColour( int row, int col, const wxColour& textColour );
static int LUACALL wxLua_wxGrid_SetCellTextColour(lua_State *L)
{
// const wxColour textColour
const wxColour * textColour = (const wxColour *)wxluaT_getuserdatatype(L, 4, wxluatype_wxColour);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellTextColour
self->SetCellTextColour(row, col, *textColour);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetCellValue[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGrid_SetCellValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetCellValue[1] = {{ wxLua_wxGrid_SetCellValue, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGrid_SetCellValue }};
// void SetCellValue( int row, int col, const wxString& s );
static int LUACALL wxLua_wxGrid_SetCellValue(lua_State *L)
{
// const wxString s
const wxString s = wxlua_getwxStringtype(L, 4);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetCellValue
self->SetCellValue(row, col, s);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColAttr[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGrid_SetColAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColAttr[1] = {{ wxLua_wxGrid_SetColAttr, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetColAttr }};
// void SetColAttr(int col, %IncRef wxGridCellAttr *attr );
static int LUACALL wxLua_wxGrid_SetColAttr(lua_State *L)
{
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 3, wxluatype_wxGridCellAttr);
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
attr->IncRef();
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColAttr
self->SetColAttr(col, attr);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColFormatBool[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetColFormatBool(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColFormatBool[1] = {{ wxLua_wxGrid_SetColFormatBool, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetColFormatBool }};
// void SetColFormatBool(int col );
static int LUACALL wxLua_wxGrid_SetColFormatBool(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColFormatBool
self->SetColFormatBool(col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColFormatCustom[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGrid_SetColFormatCustom(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColFormatCustom[1] = {{ wxLua_wxGrid_SetColFormatCustom, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetColFormatCustom }};
// void SetColFormatCustom(int col, const wxString& typeName );
static int LUACALL wxLua_wxGrid_SetColFormatCustom(lua_State *L)
{
// const wxString typeName
const wxString typeName = wxlua_getwxStringtype(L, 3);
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColFormatCustom
self->SetColFormatCustom(col, typeName);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColFormatFloat[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetColFormatFloat(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColFormatFloat[1] = {{ wxLua_wxGrid_SetColFormatFloat, WXLUAMETHOD_METHOD, 2, 4, s_wxluatypeArray_wxLua_wxGrid_SetColFormatFloat }};
// void SetColFormatFloat(int col, int width = -1, int precision = -1 );
static int LUACALL wxLua_wxGrid_SetColFormatFloat(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// int precision = -1
int precision = (argCount >= 4 ? (int)wxlua_getnumbertype(L, 4) : -1);
// int width = -1
int width = (argCount >= 3 ? (int)wxlua_getnumbertype(L, 3) : -1);
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColFormatFloat
self->SetColFormatFloat(col, width, precision);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColFormatNumber[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetColFormatNumber(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColFormatNumber[1] = {{ wxLua_wxGrid_SetColFormatNumber, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetColFormatNumber }};
// void SetColFormatNumber(int col );
static int LUACALL wxLua_wxGrid_SetColFormatNumber(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColFormatNumber
self->SetColFormatNumber(col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColLabelAlignment[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetColLabelAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColLabelAlignment[1] = {{ wxLua_wxGrid_SetColLabelAlignment, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetColLabelAlignment }};
// void SetColLabelAlignment( int horiz, int vert );
static int LUACALL wxLua_wxGrid_SetColLabelAlignment(lua_State *L)
{
// int vert
int vert = (int)wxlua_getnumbertype(L, 3);
// int horiz
int horiz = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColLabelAlignment
self->SetColLabelAlignment(horiz, vert);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColLabelSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetColLabelSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColLabelSize[1] = {{ wxLua_wxGrid_SetColLabelSize, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetColLabelSize }};
// void SetColLabelSize( int height );
static int LUACALL wxLua_wxGrid_SetColLabelSize(lua_State *L)
{
// int height
int height = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColLabelSize
self->SetColLabelSize(height);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColLabelValue[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGrid_SetColLabelValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColLabelValue[1] = {{ wxLua_wxGrid_SetColLabelValue, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetColLabelValue }};
// void SetColLabelValue( int col, const wxString& value );
static int LUACALL wxLua_wxGrid_SetColLabelValue(lua_State *L)
{
// const wxString value
const wxString value = wxlua_getwxStringtype(L, 3);
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColLabelValue
self->SetColLabelValue(col, value);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColMinimalAcceptableWidth[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetColMinimalAcceptableWidth(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColMinimalAcceptableWidth[1] = {{ wxLua_wxGrid_SetColMinimalAcceptableWidth, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetColMinimalAcceptableWidth }};
// void SetColMinimalAcceptableWidth( int width );
static int LUACALL wxLua_wxGrid_SetColMinimalAcceptableWidth(lua_State *L)
{
// int width
int width = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColMinimalAcceptableWidth
self->SetColMinimalAcceptableWidth(width);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColMinimalWidth[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetColMinimalWidth(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColMinimalWidth[1] = {{ wxLua_wxGrid_SetColMinimalWidth, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetColMinimalWidth }};
// void SetColMinimalWidth( int col, int width );
static int LUACALL wxLua_wxGrid_SetColMinimalWidth(lua_State *L)
{
// int width
int width = (int)wxlua_getnumbertype(L, 3);
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColMinimalWidth
self->SetColMinimalWidth(col, width);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetColSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetColSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetColSize[1] = {{ wxLua_wxGrid_SetColSize, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetColSize }};
// void SetColSize( int col, int width );
static int LUACALL wxLua_wxGrid_SetColSize(lua_State *L)
{
// int width
int width = (int)wxlua_getnumbertype(L, 3);
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetColSize
self->SetColSize(col, width);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetDefaultCellAlignment[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetDefaultCellAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetDefaultCellAlignment[1] = {{ wxLua_wxGrid_SetDefaultCellAlignment, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetDefaultCellAlignment }};
// void SetDefaultCellAlignment( int horiz, int vert );
static int LUACALL wxLua_wxGrid_SetDefaultCellAlignment(lua_State *L)
{
// int vert
int vert = (int)wxlua_getnumbertype(L, 3);
// int horiz
int horiz = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetDefaultCellAlignment
self->SetDefaultCellAlignment(horiz, vert);
return 0;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetDefaultCellBackgroundColour[] = { &wxluatype_wxGrid, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGrid_SetDefaultCellBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetDefaultCellBackgroundColour[1] = {{ wxLua_wxGrid_SetDefaultCellBackgroundColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetDefaultCellBackgroundColour }};
// void SetDefaultCellBackgroundColour( const wxColour& backColour );
static int LUACALL wxLua_wxGrid_SetDefaultCellBackgroundColour(lua_State *L)
{
// const wxColour backColour
const wxColour * backColour = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetDefaultCellBackgroundColour
self->SetDefaultCellBackgroundColour(*backColour);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetDefaultCellFont[] = { &wxluatype_wxGrid, &wxluatype_wxFont, NULL };
static int LUACALL wxLua_wxGrid_SetDefaultCellFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetDefaultCellFont[1] = {{ wxLua_wxGrid_SetDefaultCellFont, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetDefaultCellFont }};
// void SetDefaultCellFont( const wxFont& cellFont );
static int LUACALL wxLua_wxGrid_SetDefaultCellFont(lua_State *L)
{
// const wxFont cellFont
const wxFont * cellFont = (const wxFont *)wxluaT_getuserdatatype(L, 2, wxluatype_wxFont);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetDefaultCellFont
self->SetDefaultCellFont(*cellFont);
return 0;
}
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetDefaultCellOverflow[] = { &wxluatype_wxGrid, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_SetDefaultCellOverflow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetDefaultCellOverflow[1] = {{ wxLua_wxGrid_SetDefaultCellOverflow, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetDefaultCellOverflow }};
// void SetDefaultCellOverflow( bool allow );
static int LUACALL wxLua_wxGrid_SetDefaultCellOverflow(lua_State *L)
{
// bool allow
bool allow = wxlua_getbooleantype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetDefaultCellOverflow
self->SetDefaultCellOverflow(allow);
return 0;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetDefaultCellTextColour[] = { &wxluatype_wxGrid, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGrid_SetDefaultCellTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetDefaultCellTextColour[1] = {{ wxLua_wxGrid_SetDefaultCellTextColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetDefaultCellTextColour }};
// void SetDefaultCellTextColour( const wxColour& textColour );
static int LUACALL wxLua_wxGrid_SetDefaultCellTextColour(lua_State *L)
{
// const wxColour textColour
const wxColour * textColour = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetDefaultCellTextColour
self->SetDefaultCellTextColour(*textColour);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetDefaultColSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_SetDefaultColSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetDefaultColSize[1] = {{ wxLua_wxGrid_SetDefaultColSize, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxGrid_SetDefaultColSize }};
// void SetDefaultColSize( int width, bool resizeExistingCols = false );
static int LUACALL wxLua_wxGrid_SetDefaultColSize(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool resizeExistingCols = false
bool resizeExistingCols = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : false);
// int width
int width = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetDefaultColSize
self->SetDefaultColSize(width, resizeExistingCols);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetDefaultEditor[] = { &wxluatype_wxGrid, &wxluatype_wxGridCellEditor, NULL };
static int LUACALL wxLua_wxGrid_SetDefaultEditor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetDefaultEditor[1] = {{ wxLua_wxGrid_SetDefaultEditor, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetDefaultEditor }};
// void SetDefaultEditor(%IncRef wxGridCellEditor *editor );
static int LUACALL wxLua_wxGrid_SetDefaultEditor(lua_State *L)
{
// wxGridCellEditor editor
wxGridCellEditor * editor = (wxGridCellEditor *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellEditor);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
editor->IncRef();
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetDefaultEditor
self->SetDefaultEditor(editor);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetDefaultRenderer[] = { &wxluatype_wxGrid, &wxluatype_wxGridCellRenderer, NULL };
static int LUACALL wxLua_wxGrid_SetDefaultRenderer(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetDefaultRenderer[1] = {{ wxLua_wxGrid_SetDefaultRenderer, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetDefaultRenderer }};
// void SetDefaultRenderer(%IncRef wxGridCellRenderer *renderer );
static int LUACALL wxLua_wxGrid_SetDefaultRenderer(lua_State *L)
{
// wxGridCellRenderer renderer
wxGridCellRenderer * renderer = (wxGridCellRenderer *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridCellRenderer);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
renderer->IncRef();
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetDefaultRenderer
self->SetDefaultRenderer(renderer);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetDefaultRowSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_SetDefaultRowSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetDefaultRowSize[1] = {{ wxLua_wxGrid_SetDefaultRowSize, WXLUAMETHOD_METHOD, 2, 3, s_wxluatypeArray_wxLua_wxGrid_SetDefaultRowSize }};
// void SetDefaultRowSize( int height, bool resizeExistingRows = false );
static int LUACALL wxLua_wxGrid_SetDefaultRowSize(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool resizeExistingRows = false
bool resizeExistingRows = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : false);
// int height
int height = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetDefaultRowSize
self->SetDefaultRowSize(height, resizeExistingRows);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetGridCursor[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetGridCursor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetGridCursor[1] = {{ wxLua_wxGrid_SetGridCursor, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetGridCursor }};
// void SetGridCursor( int row, int col );
static int LUACALL wxLua_wxGrid_SetGridCursor(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetGridCursor
self->SetGridCursor(row, col);
return 0;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetGridLineColour[] = { &wxluatype_wxGrid, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGrid_SetGridLineColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetGridLineColour[1] = {{ wxLua_wxGrid_SetGridLineColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetGridLineColour }};
// void SetGridLineColour( const wxColour& lineColour );
static int LUACALL wxLua_wxGrid_SetGridLineColour(lua_State *L)
{
// const wxColour lineColour
const wxColour * lineColour = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetGridLineColour
self->SetGridLineColour(*lineColour);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetLabelBackgroundColour[] = { &wxluatype_wxGrid, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGrid_SetLabelBackgroundColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetLabelBackgroundColour[1] = {{ wxLua_wxGrid_SetLabelBackgroundColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetLabelBackgroundColour }};
// void SetLabelBackgroundColour( const wxColour& backColour );
static int LUACALL wxLua_wxGrid_SetLabelBackgroundColour(lua_State *L)
{
// const wxColour backColour
const wxColour * backColour = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetLabelBackgroundColour
self->SetLabelBackgroundColour(*backColour);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetLabelFont[] = { &wxluatype_wxGrid, &wxluatype_wxFont, NULL };
static int LUACALL wxLua_wxGrid_SetLabelFont(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetLabelFont[1] = {{ wxLua_wxGrid_SetLabelFont, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetLabelFont }};
// void SetLabelFont( const wxFont& labelFont );
static int LUACALL wxLua_wxGrid_SetLabelFont(lua_State *L)
{
// const wxFont labelFont
const wxFont * labelFont = (const wxFont *)wxluaT_getuserdatatype(L, 2, wxluatype_wxFont);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetLabelFont
self->SetLabelFont(*labelFont);
return 0;
}
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetLabelTextColour[] = { &wxluatype_wxGrid, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGrid_SetLabelTextColour(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetLabelTextColour[1] = {{ wxLua_wxGrid_SetLabelTextColour, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetLabelTextColour }};
// void SetLabelTextColour( const wxColour& textColour );
static int LUACALL wxLua_wxGrid_SetLabelTextColour(lua_State *L)
{
// const wxColour textColour
const wxColour * textColour = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetLabelTextColour
self->SetLabelTextColour(*textColour);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetMargins[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetMargins(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetMargins[1] = {{ wxLua_wxGrid_SetMargins, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetMargins }};
// void SetMargins(int extraWidth, int extraHeight );
static int LUACALL wxLua_wxGrid_SetMargins(lua_State *L)
{
// int extraHeight
int extraHeight = (int)wxlua_getnumbertype(L, 3);
// int extraWidth
int extraWidth = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetMargins
self->SetMargins(extraWidth, extraHeight);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetReadOnly[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGrid_SetReadOnly(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetReadOnly[1] = {{ wxLua_wxGrid_SetReadOnly, WXLUAMETHOD_METHOD, 3, 4, s_wxluatypeArray_wxLua_wxGrid_SetReadOnly }};
// void SetReadOnly(int row, int col, bool isReadOnly = true );
static int LUACALL wxLua_wxGrid_SetReadOnly(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool isReadOnly = true
bool isReadOnly = (argCount >= 4 ? wxlua_getbooleantype(L, 4) : true);
// int col
int col = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetReadOnly
self->SetReadOnly(row, col, isReadOnly);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetRowAttr[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_wxGridCellAttr, NULL };
static int LUACALL wxLua_wxGrid_SetRowAttr(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetRowAttr[1] = {{ wxLua_wxGrid_SetRowAttr, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetRowAttr }};
// void SetRowAttr(int row, %IncRef wxGridCellAttr *attr );
static int LUACALL wxLua_wxGrid_SetRowAttr(lua_State *L)
{
// wxGridCellAttr attr
wxGridCellAttr * attr = (wxGridCellAttr *)wxluaT_getuserdatatype(L, 3, wxluatype_wxGridCellAttr);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// This param will have DecRef() called on it so we IncRef() it to not have to worry about the Lua gc
attr->IncRef();
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetRowAttr
self->SetRowAttr(row, attr);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetRowLabelAlignment[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetRowLabelAlignment(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetRowLabelAlignment[1] = {{ wxLua_wxGrid_SetRowLabelAlignment, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetRowLabelAlignment }};
// void SetRowLabelAlignment( int horiz, int vert );
static int LUACALL wxLua_wxGrid_SetRowLabelAlignment(lua_State *L)
{
// int vert
int vert = (int)wxlua_getnumbertype(L, 3);
// int horiz
int horiz = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetRowLabelAlignment
self->SetRowLabelAlignment(horiz, vert);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetRowLabelSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetRowLabelSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetRowLabelSize[1] = {{ wxLua_wxGrid_SetRowLabelSize, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetRowLabelSize }};
// void SetRowLabelSize( int width );
static int LUACALL wxLua_wxGrid_SetRowLabelSize(lua_State *L)
{
// int width
int width = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetRowLabelSize
self->SetRowLabelSize(width);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetRowLabelValue[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGrid_SetRowLabelValue(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetRowLabelValue[1] = {{ wxLua_wxGrid_SetRowLabelValue, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetRowLabelValue }};
// void SetRowLabelValue( int row, const wxString& value );
static int LUACALL wxLua_wxGrid_SetRowLabelValue(lua_State *L)
{
// const wxString value
const wxString value = wxlua_getwxStringtype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetRowLabelValue
self->SetRowLabelValue(row, value);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetRowMinimalAcceptableHeight[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetRowMinimalAcceptableHeight(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetRowMinimalAcceptableHeight[1] = {{ wxLua_wxGrid_SetRowMinimalAcceptableHeight, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetRowMinimalAcceptableHeight }};
// void SetRowMinimalAcceptableHeight( int width );
static int LUACALL wxLua_wxGrid_SetRowMinimalAcceptableHeight(lua_State *L)
{
// int width
int width = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetRowMinimalAcceptableHeight
self->SetRowMinimalAcceptableHeight(width);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetRowMinimalHeight[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetRowMinimalHeight(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetRowMinimalHeight[1] = {{ wxLua_wxGrid_SetRowMinimalHeight, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetRowMinimalHeight }};
// void SetRowMinimalHeight( int row, int width );
static int LUACALL wxLua_wxGrid_SetRowMinimalHeight(lua_State *L)
{
// int width
int width = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetRowMinimalHeight
self->SetRowMinimalHeight(row, width);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetRowSize[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_SetRowSize(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetRowSize[1] = {{ wxLua_wxGrid_SetRowSize, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_SetRowSize }};
// void SetRowSize( int row, int height );
static int LUACALL wxLua_wxGrid_SetRowSize(lua_State *L)
{
// int height
int height = (int)wxlua_getnumbertype(L, 3);
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetRowSize
self->SetRowSize(row, height);
return 0;
}
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetSelectionBackground[] = { &wxluatype_wxGrid, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGrid_SetSelectionBackground(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetSelectionBackground[1] = {{ wxLua_wxGrid_SetSelectionBackground, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetSelectionBackground }};
// void SetSelectionBackground(const wxColour& c );
static int LUACALL wxLua_wxGrid_SetSelectionBackground(lua_State *L)
{
// const wxColour c
const wxColour * c = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetSelectionBackground
self->SetSelectionBackground(*c);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetSelectionForeground[] = { &wxluatype_wxGrid, &wxluatype_wxColour, NULL };
static int LUACALL wxLua_wxGrid_SetSelectionForeground(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetSelectionForeground[1] = {{ wxLua_wxGrid_SetSelectionForeground, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetSelectionForeground }};
// void SetSelectionForeground(const wxColour& c );
static int LUACALL wxLua_wxGrid_SetSelectionForeground(lua_State *L)
{
// const wxColour c
const wxColour * c = (const wxColour *)wxluaT_getuserdatatype(L, 2, wxluatype_wxColour);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetSelectionForeground
self->SetSelectionForeground(*c);
return 0;
}
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetSelectionMode[] = { &wxluatype_wxGrid, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGrid_SetSelectionMode(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetSelectionMode[1] = {{ wxLua_wxGrid_SetSelectionMode, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_SetSelectionMode }};
// void SetSelectionMode(wxGrid::wxGridSelectionModes selmode );
static int LUACALL wxLua_wxGrid_SetSelectionMode(lua_State *L)
{
// wxGrid::wxGridSelectionModes selmode
wxGrid::wxGridSelectionModes selmode = (wxGrid::wxGridSelectionModes)wxlua_getenumtype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetSelectionMode
self->SetSelectionMode(selmode);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_SetTable[] = { &wxluatype_wxGrid, &wxluatype_wxGridTableBase, &wxluatype_TBOOLEAN, &wxluatype_TINTEGER, NULL };
static int LUACALL wxLua_wxGrid_SetTable(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_SetTable[1] = {{ wxLua_wxGrid_SetTable, WXLUAMETHOD_METHOD, 2, 4, s_wxluatypeArray_wxLua_wxGrid_SetTable }};
// %override wxLua_wxGrid_SetTable
// bool SetTable(wxGridTableBase *table, bool takeOwnership = false,
// wxGrid::wxGridSelectionModes selmode =
// wxGrid::wxGridSelectCells)
static int LUACALL wxLua_wxGrid_SetTable(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// wxGrid::wxGridSelectionModes selmode = wxGrid::wxGridSelectCells
wxGrid::wxGridSelectionModes selmode = (argCount >= 4 ? (wxGrid::wxGridSelectionModes)wxlua_getenumtype(L, 4) : wxGrid::wxGridSelectCells);
// bool takeOwnership = false
bool takeOwnership = (argCount >= 3 ? wxlua_getbooleantype(L, 3) : false);
// wxGridTableBase table
wxGridTableBase * table = (wxGridTableBase *)wxluaT_getuserdatatype(L, 2, wxluatype_wxGridTableBase);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call SetTable
bool returns = (self->SetTable(table, takeOwnership, selmode));
if (returns && takeOwnership)
{
// The wxGrid is now responsible for deleting it
if (wxluaO_isgcobject(L, table)) wxluaO_undeletegcobject(L, table);
}
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_ShowCellEditControl[] = { &wxluatype_wxGrid, NULL };
static int LUACALL wxLua_wxGrid_ShowCellEditControl(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_ShowCellEditControl[1] = {{ wxLua_wxGrid_ShowCellEditControl, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_ShowCellEditControl }};
// void ShowCellEditControl( );
static int LUACALL wxLua_wxGrid_ShowCellEditControl(lua_State *L)
{
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call ShowCellEditControl
self->ShowCellEditControl();
return 0;
}
#if (wxLUA_USE_wxArrayString) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_StringToLines[] = { &wxluatype_wxGrid, &wxluatype_TSTRING, &wxluatype_wxArrayString, NULL };
static int LUACALL wxLua_wxGrid_StringToLines(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_StringToLines[1] = {{ wxLua_wxGrid_StringToLines, WXLUAMETHOD_METHOD, 3, 3, s_wxluatypeArray_wxLua_wxGrid_StringToLines }};
// void StringToLines( const wxString& value, wxArrayString& lines );
static int LUACALL wxLua_wxGrid_StringToLines(lua_State *L)
{
// wxArrayString lines
wxArrayString * lines = (wxArrayString *)wxluaT_getuserdatatype(L, 3, wxluatype_wxArrayString);
// const wxString value
const wxString value = wxlua_getwxStringtype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call StringToLines
self->StringToLines(value, *lines);
return 0;
}
#endif // (wxLUA_USE_wxArrayString) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_XToCol[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_XToCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_XToCol[1] = {{ wxLua_wxGrid_XToCol, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_XToCol }};
// int XToCol( int x );
static int LUACALL wxLua_wxGrid_XToCol(lua_State *L)
{
// int x
int x = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call XToCol
int returns = (self->XToCol(x));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_XToEdgeOfCol[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_XToEdgeOfCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_XToEdgeOfCol[1] = {{ wxLua_wxGrid_XToEdgeOfCol, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_XToEdgeOfCol }};
// int XToEdgeOfCol( int x );
static int LUACALL wxLua_wxGrid_XToEdgeOfCol(lua_State *L)
{
// int x
int x = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call XToEdgeOfCol
int returns = (self->XToEdgeOfCol(x));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_XYToCell[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxGridCellCoords, NULL };
static int LUACALL wxLua_wxGrid_XYToCell(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_XYToCell[1] = {{ wxLua_wxGrid_XYToCell, WXLUAMETHOD_METHOD, 4, 4, s_wxluatypeArray_wxLua_wxGrid_XYToCell }};
// void XYToCell( int x, int y, wxGridCellCoords& coords );
static int LUACALL wxLua_wxGrid_XYToCell(lua_State *L)
{
// wxGridCellCoords coords
wxGridCellCoords * coords = (wxGridCellCoords *)wxluaT_getuserdatatype(L, 4, wxluatype_wxGridCellCoords);
// int y
int y = (int)wxlua_getnumbertype(L, 3);
// int x
int x = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call XYToCell
self->XYToCell(x, y, *coords);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_YToEdgeOfRow[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_YToEdgeOfRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_YToEdgeOfRow[1] = {{ wxLua_wxGrid_YToEdgeOfRow, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_YToEdgeOfRow }};
// int YToEdgeOfRow( int y );
static int LUACALL wxLua_wxGrid_YToEdgeOfRow(lua_State *L)
{
// int y
int y = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call YToEdgeOfRow
int returns = (self->YToEdgeOfRow(y));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_YToRow[] = { &wxluatype_wxGrid, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGrid_YToRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_YToRow[1] = {{ wxLua_wxGrid_YToRow, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_YToRow }};
// int YToRow( int y );
static int LUACALL wxLua_wxGrid_YToRow(lua_State *L)
{
// int y
int y = (int)wxlua_getnumbertype(L, 2);
// get this
wxGrid * self = (wxGrid *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGrid);
// call YToRow
int returns = (self->YToRow(y));
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGrid_constructor[] = { &wxluatype_wxWindow, &wxluatype_TNUMBER, &wxluatype_wxPoint, &wxluatype_wxSize, &wxluatype_TNUMBER, &wxluatype_TSTRING, NULL };
static int LUACALL wxLua_wxGrid_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_constructor[1] = {{ wxLua_wxGrid_constructor, WXLUAMETHOD_CONSTRUCTOR, 2, 6, s_wxluatypeArray_wxLua_wxGrid_constructor }};
// wxGrid( wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxWANTS_CHARS, const wxString &name = "wxGrid" );
static int LUACALL wxLua_wxGrid_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// const wxString name = "wxGrid"
const wxString name = (argCount >= 6 ? wxlua_getwxStringtype(L, 6) : wxString(wxT("wxGrid")));
// long style = wxWANTS_CHARS
long style = (argCount >= 5 ? (long)wxlua_getnumbertype(L, 5) : wxWANTS_CHARS);
// const wxSize size = wxDefaultSize
const wxSize * size = (argCount >= 4 ? (const wxSize *)wxluaT_getuserdatatype(L, 4, wxluatype_wxSize) : &wxDefaultSize);
// const wxPoint pos = wxDefaultPosition
const wxPoint * pos = (argCount >= 3 ? (const wxPoint *)wxluaT_getuserdatatype(L, 3, wxluatype_wxPoint) : &wxDefaultPosition);
// wxWindowID id
wxWindowID id = (wxWindowID)wxlua_getnumbertype(L, 2);
// wxWindow parent
wxWindow * parent = (wxWindow *)wxluaT_getuserdatatype(L, 1, wxluatype_wxWindow);
// call constructor
wxGrid* returns = new wxGrid(parent, id, *pos, *size, style, name);
// add to tracked window list, it will check validity
wxluaW_addtrackedwindow(L, returns);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGrid);
return 1;
}
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0)))||((wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8)))
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CanDragColSize_overload[] =
{
#if (wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0))
{ wxLua_wxGrid_CanDragColSize1, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_CanDragColSize1 },
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0))
#if (wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8))
{ wxLua_wxGrid_CanDragColSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_CanDragColSize },
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8))
};
static int s_wxluafunc_wxLua_wxGrid_CanDragColSize_overload_count = sizeof(s_wxluafunc_wxLua_wxGrid_CanDragColSize_overload)/sizeof(wxLuaBindCFunc);
// function overload table
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGrid_CanDragRowSize_overload[] =
{
#if (wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0))
{ wxLua_wxGrid_CanDragRowSize1, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGrid_CanDragRowSize1 },
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0))
#if (wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8))
{ wxLua_wxGrid_CanDragRowSize, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGrid_CanDragRowSize },
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8))
};
static int s_wxluafunc_wxLua_wxGrid_CanDragRowSize_overload_count = sizeof(s_wxluafunc_wxLua_wxGrid_CanDragRowSize_overload)/sizeof(wxLuaBindCFunc);
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0)))||((wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8)))
void wxLua_wxGrid_delete_function(void** p)
{
wxGrid* o = (wxGrid*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGrid_methods[] = {
{ "AppendCols", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_AppendCols, 1, NULL },
{ "AppendRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_AppendRows, 1, NULL },
{ "AutoSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_AutoSize, 1, NULL },
{ "AutoSizeColLabelSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_AutoSizeColLabelSize, 1, NULL },
{ "AutoSizeColumn", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_AutoSizeColumn, 1, NULL },
{ "AutoSizeColumns", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_AutoSizeColumns, 1, NULL },
{ "AutoSizeRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_AutoSizeRow, 1, NULL },
{ "AutoSizeRowLabelSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_AutoSizeRowLabelSize, 1, NULL },
{ "AutoSizeRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_AutoSizeRows, 1, NULL },
{ "BeginBatch", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_BeginBatch, 1, NULL },
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "BlockToDeviceRect", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_BlockToDeviceRect, 1, NULL },
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "CanDragCell", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_CanDragCell, 1, NULL },
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0)))||((wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8)))
{ "CanDragColSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_CanDragColSize_overload, s_wxluafunc_wxLua_wxGrid_CanDragColSize_overload_count, 0 },
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0)))||((wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8)))
{ "CanDragGridSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_CanDragGridSize, 1, NULL },
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0)))||((wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8)))
{ "CanDragRowSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_CanDragRowSize_overload, s_wxluafunc_wxLua_wxGrid_CanDragRowSize_overload_count, 0 },
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0)))||((wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8)))
{ "CanEnableCellControl", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_CanEnableCellControl, 1, NULL },
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "CellToRect", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_CellToRect, 1, NULL },
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "ClearGrid", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_ClearGrid, 1, NULL },
{ "ClearSelection", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_ClearSelection, 1, NULL },
{ "CreateGrid", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_CreateGrid, 1, NULL },
{ "DeleteCols", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DeleteCols, 1, NULL },
{ "DeleteRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DeleteRows, 1, NULL },
{ "DeselectCell", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DeselectCell, 1, NULL },
{ "DeselectCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DeselectCol, 1, NULL },
{ "DeselectRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DeselectRow, 1, NULL },
{ "DisableCellEditControl", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DisableCellEditControl, 1, NULL },
{ "DisableDragCell", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DisableDragCell, 1, NULL },
{ "DisableDragColSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DisableDragColSize, 1, NULL },
{ "DisableDragGridSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DisableDragGridSize, 1, NULL },
{ "DisableDragRowSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DisableDragRowSize, 1, NULL },
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && (wxLUA_USE_wxDC)
{ "DrawTextRectangle", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_DrawTextRectangle, 1, NULL },
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxPointSizeRect)) && (wxLUA_USE_wxDC)
{ "EnableCellEditControl", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_EnableCellEditControl, 1, NULL },
{ "EnableDragCell", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_EnableDragCell, 1, NULL },
{ "EnableDragColSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_EnableDragColSize, 1, NULL },
{ "EnableDragGridSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_EnableDragGridSize, 1, NULL },
{ "EnableDragRowSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_EnableDragRowSize, 1, NULL },
{ "EnableEditing", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_EnableEditing, 1, NULL },
{ "EnableGridLines", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_EnableGridLines, 1, NULL },
{ "EndBatch", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_EndBatch, 1, NULL },
{ "ForceRefresh", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_ForceRefresh, 1, NULL },
{ "GetBatchCount", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetBatchCount, 1, NULL },
{ "GetCellAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellAlignment, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetCellBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellBackgroundColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetCellEditor", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellEditor, 1, NULL },
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetCellFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellFont, 1, NULL },
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetCellHighlightColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellHighlightColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetCellHighlightPenWidth", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellHighlightPenWidth, 1, NULL },
{ "GetCellHighlightROPenWidth", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellHighlightROPenWidth, 1, NULL },
{ "GetCellOverflow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellOverflow, 1, NULL },
{ "GetCellRenderer", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellRenderer, 1, NULL },
{ "GetCellSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellSize, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetCellTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellTextColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetCellValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetCellValue, 1, NULL },
{ "GetColLabelAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetColLabelAlignment, 1, NULL },
{ "GetColLabelSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetColLabelSize, 1, NULL },
{ "GetColLabelTextOrientation", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetColLabelTextOrientation, 1, NULL },
{ "GetColLabelValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetColLabelValue, 1, NULL },
{ "GetColMinimalAcceptableWidth", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetColMinimalAcceptableWidth, 1, NULL },
{ "GetColSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetColSize, 1, NULL },
{ "GetDefaultCellAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultCellAlignment, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetDefaultCellBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultCellBackgroundColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetDefaultCellFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultCellFont, 1, NULL },
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetDefaultCellOverflow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultCellOverflow, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetDefaultCellTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultCellTextColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetDefaultColLabelSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultColLabelSize, 1, NULL },
{ "GetDefaultColSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultColSize, 1, NULL },
{ "GetDefaultEditor", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultEditor, 1, NULL },
{ "GetDefaultEditorForCell", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultEditorForCell, 1, NULL },
{ "GetDefaultEditorForType", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultEditorForType, 1, NULL },
{ "GetDefaultRenderer", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultRenderer, 1, NULL },
{ "GetDefaultRendererForCell", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultRendererForCell, 1, NULL },
{ "GetDefaultRendererForType", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultRendererForType, 1, NULL },
{ "GetDefaultRowLabelSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultRowLabelSize, 1, NULL },
{ "GetDefaultRowSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetDefaultRowSize, 1, NULL },
{ "GetGridColLabelWindow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetGridColLabelWindow, 1, NULL },
{ "GetGridCornerLabelWindow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetGridCornerLabelWindow, 1, NULL },
{ "GetGridCursorCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetGridCursorCol, 1, NULL },
{ "GetGridCursorRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetGridCursorRow, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetGridLineColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetGridLineColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetGridRowLabelWindow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetGridRowLabelWindow, 1, NULL },
{ "GetGridWindow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetGridWindow, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetLabelBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetLabelBackgroundColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetLabelFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetLabelFont, 1, NULL },
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetLabelTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetLabelTextColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetNumberCols", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetNumberCols, 1, NULL },
{ "GetNumberRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetNumberRows, 1, NULL },
{ "GetOrCreateCellAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetOrCreateCellAttr, 1, NULL },
{ "GetRowLabelAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetRowLabelAlignment, 1, NULL },
{ "GetRowLabelSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetRowLabelSize, 1, NULL },
{ "GetRowLabelValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetRowLabelValue, 1, NULL },
{ "GetRowMinimalAcceptableHeight", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetRowMinimalAcceptableHeight, 1, NULL },
{ "GetRowSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetRowSize, 1, NULL },
{ "GetSelectedCells", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetSelectedCells, 1, NULL },
#if (wxLUA_USE_wxArrayInt) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetSelectedCols", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetSelectedCols, 1, NULL },
{ "GetSelectedRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetSelectedRows, 1, NULL },
#endif // (wxLUA_USE_wxArrayInt) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetSelectionBackground", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetSelectionBackground, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetSelectionBlockBottomRight", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetSelectionBlockBottomRight, 1, NULL },
{ "GetSelectionBlockTopLeft", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetSelectionBlockTopLeft, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetSelectionForeground", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetSelectionForeground, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetSelectionMode", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetSelectionMode, 1, NULL },
{ "GetTable", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetTable, 1, NULL },
#if ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxDC)
{ "GetTextBoxSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GetTextBoxSize, 1, NULL },
#endif // ((wxLUA_USE_wxGrid && wxUSE_GRID) && (wxLUA_USE_wxArrayString)) && (wxLUA_USE_wxDC)
{ "GridLinesEnabled", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_GridLinesEnabled, 1, NULL },
{ "HideCellEditControl", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_HideCellEditControl, 1, NULL },
{ "InsertCols", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_InsertCols, 1, NULL },
{ "InsertRows", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_InsertRows, 1, NULL },
{ "IsCellEditControlEnabled", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_IsCellEditControlEnabled, 1, NULL },
{ "IsCellEditControlShown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_IsCellEditControlShown, 1, NULL },
{ "IsCurrentCellReadOnly", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_IsCurrentCellReadOnly, 1, NULL },
{ "IsEditable", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_IsEditable, 1, NULL },
{ "IsInSelection", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_IsInSelection, 1, NULL },
{ "IsReadOnly", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_IsReadOnly, 1, NULL },
{ "IsSelection", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_IsSelection, 1, NULL },
{ "IsVisible", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_IsVisible, 1, NULL },
{ "MakeCellVisible", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MakeCellVisible, 1, NULL },
{ "MoveCursorDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MoveCursorDown, 1, NULL },
{ "MoveCursorDownBlock", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MoveCursorDownBlock, 1, NULL },
{ "MoveCursorLeft", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MoveCursorLeft, 1, NULL },
{ "MoveCursorLeftBlock", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MoveCursorLeftBlock, 1, NULL },
{ "MoveCursorRight", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MoveCursorRight, 1, NULL },
{ "MoveCursorRightBlock", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MoveCursorRightBlock, 1, NULL },
{ "MoveCursorUp", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MoveCursorUp, 1, NULL },
{ "MoveCursorUpBlock", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MoveCursorUpBlock, 1, NULL },
{ "MovePageDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MovePageDown, 1, NULL },
{ "MovePageUp", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_MovePageUp, 1, NULL },
{ "ProcessTableMessage", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_ProcessTableMessage, 1, NULL },
{ "RegisterDataType", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_RegisterDataType, 1, NULL },
{ "SaveEditControlValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SaveEditControlValue, 1, NULL },
{ "SelectAll", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SelectAll, 1, NULL },
{ "SelectBlock", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SelectBlock, 1, NULL },
{ "SelectCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SelectCol, 1, NULL },
{ "SelectRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SelectRow, 1, NULL },
{ "SetAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetAttr, 1, NULL },
{ "SetCellAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellAlignment, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetCellBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellBackgroundColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetCellEditor", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellEditor, 1, NULL },
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetCellFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellFont, 1, NULL },
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetCellHighlightColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellHighlightColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetCellHighlightPenWidth", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellHighlightPenWidth, 1, NULL },
{ "SetCellHighlightROPenWidth", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellHighlightROPenWidth, 1, NULL },
{ "SetCellOverflow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellOverflow, 1, NULL },
{ "SetCellRenderer", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellRenderer, 1, NULL },
{ "SetCellSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellSize, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetCellTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellTextColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetCellValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetCellValue, 1, NULL },
{ "SetColAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColAttr, 1, NULL },
{ "SetColFormatBool", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColFormatBool, 1, NULL },
{ "SetColFormatCustom", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColFormatCustom, 1, NULL },
{ "SetColFormatFloat", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColFormatFloat, 1, NULL },
{ "SetColFormatNumber", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColFormatNumber, 1, NULL },
{ "SetColLabelAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColLabelAlignment, 1, NULL },
{ "SetColLabelSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColLabelSize, 1, NULL },
{ "SetColLabelValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColLabelValue, 1, NULL },
{ "SetColMinimalAcceptableWidth", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColMinimalAcceptableWidth, 1, NULL },
{ "SetColMinimalWidth", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColMinimalWidth, 1, NULL },
{ "SetColSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetColSize, 1, NULL },
{ "SetDefaultCellAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetDefaultCellAlignment, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetDefaultCellBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetDefaultCellBackgroundColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetDefaultCellFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetDefaultCellFont, 1, NULL },
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetDefaultCellOverflow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetDefaultCellOverflow, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetDefaultCellTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetDefaultCellTextColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetDefaultColSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetDefaultColSize, 1, NULL },
{ "SetDefaultEditor", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetDefaultEditor, 1, NULL },
{ "SetDefaultRenderer", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetDefaultRenderer, 1, NULL },
{ "SetDefaultRowSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetDefaultRowSize, 1, NULL },
{ "SetGridCursor", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetGridCursor, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetGridLineColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetGridLineColour, 1, NULL },
{ "SetLabelBackgroundColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetLabelBackgroundColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetLabelFont", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetLabelFont, 1, NULL },
#endif // (wxLUA_USE_wxFont) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetLabelTextColour", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetLabelTextColour, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetMargins", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetMargins, 1, NULL },
{ "SetReadOnly", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetReadOnly, 1, NULL },
{ "SetRowAttr", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetRowAttr, 1, NULL },
{ "SetRowLabelAlignment", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetRowLabelAlignment, 1, NULL },
{ "SetRowLabelSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetRowLabelSize, 1, NULL },
{ "SetRowLabelValue", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetRowLabelValue, 1, NULL },
{ "SetRowMinimalAcceptableHeight", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetRowMinimalAcceptableHeight, 1, NULL },
{ "SetRowMinimalHeight", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetRowMinimalHeight, 1, NULL },
{ "SetRowSize", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetRowSize, 1, NULL },
#if (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetSelectionBackground", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetSelectionBackground, 1, NULL },
{ "SetSelectionForeground", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetSelectionForeground, 1, NULL },
#endif // (wxLUA_USE_wxColourPenBrush) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "SetSelectionMode", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetSelectionMode, 1, NULL },
{ "SetTable", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_SetTable, 1, NULL },
{ "ShowCellEditControl", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_ShowCellEditControl, 1, NULL },
#if (wxLUA_USE_wxArrayString) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "StringToLines", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_StringToLines, 1, NULL },
#endif // (wxLUA_USE_wxArrayString) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "XToCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_XToCol, 1, NULL },
{ "XToEdgeOfCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_XToEdgeOfCol, 1, NULL },
{ "XYToCell", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_XYToCell, 1, NULL },
{ "YToEdgeOfRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_YToEdgeOfRow, 1, NULL },
{ "YToRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGrid_YToRow, 1, NULL },
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "wxGrid", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGrid_constructor, 1, NULL },
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ 0, 0, 0, 0 },
};
int wxGrid_methodCount = sizeof(wxGrid_methods)/sizeof(wxLuaBindMethod) - 1;
wxLuaBindNumber wxGrid_enums[] = {
#if wxLUA_USE_wxGrid && wxUSE_GRID
{ "wxGridSelectCells", wxGrid::wxGridSelectCells },
{ "wxGridSelectColumns", wxGrid::wxGridSelectColumns },
{ "wxGridSelectRows", wxGrid::wxGridSelectRows },
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
{ NULL, 0, },
};
int wxGrid_enumCount = sizeof(wxGrid_enums)/sizeof(wxLuaBindNumber) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridEvent'
int wxluatype_wxGridEvent = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEvent_AltDown[] = { &wxluatype_wxGridEvent, NULL };
static int LUACALL wxLua_wxGridEvent_AltDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEvent_AltDown[1] = {{ wxLua_wxGridEvent_AltDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEvent_AltDown }};
// bool AltDown( );
static int LUACALL wxLua_wxGridEvent_AltDown(lua_State *L)
{
// get this
wxGridEvent * self = (wxGridEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEvent);
// call AltDown
bool returns = (self->AltDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEvent_ControlDown[] = { &wxluatype_wxGridEvent, NULL };
static int LUACALL wxLua_wxGridEvent_ControlDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEvent_ControlDown[1] = {{ wxLua_wxGridEvent_ControlDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEvent_ControlDown }};
// bool ControlDown( );
static int LUACALL wxLua_wxGridEvent_ControlDown(lua_State *L)
{
// get this
wxGridEvent * self = (wxGridEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEvent);
// call ControlDown
bool returns = (self->ControlDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEvent_GetCol[] = { &wxluatype_wxGridEvent, NULL };
static int LUACALL wxLua_wxGridEvent_GetCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEvent_GetCol[1] = {{ wxLua_wxGridEvent_GetCol, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEvent_GetCol }};
// virtual int GetCol( );
static int LUACALL wxLua_wxGridEvent_GetCol(lua_State *L)
{
// get this
wxGridEvent * self = (wxGridEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEvent);
// call GetCol
int returns = (self->GetCol());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEvent_GetPosition[] = { &wxluatype_wxGridEvent, NULL };
static int LUACALL wxLua_wxGridEvent_GetPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEvent_GetPosition[1] = {{ wxLua_wxGridEvent_GetPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEvent_GetPosition }};
// wxPoint GetPosition( );
static int LUACALL wxLua_wxGridEvent_GetPosition(lua_State *L)
{
// get this
wxGridEvent * self = (wxGridEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEvent);
// call GetPosition
// allocate a new object using the copy constructor
wxPoint* returns = new wxPoint(self->GetPosition());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxPoint);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxPoint);
return 1;
}
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEvent_GetRow[] = { &wxluatype_wxGridEvent, NULL };
static int LUACALL wxLua_wxGridEvent_GetRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEvent_GetRow[1] = {{ wxLua_wxGridEvent_GetRow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEvent_GetRow }};
// virtual int GetRow( );
static int LUACALL wxLua_wxGridEvent_GetRow(lua_State *L)
{
// get this
wxGridEvent * self = (wxGridEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEvent);
// call GetRow
int returns = (self->GetRow());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEvent_MetaDown[] = { &wxluatype_wxGridEvent, NULL };
static int LUACALL wxLua_wxGridEvent_MetaDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEvent_MetaDown[1] = {{ wxLua_wxGridEvent_MetaDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEvent_MetaDown }};
// bool MetaDown( );
static int LUACALL wxLua_wxGridEvent_MetaDown(lua_State *L)
{
// get this
wxGridEvent * self = (wxGridEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEvent);
// call MetaDown
bool returns = (self->MetaDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEvent_Selecting[] = { &wxluatype_wxGridEvent, NULL };
static int LUACALL wxLua_wxGridEvent_Selecting(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEvent_Selecting[1] = {{ wxLua_wxGridEvent_Selecting, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEvent_Selecting }};
// bool Selecting( );
static int LUACALL wxLua_wxGridEvent_Selecting(lua_State *L)
{
// get this
wxGridEvent * self = (wxGridEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEvent);
// call Selecting
bool returns = (self->Selecting());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEvent_ShiftDown[] = { &wxluatype_wxGridEvent, NULL };
static int LUACALL wxLua_wxGridEvent_ShiftDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEvent_ShiftDown[1] = {{ wxLua_wxGridEvent_ShiftDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEvent_ShiftDown }};
// bool ShiftDown( );
static int LUACALL wxLua_wxGridEvent_ShiftDown(lua_State *L)
{
// get this
wxGridEvent * self = (wxGridEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEvent);
// call ShiftDown
bool returns = (self->ShiftDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEvent_delete[] = { &wxluatype_wxGridEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridEvent_delete }};
#if (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEvent_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxObject, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGridEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEvent_constructor[1] = {{ wxLua_wxGridEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 3, 12, s_wxluatypeArray_wxLua_wxGridEvent_constructor }};
// !%wxchkver_2_9_0 wxGridEvent(int id, wxEventType type, wxObject* obj, int row = -1, int col = -1, int x = -1, int y = -1, bool sel = true, bool control = false, bool shift = false, bool alt = false, bool meta = false );
static int LUACALL wxLua_wxGridEvent_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool meta = false
bool meta = (argCount >= 12 ? wxlua_getbooleantype(L, 12) : false);
// bool alt = false
bool alt = (argCount >= 11 ? wxlua_getbooleantype(L, 11) : false);
// bool shift = false
bool shift = (argCount >= 10 ? wxlua_getbooleantype(L, 10) : false);
// bool control = false
bool control = (argCount >= 9 ? wxlua_getbooleantype(L, 9) : false);
// bool sel = true
bool sel = (argCount >= 8 ? wxlua_getbooleantype(L, 8) : true);
// int y = -1
int y = (argCount >= 7 ? (int)wxlua_getnumbertype(L, 7) : -1);
// int x = -1
int x = (argCount >= 6 ? (int)wxlua_getnumbertype(L, 6) : -1);
// int col = -1
int col = (argCount >= 5 ? (int)wxlua_getnumbertype(L, 5) : -1);
// int row = -1
int row = (argCount >= 4 ? (int)wxlua_getnumbertype(L, 4) : -1);
// wxObject obj
wxObject * obj = (wxObject *)wxluaT_getuserdatatype(L, 3, wxluatype_wxObject);
// wxEventType type
wxEventType type = (wxEventType)wxlua_getnumbertype(L, 2);
// int id
int id = (int)wxlua_getnumbertype(L, 1);
// call constructor
wxGridEvent* returns = new wxGridEvent(id, type, obj, row, col, x, y, sel, control, shift, alt, meta);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridEvent);
return 1;
}
#endif // (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
void wxLua_wxGridEvent_delete_function(void** p)
{
wxGridEvent* o = (wxGridEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridEvent_methods[] = {
{ "AltDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEvent_AltDown, 1, NULL },
{ "ControlDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEvent_ControlDown, 1, NULL },
{ "GetCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEvent_GetCol, 1, NULL },
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEvent_GetPosition, 1, NULL },
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEvent_GetRow, 1, NULL },
{ "MetaDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEvent_MetaDown, 1, NULL },
{ "Selecting", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEvent_Selecting, 1, NULL },
{ "ShiftDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEvent_ShiftDown, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridEvent_delete, 1, NULL },
#if (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "wxGridEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridEvent_constructor, 1, NULL },
#endif // (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ 0, 0, 0, 0 },
};
int wxGridEvent_methodCount = sizeof(wxGridEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridSizeEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridSizeEvent'
int wxluatype_wxGridSizeEvent = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridSizeEvent_AltDown[] = { &wxluatype_wxGridSizeEvent, NULL };
static int LUACALL wxLua_wxGridSizeEvent_AltDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridSizeEvent_AltDown[1] = {{ wxLua_wxGridSizeEvent_AltDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridSizeEvent_AltDown }};
// bool AltDown( );
static int LUACALL wxLua_wxGridSizeEvent_AltDown(lua_State *L)
{
// get this
wxGridSizeEvent * self = (wxGridSizeEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridSizeEvent);
// call AltDown
bool returns = (self->AltDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridSizeEvent_ControlDown[] = { &wxluatype_wxGridSizeEvent, NULL };
static int LUACALL wxLua_wxGridSizeEvent_ControlDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridSizeEvent_ControlDown[1] = {{ wxLua_wxGridSizeEvent_ControlDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridSizeEvent_ControlDown }};
// bool ControlDown( );
static int LUACALL wxLua_wxGridSizeEvent_ControlDown(lua_State *L)
{
// get this
wxGridSizeEvent * self = (wxGridSizeEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridSizeEvent);
// call ControlDown
bool returns = (self->ControlDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridSizeEvent_GetPosition[] = { &wxluatype_wxGridSizeEvent, NULL };
static int LUACALL wxLua_wxGridSizeEvent_GetPosition(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridSizeEvent_GetPosition[1] = {{ wxLua_wxGridSizeEvent_GetPosition, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridSizeEvent_GetPosition }};
// wxPoint GetPosition( );
static int LUACALL wxLua_wxGridSizeEvent_GetPosition(lua_State *L)
{
// get this
wxGridSizeEvent * self = (wxGridSizeEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridSizeEvent);
// call GetPosition
// allocate a new object using the copy constructor
wxPoint* returns = new wxPoint(self->GetPosition());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxPoint);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxPoint);
return 1;
}
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridSizeEvent_GetRowOrCol[] = { &wxluatype_wxGridSizeEvent, NULL };
static int LUACALL wxLua_wxGridSizeEvent_GetRowOrCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridSizeEvent_GetRowOrCol[1] = {{ wxLua_wxGridSizeEvent_GetRowOrCol, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridSizeEvent_GetRowOrCol }};
// int GetRowOrCol( );
static int LUACALL wxLua_wxGridSizeEvent_GetRowOrCol(lua_State *L)
{
// get this
wxGridSizeEvent * self = (wxGridSizeEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridSizeEvent);
// call GetRowOrCol
int returns = (self->GetRowOrCol());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridSizeEvent_MetaDown[] = { &wxluatype_wxGridSizeEvent, NULL };
static int LUACALL wxLua_wxGridSizeEvent_MetaDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridSizeEvent_MetaDown[1] = {{ wxLua_wxGridSizeEvent_MetaDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridSizeEvent_MetaDown }};
// bool MetaDown( );
static int LUACALL wxLua_wxGridSizeEvent_MetaDown(lua_State *L)
{
// get this
wxGridSizeEvent * self = (wxGridSizeEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridSizeEvent);
// call MetaDown
bool returns = (self->MetaDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridSizeEvent_ShiftDown[] = { &wxluatype_wxGridSizeEvent, NULL };
static int LUACALL wxLua_wxGridSizeEvent_ShiftDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridSizeEvent_ShiftDown[1] = {{ wxLua_wxGridSizeEvent_ShiftDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridSizeEvent_ShiftDown }};
// bool ShiftDown( );
static int LUACALL wxLua_wxGridSizeEvent_ShiftDown(lua_State *L)
{
// get this
wxGridSizeEvent * self = (wxGridSizeEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridSizeEvent);
// call ShiftDown
bool returns = (self->ShiftDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridSizeEvent_delete[] = { &wxluatype_wxGridSizeEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridSizeEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridSizeEvent_delete }};
#if (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridSizeEvent_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxObject, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGridSizeEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridSizeEvent_constructor[1] = {{ wxLua_wxGridSizeEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 3, 10, s_wxluatypeArray_wxLua_wxGridSizeEvent_constructor }};
// !%wxchkver_2_9_0 wxGridSizeEvent(int id, wxEventType type, wxObject* obj, int rowOrCol = -1, int x = -1, int y = -1, bool control = false, bool shift = false, bool alt = false, bool meta = false );
static int LUACALL wxLua_wxGridSizeEvent_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool meta = false
bool meta = (argCount >= 10 ? wxlua_getbooleantype(L, 10) : false);
// bool alt = false
bool alt = (argCount >= 9 ? wxlua_getbooleantype(L, 9) : false);
// bool shift = false
bool shift = (argCount >= 8 ? wxlua_getbooleantype(L, 8) : false);
// bool control = false
bool control = (argCount >= 7 ? wxlua_getbooleantype(L, 7) : false);
// int y = -1
int y = (argCount >= 6 ? (int)wxlua_getnumbertype(L, 6) : -1);
// int x = -1
int x = (argCount >= 5 ? (int)wxlua_getnumbertype(L, 5) : -1);
// int rowOrCol = -1
int rowOrCol = (argCount >= 4 ? (int)wxlua_getnumbertype(L, 4) : -1);
// wxObject obj
wxObject * obj = (wxObject *)wxluaT_getuserdatatype(L, 3, wxluatype_wxObject);
// wxEventType type
wxEventType type = (wxEventType)wxlua_getnumbertype(L, 2);
// int id
int id = (int)wxlua_getnumbertype(L, 1);
// call constructor
wxGridSizeEvent* returns = new wxGridSizeEvent(id, type, obj, rowOrCol, x, y, control, shift, alt, meta);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridSizeEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridSizeEvent);
return 1;
}
#endif // (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
void wxLua_wxGridSizeEvent_delete_function(void** p)
{
wxGridSizeEvent* o = (wxGridSizeEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridSizeEvent_methods[] = {
{ "AltDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridSizeEvent_AltDown, 1, NULL },
{ "ControlDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridSizeEvent_ControlDown, 1, NULL },
#if (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetPosition", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridSizeEvent_GetPosition, 1, NULL },
#endif // (wxLUA_USE_wxPointSizeRect) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "GetRowOrCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridSizeEvent_GetRowOrCol, 1, NULL },
{ "MetaDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridSizeEvent_MetaDown, 1, NULL },
{ "ShiftDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridSizeEvent_ShiftDown, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridSizeEvent_delete, 1, NULL },
#if (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "wxGridSizeEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridSizeEvent_constructor, 1, NULL },
#endif // (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ 0, 0, 0, 0 },
};
int wxGridSizeEvent_methodCount = sizeof(wxGridSizeEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridRangeSelectEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridRangeSelectEvent'
int wxluatype_wxGridRangeSelectEvent = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_AltDown[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_AltDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_AltDown[1] = {{ wxLua_wxGridRangeSelectEvent_AltDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_AltDown }};
// bool AltDown( );
static int LUACALL wxLua_wxGridRangeSelectEvent_AltDown(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call AltDown
bool returns = (self->AltDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_ControlDown[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_ControlDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_ControlDown[1] = {{ wxLua_wxGridRangeSelectEvent_ControlDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_ControlDown }};
// bool ControlDown( );
static int LUACALL wxLua_wxGridRangeSelectEvent_ControlDown(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call ControlDown
bool returns = (self->ControlDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetBottomRightCoords[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_GetBottomRightCoords(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetBottomRightCoords[1] = {{ wxLua_wxGridRangeSelectEvent_GetBottomRightCoords, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetBottomRightCoords }};
// wxGridCellCoords GetBottomRightCoords( );
static int LUACALL wxLua_wxGridRangeSelectEvent_GetBottomRightCoords(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call GetBottomRightCoords
// allocate a new object using the copy constructor
wxGridCellCoords* returns = new wxGridCellCoords(self->GetBottomRightCoords());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellCoords);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoords);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetBottomRow[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_GetBottomRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetBottomRow[1] = {{ wxLua_wxGridRangeSelectEvent_GetBottomRow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetBottomRow }};
// int GetBottomRow( );
static int LUACALL wxLua_wxGridRangeSelectEvent_GetBottomRow(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call GetBottomRow
int returns = (self->GetBottomRow());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetLeftCol[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_GetLeftCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetLeftCol[1] = {{ wxLua_wxGridRangeSelectEvent_GetLeftCol, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetLeftCol }};
// int GetLeftCol( );
static int LUACALL wxLua_wxGridRangeSelectEvent_GetLeftCol(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call GetLeftCol
int returns = (self->GetLeftCol());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetRightCol[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_GetRightCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetRightCol[1] = {{ wxLua_wxGridRangeSelectEvent_GetRightCol, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetRightCol }};
// int GetRightCol( );
static int LUACALL wxLua_wxGridRangeSelectEvent_GetRightCol(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call GetRightCol
int returns = (self->GetRightCol());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetTopLeftCoords[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_GetTopLeftCoords(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetTopLeftCoords[1] = {{ wxLua_wxGridRangeSelectEvent_GetTopLeftCoords, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetTopLeftCoords }};
// wxGridCellCoords GetTopLeftCoords( );
static int LUACALL wxLua_wxGridRangeSelectEvent_GetTopLeftCoords(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call GetTopLeftCoords
// allocate a new object using the copy constructor
wxGridCellCoords* returns = new wxGridCellCoords(self->GetTopLeftCoords());
// add the new object to the tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridCellCoords);
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridCellCoords);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetTopRow[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_GetTopRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetTopRow[1] = {{ wxLua_wxGridRangeSelectEvent_GetTopRow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_GetTopRow }};
// int GetTopRow( );
static int LUACALL wxLua_wxGridRangeSelectEvent_GetTopRow(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call GetTopRow
int returns = (self->GetTopRow());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_MetaDown[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_MetaDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_MetaDown[1] = {{ wxLua_wxGridRangeSelectEvent_MetaDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_MetaDown }};
// bool MetaDown( );
static int LUACALL wxLua_wxGridRangeSelectEvent_MetaDown(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call MetaDown
bool returns = (self->MetaDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_Selecting[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_Selecting(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_Selecting[1] = {{ wxLua_wxGridRangeSelectEvent_Selecting, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_Selecting }};
// bool Selecting( );
static int LUACALL wxLua_wxGridRangeSelectEvent_Selecting(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call Selecting
bool returns = (self->Selecting());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_ShiftDown[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_ShiftDown(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_ShiftDown[1] = {{ wxLua_wxGridRangeSelectEvent_ShiftDown, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_ShiftDown }};
// bool ShiftDown( );
static int LUACALL wxLua_wxGridRangeSelectEvent_ShiftDown(lua_State *L)
{
// get this
wxGridRangeSelectEvent * self = (wxGridRangeSelectEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridRangeSelectEvent);
// call ShiftDown
bool returns = (self->ShiftDown());
// push the result flag
lua_pushboolean(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_delete[] = { &wxluatype_wxGridRangeSelectEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_delete }};
#if (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxObject, &wxluatype_wxGridCellCoords, &wxluatype_wxGridCellCoords, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, &wxluatype_TBOOLEAN, NULL };
static int LUACALL wxLua_wxGridRangeSelectEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridRangeSelectEvent_constructor[1] = {{ wxLua_wxGridRangeSelectEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 5, 10, s_wxluatypeArray_wxLua_wxGridRangeSelectEvent_constructor }};
// !%wxchkver_2_9_0 wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj, const wxGridCellCoords& topLeft, const wxGridCellCoords& bottomRight, bool sel = true, bool control = false, bool shift = false, bool alt = false, bool meta = false );
static int LUACALL wxLua_wxGridRangeSelectEvent_constructor(lua_State *L)
{
// get number of arguments
int argCount = lua_gettop(L);
// bool meta = false
bool meta = (argCount >= 10 ? wxlua_getbooleantype(L, 10) : false);
// bool alt = false
bool alt = (argCount >= 9 ? wxlua_getbooleantype(L, 9) : false);
// bool shift = false
bool shift = (argCount >= 8 ? wxlua_getbooleantype(L, 8) : false);
// bool control = false
bool control = (argCount >= 7 ? wxlua_getbooleantype(L, 7) : false);
// bool sel = true
bool sel = (argCount >= 6 ? wxlua_getbooleantype(L, 6) : true);
// const wxGridCellCoords bottomRight
const wxGridCellCoords * bottomRight = (const wxGridCellCoords *)wxluaT_getuserdatatype(L, 5, wxluatype_wxGridCellCoords);
// const wxGridCellCoords topLeft
const wxGridCellCoords * topLeft = (const wxGridCellCoords *)wxluaT_getuserdatatype(L, 4, wxluatype_wxGridCellCoords);
// wxObject obj
wxObject * obj = (wxObject *)wxluaT_getuserdatatype(L, 3, wxluatype_wxObject);
// wxEventType type
wxEventType type = (wxEventType)wxlua_getnumbertype(L, 2);
// int id
int id = (int)wxlua_getnumbertype(L, 1);
// call constructor
wxGridRangeSelectEvent* returns = new wxGridRangeSelectEvent(id, type, obj, *topLeft, *bottomRight, sel, control, shift, alt, meta);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridRangeSelectEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridRangeSelectEvent);
return 1;
}
#endif // (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
void wxLua_wxGridRangeSelectEvent_delete_function(void** p)
{
wxGridRangeSelectEvent* o = (wxGridRangeSelectEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridRangeSelectEvent_methods[] = {
{ "AltDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_AltDown, 1, NULL },
{ "ControlDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_ControlDown, 1, NULL },
{ "GetBottomRightCoords", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetBottomRightCoords, 1, NULL },
{ "GetBottomRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetBottomRow, 1, NULL },
{ "GetLeftCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetLeftCol, 1, NULL },
{ "GetRightCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetRightCol, 1, NULL },
{ "GetTopLeftCoords", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetTopLeftCoords, 1, NULL },
{ "GetTopRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_GetTopRow, 1, NULL },
{ "MetaDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_MetaDown, 1, NULL },
{ "Selecting", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_Selecting, 1, NULL },
{ "ShiftDown", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridRangeSelectEvent_ShiftDown, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridRangeSelectEvent_delete, 1, NULL },
#if (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "wxGridRangeSelectEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridRangeSelectEvent_constructor, 1, NULL },
#endif // (((!wxCHECK_VERSION(2,9,0)) && (wxLUA_USE_wxGrid && wxUSE_GRID)) && (wxLUA_USE_wxObject)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ 0, 0, 0, 0 },
};
int wxGridRangeSelectEvent_methodCount = sizeof(wxGridRangeSelectEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// Bind class wxGridEditorCreatedEvent
// ---------------------------------------------------------------------------
// Lua MetaTable Tag for Class 'wxGridEditorCreatedEvent'
int wxluatype_wxGridEditorCreatedEvent = WXLUA_TUNKNOWN;
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_GetCol[] = { &wxluatype_wxGridEditorCreatedEvent, NULL };
static int LUACALL wxLua_wxGridEditorCreatedEvent_GetCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEditorCreatedEvent_GetCol[1] = {{ wxLua_wxGridEditorCreatedEvent_GetCol, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_GetCol }};
// int GetCol( );
static int LUACALL wxLua_wxGridEditorCreatedEvent_GetCol(lua_State *L)
{
// get this
wxGridEditorCreatedEvent * self = (wxGridEditorCreatedEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEditorCreatedEvent);
// call GetCol
int returns = (self->GetCol());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_GetControl[] = { &wxluatype_wxGridEditorCreatedEvent, NULL };
static int LUACALL wxLua_wxGridEditorCreatedEvent_GetControl(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEditorCreatedEvent_GetControl[1] = {{ wxLua_wxGridEditorCreatedEvent_GetControl, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_GetControl }};
// wxControl* GetControl( );
static int LUACALL wxLua_wxGridEditorCreatedEvent_GetControl(lua_State *L)
{
// get this
wxGridEditorCreatedEvent * self = (wxGridEditorCreatedEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEditorCreatedEvent);
// call GetControl
wxControl* returns = (wxControl*)self->GetControl();
// push the result datatype
wxluaT_pushuserdatatype(L, returns, wxluatype_wxControl);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_GetRow[] = { &wxluatype_wxGridEditorCreatedEvent, NULL };
static int LUACALL wxLua_wxGridEditorCreatedEvent_GetRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEditorCreatedEvent_GetRow[1] = {{ wxLua_wxGridEditorCreatedEvent_GetRow, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_GetRow }};
// int GetRow( );
static int LUACALL wxLua_wxGridEditorCreatedEvent_GetRow(lua_State *L)
{
// get this
wxGridEditorCreatedEvent * self = (wxGridEditorCreatedEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEditorCreatedEvent);
// call GetRow
int returns = (self->GetRow());
// push the result number
lua_pushnumber(L, returns);
return 1;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_SetCol[] = { &wxluatype_wxGridEditorCreatedEvent, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridEditorCreatedEvent_SetCol(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEditorCreatedEvent_SetCol[1] = {{ wxLua_wxGridEditorCreatedEvent_SetCol, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_SetCol }};
// void SetCol(int col );
static int LUACALL wxLua_wxGridEditorCreatedEvent_SetCol(lua_State *L)
{
// int col
int col = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridEditorCreatedEvent * self = (wxGridEditorCreatedEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEditorCreatedEvent);
// call SetCol
self->SetCol(col);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_SetControl[] = { &wxluatype_wxGridEditorCreatedEvent, &wxluatype_wxControl, NULL };
static int LUACALL wxLua_wxGridEditorCreatedEvent_SetControl(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEditorCreatedEvent_SetControl[1] = {{ wxLua_wxGridEditorCreatedEvent_SetControl, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_SetControl }};
// void SetControl(wxControl * ctrl );
static int LUACALL wxLua_wxGridEditorCreatedEvent_SetControl(lua_State *L)
{
// wxControl ctrl
wxControl * ctrl = (wxControl *)wxluaT_getuserdatatype(L, 2, wxluatype_wxControl);
// get this
wxGridEditorCreatedEvent * self = (wxGridEditorCreatedEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEditorCreatedEvent);
// call SetControl
self->SetControl(ctrl);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_SetRow[] = { &wxluatype_wxGridEditorCreatedEvent, &wxluatype_TNUMBER, NULL };
static int LUACALL wxLua_wxGridEditorCreatedEvent_SetRow(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEditorCreatedEvent_SetRow[1] = {{ wxLua_wxGridEditorCreatedEvent_SetRow, WXLUAMETHOD_METHOD, 2, 2, s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_SetRow }};
// void SetRow(int row );
static int LUACALL wxLua_wxGridEditorCreatedEvent_SetRow(lua_State *L)
{
// int row
int row = (int)wxlua_getnumbertype(L, 2);
// get this
wxGridEditorCreatedEvent * self = (wxGridEditorCreatedEvent *)wxluaT_getuserdatatype(L, 1, wxluatype_wxGridEditorCreatedEvent);
// call SetRow
self->SetRow(row);
return 0;
}
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_delete[] = { &wxluatype_wxGridEditorCreatedEvent, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEditorCreatedEvent_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_delete }};
#if (wxLUA_USE_wxObject) && (wxLUA_USE_wxGrid && wxUSE_GRID)
static wxLuaArgType s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_constructor[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxObject, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_wxControl, NULL };
static int LUACALL wxLua_wxGridEditorCreatedEvent_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxGridEditorCreatedEvent_constructor[1] = {{ wxLua_wxGridEditorCreatedEvent_constructor, WXLUAMETHOD_CONSTRUCTOR, 6, 6, s_wxluatypeArray_wxLua_wxGridEditorCreatedEvent_constructor }};
// wxGridEditorCreatedEvent(int id, wxEventType type, wxObject* obj, int row, int col, wxControl* ctrl );
static int LUACALL wxLua_wxGridEditorCreatedEvent_constructor(lua_State *L)
{
// wxControl ctrl
wxControl * ctrl = (wxControl *)wxluaT_getuserdatatype(L, 6, wxluatype_wxControl);
// int col
int col = (int)wxlua_getnumbertype(L, 5);
// int row
int row = (int)wxlua_getnumbertype(L, 4);
// wxObject obj
wxObject * obj = (wxObject *)wxluaT_getuserdatatype(L, 3, wxluatype_wxObject);
// wxEventType type
wxEventType type = (wxEventType)wxlua_getnumbertype(L, 2);
// int id
int id = (int)wxlua_getnumbertype(L, 1);
// call constructor
wxGridEditorCreatedEvent* returns = new wxGridEditorCreatedEvent(id, type, obj, row, col, ctrl);
// add to tracked memory list
wxluaO_addgcobject(L, returns, wxluatype_wxGridEditorCreatedEvent);
// push the constructed class pointer
wxluaT_pushuserdatatype(L, returns, wxluatype_wxGridEditorCreatedEvent);
return 1;
}
#endif // (wxLUA_USE_wxObject) && (wxLUA_USE_wxGrid && wxUSE_GRID)
void wxLua_wxGridEditorCreatedEvent_delete_function(void** p)
{
wxGridEditorCreatedEvent* o = (wxGridEditorCreatedEvent*)(*p);
delete o;
}
// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxGridEditorCreatedEvent_methods[] = {
{ "GetCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEditorCreatedEvent_GetCol, 1, NULL },
{ "GetControl", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEditorCreatedEvent_GetControl, 1, NULL },
{ "GetRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEditorCreatedEvent_GetRow, 1, NULL },
{ "SetCol", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEditorCreatedEvent_SetCol, 1, NULL },
{ "SetControl", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEditorCreatedEvent_SetControl, 1, NULL },
{ "SetRow", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxGridEditorCreatedEvent_SetRow, 1, NULL },
{ "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxGridEditorCreatedEvent_delete, 1, NULL },
#if (wxLUA_USE_wxObject) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "wxGridEditorCreatedEvent", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxGridEditorCreatedEvent_constructor, 1, NULL },
#endif // (wxLUA_USE_wxObject) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ 0, 0, 0, 0 },
};
int wxGridEditorCreatedEvent_methodCount = sizeof(wxGridEditorCreatedEvent_methods)/sizeof(wxLuaBindMethod) - 1;
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
// ---------------------------------------------------------------------------
// ../modules/wxbind/src/wxadv_bind.cpp was generated by genwxbind.lua
//
// Any changes made to this file will be lost when the file is regenerated.
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// wxLuaGetEventList_wxadv() is called to register events
// ---------------------------------------------------------------------------
wxLuaBindEvent* wxLuaGetEventList_wxadv(size_t &count)
{
static wxLuaBindEvent eventList[] =
{
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
{ "wxEVT_CALCULATE_LAYOUT", WXLUA_GET_wxEventType_ptr(wxEVT_CALCULATE_LAYOUT), &wxluatype_wxCalculateLayoutEvent },
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
{ "wxEVT_CALENDAR_DAY_CHANGED", WXLUA_GET_wxEventType_ptr(wxEVT_CALENDAR_DAY_CHANGED), &wxluatype_wxCalendarEvent },
{ "wxEVT_CALENDAR_DOUBLECLICKED", WXLUA_GET_wxEventType_ptr(wxEVT_CALENDAR_DOUBLECLICKED), &wxluatype_wxCalendarEvent },
{ "wxEVT_CALENDAR_MONTH_CHANGED", WXLUA_GET_wxEventType_ptr(wxEVT_CALENDAR_MONTH_CHANGED), &wxluatype_wxCalendarEvent },
{ "wxEVT_CALENDAR_SEL_CHANGED", WXLUA_GET_wxEventType_ptr(wxEVT_CALENDAR_SEL_CHANGED), &wxluatype_wxCalendarEvent },
{ "wxEVT_CALENDAR_WEEKDAY_CLICKED", WXLUA_GET_wxEventType_ptr(wxEVT_CALENDAR_WEEKDAY_CLICKED), &wxluatype_wxCalendarEvent },
{ "wxEVT_CALENDAR_YEAR_CHANGED", WXLUA_GET_wxEventType_ptr(wxEVT_CALENDAR_YEAR_CHANGED), &wxluatype_wxCalendarEvent },
#endif // wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
#if wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
{ "wxEVT_COMMAND_HYPERLINK", WXLUA_GET_wxEventType_ptr(wxEVT_COMMAND_HYPERLINK), &wxluatype_wxHyperlinkEvent },
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
#if wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
{ "wxEVT_DATE_CHANGED", WXLUA_GET_wxEventType_ptr(wxEVT_DATE_CHANGED), &wxluatype_wxDateEvent },
#endif // wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
#if wxLUA_USE_wxGrid && wxUSE_GRID
{ "wxEVT_GRID_CELL_BEGIN_DRAG", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_CELL_BEGIN_DRAG), &wxluatype_wxGridEvent },
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if (wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8))
{ "wxEVT_GRID_CELL_CHANGE", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_CELL_CHANGE), &wxluatype_wxGridEvent },
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID) && (!wxCHECK_VERSION(3,0,0) || (defined(WXWIN_COMPATIBILITY_2_8) && WXWIN_COMPATIBILITY_2_8))
#if (wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0))
{ "wxEVT_GRID_CELL_CHANGED", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_CELL_CHANGED), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_CELL_CHANGING", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_CELL_CHANGING), &wxluatype_wxGridEvent },
#endif // (wxLUA_USE_wxGrid && wxUSE_GRID) && (wxCHECK_VERSION(3,0,0))
#if wxLUA_USE_wxGrid && wxUSE_GRID
{ "wxEVT_GRID_CELL_LEFT_CLICK", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_CELL_LEFT_CLICK), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_CELL_LEFT_DCLICK", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_CELL_LEFT_DCLICK), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_CELL_RIGHT_CLICK", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_CELL_RIGHT_CLICK), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_CELL_RIGHT_DCLICK", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_CELL_RIGHT_DCLICK), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_COL_SIZE", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_COL_SIZE), &wxluatype_wxGridSizeEvent },
{ "wxEVT_GRID_EDITOR_CREATED", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_EDITOR_CREATED), &wxluatype_wxGridEditorCreatedEvent },
{ "wxEVT_GRID_EDITOR_HIDDEN", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_EDITOR_HIDDEN), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_EDITOR_SHOWN", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_EDITOR_SHOWN), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_LABEL_LEFT_CLICK", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_LABEL_LEFT_CLICK), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_LABEL_LEFT_DCLICK", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_LABEL_LEFT_DCLICK), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_LABEL_RIGHT_CLICK", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_LABEL_RIGHT_CLICK), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_LABEL_RIGHT_DCLICK", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_LABEL_RIGHT_DCLICK), &wxluatype_wxGridEvent },
{ "wxEVT_GRID_RANGE_SELECT", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_RANGE_SELECT), &wxluatype_wxGridRangeSelectEvent },
{ "wxEVT_GRID_ROW_SIZE", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_ROW_SIZE), &wxluatype_wxGridSizeEvent },
{ "wxEVT_GRID_SELECT_CELL", WXLUA_GET_wxEventType_ptr(wxEVT_GRID_SELECT_CELL), &wxluatype_wxGridEvent },
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
{ "wxEVT_JOY_BUTTON_DOWN", WXLUA_GET_wxEventType_ptr(wxEVT_JOY_BUTTON_DOWN), &wxluatype_wxJoystickEvent },
{ "wxEVT_JOY_BUTTON_UP", WXLUA_GET_wxEventType_ptr(wxEVT_JOY_BUTTON_UP), &wxluatype_wxJoystickEvent },
{ "wxEVT_JOY_MOVE", WXLUA_GET_wxEventType_ptr(wxEVT_JOY_MOVE), &wxluatype_wxJoystickEvent },
{ "wxEVT_JOY_ZMOVE", WXLUA_GET_wxEventType_ptr(wxEVT_JOY_ZMOVE), &wxluatype_wxJoystickEvent },
#endif // wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
{ "wxEVT_QUERY_LAYOUT_INFO", WXLUA_GET_wxEventType_ptr(wxEVT_QUERY_LAYOUT_INFO), &wxluatype_wxQueryLayoutInfoEvent },
{ "wxEVT_SASH_DRAGGED", WXLUA_GET_wxEventType_ptr(wxEVT_SASH_DRAGGED), &wxluatype_wxSashEvent },
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON )
{ "wxEVT_TASKBAR_LEFT_DCLICK", WXLUA_GET_wxEventType_ptr(wxEVT_TASKBAR_LEFT_DCLICK), &wxluatype_wxTaskBarIconEvent },
{ "wxEVT_TASKBAR_LEFT_DOWN", WXLUA_GET_wxEventType_ptr(wxEVT_TASKBAR_LEFT_DOWN), &wxluatype_wxTaskBarIconEvent },
{ "wxEVT_TASKBAR_LEFT_UP", WXLUA_GET_wxEventType_ptr(wxEVT_TASKBAR_LEFT_UP), &wxluatype_wxTaskBarIconEvent },
{ "wxEVT_TASKBAR_MOVE", WXLUA_GET_wxEventType_ptr(wxEVT_TASKBAR_MOVE), &wxluatype_wxTaskBarIconEvent },
{ "wxEVT_TASKBAR_RIGHT_DCLICK", WXLUA_GET_wxEventType_ptr(wxEVT_TASKBAR_RIGHT_DCLICK), &wxluatype_wxTaskBarIconEvent },
{ "wxEVT_TASKBAR_RIGHT_DOWN", WXLUA_GET_wxEventType_ptr(wxEVT_TASKBAR_RIGHT_DOWN), &wxluatype_wxTaskBarIconEvent },
{ "wxEVT_TASKBAR_RIGHT_UP", WXLUA_GET_wxEventType_ptr(wxEVT_TASKBAR_RIGHT_UP), &wxluatype_wxTaskBarIconEvent },
#endif // wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON )
#if wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
{ "wxEVT_WIZARD_CANCEL", WXLUA_GET_wxEventType_ptr(wxEVT_WIZARD_CANCEL), &wxluatype_wxWizardEvent },
{ "wxEVT_WIZARD_FINISHED", WXLUA_GET_wxEventType_ptr(wxEVT_WIZARD_FINISHED), &wxluatype_wxWizardEvent },
{ "wxEVT_WIZARD_HELP", WXLUA_GET_wxEventType_ptr(wxEVT_WIZARD_HELP), &wxluatype_wxWizardEvent },
{ "wxEVT_WIZARD_PAGE_CHANGED", WXLUA_GET_wxEventType_ptr(wxEVT_WIZARD_PAGE_CHANGED), &wxluatype_wxWizardEvent },
{ "wxEVT_WIZARD_PAGE_CHANGING", WXLUA_GET_wxEventType_ptr(wxEVT_WIZARD_PAGE_CHANGING), &wxluatype_wxWizardEvent },
#endif // wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
{ 0, 0, 0 },
};
count = sizeof(eventList)/sizeof(wxLuaBindEvent) - 1;
return eventList;
}
// ---------------------------------------------------------------------------
// wxLuaGetDefineList_wxadv() is called to register #define and enum
// ---------------------------------------------------------------------------
wxLuaBindNumber* wxLuaGetDefineList_wxadv(size_t &count)
{
static wxLuaBindNumber numberList[] =
{
#if wxLUA_USE_wxGrid && wxUSE_GRID
{ "WXGRID_DEFAULT_COL_LABEL_HEIGHT", WXGRID_DEFAULT_COL_LABEL_HEIGHT },
{ "WXGRID_DEFAULT_COL_WIDTH", WXGRID_DEFAULT_COL_WIDTH },
{ "WXGRID_DEFAULT_NUMBER_COLS", WXGRID_DEFAULT_NUMBER_COLS },
{ "WXGRID_DEFAULT_NUMBER_ROWS", WXGRID_DEFAULT_NUMBER_ROWS },
{ "WXGRID_DEFAULT_ROW_HEIGHT", WXGRID_DEFAULT_ROW_HEIGHT },
{ "WXGRID_DEFAULT_ROW_LABEL_WIDTH", WXGRID_DEFAULT_ROW_LABEL_WIDTH },
{ "WXGRID_DEFAULT_SCROLLBAR_WIDTH", WXGRID_DEFAULT_SCROLLBAR_WIDTH },
{ "WXGRID_LABEL_EDGE_ZONE", WXGRID_LABEL_EDGE_ZONE },
{ "WXGRID_MIN_COL_WIDTH", WXGRID_MIN_COL_WIDTH },
{ "WXGRID_MIN_ROW_HEIGHT", WXGRID_MIN_ROW_HEIGHT },
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
{ "wxAC_DEFAULT_STYLE", wxAC_DEFAULT_STYLE },
{ "wxAC_NO_AUTORESIZE", wxAC_NO_AUTORESIZE },
{ "wxANIMATION_TYPE_ANI", wxANIMATION_TYPE_ANI },
{ "wxANIMATION_TYPE_ANY", wxANIMATION_TYPE_ANY },
{ "wxANIMATION_TYPE_GIF", wxANIMATION_TYPE_GIF },
{ "wxANIMATION_TYPE_INVALID", wxANIMATION_TYPE_INVALID },
#endif // wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
#if wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
{ "wxCAL_BORDER_NONE", wxCAL_BORDER_NONE },
{ "wxCAL_BORDER_ROUND", wxCAL_BORDER_ROUND },
{ "wxCAL_BORDER_SQUARE", wxCAL_BORDER_SQUARE },
{ "wxCAL_HITTEST_DAY", wxCAL_HITTEST_DAY },
{ "wxCAL_HITTEST_DECMONTH", wxCAL_HITTEST_DECMONTH },
{ "wxCAL_HITTEST_HEADER", wxCAL_HITTEST_HEADER },
{ "wxCAL_HITTEST_INCMONTH", wxCAL_HITTEST_INCMONTH },
{ "wxCAL_HITTEST_NOWHERE", wxCAL_HITTEST_NOWHERE },
{ "wxCAL_HITTEST_SURROUNDING_WEEK", wxCAL_HITTEST_SURROUNDING_WEEK },
{ "wxCAL_MONDAY_FIRST", wxCAL_MONDAY_FIRST },
{ "wxCAL_NO_MONTH_CHANGE", wxCAL_NO_MONTH_CHANGE },
{ "wxCAL_NO_YEAR_CHANGE", wxCAL_NO_YEAR_CHANGE },
{ "wxCAL_SEQUENTIAL_MONTH_SELECTION", wxCAL_SEQUENTIAL_MONTH_SELECTION },
{ "wxCAL_SHOW_HOLIDAYS", wxCAL_SHOW_HOLIDAYS },
{ "wxCAL_SHOW_SURROUNDING_WEEKS", wxCAL_SHOW_SURROUNDING_WEEKS },
{ "wxCAL_SUNDAY_FIRST", wxCAL_SUNDAY_FIRST },
#endif // wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
#if wxLUA_USE_wxGrid && wxUSE_GRID
{ "wxGRIDTABLE_NOTIFY_COLS_APPENDED", wxGRIDTABLE_NOTIFY_COLS_APPENDED },
{ "wxGRIDTABLE_NOTIFY_COLS_DELETED", wxGRIDTABLE_NOTIFY_COLS_DELETED },
{ "wxGRIDTABLE_NOTIFY_COLS_INSERTED", wxGRIDTABLE_NOTIFY_COLS_INSERTED },
{ "wxGRIDTABLE_NOTIFY_ROWS_APPENDED", wxGRIDTABLE_NOTIFY_ROWS_APPENDED },
{ "wxGRIDTABLE_NOTIFY_ROWS_DELETED", wxGRIDTABLE_NOTIFY_ROWS_DELETED },
{ "wxGRIDTABLE_NOTIFY_ROWS_INSERTED", wxGRIDTABLE_NOTIFY_ROWS_INSERTED },
{ "wxGRIDTABLE_REQUEST_VIEW_GET_VALUES", wxGRIDTABLE_REQUEST_VIEW_GET_VALUES },
{ "wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES", wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES },
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if (wxCHECK_VERSION(2,8,8)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
{ "wxGRID_AUTOSIZE", wxGRID_AUTOSIZE },
#endif // (wxCHECK_VERSION(2,8,8)) && (wxLUA_USE_wxGrid && wxUSE_GRID)
#if wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
{ "wxHL_ALIGN_CENTRE", wxHL_ALIGN_CENTRE },
{ "wxHL_ALIGN_LEFT", wxHL_ALIGN_LEFT },
{ "wxHL_ALIGN_RIGHT", wxHL_ALIGN_RIGHT },
{ "wxHL_CONTEXTMENU", wxHL_CONTEXTMENU },
{ "wxHL_DEFAULT_STYLE", wxHL_DEFAULT_STYLE },
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
#if wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
{ "wxJOYSTICK1", wxJOYSTICK1 },
{ "wxJOYSTICK2", wxJOYSTICK2 },
{ "wxJOY_BUTTON1", wxJOY_BUTTON1 },
{ "wxJOY_BUTTON2", wxJOY_BUTTON2 },
{ "wxJOY_BUTTON3", wxJOY_BUTTON3 },
{ "wxJOY_BUTTON4", wxJOY_BUTTON4 },
{ "wxJOY_BUTTON_ANY", wxJOY_BUTTON_ANY },
#endif // wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
{ "wxLAYOUT_BOTTOM", wxLAYOUT_BOTTOM },
{ "wxLAYOUT_HORIZONTAL", wxLAYOUT_HORIZONTAL },
{ "wxLAYOUT_LEFT", wxLAYOUT_LEFT },
{ "wxLAYOUT_NONE", wxLAYOUT_NONE },
{ "wxLAYOUT_RIGHT", wxLAYOUT_RIGHT },
{ "wxLAYOUT_TOP", wxLAYOUT_TOP },
{ "wxLAYOUT_VERTICAL", wxLAYOUT_VERTICAL },
{ "wxSASH_BOTTOM", wxSASH_BOTTOM },
{ "wxSASH_LEFT", wxSASH_LEFT },
{ "wxSASH_NONE", wxSASH_NONE },
{ "wxSASH_RIGHT", wxSASH_RIGHT },
{ "wxSASH_STATUS_OK", wxSASH_STATUS_OK },
{ "wxSASH_STATUS_OUT_OF_RANGE", wxSASH_STATUS_OUT_OF_RANGE },
{ "wxSASH_TOP", wxSASH_TOP },
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if (wxUSE_SOUND || (defined(__WXMSW__) && wxUSE_WAVE )) && (wxLUA_USE_wxWave)
{ "wxSOUND_ASYNC", wxSOUND_ASYNC },
{ "wxSOUND_LOOP", wxSOUND_LOOP },
{ "wxSOUND_SYNC", wxSOUND_SYNC },
#endif // (wxUSE_SOUND || (defined(__WXMSW__) && wxUSE_WAVE )) && (wxLUA_USE_wxWave)
#if wxLUA_USE_wxSplashScreen
{ "wxSPLASH_CENTRE_ON_PARENT", wxSPLASH_CENTRE_ON_PARENT },
{ "wxSPLASH_CENTRE_ON_SCREEN", wxSPLASH_CENTRE_ON_SCREEN },
{ "wxSPLASH_NO_CENTRE", wxSPLASH_NO_CENTRE },
{ "wxSPLASH_NO_TIMEOUT", wxSPLASH_NO_TIMEOUT },
{ "wxSPLASH_TIMEOUT", wxSPLASH_TIMEOUT },
#endif // wxLUA_USE_wxSplashScreen
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
{ "wxSW_3D", wxSW_3D },
{ "wxSW_3DBORDER", wxSW_3DBORDER },
{ "wxSW_3DSASH", wxSW_3DSASH },
{ "wxSW_BORDER", wxSW_BORDER },
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
{ "wxWIZARD_EX_HELPBUTTON", wxWIZARD_EX_HELPBUTTON },
#endif // wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
{ 0, 0 },
};
count = sizeof(numberList)/sizeof(wxLuaBindNumber) - 1;
return numberList;
}
// ---------------------------------------------------------------------------
// wxLuaGetStringList_wxadv() is called to register #define_string
// ---------------------------------------------------------------------------
wxLuaBindString* wxLuaGetStringList_wxadv(size_t &count)
{
static wxLuaBindString stringList[] =
{
#if wxLUA_USE_wxGrid && wxUSE_GRID
{ "wxGRID_VALUE_BOOL", NULL, wxGRID_VALUE_BOOL },
{ "wxGRID_VALUE_CHOICE", NULL, wxGRID_VALUE_CHOICE },
{ "wxGRID_VALUE_CHOICEINT", NULL, wxGRID_VALUE_CHOICEINT },
{ "wxGRID_VALUE_DATETIME", NULL, wxGRID_VALUE_DATETIME },
{ "wxGRID_VALUE_FLOAT", NULL, wxGRID_VALUE_FLOAT },
{ "wxGRID_VALUE_LONG", NULL, wxGRID_VALUE_LONG },
{ "wxGRID_VALUE_NUMBER", NULL, wxGRID_VALUE_NUMBER },
{ "wxGRID_VALUE_STRING", NULL, wxGRID_VALUE_STRING },
{ "wxGRID_VALUE_TEXT", NULL, wxGRID_VALUE_TEXT },
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
{ 0, 0 },
};
count = sizeof(stringList)/sizeof(wxLuaBindString) - 1;
return stringList;
}
// ---------------------------------------------------------------------------
// wxLuaGetObjectList_wxadv() is called to register object and pointer bindings
// ---------------------------------------------------------------------------
wxLuaBindObject* wxLuaGetObjectList_wxadv(size_t &count)
{
static wxLuaBindObject objectList[] =
{
#if wxLUA_USE_wxGrid && wxUSE_GRID
{ "wxGridNoCellCoords", &wxluatype_wxGridCellCoords, &wxGridNoCellCoords, NULL },
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
{ 0, 0, 0, 0 },
};
count = sizeof(objectList)/sizeof(wxLuaBindObject) - 1;
return objectList;
}
// ---------------------------------------------------------------------------
// wxLuaGetFunctionList_wxadv() is called to register global functions
// ---------------------------------------------------------------------------
#if wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
static wxLuaArgType s_wxluatypeArray_wxLua_function_wxAboutBox[] = { &wxluatype_wxAboutDialogInfo, NULL };
// void wxAboutBox(const wxAboutDialogInfo& info );
static int LUACALL wxLua_function_wxAboutBox(lua_State *L)
{
// const wxAboutDialogInfo info
const wxAboutDialogInfo * info = (const wxAboutDialogInfo *)wxluaT_getuserdatatype(L, 1, wxluatype_wxAboutDialogInfo);
// call wxAboutBox
wxAboutBox(*info);
return 0;
}
static wxLuaBindCFunc s_wxluafunc_wxLua_function_wxAboutBox[1] = {{ wxLua_function_wxAboutBox, WXLUAMETHOD_CFUNCTION, 1, 1, s_wxluatypeArray_wxLua_function_wxAboutBox }};
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
// ---------------------------------------------------------------------------
// wxLuaGetFunctionList_wxadv() is called to register global functions
// ---------------------------------------------------------------------------
wxLuaBindMethod* wxLuaGetFunctionList_wxadv(size_t &count)
{
static wxLuaBindMethod functionList[] =
{
#if wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
{ "wxAboutBox", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_wxAboutBox, 1, NULL },
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
{ 0, 0, 0, 0 },
};
count = sizeof(functionList)/sizeof(wxLuaBindMethod) - 1;
return functionList;
}
// ---------------------------------------------------------------------------
// wxLuaGetClassList_wxadv() is called to register classes
// ---------------------------------------------------------------------------
static const char* wxluaclassname_wxAboutDialogInfo = "wxAboutDialogInfo";
static const char* wxluaclassname_wxAnimation = "wxAnimation";
static const char* wxluaclassname_wxAnimationCtrl = "wxAnimationCtrl";
static const char* wxluaclassname_wxBitmapComboBox = "wxBitmapComboBox";
static const char* wxluaclassname_wxCalculateLayoutEvent = "wxCalculateLayoutEvent";
static const char* wxluaclassname_wxCalendarCtrl = "wxCalendarCtrl";
static const char* wxluaclassname_wxCalendarDateAttr = "wxCalendarDateAttr";
static const char* wxluaclassname_wxCalendarEvent = "wxCalendarEvent";
static const char* wxluaclassname_wxClientDataContainer = "wxClientDataContainer";
static const char* wxluaclassname_wxCommandEvent = "wxCommandEvent";
static const char* wxluaclassname_wxControl = "wxControl";
static const char* wxluaclassname_wxDateEvent = "wxDateEvent";
static const char* wxluaclassname_wxDialog = "wxDialog";
static const char* wxluaclassname_wxEvent = "wxEvent";
static const char* wxluaclassname_wxEvtHandler = "wxEvtHandler";
static const char* wxluaclassname_wxFrame = "wxFrame";
static const char* wxluaclassname_wxGDIObject = "wxGDIObject";
static const char* wxluaclassname_wxGrid = "wxGrid";
static const char* wxluaclassname_wxGridCellAttr = "wxGridCellAttr";
static const char* wxluaclassname_wxGridCellAttrProvider = "wxGridCellAttrProvider";
static const char* wxluaclassname_wxGridCellAutoWrapStringEditor = "wxGridCellAutoWrapStringEditor";
static const char* wxluaclassname_wxGridCellAutoWrapStringRenderer = "wxGridCellAutoWrapStringRenderer";
static const char* wxluaclassname_wxGridCellBoolEditor = "wxGridCellBoolEditor";
static const char* wxluaclassname_wxGridCellBoolRenderer = "wxGridCellBoolRenderer";
static const char* wxluaclassname_wxGridCellChoiceEditor = "wxGridCellChoiceEditor";
static const char* wxluaclassname_wxGridCellCoords = "wxGridCellCoords";
static const char* wxluaclassname_wxGridCellCoordsArray = "wxGridCellCoordsArray";
static const char* wxluaclassname_wxGridCellDateTimeRenderer = "wxGridCellDateTimeRenderer";
static const char* wxluaclassname_wxGridCellEditor = "wxGridCellEditor";
static const char* wxluaclassname_wxGridCellEnumEditor = "wxGridCellEnumEditor";
static const char* wxluaclassname_wxGridCellEnumRenderer = "wxGridCellEnumRenderer";
static const char* wxluaclassname_wxGridCellFloatEditor = "wxGridCellFloatEditor";
static const char* wxluaclassname_wxGridCellFloatRenderer = "wxGridCellFloatRenderer";
static const char* wxluaclassname_wxGridCellNumberEditor = "wxGridCellNumberEditor";
static const char* wxluaclassname_wxGridCellNumberRenderer = "wxGridCellNumberRenderer";
static const char* wxluaclassname_wxGridCellRenderer = "wxGridCellRenderer";
static const char* wxluaclassname_wxGridCellStringRenderer = "wxGridCellStringRenderer";
static const char* wxluaclassname_wxGridCellTextEditor = "wxGridCellTextEditor";
static const char* wxluaclassname_wxGridCellWorker = "wxGridCellWorker";
static const char* wxluaclassname_wxGridEditorCreatedEvent = "wxGridEditorCreatedEvent";
static const char* wxluaclassname_wxGridEvent = "wxGridEvent";
static const char* wxluaclassname_wxGridRangeSelectEvent = "wxGridRangeSelectEvent";
static const char* wxluaclassname_wxGridSizeEvent = "wxGridSizeEvent";
static const char* wxluaclassname_wxGridStringTable = "wxGridStringTable";
static const char* wxluaclassname_wxGridTableBase = "wxGridTableBase";
static const char* wxluaclassname_wxGridTableMessage = "wxGridTableMessage";
static const char* wxluaclassname_wxHyperlinkCtrl = "wxHyperlinkCtrl";
static const char* wxluaclassname_wxHyperlinkEvent = "wxHyperlinkEvent";
static const char* wxluaclassname_wxJoystick = "wxJoystick";
static const char* wxluaclassname_wxJoystickEvent = "wxJoystickEvent";
static const char* wxluaclassname_wxLayoutAlgorithm = "wxLayoutAlgorithm";
static const char* wxluaclassname_wxLuaGridTableBase = "wxLuaGridTableBase";
static const char* wxluaclassname_wxNotifyEvent = "wxNotifyEvent";
static const char* wxluaclassname_wxObject = "wxObject";
static const char* wxluaclassname_wxPanel = "wxPanel";
static const char* wxluaclassname_wxQueryLayoutInfoEvent = "wxQueryLayoutInfoEvent";
static const char* wxluaclassname_wxSashEvent = "wxSashEvent";
static const char* wxluaclassname_wxSashLayoutWindow = "wxSashLayoutWindow";
static const char* wxluaclassname_wxSashWindow = "wxSashWindow";
static const char* wxluaclassname_wxScrolledWindow = "wxScrolledWindow";
static const char* wxluaclassname_wxSound = "wxSound";
static const char* wxluaclassname_wxSplashScreen = "wxSplashScreen";
static const char* wxluaclassname_wxSplashScreenWindow = "wxSplashScreenWindow";
static const char* wxluaclassname_wxTaskBarIcon = "wxTaskBarIcon";
static const char* wxluaclassname_wxTaskBarIconEvent = "wxTaskBarIconEvent";
static const char* wxluaclassname_wxWave = "wxWave";
static const char* wxluaclassname_wxWindow = "wxWindow";
static const char* wxluaclassname_wxWizard = "wxWizard";
static const char* wxluaclassname_wxWizardEvent = "wxWizardEvent";
static const char* wxluaclassname_wxWizardPage = "wxWizardPage";
static const char* wxluaclassname_wxWizardPageSimple = "wxWizardPageSimple";
static const char* wxluabaseclassnames_wxAnimation[] = { wxluaclassname_wxGDIObject, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxAnimation[] = { NULL };
static const char* wxluabaseclassnames_wxAnimationCtrl[] = { wxluaclassname_wxControl, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxAnimationCtrl[] = { NULL };
static const char* wxluabaseclassnames_wxBitmapComboBox[] = { wxluaclassname_wxControl, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxBitmapComboBox[] = { NULL };
static const char* wxluabaseclassnames_wxCalculateLayoutEvent[] = { wxluaclassname_wxEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxCalculateLayoutEvent[] = { NULL };
static const char* wxluabaseclassnames_wxCalendarCtrl[] = { wxluaclassname_wxControl, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxCalendarCtrl[] = { NULL };
static const char* wxluabaseclassnames_wxCalendarEvent[] = { wxluaclassname_wxDateEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxCalendarEvent[] = { NULL };
static const char* wxluabaseclassnames_wxDateEvent[] = { wxluaclassname_wxCommandEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxDateEvent[] = { NULL };
static const char* wxluabaseclassnames_wxGrid[] = { wxluaclassname_wxScrolledWindow, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGrid[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellAttr[] = { wxluaclassname_wxClientDataContainer, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellAttr[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellAttrProvider[] = { wxluaclassname_wxClientDataContainer, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellAttrProvider[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellAutoWrapStringEditor[] = { wxluaclassname_wxGridCellTextEditor, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellAutoWrapStringEditor[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellAutoWrapStringRenderer[] = { wxluaclassname_wxGridCellStringRenderer, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellAutoWrapStringRenderer[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellBoolEditor[] = { wxluaclassname_wxGridCellEditor, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellBoolEditor[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellBoolRenderer[] = { wxluaclassname_wxGridCellRenderer, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellBoolRenderer[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellChoiceEditor[] = { wxluaclassname_wxGridCellEditor, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellChoiceEditor[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellDateTimeRenderer[] = { wxluaclassname_wxGridCellStringRenderer, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellDateTimeRenderer[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellEditor[] = { wxluaclassname_wxGridCellWorker, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellEditor[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellEnumEditor[] = { wxluaclassname_wxGridCellChoiceEditor, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellEnumEditor[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellEnumRenderer[] = { wxluaclassname_wxGridCellStringRenderer, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellEnumRenderer[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellFloatEditor[] = { wxluaclassname_wxGridCellTextEditor, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellFloatEditor[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellFloatRenderer[] = { wxluaclassname_wxGridCellStringRenderer, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellFloatRenderer[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellNumberEditor[] = { wxluaclassname_wxGridCellTextEditor, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellNumberEditor[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellNumberRenderer[] = { wxluaclassname_wxGridCellStringRenderer, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellNumberRenderer[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellRenderer[] = { wxluaclassname_wxGridCellWorker, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellRenderer[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellStringRenderer[] = { wxluaclassname_wxGridCellRenderer, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellStringRenderer[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellTextEditor[] = { wxluaclassname_wxGridCellEditor, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellTextEditor[] = { NULL };
static const char* wxluabaseclassnames_wxGridCellWorker[] = { wxluaclassname_wxClientDataContainer, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridCellWorker[] = { NULL };
static const char* wxluabaseclassnames_wxGridEditorCreatedEvent[] = { wxluaclassname_wxCommandEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridEditorCreatedEvent[] = { NULL };
static const char* wxluabaseclassnames_wxGridEvent[] = { wxluaclassname_wxNotifyEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridEvent[] = { NULL };
static const char* wxluabaseclassnames_wxGridRangeSelectEvent[] = { wxluaclassname_wxNotifyEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridRangeSelectEvent[] = { NULL };
static const char* wxluabaseclassnames_wxGridSizeEvent[] = { wxluaclassname_wxNotifyEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridSizeEvent[] = { NULL };
static const char* wxluabaseclassnames_wxGridStringTable[] = { wxluaclassname_wxGridTableBase, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridStringTable[] = { NULL };
static const char* wxluabaseclassnames_wxGridTableBase[] = { wxluaclassname_wxObject, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxGridTableBase[] = { NULL };
static const char* wxluabaseclassnames_wxHyperlinkCtrl[] = { wxluaclassname_wxControl, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxHyperlinkCtrl[] = { NULL };
static const char* wxluabaseclassnames_wxHyperlinkEvent[] = { wxluaclassname_wxCommandEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxHyperlinkEvent[] = { NULL };
static const char* wxluabaseclassnames_wxJoystick[] = { wxluaclassname_wxObject, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxJoystick[] = { NULL };
static const char* wxluabaseclassnames_wxJoystickEvent[] = { wxluaclassname_wxEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxJoystickEvent[] = { NULL };
static const char* wxluabaseclassnames_wxLayoutAlgorithm[] = { wxluaclassname_wxObject, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxLayoutAlgorithm[] = { NULL };
static const char* wxluabaseclassnames_wxLuaGridTableBase[] = { wxluaclassname_wxGridTableBase, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxLuaGridTableBase[] = { NULL };
static const char* wxluabaseclassnames_wxQueryLayoutInfoEvent[] = { wxluaclassname_wxEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxQueryLayoutInfoEvent[] = { NULL };
static const char* wxluabaseclassnames_wxSashEvent[] = { wxluaclassname_wxCommandEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxSashEvent[] = { NULL };
static const char* wxluabaseclassnames_wxSashLayoutWindow[] = { wxluaclassname_wxSashWindow, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxSashLayoutWindow[] = { NULL };
static const char* wxluabaseclassnames_wxSashWindow[] = { wxluaclassname_wxWindow, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxSashWindow[] = { NULL };
static const char* wxluabaseclassnames_wxSound[] = { wxluaclassname_wxObject, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxSound[] = { NULL };
static const char* wxluabaseclassnames_wxSplashScreen[] = { wxluaclassname_wxFrame, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxSplashScreen[] = { NULL };
static const char* wxluabaseclassnames_wxSplashScreenWindow[] = { wxluaclassname_wxWindow, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxSplashScreenWindow[] = { NULL };
static const char* wxluabaseclassnames_wxTaskBarIcon[] = { wxluaclassname_wxEvtHandler, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxTaskBarIcon[] = { NULL };
static const char* wxluabaseclassnames_wxTaskBarIconEvent[] = { wxluaclassname_wxEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxTaskBarIconEvent[] = { NULL };
static const char* wxluabaseclassnames_wxWave[] = { wxluaclassname_wxObject, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxWave[] = { NULL };
static const char* wxluabaseclassnames_wxWizard[] = { wxluaclassname_wxDialog, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxWizard[] = { NULL };
static const char* wxluabaseclassnames_wxWizardEvent[] = { wxluaclassname_wxNotifyEvent, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxWizardEvent[] = { NULL };
static const char* wxluabaseclassnames_wxWizardPage[] = { wxluaclassname_wxPanel, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxWizardPage[] = { NULL };
static const char* wxluabaseclassnames_wxWizardPageSimple[] = { wxluaclassname_wxWizardPage, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxWizardPageSimple[] = { NULL };
// ---------------------------------------------------------------------------
// Lua Tag Method Values and Tables for each Class
// ---------------------------------------------------------------------------
#if (wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)
extern wxLuaBindMethod wxWave_methods[];
extern int wxWave_methodCount;
extern void wxLua_wxWave_delete_function(void** p);
#endif // (wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)
#if (wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND)
extern wxLuaBindMethod wxSound_methods[];
extern int wxSound_methodCount;
extern void wxLua_wxSound_delete_function(void** p);
#endif // (wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND)
#if wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
extern wxLuaBindMethod wxAnimation_methods[];
extern int wxAnimation_methodCount;
extern void wxLua_wxAnimation_delete_function(void** p);
extern wxLuaBindMethod wxAnimationCtrl_methods[];
extern int wxAnimationCtrl_methodCount;
extern void wxLua_wxAnimationCtrl_delete_function(void** p);
#endif // wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
#if wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
extern wxLuaBindMethod wxAboutDialogInfo_methods[];
extern int wxAboutDialogInfo_methodCount;
extern void wxLua_wxAboutDialogInfo_delete_function(void** p);
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
#if wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
extern wxLuaBindMethod wxHyperlinkCtrl_methods[];
extern int wxHyperlinkCtrl_methodCount;
extern void wxLua_wxHyperlinkCtrl_delete_function(void** p);
extern wxLuaBindMethod wxHyperlinkEvent_methods[];
extern int wxHyperlinkEvent_methodCount;
extern void wxLua_wxHyperlinkEvent_delete_function(void** p);
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
#if wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX
extern wxLuaBindMethod wxBitmapComboBox_methods[];
extern int wxBitmapComboBox_methodCount;
extern void wxLua_wxBitmapComboBox_delete_function(void** p);
#endif // wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX
#if wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
extern wxLuaBindMethod wxCalendarCtrl_methods[];
extern int wxCalendarCtrl_methodCount;
extern void wxLua_wxCalendarCtrl_delete_function(void** p);
extern wxLuaBindMethod wxCalendarDateAttr_methods[];
extern int wxCalendarDateAttr_methodCount;
extern void wxLua_wxCalendarDateAttr_delete_function(void** p);
extern wxLuaBindMethod wxCalendarEvent_methods[];
extern int wxCalendarEvent_methodCount;
extern void wxLua_wxCalendarEvent_delete_function(void** p);
extern wxLuaBindMethod wxDateEvent_methods[];
extern int wxDateEvent_methodCount;
extern void wxLua_wxDateEvent_delete_function(void** p);
#endif // wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
#if wxLUA_USE_wxGrid && wxUSE_GRID
extern wxLuaBindMethod wxGrid_methods[];
extern int wxGrid_methodCount;
extern wxLuaBindNumber wxGrid_enums[];
extern int wxGrid_enumCount;
extern void wxLua_wxGrid_delete_function(void** p);
extern wxLuaBindMethod wxGridCellAttr_methods[];
extern int wxGridCellAttr_methodCount;
extern wxLuaBindNumber wxGridCellAttr_enums[];
extern int wxGridCellAttr_enumCount;
extern void wxLua_wxGridCellAttr_delete_function(void** p);
extern wxLuaBindMethod wxGridCellAttrProvider_methods[];
extern int wxGridCellAttrProvider_methodCount;
extern void wxLua_wxGridCellAttrProvider_delete_function(void** p);
extern wxLuaBindMethod wxGridCellAutoWrapStringEditor_methods[];
extern int wxGridCellAutoWrapStringEditor_methodCount;
extern void wxLua_wxGridCellAutoWrapStringEditor_delete_function(void** p);
extern wxLuaBindMethod wxGridCellAutoWrapStringRenderer_methods[];
extern int wxGridCellAutoWrapStringRenderer_methodCount;
extern void wxLua_wxGridCellAutoWrapStringRenderer_delete_function(void** p);
extern wxLuaBindMethod wxGridCellBoolEditor_methods[];
extern int wxGridCellBoolEditor_methodCount;
extern void wxLua_wxGridCellBoolEditor_delete_function(void** p);
extern wxLuaBindMethod wxGridCellBoolRenderer_methods[];
extern int wxGridCellBoolRenderer_methodCount;
extern void wxLua_wxGridCellBoolRenderer_delete_function(void** p);
extern wxLuaBindMethod wxGridCellChoiceEditor_methods[];
extern int wxGridCellChoiceEditor_methodCount;
extern void wxLua_wxGridCellChoiceEditor_delete_function(void** p);
extern wxLuaBindMethod wxGridCellCoords_methods[];
extern int wxGridCellCoords_methodCount;
extern void wxLua_wxGridCellCoords_delete_function(void** p);
extern wxLuaBindMethod wxGridCellCoordsArray_methods[];
extern int wxGridCellCoordsArray_methodCount;
extern void wxLua_wxGridCellCoordsArray_delete_function(void** p);
extern wxLuaBindMethod wxGridCellDateTimeRenderer_methods[];
extern int wxGridCellDateTimeRenderer_methodCount;
extern void wxLua_wxGridCellDateTimeRenderer_delete_function(void** p);
extern wxLuaBindMethod wxGridCellEditor_methods[];
extern int wxGridCellEditor_methodCount;
extern void wxLua_wxGridCellEditor_delete_function(void** p);
extern wxLuaBindMethod wxGridCellEnumEditor_methods[];
extern int wxGridCellEnumEditor_methodCount;
extern void wxLua_wxGridCellEnumEditor_delete_function(void** p);
extern wxLuaBindMethod wxGridCellEnumRenderer_methods[];
extern int wxGridCellEnumRenderer_methodCount;
extern void wxLua_wxGridCellEnumRenderer_delete_function(void** p);
extern wxLuaBindMethod wxGridCellFloatEditor_methods[];
extern int wxGridCellFloatEditor_methodCount;
extern void wxLua_wxGridCellFloatEditor_delete_function(void** p);
extern wxLuaBindMethod wxGridCellFloatRenderer_methods[];
extern int wxGridCellFloatRenderer_methodCount;
extern void wxLua_wxGridCellFloatRenderer_delete_function(void** p);
extern wxLuaBindMethod wxGridCellNumberEditor_methods[];
extern int wxGridCellNumberEditor_methodCount;
extern void wxLua_wxGridCellNumberEditor_delete_function(void** p);
extern wxLuaBindMethod wxGridCellNumberRenderer_methods[];
extern int wxGridCellNumberRenderer_methodCount;
extern void wxLua_wxGridCellNumberRenderer_delete_function(void** p);
extern wxLuaBindMethod wxGridCellRenderer_methods[];
extern int wxGridCellRenderer_methodCount;
extern void wxLua_wxGridCellRenderer_delete_function(void** p);
extern wxLuaBindMethod wxGridCellStringRenderer_methods[];
extern int wxGridCellStringRenderer_methodCount;
extern void wxLua_wxGridCellStringRenderer_delete_function(void** p);
extern wxLuaBindMethod wxGridCellTextEditor_methods[];
extern int wxGridCellTextEditor_methodCount;
extern void wxLua_wxGridCellTextEditor_delete_function(void** p);
extern wxLuaBindMethod wxGridCellWorker_methods[];
extern int wxGridCellWorker_methodCount;
extern void wxLua_wxGridCellWorker_delete_function(void** p);
extern wxLuaBindMethod wxGridEditorCreatedEvent_methods[];
extern int wxGridEditorCreatedEvent_methodCount;
extern void wxLua_wxGridEditorCreatedEvent_delete_function(void** p);
extern wxLuaBindMethod wxGridEvent_methods[];
extern int wxGridEvent_methodCount;
extern void wxLua_wxGridEvent_delete_function(void** p);
extern wxLuaBindMethod wxGridRangeSelectEvent_methods[];
extern int wxGridRangeSelectEvent_methodCount;
extern void wxLua_wxGridRangeSelectEvent_delete_function(void** p);
extern wxLuaBindMethod wxGridSizeEvent_methods[];
extern int wxGridSizeEvent_methodCount;
extern void wxLua_wxGridSizeEvent_delete_function(void** p);
extern wxLuaBindMethod wxGridStringTable_methods[];
extern int wxGridStringTable_methodCount;
extern void wxLua_wxGridStringTable_delete_function(void** p);
extern wxLuaBindMethod wxGridTableBase_methods[];
extern int wxGridTableBase_methodCount;
extern void wxLua_wxGridTableBase_delete_function(void** p);
extern wxLuaBindMethod wxGridTableMessage_methods[];
extern int wxGridTableMessage_methodCount;
extern void wxLua_wxGridTableMessage_delete_function(void** p);
extern wxLuaBindMethod wxLuaGridTableBase_methods[];
extern int wxLuaGridTableBase_methodCount;
extern void wxLua_wxLuaGridTableBase_delete_function(void** p);
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
extern wxLuaBindMethod wxJoystick_methods[];
extern int wxJoystick_methodCount;
extern void wxLua_wxJoystick_delete_function(void** p);
extern wxLuaBindMethod wxJoystickEvent_methods[];
extern int wxJoystickEvent_methodCount;
extern void wxLua_wxJoystickEvent_delete_function(void** p);
#endif // wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
extern wxLuaBindMethod wxCalculateLayoutEvent_methods[];
extern int wxCalculateLayoutEvent_methodCount;
extern void wxLua_wxCalculateLayoutEvent_delete_function(void** p);
extern wxLuaBindMethod wxLayoutAlgorithm_methods[];
extern int wxLayoutAlgorithm_methodCount;
extern void wxLua_wxLayoutAlgorithm_delete_function(void** p);
extern wxLuaBindMethod wxQueryLayoutInfoEvent_methods[];
extern int wxQueryLayoutInfoEvent_methodCount;
extern void wxLua_wxQueryLayoutInfoEvent_delete_function(void** p);
extern wxLuaBindMethod wxSashEvent_methods[];
extern int wxSashEvent_methodCount;
extern void wxLua_wxSashEvent_delete_function(void** p);
extern wxLuaBindMethod wxSashLayoutWindow_methods[];
extern int wxSashLayoutWindow_methodCount;
extern void wxLua_wxSashLayoutWindow_delete_function(void** p);
extern wxLuaBindMethod wxSashWindow_methods[];
extern int wxSashWindow_methodCount;
extern void wxLua_wxSashWindow_delete_function(void** p);
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxSplashScreen
extern wxLuaBindMethod wxSplashScreen_methods[];
extern int wxSplashScreen_methodCount;
extern void wxLua_wxSplashScreen_delete_function(void** p);
extern wxLuaBindMethod wxSplashScreenWindow_methods[];
extern int wxSplashScreenWindow_methodCount;
extern void wxLua_wxSplashScreenWindow_delete_function(void** p);
#endif // wxLUA_USE_wxSplashScreen
#if wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON )
extern wxLuaBindMethod wxTaskBarIcon_methods[];
extern int wxTaskBarIcon_methodCount;
extern void wxLua_wxTaskBarIcon_delete_function(void** p);
extern wxLuaBindMethod wxTaskBarIconEvent_methods[];
extern int wxTaskBarIconEvent_methodCount;
extern void wxLua_wxTaskBarIconEvent_delete_function(void** p);
#endif // wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON )
#if wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
extern wxLuaBindMethod wxWizard_methods[];
extern int wxWizard_methodCount;
extern void wxLua_wxWizard_delete_function(void** p);
extern wxLuaBindMethod wxWizardEvent_methods[];
extern int wxWizardEvent_methodCount;
extern void wxLua_wxWizardEvent_delete_function(void** p);
extern wxLuaBindMethod wxWizardPage_methods[];
extern int wxWizardPage_methodCount;
extern void wxLua_wxWizardPage_delete_function(void** p);
extern wxLuaBindMethod wxWizardPageSimple_methods[];
extern int wxWizardPageSimple_methodCount;
extern void wxLua_wxWizardPageSimple_delete_function(void** p);
#endif // wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
wxLuaBindClass* wxLuaGetClassList_wxadv(size_t &count)
{
static wxLuaBindClass classList[] =
{
#if wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
{ wxluaclassname_wxAboutDialogInfo, wxAboutDialogInfo_methods, wxAboutDialogInfo_methodCount, NULL, &wxluatype_wxAboutDialogInfo, NULL, NULL, NULL, NULL, NULL, 0, &wxLua_wxAboutDialogInfo_delete_function, },
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
#if wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
{ wxluaclassname_wxAnimation, wxAnimation_methods, wxAnimation_methodCount, CLASSINFO(wxAnimation), &wxluatype_wxAnimation, wxluabaseclassnames_wxAnimation, wxluabaseclassbinds_wxAnimation, NULL, NULL, NULL, 0, &wxLua_wxAnimation_delete_function, },
{ wxluaclassname_wxAnimationCtrl, wxAnimationCtrl_methods, wxAnimationCtrl_methodCount, CLASSINFO(wxAnimationCtrl), &wxluatype_wxAnimationCtrl, wxluabaseclassnames_wxAnimationCtrl, wxluabaseclassbinds_wxAnimationCtrl, NULL, NULL, NULL, 0, &wxLua_wxAnimationCtrl_delete_function, },
#endif // wxCHECK_VERSION(2,8,0) && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
#if wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX
{ wxluaclassname_wxBitmapComboBox, wxBitmapComboBox_methods, wxBitmapComboBox_methodCount, CLASSINFO(wxBitmapComboBox), &wxluatype_wxBitmapComboBox, wxluabaseclassnames_wxBitmapComboBox, wxluabaseclassbinds_wxBitmapComboBox, NULL, NULL, NULL, 0, &wxLua_wxBitmapComboBox_delete_function, },
#endif // wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
{ wxluaclassname_wxCalculateLayoutEvent, wxCalculateLayoutEvent_methods, wxCalculateLayoutEvent_methodCount, CLASSINFO(wxCalculateLayoutEvent), &wxluatype_wxCalculateLayoutEvent, wxluabaseclassnames_wxCalculateLayoutEvent, wxluabaseclassbinds_wxCalculateLayoutEvent, NULL, NULL, NULL, 0, &wxLua_wxCalculateLayoutEvent_delete_function, },
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
{ wxluaclassname_wxCalendarCtrl, wxCalendarCtrl_methods, wxCalendarCtrl_methodCount, CLASSINFO(wxCalendarCtrl), &wxluatype_wxCalendarCtrl, wxluabaseclassnames_wxCalendarCtrl, wxluabaseclassbinds_wxCalendarCtrl, NULL, NULL, NULL, 0, &wxLua_wxCalendarCtrl_delete_function, },
{ wxluaclassname_wxCalendarDateAttr, wxCalendarDateAttr_methods, wxCalendarDateAttr_methodCount, NULL, &wxluatype_wxCalendarDateAttr, NULL, NULL, NULL, NULL, NULL, 0, &wxLua_wxCalendarDateAttr_delete_function, },
{ wxluaclassname_wxCalendarEvent, wxCalendarEvent_methods, wxCalendarEvent_methodCount, CLASSINFO(wxCalendarEvent), &wxluatype_wxCalendarEvent, wxluabaseclassnames_wxCalendarEvent, wxluabaseclassbinds_wxCalendarEvent, NULL, NULL, NULL, 0, &wxLua_wxCalendarEvent_delete_function, },
{ wxluaclassname_wxDateEvent, wxDateEvent_methods, wxDateEvent_methodCount, CLASSINFO(wxDateEvent), &wxluatype_wxDateEvent, wxluabaseclassnames_wxDateEvent, wxluabaseclassbinds_wxDateEvent, NULL, NULL, NULL, 0, &wxLua_wxDateEvent_delete_function, },
#endif // wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
#if wxLUA_USE_wxGrid && wxUSE_GRID
{ wxluaclassname_wxGrid, wxGrid_methods, wxGrid_methodCount, CLASSINFO(wxGrid), &wxluatype_wxGrid, wxluabaseclassnames_wxGrid, wxluabaseclassbinds_wxGrid, NULL, NULL, wxGrid_enums, wxGrid_enumCount, &wxLua_wxGrid_delete_function, },
{ wxluaclassname_wxGridCellAttr, wxGridCellAttr_methods, wxGridCellAttr_methodCount, NULL, &wxluatype_wxGridCellAttr, wxluabaseclassnames_wxGridCellAttr, wxluabaseclassbinds_wxGridCellAttr, NULL, NULL, wxGridCellAttr_enums, wxGridCellAttr_enumCount, &wxLua_wxGridCellAttr_delete_function, },
{ wxluaclassname_wxGridCellAttrProvider, wxGridCellAttrProvider_methods, wxGridCellAttrProvider_methodCount, NULL, &wxluatype_wxGridCellAttrProvider, wxluabaseclassnames_wxGridCellAttrProvider, wxluabaseclassbinds_wxGridCellAttrProvider, NULL, NULL, NULL, 0, &wxLua_wxGridCellAttrProvider_delete_function, },
{ wxluaclassname_wxGridCellAutoWrapStringEditor, wxGridCellAutoWrapStringEditor_methods, wxGridCellAutoWrapStringEditor_methodCount, NULL, &wxluatype_wxGridCellAutoWrapStringEditor, wxluabaseclassnames_wxGridCellAutoWrapStringEditor, wxluabaseclassbinds_wxGridCellAutoWrapStringEditor, NULL, NULL, NULL, 0, &wxLua_wxGridCellAutoWrapStringEditor_delete_function, },
{ wxluaclassname_wxGridCellAutoWrapStringRenderer, wxGridCellAutoWrapStringRenderer_methods, wxGridCellAutoWrapStringRenderer_methodCount, NULL, &wxluatype_wxGridCellAutoWrapStringRenderer, wxluabaseclassnames_wxGridCellAutoWrapStringRenderer, wxluabaseclassbinds_wxGridCellAutoWrapStringRenderer, NULL, NULL, NULL, 0, &wxLua_wxGridCellAutoWrapStringRenderer_delete_function, },
{ wxluaclassname_wxGridCellBoolEditor, wxGridCellBoolEditor_methods, wxGridCellBoolEditor_methodCount, NULL, &wxluatype_wxGridCellBoolEditor, wxluabaseclassnames_wxGridCellBoolEditor, wxluabaseclassbinds_wxGridCellBoolEditor, NULL, NULL, NULL, 0, &wxLua_wxGridCellBoolEditor_delete_function, },
{ wxluaclassname_wxGridCellBoolRenderer, wxGridCellBoolRenderer_methods, wxGridCellBoolRenderer_methodCount, NULL, &wxluatype_wxGridCellBoolRenderer, wxluabaseclassnames_wxGridCellBoolRenderer, wxluabaseclassbinds_wxGridCellBoolRenderer, NULL, NULL, NULL, 0, &wxLua_wxGridCellBoolRenderer_delete_function, },
{ wxluaclassname_wxGridCellChoiceEditor, wxGridCellChoiceEditor_methods, wxGridCellChoiceEditor_methodCount, NULL, &wxluatype_wxGridCellChoiceEditor, wxluabaseclassnames_wxGridCellChoiceEditor, wxluabaseclassbinds_wxGridCellChoiceEditor, NULL, NULL, NULL, 0, &wxLua_wxGridCellChoiceEditor_delete_function, },
{ wxluaclassname_wxGridCellCoords, wxGridCellCoords_methods, wxGridCellCoords_methodCount, NULL, &wxluatype_wxGridCellCoords, NULL, NULL, NULL, NULL, NULL, 0, &wxLua_wxGridCellCoords_delete_function, },
{ wxluaclassname_wxGridCellCoordsArray, wxGridCellCoordsArray_methods, wxGridCellCoordsArray_methodCount, NULL, &wxluatype_wxGridCellCoordsArray, NULL, NULL, NULL, NULL, NULL, 0, &wxLua_wxGridCellCoordsArray_delete_function, },
{ wxluaclassname_wxGridCellDateTimeRenderer, wxGridCellDateTimeRenderer_methods, wxGridCellDateTimeRenderer_methodCount, NULL, &wxluatype_wxGridCellDateTimeRenderer, wxluabaseclassnames_wxGridCellDateTimeRenderer, wxluabaseclassbinds_wxGridCellDateTimeRenderer, NULL, NULL, NULL, 0, &wxLua_wxGridCellDateTimeRenderer_delete_function, },
{ wxluaclassname_wxGridCellEditor, wxGridCellEditor_methods, wxGridCellEditor_methodCount, NULL, &wxluatype_wxGridCellEditor, wxluabaseclassnames_wxGridCellEditor, wxluabaseclassbinds_wxGridCellEditor, NULL, NULL, NULL, 0, &wxLua_wxGridCellEditor_delete_function, },
{ wxluaclassname_wxGridCellEnumEditor, wxGridCellEnumEditor_methods, wxGridCellEnumEditor_methodCount, NULL, &wxluatype_wxGridCellEnumEditor, wxluabaseclassnames_wxGridCellEnumEditor, wxluabaseclassbinds_wxGridCellEnumEditor, NULL, NULL, NULL, 0, &wxLua_wxGridCellEnumEditor_delete_function, },
{ wxluaclassname_wxGridCellEnumRenderer, wxGridCellEnumRenderer_methods, wxGridCellEnumRenderer_methodCount, NULL, &wxluatype_wxGridCellEnumRenderer, wxluabaseclassnames_wxGridCellEnumRenderer, wxluabaseclassbinds_wxGridCellEnumRenderer, NULL, NULL, NULL, 0, &wxLua_wxGridCellEnumRenderer_delete_function, },
{ wxluaclassname_wxGridCellFloatEditor, wxGridCellFloatEditor_methods, wxGridCellFloatEditor_methodCount, NULL, &wxluatype_wxGridCellFloatEditor, wxluabaseclassnames_wxGridCellFloatEditor, wxluabaseclassbinds_wxGridCellFloatEditor, NULL, NULL, NULL, 0, &wxLua_wxGridCellFloatEditor_delete_function, },
{ wxluaclassname_wxGridCellFloatRenderer, wxGridCellFloatRenderer_methods, wxGridCellFloatRenderer_methodCount, NULL, &wxluatype_wxGridCellFloatRenderer, wxluabaseclassnames_wxGridCellFloatRenderer, wxluabaseclassbinds_wxGridCellFloatRenderer, NULL, NULL, NULL, 0, &wxLua_wxGridCellFloatRenderer_delete_function, },
{ wxluaclassname_wxGridCellNumberEditor, wxGridCellNumberEditor_methods, wxGridCellNumberEditor_methodCount, NULL, &wxluatype_wxGridCellNumberEditor, wxluabaseclassnames_wxGridCellNumberEditor, wxluabaseclassbinds_wxGridCellNumberEditor, NULL, NULL, NULL, 0, &wxLua_wxGridCellNumberEditor_delete_function, },
{ wxluaclassname_wxGridCellNumberRenderer, wxGridCellNumberRenderer_methods, wxGridCellNumberRenderer_methodCount, NULL, &wxluatype_wxGridCellNumberRenderer, wxluabaseclassnames_wxGridCellNumberRenderer, wxluabaseclassbinds_wxGridCellNumberRenderer, NULL, NULL, NULL, 0, &wxLua_wxGridCellNumberRenderer_delete_function, },
{ wxluaclassname_wxGridCellRenderer, wxGridCellRenderer_methods, wxGridCellRenderer_methodCount, NULL, &wxluatype_wxGridCellRenderer, wxluabaseclassnames_wxGridCellRenderer, wxluabaseclassbinds_wxGridCellRenderer, NULL, NULL, NULL, 0, &wxLua_wxGridCellRenderer_delete_function, },
{ wxluaclassname_wxGridCellStringRenderer, wxGridCellStringRenderer_methods, wxGridCellStringRenderer_methodCount, NULL, &wxluatype_wxGridCellStringRenderer, wxluabaseclassnames_wxGridCellStringRenderer, wxluabaseclassbinds_wxGridCellStringRenderer, NULL, NULL, NULL, 0, &wxLua_wxGridCellStringRenderer_delete_function, },
{ wxluaclassname_wxGridCellTextEditor, wxGridCellTextEditor_methods, wxGridCellTextEditor_methodCount, NULL, &wxluatype_wxGridCellTextEditor, wxluabaseclassnames_wxGridCellTextEditor, wxluabaseclassbinds_wxGridCellTextEditor, NULL, NULL, NULL, 0, &wxLua_wxGridCellTextEditor_delete_function, },
{ wxluaclassname_wxGridCellWorker, wxGridCellWorker_methods, wxGridCellWorker_methodCount, NULL, &wxluatype_wxGridCellWorker, wxluabaseclassnames_wxGridCellWorker, wxluabaseclassbinds_wxGridCellWorker, NULL, NULL, NULL, 0, &wxLua_wxGridCellWorker_delete_function, },
{ wxluaclassname_wxGridEditorCreatedEvent, wxGridEditorCreatedEvent_methods, wxGridEditorCreatedEvent_methodCount, CLASSINFO(wxGridEditorCreatedEvent), &wxluatype_wxGridEditorCreatedEvent, wxluabaseclassnames_wxGridEditorCreatedEvent, wxluabaseclassbinds_wxGridEditorCreatedEvent, NULL, NULL, NULL, 0, &wxLua_wxGridEditorCreatedEvent_delete_function, },
{ wxluaclassname_wxGridEvent, wxGridEvent_methods, wxGridEvent_methodCount, CLASSINFO(wxGridEvent), &wxluatype_wxGridEvent, wxluabaseclassnames_wxGridEvent, wxluabaseclassbinds_wxGridEvent, NULL, NULL, NULL, 0, &wxLua_wxGridEvent_delete_function, },
{ wxluaclassname_wxGridRangeSelectEvent, wxGridRangeSelectEvent_methods, wxGridRangeSelectEvent_methodCount, CLASSINFO(wxGridRangeSelectEvent), &wxluatype_wxGridRangeSelectEvent, wxluabaseclassnames_wxGridRangeSelectEvent, wxluabaseclassbinds_wxGridRangeSelectEvent, NULL, NULL, NULL, 0, &wxLua_wxGridRangeSelectEvent_delete_function, },
{ wxluaclassname_wxGridSizeEvent, wxGridSizeEvent_methods, wxGridSizeEvent_methodCount, CLASSINFO(wxGridSizeEvent), &wxluatype_wxGridSizeEvent, wxluabaseclassnames_wxGridSizeEvent, wxluabaseclassbinds_wxGridSizeEvent, NULL, NULL, NULL, 0, &wxLua_wxGridSizeEvent_delete_function, },
{ wxluaclassname_wxGridStringTable, wxGridStringTable_methods, wxGridStringTable_methodCount, CLASSINFO(wxGridStringTable), &wxluatype_wxGridStringTable, wxluabaseclassnames_wxGridStringTable, wxluabaseclassbinds_wxGridStringTable, NULL, NULL, NULL, 0, &wxLua_wxGridStringTable_delete_function, },
{ wxluaclassname_wxGridTableBase, wxGridTableBase_methods, wxGridTableBase_methodCount, CLASSINFO(wxGridTableBase), &wxluatype_wxGridTableBase, wxluabaseclassnames_wxGridTableBase, wxluabaseclassbinds_wxGridTableBase, NULL, NULL, NULL, 0, &wxLua_wxGridTableBase_delete_function, },
{ wxluaclassname_wxGridTableMessage, wxGridTableMessage_methods, wxGridTableMessage_methodCount, NULL, &wxluatype_wxGridTableMessage, NULL, NULL, NULL, NULL, NULL, 0, &wxLua_wxGridTableMessage_delete_function, },
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
{ wxluaclassname_wxHyperlinkCtrl, wxHyperlinkCtrl_methods, wxHyperlinkCtrl_methodCount, CLASSINFO(wxHyperlinkCtrl), &wxluatype_wxHyperlinkCtrl, wxluabaseclassnames_wxHyperlinkCtrl, wxluabaseclassbinds_wxHyperlinkCtrl, NULL, NULL, NULL, 0, &wxLua_wxHyperlinkCtrl_delete_function, },
{ wxluaclassname_wxHyperlinkEvent, wxHyperlinkEvent_methods, wxHyperlinkEvent_methodCount, CLASSINFO(wxHyperlinkEvent), &wxluatype_wxHyperlinkEvent, wxluabaseclassnames_wxHyperlinkEvent, wxluabaseclassbinds_wxHyperlinkEvent, NULL, NULL, NULL, 0, &wxLua_wxHyperlinkEvent_delete_function, },
#endif // wxCHECK_VERSION(2,8,0) && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
#if wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
{ wxluaclassname_wxJoystick, wxJoystick_methods, wxJoystick_methodCount, CLASSINFO(wxJoystick), &wxluatype_wxJoystick, wxluabaseclassnames_wxJoystick, wxluabaseclassbinds_wxJoystick, NULL, NULL, NULL, 0, &wxLua_wxJoystick_delete_function, },
{ wxluaclassname_wxJoystickEvent, wxJoystickEvent_methods, wxJoystickEvent_methodCount, CLASSINFO(wxJoystickEvent), &wxluatype_wxJoystickEvent, wxluabaseclassnames_wxJoystickEvent, wxluabaseclassbinds_wxJoystickEvent, NULL, NULL, NULL, 0, &wxLua_wxJoystickEvent_delete_function, },
#endif // wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
{ wxluaclassname_wxLayoutAlgorithm, wxLayoutAlgorithm_methods, wxLayoutAlgorithm_methodCount, CLASSINFO(wxLayoutAlgorithm), &wxluatype_wxLayoutAlgorithm, wxluabaseclassnames_wxLayoutAlgorithm, wxluabaseclassbinds_wxLayoutAlgorithm, NULL, NULL, NULL, 0, &wxLua_wxLayoutAlgorithm_delete_function, },
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if wxLUA_USE_wxGrid && wxUSE_GRID
{ wxluaclassname_wxLuaGridTableBase, wxLuaGridTableBase_methods, wxLuaGridTableBase_methodCount, CLASSINFO(wxLuaGridTableBase), &wxluatype_wxLuaGridTableBase, wxluabaseclassnames_wxLuaGridTableBase, wxluabaseclassbinds_wxLuaGridTableBase, NULL, NULL, NULL, 0, &wxLua_wxLuaGridTableBase_delete_function, },
#endif // wxLUA_USE_wxGrid && wxUSE_GRID
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
{ wxluaclassname_wxQueryLayoutInfoEvent, wxQueryLayoutInfoEvent_methods, wxQueryLayoutInfoEvent_methodCount, CLASSINFO(wxQueryLayoutInfoEvent), &wxluatype_wxQueryLayoutInfoEvent, wxluabaseclassnames_wxQueryLayoutInfoEvent, wxluabaseclassbinds_wxQueryLayoutInfoEvent, NULL, NULL, NULL, 0, &wxLua_wxQueryLayoutInfoEvent_delete_function, },
{ wxluaclassname_wxSashEvent, wxSashEvent_methods, wxSashEvent_methodCount, CLASSINFO(wxSashEvent), &wxluatype_wxSashEvent, wxluabaseclassnames_wxSashEvent, wxluabaseclassbinds_wxSashEvent, NULL, NULL, NULL, 0, &wxLua_wxSashEvent_delete_function, },
{ wxluaclassname_wxSashLayoutWindow, wxSashLayoutWindow_methods, wxSashLayoutWindow_methodCount, CLASSINFO(wxSashLayoutWindow), &wxluatype_wxSashLayoutWindow, wxluabaseclassnames_wxSashLayoutWindow, wxluabaseclassbinds_wxSashLayoutWindow, NULL, NULL, NULL, 0, &wxLua_wxSashLayoutWindow_delete_function, },
{ wxluaclassname_wxSashWindow, wxSashWindow_methods, wxSashWindow_methodCount, CLASSINFO(wxSashWindow), &wxluatype_wxSashWindow, wxluabaseclassnames_wxSashWindow, wxluabaseclassbinds_wxSashWindow, NULL, NULL, NULL, 0, &wxLua_wxSashWindow_delete_function, },
#endif // wxLUA_USE_wxSashWindow && wxUSE_SASH
#if (wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND)
{ wxluaclassname_wxSound, wxSound_methods, wxSound_methodCount, CLASSINFO(wxSound), &wxluatype_wxSound, wxluabaseclassnames_wxSound, wxluabaseclassbinds_wxSound, NULL, NULL, NULL, 0, &wxLua_wxSound_delete_function, },
#endif // (wxLUA_USE_wxWave) && (wxCHECK_VERSION(2,6,0) && wxUSE_SOUND)
#if wxLUA_USE_wxSplashScreen
{ wxluaclassname_wxSplashScreen, wxSplashScreen_methods, wxSplashScreen_methodCount, CLASSINFO(wxSplashScreen), &wxluatype_wxSplashScreen, wxluabaseclassnames_wxSplashScreen, wxluabaseclassbinds_wxSplashScreen, NULL, NULL, NULL, 0, &wxLua_wxSplashScreen_delete_function, },
{ wxluaclassname_wxSplashScreenWindow, wxSplashScreenWindow_methods, wxSplashScreenWindow_methodCount, CLASSINFO(wxSplashScreenWindow), &wxluatype_wxSplashScreenWindow, wxluabaseclassnames_wxSplashScreenWindow, wxluabaseclassbinds_wxSplashScreenWindow, NULL, NULL, NULL, 0, &wxLua_wxSplashScreenWindow_delete_function, },
#endif // wxLUA_USE_wxSplashScreen
#if wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON )
{ wxluaclassname_wxTaskBarIcon, wxTaskBarIcon_methods, wxTaskBarIcon_methodCount, CLASSINFO(wxTaskBarIcon), &wxluatype_wxTaskBarIcon, wxluabaseclassnames_wxTaskBarIcon, wxluabaseclassbinds_wxTaskBarIcon, NULL, NULL, NULL, 0, &wxLua_wxTaskBarIcon_delete_function, },
{ wxluaclassname_wxTaskBarIconEvent, wxTaskBarIconEvent_methods, wxTaskBarIconEvent_methodCount, CLASSINFO(wxTaskBarIconEvent), &wxluatype_wxTaskBarIconEvent, wxluabaseclassnames_wxTaskBarIconEvent, wxluabaseclassbinds_wxTaskBarIconEvent, NULL, NULL, NULL, 0, &wxLua_wxTaskBarIconEvent_delete_function, },
#endif // wxLUA_USE_wxTaskBarIcon && defined (wxHAS_TASK_BAR_ICON )
#if (wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)
{ wxluaclassname_wxWave, wxWave_methods, wxWave_methodCount, CLASSINFO(wxWave), &wxluatype_wxWave, wxluabaseclassnames_wxWave, wxluabaseclassbinds_wxWave, NULL, NULL, NULL, 0, &wxLua_wxWave_delete_function, },
#endif // (wxLUA_USE_wxWave) && (defined(__WXMSW__) && !wxCHECK_VERSION(2,6,0) && wxUSE_WAVE)
#if wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
{ wxluaclassname_wxWizard, wxWizard_methods, wxWizard_methodCount, CLASSINFO(wxWizard), &wxluatype_wxWizard, wxluabaseclassnames_wxWizard, wxluabaseclassbinds_wxWizard, NULL, NULL, NULL, 0, &wxLua_wxWizard_delete_function, },
{ wxluaclassname_wxWizardEvent, wxWizardEvent_methods, wxWizardEvent_methodCount, CLASSINFO(wxWizardEvent), &wxluatype_wxWizardEvent, wxluabaseclassnames_wxWizardEvent, wxluabaseclassbinds_wxWizardEvent, NULL, NULL, NULL, 0, &wxLua_wxWizardEvent_delete_function, },
{ wxluaclassname_wxWizardPage, wxWizardPage_methods, wxWizardPage_methodCount, CLASSINFO(wxWizardPage), &wxluatype_wxWizardPage, wxluabaseclassnames_wxWizardPage, wxluabaseclassbinds_wxWizardPage, NULL, NULL, NULL, 0, &wxLua_wxWizardPage_delete_function, },
{ wxluaclassname_wxWizardPageSimple, wxWizardPageSimple_methods, wxWizardPageSimple_methodCount, CLASSINFO(wxWizardPageSimple), &wxluatype_wxWizardPageSimple, wxluabaseclassnames_wxWizardPageSimple, wxluabaseclassbinds_wxWizardPageSimple, NULL, NULL, NULL, 0, &wxLua_wxWizardPageSimple_delete_function, },
#endif // wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
{ 0, 0, 0, 0, 0, 0, 0 },
};
count = sizeof(classList)/sizeof(wxLuaBindClass) - 1;
return classList;
}
// ---------------------------------------------------------------------------
// wxLuaBinding_wxadv() - the binding class
// ---------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxLuaBinding_wxadv, wxLuaBinding)
wxLuaBinding_wxadv::wxLuaBinding_wxadv() : wxLuaBinding()
{
m_bindingName = wxT("wxadv");
m_nameSpace = wxT("wx");
m_classArray = wxLuaGetClassList_wxadv(m_classCount);
m_numberArray = wxLuaGetDefineList_wxadv(m_numberCount);
m_stringArray = wxLuaGetStringList_wxadv(m_stringCount);
m_eventArray = wxLuaGetEventList_wxadv(m_eventCount);
m_objectArray = wxLuaGetObjectList_wxadv(m_objectCount);
m_functionArray = wxLuaGetFunctionList_wxadv(m_functionCount);
InitBinding();
}
// ---------------------------------------------------------------------------
wxLuaBinding* wxLuaBinding_wxadv_init()
{
static wxLuaBinding_wxadv m_binding;
if (wxLuaBinding::GetBindingArray().Index(&m_binding) == wxNOT_FOUND)
wxLuaBinding::GetBindingArray().Add(&m_binding);
return &m_binding;
}
| [
"jrl1@bc88403a-3a91-4506-9056-abb4039e9f02"
] | jrl1@bc88403a-3a91-4506-9056-abb4039e9f02 |
80f6e030d220a78e847cf37a0007a2e7a8221796 | 90ac75ef7ceee00344bed6679ec7f2f4427f8240 | /AOC_2019/Day2/Day2.cc | 15a07a7ee63a6084032a878c4c2cee3775c7f5ce | [] | no_license | ZandorTeseling/AdventofCode | 4645c1b56321ed8310dc356d8d73992f1a029a96 | c7f52a5c744d4478c242fbd691d9bfcdb6ceb379 | refs/heads/master | 2020-12-28T01:47:36.334147 | 2020-02-04T08:00:33 | 2020-02-04T08:00:33 | 238,142,012 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,954 | cc | #include "gtest/gtest.h"
#include <iostream>
#include <fstream>
#include <istream>
#include <stdio.h>
#include <vector>
#include <string>
#include <math.h>
using namespace::std;
class Day2Test : public ::testing::Test{
protected:
virtual void SetUp(){
resetMemory(m_Program);
}
virtual void TearDown(){
}
void runProgram(vector<int64_t>& a_Program)
{
for(uint i =0; i < a_Program.size(); i +=4)
{
runOp(i,a_Program);
}
}
bool runOp(int a_address, vector<int64_t>& a_Program){
//Check addresses lie in program.
int ProSize = a_Program.size();
if( a_address > ProSize
|| a_Program[a_address+1] > ProSize
||a_Program[a_address+2] > ProSize
|| a_Program[a_address+3] > ProSize) return exitEarly(a_Program);
if(a_Program[a_address] == 1) return addOp(a_Program[a_address+1],a_Program[a_address+2],a_Program[a_address+3],a_Program);
else if(a_Program[a_address] == 2) return mulOp(a_Program[a_address+1],a_Program[a_address+2],a_Program[a_address+3],a_Program);
else if(a_Program[a_address] == 99) return exitOp(a_Program);
return false;
}
bool addOp(int pos1, int pos2, int pos3, vector<int64_t>& a_program){
a_program[pos3] = a_program[pos1] + a_program[pos2];
return false;
}
bool mulOp(int pos1, int pos2, int pos3, vector<int64_t>& a_program){
a_program[pos3] = a_program[pos1] * a_program[pos2];
return false;
}
bool exitEarly(vector<int64_t>& a_program)
{
cout << "Program finished: " << a_program[0] << endl;
return exitOp(a_program);
}
bool exitOp( vector<int64_t>& a_program){
cout << "Program finished: " << a_program[0] << endl;
return true;
}
bool resetMemory(vector<int64_t>& a_program)
{
a_program.clear();
//Read InputDay2.txt
ifstream InputFile("InputDay2.txt");
bool success = InputFile.is_open();
EXPECT_TRUE(success);
if(InputFile.is_open())
{
string s;
stringstream ss;
string token;
while(getline(InputFile, s) && !InputFile.eof())
{
ss << s;
int i = 0;
while(getline(ss,token,','))
{
i++;
if(token[0] == '\0')
continue;
a_program.push_back(stoi(token));
}
}
InputFile.close();
}
return success;
}
vector<int64_t> m_Program;
};
/*--- Day 2: 1202 Program Alarm ---
Instructions:
1: [Add] two numbers and store in third position [Prog Pos1 Pos2 StorageLoc]
2: [Multiply] two numbers and store in third position [Prog Pos1 Pos2 StorageLoc]
99:Exit program
Opcodes are in 4 position chuncks.
*/
//Part1
TEST_F ( Day2Test, attempt1P1)
{
//Part1
//Replace pos[1] with 12 ans pos[2] with 2
m_Program[1]=12;
m_Program[2]=2;
runProgram(m_Program);
}
TEST_F ( Day2Test, attempt1P2)
{
//Noun : parameter 1
//Verb : parameter 2
//Look for 19690720.
bool Found = false;
int Noun;
int Verb;
for(int i =0; i<= 99 && !Found; i++){
for( int j = 0; j <= 99 && !Found; j++){
resetMemory(m_Program);
m_Program[1] = i;
m_Program[2] = j;
runProgram(m_Program);
if(m_Program[0] == 19690720)
{
cout << "Noun: " << i << " \tVerb: " << j << endl;
Noun = i;
Verb = j;
Found = true;
}
}
}
//Whats it 100*noun + verb;
cout << "Part 2: " << 100*Noun+ Verb << endl;
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| [
"zandorteseling@gmail.com"
] | zandorteseling@gmail.com |
4f59b6714b6d21a89ca3768f4f6b0a6f01cad383 | 73df58bb1c256e35465787c24135f85156694532 | /Engine/Plugins/2D/Paper2D/Source/Paper2D/Private/PaperCharacter.cpp | a78bf43452749738ab92a9d466d9edcee9e63015 | [] | no_license | igchesnok/AHRUnrealEngine | 9c003bf9988d58ece42be4af030ec6ec092cd12e | d300f83087a2d790f5bd9571dad441c67b2776b6 | refs/heads/master | 2021-01-18T17:49:35.497706 | 2014-10-09T22:32:35 | 2014-10-09T22:32:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,406 | cpp | // Copyright 1998-2014 Epic Games, Inc. All Rights Reserved.
#include "Paper2DPrivatePCH.h"
FName APaperCharacter::SpriteComponentName(TEXT("Sprite0"));
//////////////////////////////////////////////////////////////////////////
// APaperCharacter
APaperCharacter::APaperCharacter(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP.DoNotCreateDefaultSubobject(ACharacter::MeshComponentName))
{
// Try to create the sprite component
Sprite = PCIP.CreateOptionalDefaultSubobject<UPaperFlipbookComponent>(this, APaperCharacter::SpriteComponentName);
if (Sprite)
{
Sprite->AlwaysLoadOnClient = true;
Sprite->AlwaysLoadOnServer = true;
Sprite->bOwnerNoSee = false;
Sprite->bAffectDynamicIndirectLighting = true;
Sprite->PrimaryComponentTick.TickGroup = TG_PrePhysics;
Sprite->AttachParent = CapsuleComponent;
static FName CollisionProfileName(TEXT("CharacterMesh"));
Sprite->SetCollisionProfileName(CollisionProfileName);
Sprite->bGenerateOverlapEvents = false;
}
}
void APaperCharacter::PostInitializeComponents()
{
Super::PostInitializeComponents();
if (!IsPendingKill())
{
if (Sprite)
{
// force animation tick after movement component updates
if (Sprite->PrimaryComponentTick.bCanEverTick && CharacterMovement.IsValid())
{
Sprite->PrimaryComponentTick.AddPrerequisite(CharacterMovement, CharacterMovement->PrimaryComponentTick);
}
}
}
} | [
"unrealbot@users.noreply.github.com"
] | unrealbot@users.noreply.github.com |
34416f1d6382318207276c72f5dda5bf8683049f | c6fc0c923576e3aafe5e38ad9d5436632376cb81 | /tutorial7/lud-openblas-cuda-v5/data/MatrixPanelData.h | 688a4cef93b9b08a5e2ca64f9664200d24e4dde5 | [
"NIST-Software"
] | permissive | sowo/HTGS-Tutorials | d09d71219c9457dbf655c99c8766c81780592ada | bc1dc18b3f6ca91fb5d457f31430498cbf1d606e | refs/heads/master | 2020-07-17T13:56:29.158130 | 2019-04-12T21:06:24 | 2019-04-12T21:06:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,387 | h |
// NIST-developed software is provided by NIST as a public service. You may use, copy and distribute copies of the software in any medium, provided that you keep intact this entire notice. You may improve, modify and create derivative works of the software or any portion of the software, and you may copy and distribute such modifications or works. Modified works should carry a notice stating that you changed the software and should note the date and nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the source of the software.
// NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED, IN FACT OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE.
// You are solely responsible for determining the appropriateness of using and distributing the software and you assume all risks associated with its use, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of operation. This software is not intended to be used in any situation where a failure could cause risk of injury or damage to property. The software developed by NIST employees is not subject to copyright protection within the United States.
//
// Created by tjb3 on 2/23/16.
//
#ifndef HTGS_MATRIXPANELDATA_H
#define HTGS_MATRIXPANELDATA_H
#include <htgs/api/IData.hpp>
#include "MatrixBlockData.h"
enum class PanelState {
NONE,
ALL_FACTORED,
TOP_FACTORED,
UPDATED
};
class MatrixPanelData : public htgs::IData {
public:
MatrixPanelData(long height, long blockSize, int panelCol, int panelOperatingDiagonal, PanelState panelState) :
height(height), blockSize(blockSize), panelCol(panelCol), panelOperatingDiagonal(panelOperatingDiagonal), panelState(panelState)
{
memory = nullptr;
memoryData = nullptr;
windowed = false;
}
double *getStartMemoryAddr() const {
return &memory[blockSize*panelOperatingDiagonal];
}
double *getMemory() const {
return memory;
}
void setMemory(double *memory) {
this->memory = memory;
}
const MatrixMemoryData_t &getMemoryData() const {
return memoryData;
}
void setMemoryData(const MatrixMemoryData_t &memoryData) {
this->memoryData = memoryData;
}
double *getCudaMemoryStartAddr() const {
return cudaMemoryStartAddr;
}
void setCudaMemoryStartAddr(double *cudaMemoryStartAddr) {
this->cudaMemoryStartAddr = cudaMemoryStartAddr;
}
long getHeight() const {
return height;
}
int getPanelCol() const {
return panelCol;
}
int getPanelOperatingDiagonal() const {
return panelOperatingDiagonal;
}
PanelState getPanelState() const {
return panelState;
}
void setPanelState(PanelState panelState) {
this->panelState = panelState;
}
int getOriginalOperatingDiagonal() const {
return originalOperatingDiagonal;
}
void setOriginalOperatingDiagonal(int originalOperatingDiagonal) {
MatrixPanelData::originalOperatingDiagonal = originalOperatingDiagonal;
}
bool isWindowed() const {
return windowed;
}
void setWindowed(bool windowed) {
MatrixPanelData::windowed = windowed;
}
double *getOrigMemory() const {
return origMemory;
}
void setOrigMemory(double *origMemory) {
MatrixPanelData::origMemory = origMemory;
}
long getOrigHeight() const {
return origHeight;
}
void setOrigHeight(long origHeight) {
MatrixPanelData::origHeight = origHeight;
}
private:
double *memory;
double *origMemory;
long origHeight;
MatrixMemoryData_t memoryData;
double *cudaMemoryStartAddr;
long height;
long blockSize;
int panelCol;
int panelOperatingDiagonal;
int originalOperatingDiagonal;
PanelState panelState;
bool windowed;
};
#endif //HTGS_MATRIXPANELDATA_H
| [
"timothy.blattner@nist.gov"
] | timothy.blattner@nist.gov |
0883dfa5f66edc856eae5d404cecb341c1e56885 | c4421a0b1ffa996d9e2fdd7193188c22edc07672 | /socket/src/socket_abstraction.h | 1e94416c309f5c74d2b82a3483d15c9015f3badf | [
"MIT"
] | permissive | tftelkamp/vrt_tools_cmd | 1ebe8715d5b71eadcff6f5e1843a6a54fa8fda68 | 6c56d8d9c9d069db68f229912eb39364c4294cf2 | refs/heads/main | 2023-02-23T00:00:02.605301 | 2021-01-24T17:56:47 | 2021-01-24T17:56:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,141 | h | #ifndef VRT_SOCKET_SRC_SOCKET_ABSTRACTION_H_
#define VRT_SOCKET_SRC_SOCKET_ABSTRACTION_H_
#include "libsocket/headers/exception.hpp"
#include "libsocket/headers/inetclientdgram.hpp"
#include "libsocket/headers/inetclientstream.hpp"
#include "libsocket/headers/libinetsocket.h"
namespace vrt::socket {
/**
* Socket abstraction, just for a common call to snd().
*/
class Socket {
public:
virtual void send(const void* buf, size_t size) = 0;
};
/**
* UDP socket.
*/
class SocketUdp : public Socket {
public:
SocketUdp(std::string host, std::string service) : sock_{std::move(host), std::move(service), LIBSOCKET_BOTH, 0} {}
void send(const void* buf, size_t size) override { sock_.snd(buf, size, 0); }
private:
libsocket::inet_dgram_client sock_;
};
/**
* TCP socket.
*/
class SocketTcp : public Socket {
public:
SocketTcp(std::string host, std::string service) : sock_{std::move(host), std::move(service), LIBSOCKET_BOTH, 0} {}
void send(const void* buf, size_t size) override { sock_.snd(buf, size, 0); }
private:
libsocket::inet_stream sock_;
};
} // namespace vrt::socket
#endif
| [
"emil.berg1991@gmail.com"
] | emil.berg1991@gmail.com |
7f99fadf454583d31cbe97dfefb714fc88c01892 | fd01deec95942116e6edaa487441de622bb47b60 | /AP_SV.ino | 52fe24364e56dc239bec64791bef55eb014ab6ba | [] | no_license | mathangspk/ESP8266PowerMonit | f4783a5de5886b699a926efb75ce002ee9631c3c | 9726d628e3381f5482d46e8dbff9821a22dd954c | refs/heads/main | 2023-05-08T00:48:52.037593 | 2021-06-07T09:36:25 | 2021-06-07T09:36:25 | 374,610,439 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,133 | ino | #include <ESP8266WiFi.h>
#include <DNSServer.h>
#include <WiFiClient.h>
#include <EEPROM.h>
#include <ESP8266WebServer.h>
#include <EasyButton.h>
#include <PubSubClient.h>
#include <PZEM004Tv30.h>
PZEM004Tv30 pzem(5, 4);
// Arduino pin where the button is connected to.
#define BUTTON_PIN 0
// Instance of the button.
EasyButton button(BUTTON_PIN);
const IPAddress apIP(10 , 1 , 23 , 1);
const char* apSSID = "ESP8266_SETUP";
boolean settingMode;
String ssidList;
String localIpp;
#define mqtt_server "192.168.1.99"
const uint16_t mqtt_port = 1883; //Port của CloudMQTT TCP
String email = "";
String mqtt = "";
String sn = "";
DNSServer dnsServer;
ESP8266WebServer webServer(80);
WiFiClient espClient;
PubSubClient client(espClient);
const int ledPin = LED_BUILTIN;// the number of the LED pin
// Variables will change:
int ledState = LOW; // ledState used to set the LED
// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0; // will store last time LED was updated
int state = 0;
int countCycle = 0;
void setup() {
pinMode(ledPin, OUTPUT); // Initialize the LED_BUILTIN pin as an output
// Initialize the button.
button.begin();
// Add the callback function to be called when the button is pressed.
button.onPressed(onPressed);
Serial.begin(115200);
EEPROM.begin(512);
delay(10);
if (restoreConfig()) {
if (checkConnection()) {
settingMode = false;
startWebServer();
return;
}
}
settingMode = true;
setupMode();
}
void blinkLedSettingMode(const long interval) {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}
void blinkLedConnectedRouter(const long interval) {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;
switch (state) {
case 0:
countCycle++;
if (countCycle == 5) {
ledState = HIGH;
countCycle = 0;
state = 1;
}
case 1:
countCycle++;
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
if (countCycle == 5) {
ledState = LOW;
countCycle = 0;
state = 0;
}
}
// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}
String genStringRandom(int numBytes) {
int i = 0;
int j = 0;
String letters[40] = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"};
String randString = "";
for (i = 0; i < numBytes; i++)
{
randString = randString + letters[random(0, 40)];
}
return randString;
}
// Hàm call back để nhận dữ liệu
void callback(char* topic, byte* payload, unsigned int length)
{
Serial.print("Co tin nhan moi tu topic:");
Serial.println(topic);
for (int i = 0; i < length; i++)
Serial.print((char)payload[i]);
Serial.println();
}
// Hàm reconnect thực hiện kết nối lại khi mất kết nối với MQTT Broker
void reconnect()
{
while (!client.connected()) // Chờ tới khi kết nối
{
// Thực hiện kết nối với mqtt user và pass
if (client.connect(sn.c_str(), "ESP_offline", 0, 0, "ESP8266_id1_offline")) //kết nối vào broker
{
Serial.println("Đã kết nối to MQTT server");
client.subscribe("ESP8266_read_data"); //đăng kí nhận dữ liệu từ topic ESP8266_read_data
}
else
{
Serial.print("Lỗi:, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
// Đợi 5s
button.read();
delay(5000);
}
}
}
void pubData() {
float voltage = pzem.voltage();
if (!isnan(voltage)) {
Serial.print("Voltage: "); Serial.print(voltage); Serial.println("V");
} else {
Serial.println("Error reading voltage");
}
float current = pzem.current();
if (!isnan(current)) {
Serial.print("Current: "); Serial.print(current); Serial.println("A");
} else {
Serial.println("Error reading current");
}
float power = pzem.power();
if (!isnan(power)) {
Serial.print("Power: "); Serial.print(power); Serial.println("W");
} else {
Serial.println("Error reading power");
}
float energy = pzem.energy();
if (!isnan(energy)) {
Serial.print("Energy: "); Serial.print(energy, 3); Serial.println("kWh");
} else {
Serial.println("Error reading energy");
}
float frequency = pzem.frequency();
if (!isnan(frequency)) {
Serial.print("Frequency: "); Serial.print(frequency, 1); Serial.println("Hz");
} else {
Serial.println("Error reading frequency");
}
float pf = pzem.pf();
if (!isnan(pf)) {
Serial.print("PF: "); Serial.println(pf);
} else {
Serial.println("Error reading power factor");
}
Serial.println();
String array[6] = {};
String volt = String(voltage, 1);
String cur = String(current, 2);
String po = String(power, 2);
String en = String(energy, 3);
String f = String(frequency, 1);
String pfS = String(pf, 2);
array[0] = volt;
array[1] = cur;
array[2] = po;
array[3] = en;
array[4] = f;
array[5] = pfS;
String result = "";
for (int i = 0; i < 6; i++) {
result.concat(array[i]);
result.concat("-");
}
client.publish(localIpp.c_str(), result.c_str()); // gửi dữ liệu lên topic ESP8266_sent_data
}
void loop() {
if (settingMode) {
dnsServer.processNextRequest();
//blinkLedSettingMode(500);
blinkLedConnectedRouter(200);
} else {
button.read();
pubData();
delay(2000);
digitalWrite(ledPin, !digitalRead(ledPin));
if (!client.connected())// Kiểm tra kết nối
reconnect();
client.loop();
}
webServer.handleClient();
}
void onPressed() {
for (int i = 0; i < 120; ++i) {
EEPROM.write(i, 0);
}
EEPROM.commit();
Serial.println("EEPROM is cleaned!");
}
boolean restoreConfig() {
Serial.println("Reading EEPROM...");
String ssid = "";
String pass = "";
if (EEPROM.read(0) != 0) {
for (int i = 0; i < 32; ++i) {
ssid += char(EEPROM.read(i));
}
Serial.print("SSID: ");
Serial.println(ssid);
for (int i = 32; i < 64; ++i) {
pass += char(EEPROM.read(i));
}
Serial.print("Password: ");
Serial.println(pass);
for (int i = 64; i < 100; ++i) {
email += char(EEPROM.read(i));
}
Serial.print("Email: ");
Serial.println(email);
for (int i = 100; i < 120; ++i) {
mqtt += char(EEPROM.read(i));
}
Serial.print("MQTT: ");
Serial.println(mqtt);
for (int i = 117; i < 130; ++i) {
sn += char(EEPROM.read(i));
}
Serial.print("Serial Number: ");
Serial.println(sn);
WiFi.begin(ssid.c_str(), pass.c_str());
return true;
}
else {
Serial.println("Config not found.");
return false;
}
}
boolean checkConnection() {
int count = 0;
Serial.print("Waiting for Wi-Fi connection");
while ( count < 30 ) {
if (WiFi.status() == WL_CONNECTED) {
Serial.println();
Serial.println("Connected!");
return (true);
}
delay(500);
Serial.print(".");
count++;
}
Serial.println("Timed out.");
return false;
}
void startWebServer() {
if (settingMode) {
Serial.print("Starting Web Server at ");
Serial.println(WiFi.softAPIP());
webServer.on("/settings", []() {
String s = "<h1>Wi-Fi Settings</h1><p>Please enter your password by selecting the SSID.</p>";
s += "<form method=\"get\" action=\"setap\"><label>SSID: </label><select name=\"ssid\">";
s += ssidList;
s += "</select><br>Email: <input name=\"email\" length=64 type=\"text\">";
s += "</select><br>MQTT server: <input name=\"mqtt\" length=64 type=\"text\">";
s += "</select><br>SerialNumber: <input name=\"sn\" length=64 type=\"text\">";
s += "<br>Password: <input name=\"pass\" length=64 type=\"password\"><input type=\"submit\"></form>";
webServer.send(200, "text/html", makePage("Wi-Fi Settings", s));
});
webServer.on("/setap", []() {
for (int i = 0; i < 130; ++i) {
EEPROM.write(i, 0);
}
String ssid = urlDecode(webServer.arg("ssid"));
Serial.print("SSID: ");
Serial.println(ssid);
String pass = urlDecode(webServer.arg("pass"));
Serial.print("Password: ");
Serial.println(pass);
String mqtt = urlDecode(webServer.arg("mqtt"));
Serial.print("MQTT: ");
Serial.println(mqtt);
String sn = urlDecode(webServer.arg("sn"));
Serial.print("Serial Number: ");
Serial.println(sn);
String email = urlDecode(webServer.arg("email"));
email.concat("-");
email.concat(genStringRandom(10));
Serial.print("Email: ");
Serial.println(email);
Serial.println("Writing SSID to EEPROM...");
for (int i = 0; i < ssid.length(); ++i) {
EEPROM.write(i, ssid[i]);
}
Serial.println("Writing Password to EEPROM...");
for (int i = 0; i < pass.length(); ++i) {
EEPROM.write(32 + i, pass[i]);
}
Serial.println("Writing Email to EEPROM...");
for (int i = 0; i < email.length(); ++i) {
EEPROM.write(64 + i, email[i]);
}
Serial.println("Writing MQTT to EEPROM...");
for (int i = 0; i < mqtt.length(); ++i) {
EEPROM.write(100 + i, mqtt[i]);
}
Serial.println("Writing Serial Number to EEPROM...");
for (int i = 0; i < sn.length(); ++i) {
EEPROM.write(117 + i, sn[i]);
}
EEPROM.commit();
Serial.println("Write EEPROM done!");
String s = "<h1>Setup complete.</h1><p>device will be connected to \"";
s += ssid;
s += "\" after the restart.";
webServer.send(200, "text/html", makePage("Wi-Fi Settings", s));
ESP.restart();
});
webServer.onNotFound([]() {
String s = "<h1>AP mode</h1><p><a href=\"/settings\">Wi-Fi Settings</a></p>";
webServer.send(200, "text/html", makePage("AP mode", s));
});
}
else {
//localIpp.concat(WiFi.localIP().toString().c_str());
//localIpp.concat("-");
localIpp.concat(sn.c_str());
Serial.print("Starting Web Server at ");
Serial.println(WiFi.localIP());
Serial.println(localIpp);
client.setServer(mqtt.c_str(), mqtt_port);
client.setCallback(callback);
webServer.on("/", []() {
String s = "<h1>STA mode</h1><p><a href=\"/reset\">Reset Wi-Fi Settings</a></p>";
webServer.send(200, "text/html", makePage("STA mode", s));
});
webServer.on("/reset", []() {
for (int i = 0; i < 130; ++i) {
EEPROM.write(i, 0);
}
EEPROM.commit();
String s = "<h1>Wi-Fi settings was reset.</h1><p>Please reset device.</p>";
webServer.send(200, "text/html", makePage("Reset Wi-Fi Settings", s));
});
}
webServer.begin();
}
void setupMode() {
WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
int n = WiFi.scanNetworks();
delay(100);
Serial.println("");
for (int i = 0; i < n; ++i) {
ssidList += "<option value=\"";
ssidList += WiFi.SSID(i);
ssidList += "\">";
ssidList += WiFi.SSID(i);
ssidList += "</option>";
}
delay(100);
WiFi.mode(WIFI_AP);
WiFi.softAPConfig(apIP, apIP, IPAddress(255, 255, 255, 0));
WiFi.softAP(apSSID);
dnsServer.start(53, "*", apIP);
startWebServer();
Serial.print("Starting Access Point at \"");
Serial.print(apSSID);
Serial.println("\"");
}
String makePage(String title, String contents) {
String s = "<!DOCTYPE html><html><head>";
s += "<meta name=\"viewport\" content=\"width=device-width,user-scalable=0\">";
s += "<title>";
s += title;
s += "</title></head><body>";
s += contents;
s += "</body></html>";
return s;
}
String urlDecode(String input) {
String s = input;
s.replace("%20", " ");
s.replace("+", " ");
s.replace("%21", "!");
s.replace("%22", "\"");
s.replace("%23", "#");
s.replace("%24", "$");
s.replace("%25", "%");
s.replace("%26", "&");
s.replace("%27", "\'");
s.replace("%28", "(");
s.replace("%29", ")");
s.replace("%30", "*");
s.replace("%31", "+");
s.replace("%2C", ",");
s.replace("%2E", ".");
s.replace("%2F", "/");
s.replace("%2C", ",");
s.replace("%3A", ":");
s.replace("%3A", ";");
s.replace("%3C", "<");
s.replace("%3D", "=");
s.replace("%3E", ">");
s.replace("%3F", "?");
s.replace("%40", "@");
s.replace("%5B", "[");
s.replace("%5C", "\\");
s.replace("%5D", "]");
s.replace("%5E", "^");
s.replace("%5F", "-");
s.replace("%60", "`");
return s;
}
| [
"mathangspk@gmail.com"
] | mathangspk@gmail.com |
303d6519e2fc5f74f4a83bebd3aa4f611d8e3d7b | 92b6aaade5a3f323d7f8e7d02fb9fec09f4c2f50 | /CP-Codes/Codes/Codeforces/nnsid.cpp | f7a430f67c46641766af236fce85a7ddbcc5eb90 | [] | no_license | suraj1611/Competitive_Programming | 846dee00396e2f2b6d13e2ea8aaed444a34062af | 82bd88081ac067ad4170553afedc6c479bb53753 | refs/heads/master | 2020-04-22T17:27:18.116585 | 2019-12-16T19:42:29 | 2019-12-16T19:42:29 | 170,541,477 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 218 | cpp | #include<bits/stdc++.h>
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
int main()
{
long long int x,y;
cin>>x>>y;
if((x-(y-1)%2==0)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
| [
"surajsk1611@gmail.com"
] | surajsk1611@gmail.com |
c524858f9a593c05b6e97d113dc494c8d5cef5a3 | b25f37d1c981d2340d731885681ace8725d95d34 | /train.cpp | 8c68422adf49d9891300fc3fc2f5b4586a6b26ce | [] | no_license | ChiTatZhang/server_graduate | 28cbe7b19b45c3b300c637bf05451fba4c001d49 | 0493bc9ab41f854477d891d1553ffce41918e8ae | refs/heads/master | 2021-05-04T15:50:12.005145 | 2018-02-08T07:09:35 | 2018-02-08T07:09:35 | 120,239,834 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,926 | cpp | #include <iostream>
// #include <opencv2/imgproc/imgproc.hpp>
//#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/face.hpp>
#include <opencv2/face/facerec.hpp>
#include <opencv2/opencv.hpp>
#include <vector>
#include <fstream>
#include "faceRecognise.h"
#include "database.h"
using namespace std;
using namespace cv;
using namespace face;
int save_faceImage(Mat &image,const char *path,const int lable)
{
vector<Mat> faceImg;
vector<Mat>::iterator face;
static int num =0;
detect_face(image,NULL,&faceImg);
cout<<"face:"<<faceImg.size()<<endl;
char makeDir[64]={0};
snprintf(makeDir,sizeof(makeDir),"mkdir %s",path);
system(makeDir);
imshow("img",image);
if(faceImg.size()==1)
{
char tmppath[64]={0};
snprintf(tmppath,sizeof(tmppath),"%s/%d.jpg",path,num);
num++;
cout<<"write_num: "<<num<<endl;
imshow("save",faceImg[0]);
waitKey(500);
cout<<num<<endl;
cout<<tmppath;
imwrite(tmppath,faceImg[0]);
char sql[128]={0};
sprintf(sql,"insert into imgpath (id,path) values(%d,'%s');",lable,tmppath);
int ret=sqlite(sql);
if(ret<0)
{
cout<<"data insert error"<<endl;
}
}
cout<<"over"<<endl;
return -1;
}
int add_face(VideoCapture &capture)
{
int key=0;
while(1)
{
int id=0;
string name;
cout<<"请输入id号"<<endl;
cin>>id;
cout<<"请输入名字"<<endl;
cin>>name;
while(key=waitKey(100))
{
Mat frame;
Mat myFace;
static int num=0;
capture>>frame;
vector<Rect> rec;
detect_face(frame,&rec);
if(key=='p')
{
if(rec.size()==1)
{
char path[64];
sprintf(path,"./att_faces/%d",id);
save_faceImage(frame,path,id);
num++;
}
cout<<"已保存"<<num<<"张图片"<<endl;
}
imshow("video",frame);
if(num>9){
break;
}
}
cout<<"继续添加请按n\n"<<"退出添加请按q"<<endl;
string str;
cin>>str;
if(str=="q")
{
break;
}
}
}
int train()
{
vector<Mat>imgs;
vector<int>lab;
char sql[128]="select id,path from imgpath";
struct imgpath *ip;
int num;
int ret=sqlite(&ip,sql,&num);
if(ret<0)
{
cout<<"imgpath select error"<<endl;
return -1;
}
struct imgpath *tmpip=ip;
for(int i=0;i<num;i++)
{
imgs.push_back(imread(tmpip->path,0));
lab.push_back(tmpip->id);
tmpip++;
}
free(ip);
cout<<imgs.size()<<lab.size()<<endl;
int MaxLab=lab[lab.size()-1];
cout<<"maxlab: "<<MaxLab<<endl;
cout<<"training...."<<endl;
Ptr<FaceRecognizer> model =LBPHFaceRecognizer::create();
model->train(imgs,lab);
model->write("test.xml");
return 0;
}
int recognise(Mat &tmpframe,int &label,double &number)
{
Ptr<FaceRecognizer> model =LBPHFaceRecognizer::create();
model->read("test.xml");
Mat testImg;
vector<Rect> rec;
detect_face(tmpframe,&rec);
cout<<"detect_face rec.size()"<<rec.size()<<endl;
if(rec.size()!=1)
return -1;
else
{
cvtColor(tmpframe,testImg,CV_BGR2GRAY);
vector<Rect>::iterator pRec;
for(pRec=rec.begin();pRec!=rec.end();pRec++){
Mat faceImg=testImg(*pRec);
Mat resizeImg;
resize(faceImg,resizeImg,Size(92,112));
model->predict(resizeImg, label, number);
cout<<"label:" << label << endl;
cout<<"num:" << number << endl;
}
}
return 0;
}
#if 0
int main()
{
// VideoCapture capture(0);
// int key;
// int time=0;
/*int trainRet=train();
if(trainRet>0)
cout<<"train fialed"<<endl;
else
cout<<"train success"<<endl;*/
// while(key=waitKey(100)){
Mat tmpframe=imread("./att_faces/20180100/0.jpg");
// capture>>tmpframe;
int lab;
double num;
recognise(tmpframe,lab,num);
int predictLab=lab;
double number=num;
if((predictLab==20180101 || predictLab==20180100 || predictLab==42) && number<80){
string name = "zhangzhida";
cout<<name;
}else if(predictLab==20180102 ||predictLab==45 && number<90){
string name = "liuchangxin";
cout<<name;
}else
{
string name ="other";
cout<<name;
}
imshow("video",tmpframe);
return 0;
}
#endif
| [
"zhangzhd@nationalchip.com"
] | zhangzhd@nationalchip.com |
e393e980d323a81f036e2189d9c0b925d612fff5 | 55b5bb05ea8e287ac072d07f0745a8f88df63410 | /boost_1_59_0/libs/math/test/test_jacobi.cpp | a76e371c814927b9c575a40faf0c162b74f3ef05 | [
"BSL-1.0",
"MIT"
] | permissive | lbryio/lbrycrd-dependencies | 88e187ad0b42acbfc4c13bae84dcab9338b3c830 | 48c993eb77aed55029ae66bc48d970218a357f9e | refs/heads/master | 2020-04-02T04:08:35.350210 | 2018-02-28T14:42:50 | 2018-02-28T14:42:50 | 63,198,671 | 5 | 6 | MIT | 2018-02-28T14:42:50 | 2016-07-12T23:17:26 | HTML | UTF-8 | C++ | false | false | 5,014 | cpp | // Copyright John Maddock 2012
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <pch_light.hpp>
#include <test_jacobi.hpp>
//
// DESCRIPTION:
// ~~~~~~~~~~~~
//
// This file tests the Jacobi Elliptic Functions.
// There are two sets of tests, spot
// tests which compare our results with selected values computed
// using the online special function calculator at
// functions.wolfram.com, while the bulk of the accuracy tests
// use values generated with NTL::RR at 1000-bit precision
// and our generic versions of these functions.
//
// Note that when this file is first run on a new platform many of
// these tests will fail: the default accuracy is 1 epsilon which
// is too tight for most platforms. In this situation you will
// need to cast a human eye over the error rates reported and make
// a judgement as to whether they are acceptable. Either way please
// report the results to the Boost mailing list. Acceptable rates of
// error are marked up below as a series of regular expressions that
// identify the compiler/stdlib/platform/data-type/test-data/test-function
// along with the maximum expected peek and RMS mean errors for that
// test.
//
void expected_results()
{
//
// Define the max and mean errors expected for
// various compilers and platforms.
//
const char* largest_type;
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
if(boost::math::policies::digits<double, boost::math::policies::policy<> >() == boost::math::policies::digits<long double, boost::math::policies::policy<> >())
{
largest_type = "(long\\s+)?double|real_concept";
}
else
{
largest_type = "long double|real_concept";
}
#else
largest_type = "(long\\s+)?double";
#endif
add_expected_result(
".*", // compiler
".*", // stdlib
".*", // platform
largest_type, // test type(s)
".*Mathworld.*", // test data group
".*", 500, 250); // test function
add_expected_result(
".*", // compiler
".*", // stdlib
".*", // platform
largest_type, // test type(s)
".*Large Phi.*", // test data group
".*", 50000, 5000); // test function
add_expected_result(
".*", // compiler
".*", // stdlib
".*", // platform
largest_type, // test type(s)
".*near 1.*", // test data group
".*", 7000, 500); // test function
if(std::numeric_limits<long double>::digits == 64)
{
//
// Some errors spill over into double precision:
//
add_expected_result(
".*", // compiler
".*", // stdlib
".*", // platform
"double", // test type(s)
".*Large Phi.*", // test data group
".*", 500, 50); // test function
add_expected_result(
".*", // compiler
".*", // stdlib
".*", // platform
"double", // test type(s)
".*near 1.*", // test data group
".*", 10, 5); // test function
}
//
// Catch all cases come last:
//
add_expected_result(
".*", // compiler
".*", // stdlib
".*", // platform
largest_type, // test type(s)
".*", // test data group
".*", 50, 20); // test function
//
// Finish off by printing out the compiler/stdlib/platform names,
// we do this to make it easier to mark up expected error rates.
//
std::cout << "Tests run with " << BOOST_COMPILER << ", "
<< BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}
BOOST_AUTO_TEST_CASE( test_main )
{
expected_results();
BOOST_MATH_CONTROL_FP;
test_spots(0.0F, "float");
test_spots(0.0, "double");
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
test_spots(0.0L, "long double");
#ifndef BOOST_MATH_NO_REAL_CONCEPT_TESTS
test_spots(boost::math::concepts::real_concept(0), "real_concept");
#endif
#else
std::cout << "<note>The long double tests have been disabled on this platform "
"either because the long double overloads of the usual math functions are "
"not available at all, or because they are too inaccurate for these tests "
"to pass.</note>" << std::cout;
#endif
}
| [
"jobevers@users.noreply.github.com"
] | jobevers@users.noreply.github.com |
c4bffbf79da7729688d90b5204a8c6b085e59d82 | b2995c4cffd0b6bc8014d84606cdf75c536107cf | /xp/iterator.h | fd0726bf2ad877a70e753179163649c19fb7a5f3 | [
"MIT"
] | permissive | vjacquet/praxis | 18b63463f7e7c4eafba153e2d0776f0c3eabc02b | a0558c1c4f569682792f317f9c94ff3167126fda | refs/heads/master | 2020-05-21T19:48:57.613163 | 2017-10-04T23:02:21 | 2017-10-04T23:02:21 | 17,312,905 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,687 | h | #ifndef __ITERATOR_H__
#define __ITERATOR_H__
#include <iterator>
#include "fakeconcepts.h"
namespace xp {
namespace details {
// TODO: The use of the curiously recurring template pattern makes things a little bit too complicated to my taste.
// Stepanov uses a template and a typedef
/*
* curiously recurring template pattern
* +---------------------------------------------+---------------------------------------------+
* | pros | cons |
* +---------------------------------------------+---------------------------------------------+
* | * the implementation defines the ctrs | * must make iterator_scaffolding friend |
* | * the state is the implemention itself | to hide implementation details |
* | | * must define all typedefs or adapt trait |
* | | * must cast scaffolding as implementation |
* | | before calling |
* +---------------------------------------------+---------------------------------------------+
*
* templatized implementation and typedef
* +---------------------------------------------+---------------------------------------------+
* | pros | cons |
* +---------------------------------------------+---------------------------------------------+
* | * the implementation can be in a separate | * the scaffoling must forward the ctrs to |
* | namespace and the typedef makes it | the implementation |
* | opaque | * the state is a data member |
* | * the implementation can inherit from | |
* | iterator to define the typedefs | |
* +---------------------------------------------+---------------------------------------------+
*
*/
template<typename I, typename Category, typename T, typename Diff = std::ptrdiff_t, typename Pointer = T*, typename Reference = T&>
struct iterator_scaffolding : std::iterator<Category, T, Diff, Pointer, Reference> {
// Regular
friend bool operator==(const I& x, const I& y) {
return x.position() == y.position();
}
friend bool operator!=(const I& x, const I& y) {
return !(x == y);
}
// dereference
reference operator*() const {
return static_cast<const I*>(this)->source();
}
pointer operator->() const {
return &(**this);
}
// forward
I& operator++() {
auto self = static_cast<I*>(this);
self->successor();
return *self;
}
I operator++(int) {
I i = *this;
++*this;
return i;
}
// bidirectional
I& operator--() {
auto self = static_cast<I*>(this);
self->predecessor();
return *self;
}
I operator--(int) {
I i = *this;
--*this;
return i;
}
// random access
I& operator+=(typename difference_type n) {
auto self = static_cast<I*>(this);
self->advance(n);
return *self;
}
I& operator-=(typename difference_type n) {
*this += -n;
return *this;
}
reference operator[](typename difference_type n) const {
return *(*this + n);
}
friend difference_type operator-(const I& x, const I& y) {
return static_cast<const I*>(x)->distance(y);
}
I operator-(difference_type n) {
return *this + (-n);
}
friend I operator+(I x, difference_type n) {
return x += n;
}
friend I operator+(difference_type n, I x) {
return x += n;
}
friend bool operator<(const I& x, const I& y) {
return (x - y) < 0;
}
friend bool operator>(const I& x, const I& y) {
return y < x;
}
friend bool operator<=(const I& x, const I& y) {
return !(y < x);
}
friend bool operator>=(const I& x, const I& y) {
return !(x < y);
}
};
template<typename I, typename Traits>
using iterator_scaffolding_adapter = iterator_scaffolding<I
, typename Traits::iterator_category
, typename Traits::value_type
, typename Traits::difference_type
, typename Traits::pointer
, typename Traits::reference>;
}
// Caution: Prefer counted ranges. Do not use bounded range unless you known (last - first) % S == 0.
template<InputIterator I, size_t S>
struct stride_iterator_k : public details::iterator_scaffolding_adapter<stride_iterator_k<I, S>, std::iterator_traits<I>> {
I base;
stride_iterator_k() : base() {}
stride_iterator_k(I i) : base(i) {}
I& position() {
return base;
}
reference source() const {
return *base;
}
void successor() {
base += S;
}
void predecessor() {
base -= S;
}
void advance(difference_type n) {
base += n * S;
}
difference_type distance(stride_iterator_k x) {
return (x.base - base) / S;
}
};
template<size_t S, InputIterator I>
stride_iterator_k<I, S> make_stride_iterator_k(I i) {
return stride_iterator_k<I, S>(i);
}
template<InputIterator I>
struct stride_iterator : public details::iterator_scaffolding_adapter<stride_iterator<I>, std::iterator_traits<I>> {
difference_type step;
I base;
stride_iterator() : step(0), base() {}
stride_iterator(I i, difference_type step) : step(step), base(i) {}
I& position() {
return base;
}
reference source() const {
return *base;
}
void successor() {
base += step;
}
void predecessor() {
base -= step;
}
void advance(difference_type n) {
base += n * step;
}
difference_type distance(stride_iterator x) {
return (x.base - base) / step;
}
};
template<InputIterator I>
stride_iterator<I> make_stride_iterator(I i, std::size_t n) {
return stride_iterator<I>(i, n);
}
using std::reverse_iterator;
template <Container C>
class unary_insert_iterator : public std::iterator<std::output_iterator_tag, void, void, void, void>
{
protected:
C* c;
public:
typedef C container_type;
explicit unary_insert_iterator(C& x) : c(&x) {}
unary_insert_iterator& operator= (const typename C::value_type& value) {
c->insert(value);
return *this;
}
unary_insert_iterator& operator= (typename C::value_type&& value) {
c->insert(std::move(value));
return *this;
}
unary_insert_iterator& operator* () {
return *this;
}
unary_insert_iterator& operator++ () {
return *this;
}
unary_insert_iterator operator++ (int) {
return *this;
}
};
template <Container C>
unary_insert_iterator<C> inserter(C& x) {
return unary_insert_iterator<C> {x};
}
template <BidirectionalIterator I>
reverse_iterator<I> reverse(I it) {
return reverse_iterator{ it };
}
/*
* alternate iterator categories, from EoP
* Added because some algorithms are based on indexed iterator. For instance see k_rotate_from_permutation
*/
struct input_iterator_tag {};
struct forward_iterator_tag : input_iterator_tag {};
struct indexed_iterator_tag : forward_iterator_tag {};
struct bidirectional_iterator_tag : input_iterator_tag {};
struct random_iterator_tag : bidirectional_iterator_tag, indexed_iterator_tag {};
struct output_iterator_tag {};
struct bulk_iterator_tag : output_iterator_tag {};
/*
* test for orthogonal specifications
*/
struct sparse_storage_tag { };
struct segmented_storage_tag { };
struct strided_storage_tag { };
struct contiguous_storage_tag : strided_storage_tag { };
}
#endif __ITERATOR_H__ | [
"vjacquet@flowgroup.fr"
] | vjacquet@flowgroup.fr |
1e593f01624cb7c6422d83e1104bd47c982f1849 | 27670a1f9abcd72a4d3e0e28573844b4d21a7854 | /Grid/cell/GridCellNumeric.h | 089c56307b4df0b6839eb4be599d5a315b0b7fe0 | [] | no_license | rafaelcalleja/Provision-ISRDeviceInfoTool | 284bba4091f7dcc82447cc938fc790e5dd107dc0 | eac74b6f8ac5c895047b31f3267f9ef761ee8ee1 | refs/heads/master | 2020-04-11T00:07:38.386017 | 2018-07-15T09:18:07 | 2018-07-15T09:18:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 785 | h | // GridCellNumeric.h: interface for the CGridCellNumeric class.
//
// Written by Andrew Truckle [ajtruckle@wsatkins.co.uk]
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_GRIDINTEGERCELL_H__3479ED0D_B57D_4940_B83D_9E2296ED75B5__INCLUDED_)
#define AFX_GRIDINTEGERCELL_H__3479ED0D_B57D_4940_B83D_9E2296ED75B5__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "../GridCell.h"
class CGridCellNumeric : public CGridCell
{
DECLARE_DYNCREATE(CGridCellNumeric)
public:
virtual BOOL Edit(int nRow, int nCol, CRect rect, CPoint point, UINT nID, UINT nChar);
virtual void EndEdit();
};
#endif // !defined(AFX_GRIDINTEGERCELL_H__3479ED0D_B57D_4940_B83D_9E2296ED75B5__INCLUDED_)
| [
"noreply@github.com"
] | noreply@github.com |
b91a5e7ac440b0865522394561510a66d4d9a2cb | f4891b6aa45545790f4d30f007821d48ccc2fea5 | /lib/general_timer_impl.cc | 0b3d9b6c22591f1ddabcd172b77df7a32839a745 | [] | no_license | joqoko/gr-inets | 567493dd3635c57de74a49c0b5e37edd838256c1 | 4bdf122cc7e6dc4ecc4ae49d059502634bedb16a | refs/heads/master | 2021-01-11T01:44:05.592902 | 2017-08-03T13:14:15 | 2017-08-03T13:14:15 | 70,676,456 | 1 | 1 | null | 2016-10-12T07:52:31 | 2016-10-12T07:52:30 | null | UTF-8 | C++ | false | false | 21,244 | cc | /* -*- c++ -*- */
/*
* Copyright 2017 <+YOU OR YOUR COMPANY+>.
*
* This is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3, or (at your option)
* any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gnuradio/io_signature.h>
#include "general_timer_impl.h"
//#include <algorithm>
namespace gr {
namespace inets {
general_timer::sptr
general_timer::make(int develop_mode, int block_id, int timer_type, double duration_ms, int system_time_granularity_us, double reserved_time_ms)
{
return gnuradio::get_initial_sptr
(new general_timer_impl(develop_mode, block_id, timer_type, duration_ms, system_time_granularity_us, reserved_time_ms));
}
/*
* The private constructor
*/
general_timer_impl::general_timer_impl(int develop_mode, int block_id, int timer_type, double duration_ms, int system_time_granularity_us, double reserved_time_ms)
: gr::block("general_timer",
gr::io_signature::make(0, 0, 0),
gr::io_signature::make(0, 0, 0)),
_develop_mode(develop_mode),
_block_id(block_id),
_timer_type(timer_type),
_duration_ms(duration_ms),
_system_time_granularity_us(system_time_granularity_us),
_reserved_time_ms(reserved_time_ms),
_timer_bias_s(0),
_in_active(false)
{
if(_develop_mode)
std::cout << "develop_mode of general_timer ID: " << _block_id << " is activated." << std::endl;
message_port_register_in(pmt::mp("active_in"));
set_msg_handler(pmt::mp("active_in"), boost::bind(&general_timer_impl::start_timer, this, _1 ));
message_port_register_in(pmt::mp("suspend_timer_in"));
set_msg_handler(pmt::mp("suspend_timer_in"), boost::bind(&general_timer_impl::suspend_timer, this, _1 ));
message_port_register_in(pmt::mp("resume_timer_in"));
set_msg_handler(pmt::mp("resume_timer_in"), boost::bind(&general_timer_impl::resume_timer, this, _1 ));
message_port_register_in(pmt::mp("reset_duration_in"));
set_msg_handler(pmt::mp("reset_duration_in"), boost::bind(&general_timer_impl::reset_duration, this, _1 ));
message_port_register_in(pmt::mp("disable_timer_in"));
set_msg_handler(pmt::mp("disable_timer_in"), boost::bind(&general_timer_impl::disable_timer, this, _1 ));
message_port_register_out(pmt::mp("expire_signal_out"));
message_port_register_out(pmt::mp("address_check_out"));
_disable_timer = 0;
_frame_info = pmt::from_long(0);
}
/*
* Our virtual destructor.
*/
general_timer_impl::~general_timer_impl()
{
}
void general_timer_impl::reset_duration(pmt::pmt_t cmd_in)
{
if(pmt::is_number(cmd_in))
{
_duration_ms = pmt::to_double(cmd_in);
if(_develop_mode)
std::cout << "duration of general_timer block ID " << _block_id << " is reset to " << _duration_ms << " [ms] " << std::endl;
}
else
{
std::cout << "error: general_timer block ID " << _block_id << " can only reassign duration to a number (in [ms])." << std::endl;
}
}
void
general_timer_impl::start_timer(pmt::pmt_t trigger)
{
if(!_disable_timer)
{
if(pmt::is_dict(trigger))
_frame_info = trigger;
pmt::pmt_t not_found;
struct timeval t;
gettimeofday(&t, NULL);
double current_time = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
if(!_in_active)
{
if(_develop_mode)
std::cout << "general_timer " << _block_id << " is triggered at time " << current_time << " s" << std::endl;
_in_active = true;
if(_timer_type == 0)
{
_frame_info = trigger;
boost::thread thrd(&general_timer_impl::countdown_oneshot_timer, this);
}
else if(_timer_type == 1)
{
boost::thread thrd(&general_timer_impl::countdown_periodic_timer, this);
}
else if(_timer_type == 3)
{
boost::thread thrd(&general_timer_impl::countdown_oneshot_exp_timer, this);
}
else if(_timer_type == 2)
{
int node_id = pmt::to_long(pmt::dict_ref(trigger, pmt::string_to_symbol("destination_address"), not_found));
double slot_time = pmt::to_double(pmt::dict_ref(trigger, pmt::string_to_symbol("slot_time"), not_found));
int address_check = pmt::to_long(pmt::dict_ref(trigger, pmt::string_to_symbol("address_check"), not_found));
if(node_id == 0 && slot_time == 0 && address_check == 0)
{
_in_active = false;
if(_develop_mode)
std::cout << "general_timer ID: " << _block_id << " receives new scheduling information" << std::endl;
_duration_list_ms.clear();
_node_id_list.clear();
_address_check_list.clear();
}
else
{
if(_develop_mode)
{
std::cout << "general_timer ID: " << _block_id << " new waiting request are stored." << std::endl;
std::cout << " slot_time is: " << slot_time << " and node ID is: " << node_id << std::endl;
}
_duration_list_ms.push_back(slot_time);
_node_id_list.push_back(node_id);
_address_check_list.push_back(address_check);
boost::thread thrd(&general_timer_impl::countdown_continual_timer, this);
}
}
}
else
{
if(_timer_type == 0)
{
struct timeval t;
gettimeofday(&t, NULL);
_start_time = t.tv_sec + t.tv_usec / 1000000.0;
if(_develop_mode)
std::cout << "warning: general_timer ID: " << _block_id << " is triggered before the last one finish." << std::endl;
}
if(_timer_type == 3)
{
if(_develop_mode)
std::cout << "general_timer ID: " << _block_id << " cannot be triggered before the last one finish." << std::endl;
}
else if(_timer_type == 1)
{
if(_develop_mode)
std::cout << "general_timer id: " << _block_id << " is set to periodic mode so it can only be triggered once." << std::endl;
}
else if(_timer_type == 2)
{
if(pmt::dict_has_key(trigger, pmt::string_to_symbol("slot_time")))
{
double slot_time = pmt::to_double(pmt::dict_ref(trigger, pmt::string_to_symbol("slot_time"), not_found));
int node_id = pmt::to_double(pmt::dict_ref(trigger, pmt::string_to_symbol("destination_address"), not_found));
int address_check = pmt::to_double(pmt::dict_ref(trigger, pmt::string_to_symbol("address_check"), not_found));
if(node_id == 0 && slot_time == 0 && address_check == 0)
{
if(_develop_mode)
std::cout << "general_timer ID: " << _block_id << " terminates all scheduled timer because new scheduling information is received" << std::endl;
_in_active = false;
_duration_list_ms.clear();
_node_id_list.clear();
_address_check_list.clear();
}
else
{
double slot_time = pmt::to_double(pmt::dict_ref(trigger, pmt::string_to_symbol("slot_time"), not_found));
double node_id = pmt::to_double(pmt::dict_ref(trigger, pmt::string_to_symbol("destination_address"), not_found));
int address_check = pmt::to_double(pmt::dict_ref(trigger, pmt::string_to_symbol("address_check"), not_found));
if(_develop_mode)
{
std::cout << "general_timer ID: " << _block_id << " new waiting request are stored." << std::endl;
std::cout << " slot_time is: " << slot_time << " and node ID is: " << node_id << std::endl;
}
_duration_list_ms.push_back(slot_time);
_node_id_list.push_back(node_id);
_address_check_list.push_back(address_check);
}
}
else
{
std::cout << "general_timer ID: " << _block_id << ": input pmt has no slot_time field. please check your connections." << std::endl;
}
}
}
}
else
{
if(_develop_mode)
std::cout << "general_timer ID: " << _block_id << " is disabled." << std::endl;
}
}
void
general_timer_impl::countdown_continual_timer()
{
while(_duration_list_ms.size() > 0 && _in_active)
{
pmt::pmt_t address_check = pmt::make_dict();
address_check = pmt::dict_add(address_check, pmt::string_to_symbol("beacon_address_check"), pmt::from_long(_address_check_list.front()));
message_port_pub(pmt::mp("address_check_out"), address_check);
struct timeval t;
gettimeofday(&t, NULL);
double current_time = t.tv_sec + t.tv_usec / 1000000.0;
double start_time = current_time;
double start_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
double current_time_show = start_time_show;
double duration_ms = std::max(double(_duration_list_ms.front()) - _reserved_time_ms, double(0));
if(_develop_mode)
{
std::cout << "general timer start time: " << start_time_show;
if(_address_check_list.front())
std::cout << ", it is my time slot " << std::endl;
else
std::cout << ", it is not my time slot " << std::endl;
}
while((current_time < start_time + double(duration_ms) / 1000 - _timer_bias_s) && _in_active)
{
boost::this_thread::sleep(boost::posix_time::microseconds(_system_time_granularity_us));
gettimeofday(&t, NULL);
current_time = t.tv_sec + t.tv_usec / 1000000.0;
current_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
// std::cout << "timeout is running at: " << current_time_show << std::endl;
}
std::cout << " _in_active after waiting is: " << _in_active << std::endl;
gettimeofday(&t, NULL);
current_time = t.tv_sec + t.tv_usec / 1000000.0;
if(_develop_mode)
{
current_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
if(_in_active)
{
_timer_bias_s = _timer_bias_s + current_time - start_time - duration_ms/1000;
std::cout << "general timer ID: " << _block_id << " is expired at time " << current_time_show << " s. " << " actual duration is: " << current_time - start_time << " [s]" << "and the time bias is: " << _timer_bias_s << std::endl;
}
else
std::cout << "general timer ID: " << _block_id << " is killed at time " << current_time_show << " s. " << " actual duration is: " << current_time - start_time << " [s]" << std::endl;
}
pmt::pmt_t expire = pmt::make_dict();
expire = pmt::dict_add(expire, pmt::string_to_symbol("time_stamp"), pmt::from_double(current_time));
message_port_pub(pmt::mp("expire_signal_out"), expire);
if(_in_active)
{
_duration_list_ms.erase(_duration_list_ms.begin());
_node_id_list.erase(_node_id_list.begin());
_address_check_list.erase(_address_check_list.begin());
}
}
if(!_in_active)
{
_duration_list_ms.clear();
_node_id_list.clear();
_address_check_list.clear();
}
_in_active = false;
pmt::pmt_t address_check = pmt::make_dict();
address_check = pmt::dict_add(address_check, pmt::string_to_symbol("beacon_address_check"), pmt::from_long(0));
message_port_pub(pmt::mp("address_check_out"), address_check);
}
void
general_timer_impl::suspend_timer(pmt::pmt_t trigger)
{
if(_in_active)
{
_in_active = false;
std::cout << "general_timer ID: " << _block_id << " is suspended. " << std::endl;
}
else
{
if(_develop_mode)
std::cout << "warning: general_timer ID: " << _block_id << " is suspended in inactive node. " << std::endl;
}
}
void
general_timer_impl::resume_timer(pmt::pmt_t trigger)
{
if(!_in_active)
{
_in_active = true;
}
else
{
if(_develop_mode)
std::cout << "general_timer ID: " << _block_id << " is already in active mode. " << std::endl;
}
}
void
general_timer_impl::disable_timer(pmt::pmt_t trigger)
{
_disable_timer = 1;
if(_develop_mode)
std::cout << "general_timer ID: " << _block_id << " is disabled" << std::endl;
}
void
general_timer_impl::countdown_oneshot_exp_timer()
{
struct timeval t;
gettimeofday(&t, NULL);
double current_time = t.tv_sec + t.tv_usec / 1000000.0;
_start_time = current_time;
double start_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
double current_time_show = start_time_show;
if(_develop_mode)
std::cout << "timer start time: " << start_time_show << std::endl;
double exp = (double)rand()/(double)(RAND_MAX);
double next_time = - log(exp) * _duration_ms;
while((current_time < _start_time + double(next_time) / 1000) && _in_active)
{
boost::this_thread::sleep(boost::posix_time::microseconds(_system_time_granularity_us));
gettimeofday(&t, NULL);
current_time = t.tv_sec + t.tv_usec / 1000000.0;
current_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
// std::cout << "timeout is running at: " << current_time_show << std::endl;
}
gettimeofday(&t, NULL);
current_time = t.tv_sec + t.tv_usec / 1000000.0;
if(_develop_mode)
{
current_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
if(_in_active)
{
_timer_bias_s = _timer_bias_s + current_time - _start_time - double(_duration_ms)/1000;
std::cout << "general_timer ID: " << _block_id << " is expired at time " << current_time_show << " s. " << " actual duration is: " << current_time - _start_time << " [s]" << ". the time bias is: " << _timer_bias_s << std::endl;
}
else
std::cout << "* general timer ID: " << _block_id << " is killed at time " << current_time_show << " s. " << " actual duration is: " << current_time_show - start_time_show << " s" << std::endl;
}
if(pmt::is_dict(_frame_info))
{
_frame_info = pmt::dict_add(_frame_info, pmt::string_to_symbol("time_stamp"), pmt::from_double(current_time));
_in_active = false;
message_port_pub(pmt::mp("expire_signal_out"), _frame_info);
}
else
{
pmt::pmt_t expire = pmt::make_dict();
expire = pmt::dict_add(expire, pmt::string_to_symbol("time_stamp"), pmt::from_double(current_time));
_in_active = false;
message_port_pub(pmt::mp("expire_signal_out"), _frame_info);
}
}
void
general_timer_impl::countdown_oneshot_timer()
{
struct timeval t;
gettimeofday(&t, NULL);
double current_time = t.tv_sec + t.tv_usec / 1000000.0;
_start_time = current_time;
double local_start_time = current_time;
double start_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
double current_time_show = start_time_show;
if(_develop_mode)
std::cout << "timer start time: " << start_time_show << std::endl;
while((current_time < _start_time + double(_duration_ms) / 1000) && _in_active)
{
boost::this_thread::sleep(boost::posix_time::microseconds(_system_time_granularity_us));
gettimeofday(&t, NULL);
current_time = t.tv_sec + t.tv_usec / 1000000.0;
current_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
// std::cout << "timeout is running at: " << current_time_show << std::endl;
}
gettimeofday(&t, NULL);
current_time = t.tv_sec + t.tv_usec / 1000000.0;
if(_develop_mode)
{
current_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
if(_in_active)
{
_timer_bias_s = _timer_bias_s + current_time - _start_time - double(_duration_ms)/1000;
std::cout << "general_timer ID: " << _block_id << " is expired at time " << current_time_show << " s. " << " actual duration is: " << current_time - local_start_time << " [s]" << ". the time bias is: " << _timer_bias_s << std::endl;
}
else
std::cout << "general timer ID: " << _block_id << " is suspended at time " << current_time_show << " s. " << " actual duration is: " << current_time_show - start_time_show << " s" << std::endl;
}
if(_in_active)
{
if(pmt::is_dict(_frame_info))
{
if(_develop_mode)
{
std::cout << "* general timer ID: " << _block_id << " output input command" << std::endl;
}
_frame_info = pmt::dict_add(_frame_info, pmt::string_to_symbol("time_stamp"), pmt::from_double(current_time));
_in_active = false;
message_port_pub(pmt::mp("expire_signal_out"), _frame_info);
}
else
{
if(_develop_mode)
{
std::cout << "* general timer ID: " << _block_id << " output new command" << std::endl;
}
pmt::pmt_t expire = pmt::make_dict();
expire = pmt::dict_add(expire, pmt::string_to_symbol("time_stamp"), pmt::from_double(current_time));
_in_active = false;
message_port_pub(pmt::mp("expire_signal_out"), _frame_info);
}
}
else
if(_develop_mode)
std::cout << "general timer ID: " << _block_id << " is suspended so no output." << std::endl;
}
void
general_timer_impl::countdown_periodic_timer()
{
while(_in_active)
{
struct timeval t;
gettimeofday(&t, NULL);
double current_time = t.tv_sec + t.tv_usec / 1000000.0;
double start_time = current_time;
double start_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
double current_time_show = start_time_show;
while((current_time < start_time + double(_duration_ms) / 1000 - _timer_bias_s) && _in_active)
{
boost::this_thread::sleep(boost::posix_time::microseconds(_system_time_granularity_us));
gettimeofday(&t, NULL);
current_time = t.tv_sec + t.tv_usec / 1000000.0;
current_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
// std::cout << "timeout is running at: " << current_time_show << std::endl;
}
gettimeofday(&t, NULL);
current_time = t.tv_sec + t.tv_usec / 1000000.0;
if(_develop_mode)
{
current_time_show = t.tv_sec - double(int(t.tv_sec/100)*100) + t.tv_usec / 1000000.0;
if(_in_active)
{
_timer_bias_s = _timer_bias_s + current_time - start_time - double(_duration_ms)/1000;
std::cout << "* general timer ID: " << _block_id << " is expired at time " << current_time_show << " s. " << " actual duration is: " << current_time - start_time << " [ms]" << "and the time bias is: " << _timer_bias_s << std::endl;
}
else
{
std::cout << "* general timer ID: " << _block_id << " is killed at time " << current_time_show << " s. " << " actual duration is: " << current_time_show - start_time_show << " s" << std::endl;
}
}
if(pmt::is_dict(_frame_info))
{
_frame_info = pmt::dict_add(_frame_info, pmt::string_to_symbol("time_stamp"), pmt::from_double(current_time));
message_port_pub(pmt::mp("expire_signal_out"), _frame_info);
}
else
{
pmt::pmt_t expire = pmt::make_dict();
expire = pmt::dict_add(expire, pmt::string_to_symbol("time_stamp"), pmt::from_double(current_time));
message_port_pub(pmt::mp("expire_signal_out"), expire);
}
}
}
} /* namespace inets */
} /* namespace gr */
| [
"joqoko@hotmail.com"
] | joqoko@hotmail.com |
e07205c7bbf9f51849f9d0474a2540459d652985 | 714d4ae0ceb8efd66a486f26a0b0565f23c923ba | /za_telegram_led_act_2/za_telegram_led_act_2.ino | ae80c306ed818b8ce17ce77e1b49e529c8773c29 | [] | no_license | khalish29/BOT-Telegram | 1f6174e5b0870ff9f17ffd20f0d1720603fcce33 | 3c36883cd0988b3028f598122d16ac235ef6b551 | refs/heads/main | 2023-01-25T05:00:45.972839 | 2020-12-08T13:27:32 | 2020-12-08T13:27:32 | 319,646,612 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,935 | ino | #include "CTBot.h"
CTBot myBot;
String ssid = "NYEH";
String pass = "light gaia";
String token = "1342443857:AAHJqH1KaZJhZr30RDOQkQOxaJBHN7g0H5o";
uint8_t redLed = D1;
uint8_t greenLed = D2;
void setup() {
Serial.begin(115200);
Serial.println("Starting TelegramBot...");
myBot.wifiConnect(ssid, pass);
myBot.setTelegramToken(token);
// check if all things are ok
if (myBot.testConnection())
Serial.println("\ntestConnection OK");
else
Serial.println("\ntestConnection NOK");
pinMode(redLed, OUTPUT);
pinMode(greenLed, OUTPUT);
digitalWrite(redLed, LOW);
digitalWrite(greenLed, LOW);
}
void loop() {
TBMessage msg;
if (myBot.getNewMessage(msg)) {
if (msg.text.equalsIgnoreCase("Red Light on")) {
digitalWrite(redLed, HIGH);
myBot.sendMessage(msg.sender.id, "Red Light is now ON");
}
else if (msg.text.equalsIgnoreCase("Red Light off")) {
digitalWrite(redLed, LOW);
myBot.sendMessage(msg.sender.id, "Red Light is now OFF");
}
if (msg.text.equalsIgnoreCase("Green Light on")) {
digitalWrite(greenLed, HIGH);
myBot.sendMessage(msg.sender.id, "Green Light is now ON");
}
else if (msg.text.equalsIgnoreCase("Green Light off")) {
digitalWrite(greenLed, LOW);
myBot.sendMessage(msg.sender.id, "Green Light is now OFF");
}
else {
String reply;
reply = (String)"Welcome " + msg.sender.username + (String)". Try LIGHT ON or LIGHT OFF.";
myBot.sendMessage(msg.sender.id, reply);
}
}
delay(50);
}
| [
"noreply@github.com"
] | noreply@github.com |
63792381c17f3d35afebeb1f2afd2a471ae161cb | c4b544d9ff751fb6007f4a305a7c764c860f93b4 | /test/list/typeclass/scanr1.cpp | 741975cfc081dea4211602365bf58c83615c4531 | [
"LicenseRef-scancode-unknown-license-reference",
"BSL-1.0"
] | permissive | rbock/hana | cc630ff26c9c78cebe5facaeb98635a4d5afcc50 | 2b76377f91a5ebe037dea444e4eaabba6498d3a8 | refs/heads/master | 2021-01-16T21:42:59.613464 | 2014-08-08T02:38:54 | 2014-08-08T02:38:54 | 23,278,630 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,249 | cpp | /*
@copyright Louis Dionne 2014
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
*/
#include <boost/hana/list/mcd.hpp>
#include <boost/hana/detail/assert.hpp>
#include <boost/hana/detail/constexpr.hpp>
#include <boost/hana/detail/minimal/comparable.hpp>
#include <boost/hana/detail/minimal/list.hpp>
#include <tuple>
using namespace boost::hana;
BOOST_HANA_CONSTEXPR_LAMBDA auto f = [](auto x, auto s) {
return std::make_tuple(x, s);
};
template <int i>
constexpr auto x = detail::minimal::comparable<>(i);
template <typename mcd>
void test() {
BOOST_HANA_CONSTEXPR_LAMBDA auto list = detail::minimal::list<mcd>;
BOOST_HANA_CONSTANT_ASSERT( scanr1(list(), f) == list( ));
BOOST_HANA_CONSTEXPR_ASSERT(scanr1(list(x<0>), f) == list( x<0>));
BOOST_HANA_CONSTEXPR_ASSERT(scanr1(list(x<0>, x<1>), f) == list( f(x<0>, x<1>), x<1>));
BOOST_HANA_CONSTEXPR_ASSERT(scanr1(list(x<0>, x<1>, x<2>), f) == list(f(x<0>, f(x<1>, x<2>)), f(x<1>, x<2>), x<2>));
}
int main() {
test<List::mcd<void>>();
}
| [
"ldionne.2@gmail.com"
] | ldionne.2@gmail.com |
75678dd6554d3db9eae390937fc65d54499804f9 | a6fc8c8827aca4008d0bc48f1403e8099136d940 | /Parcial 1/Deberes/4-MemoriaDinamica/Matriz.h | 33347d0ae9b4b3e758d84cf4ba4958121ace2879 | [] | no_license | NicoleAlexandraLaraAnago/Grupo-3685 | 0735ed2ab6a4c41bdd663ec5b2087e571a22294a | bb19d62e59ed0d05781809bad29cd7069db4d117 | refs/heads/main | 2023-06-04T20:36:01.621732 | 2021-06-25T11:49:19 | 2021-06-25T11:49:19 | 368,366,898 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 430 | h | #pragma once
#include <iostream>
class Matriz{
private:
int **matriz1;
int **matriz2;
int **matrizR;
int dim;
public:
Matriz();
Matriz(int **, int**, int**, int);
int getDim();
void setDim(int);
void setMatriz1(int **);
int** getMatriz1();
void setMatriz2(int **);
int** getMatriz2();
void setMatrizR(int **);
int** getMatrizR();
};
| [
"condorsua@hotmail.com"
] | condorsua@hotmail.com |
f0e15aa64468ec8a2c6595908ae86a56a288b5a2 | 046d3f5c545d9c34c809376c30592e7719a92fee | /3_Algorithms/Robert/Algorithm_Robert/C++/Chapter4/Chapter4_1/SymbolGraph_Separation/readFile_SymbolGraph.cpp | 455243a41da8eca7bdfa9c3573e35baf6158df41 | [] | no_license | XUN-XIE/CS-self-study | b7b6552140cb249064f7b97165829a9092f4e15c | 8916ecdadb932759f0300a481488594eb32e4b83 | refs/heads/master | 2023-02-24T06:05:31.903823 | 2021-01-25T14:02:07 | 2021-01-25T14:02:07 | 309,597,884 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 488 | cpp | #include "SymbolGraph.hpp"
// 运行时 需要输入
int main()
{
string filename = "../movies.txt";
string sp = "/";
SymbolGraph sg(filename, sp);
cout << "-----" << endl;
Graph G = sg.get_graph();
string search;
while (getline(cin, search))
{
// cout << search << "!!!" << endl;
auto adj_v = G.get_adj(sg.index(search));
for (auto w = adj_v.begin(); w != adj_v.end(); w++)
cout << "\t" + sg.name(*w) << endl;
}
} | [
"2320802672@qq.com"
] | 2320802672@qq.com |
6320b2f7f7af4cdc901ee141e3dde6751218cfd3 | 533d5e1a40def1e1118895f6ba2b4d503c918d1a | /tools/BORLANDC/OWL/SOURCE/COMBOBOX.CPP | 5c865ebb980bdea235a37e52615fd8cc6f33e43a | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | gandrewstone/GameMaker | 415cccdf0f9ecf5f339b7551469f07d53e43a6fd | 1fe0070a9f8412b5b53923aae7e64769722685a3 | refs/heads/master | 2020-06-12T19:30:07.252432 | 2014-07-14T14:38:55 | 2014-07-14T14:38:55 | 21,754,773 | 103 | 23 | null | null | null | null | UTF-8 | C++ | false | false | 6,795 | cpp | // ObjectWindows - (C) Copyright 1992 by Borland International
/* -------------------------------------------------------
COMBOBOX.CPP
Defines type TComboBox. This defines the basic behavior
of all combo box controls.
-------------------------------------------------------- */
#include "combobox.h"
/* Constructor for a TComboBoxData object. Initializes Strings and
Selection. */
TComboBoxData::TComboBoxData()
{
Strings = new Array(10, 0, 10);
Selection = NULL;
}
/* Destructor for TComboBoxData. Deletes Strings and Selection. */
TComboBoxData::~TComboBoxData()
{
if ( Strings )
delete Strings;
if ( Selection )
delete Selection;
}
/* Adds the supplied string to the Strings Array and copies it into
Selection if IsSelected is TRUE. */
void TComboBoxData::AddString(Pchar AString, BOOL IsSelected)
{
Strings->add(*new String(AString));
if ( IsSelected )
{
if (AString != Selection)
{
if (Selection)
delete Selection;
Selection = strdup(AString);
}
}
}
/* Constructor for a TComboBox object. Initializes its data fields
using supplied parameters and default values. By default, an
MS-Windows combobox associated with the TComboBox will have a
vertical scrollbar and will maintain its entries in alphabetical
order. */
TComboBox::TComboBox(PTWindowsObject AParent, int AnId, int X, int Y,
int W, int H, DWORD AStyle, WORD ATextLen,
PTModule AModule)
: TListBox(AParent, AnId, X, Y, W, H, AModule)
{
TextLen = ATextLen;
Attr.Style = WS_CHILD | WS_VISIBLE | WS_GROUP | WS_TABSTOP | CBS_SORT
| CBS_AUTOHSCROLL | WS_VSCROLL | AStyle;
}
TComboBox::TComboBox(PTWindowsObject AParent, int ResourceId,
WORD ATextLen, PTModule AModule)
: TListBox(AParent, ResourceId, AModule)
{
TextLen = ATextLen;
}
/* Sets and selects the contents of the associated edit
control to the supplied string. */
void TComboBox::SetText(LPSTR AString)
{
if (SetSelString(AString, -1) < 0 ) // AString not in list box
{
SetWindowText(HWindow, AString);
SetEditSel(0, _fstrlen(AString));
}
}
/* Returns, in the supplied reference parameters, the starting and
ending positions of the text selected in the associated
edit control. Returns CB_ERR if the combo box has no edit
control */
int TComboBox::GetEditSel(int& StartPos, int& EndPos)
{
long RetValue;
RetValue = SendMessage(HWindow, CB_GETEDITSEL, 0, 0);
StartPos = LOWORD(RetValue);
EndPos = HIWORD(RetValue);
return (int)RetValue;
}
/* Shows the list of an associated drop-down combobox. */
void TComboBox::ShowList()
{
if ( (GetWindowLong(HWindow,GWL_STYLE) & CBS_DROPDOWN) == CBS_DROPDOWN )
SendMessage(HWindow, CB_SHOWDROPDOWN, 1, 0);
}
/* Hides the list of an associated drop-down combobox. */
void TComboBox::HideList()
{
if ( (GetWindowLong(HWindow,GWL_STYLE) & CBS_DROPDOWN) == CBS_DROPDOWN )
SendMessage(HWindow, CB_SHOWDROPDOWN, 0, 0);
}
static void DoAddForCB(RObject AString, Pvoid AComboBox)
{
if (AString!=NOOBJECT)
((PTListBox)AComboBox)->AddString((Pchar)(PCchar)(RString)AString);
}
/* Transfers the items and selection of the combo box to or from a
transfer buffer if TF_SETDATA or TF_GETDATA, repectively, is passed
as the TransferFlag. DataPtr should point to a PTComboBoxData
(i.e. it should be a pointer to a pointer to a TComboBoxData)
which points to the data to be transferred.
Transfer returns the size of PTComboBox (the pointer not the
object). To retrieve the size without transferring data, pass
TF_SIZEDATA as the TransferFlag. */
WORD TComboBox::Transfer(Pvoid DataPtr, WORD TransferFlag)
{
Pchar TmpString;
PTComboBoxData ComboBoxData = *(PTComboBoxData _FAR *)DataPtr;
if ( TransferFlag == TF_GETDATA )
{
#if 0
int StringSize = GetWindowTextLength(HWindow) + 1;
if ( ComboBoxData->Selection )
delete ComboBoxData->Selection;
ComboBoxData->Selection= new char[StringSize];
GetWindowText(HWindow, ComboBoxData->Selection, StringSize);
#endif
// first, clear out Strings array and fill with contents of list box
ComboBoxData->Strings->flush();
for (int i=0; i<GetCount(); i++) {
TmpString = new char[GetStringLen(i)+1];
GetString(TmpString, i);
ComboBoxData->AddString(TmpString, FALSE);
delete TmpString;
}
LONG nCBIndex = SendMessage(HWindow, CB_GETCURSEL, (WORD) NULL, (DWORD) NULL);
if (ComboBoxData->Selection)
delete ComboBoxData->Selection;
if (nCBIndex != CB_ERR) //item is selected
{ int StringSize = SendMessage (HWindow, CB_GETLBTEXTLEN, nCBIndex, (DWORD) NULL);
ComboBoxData->Selection = new char[StringSize];
if (SendMessage (HWindow, CB_GETLBTEXT, nCBIndex, (DWORD) ComboBoxData->Selection) == CB_ERR)
delete ComboBoxData->Selection; //delete if not successfully filled
}
}
else
if ( TransferFlag == TF_SETDATA )
{
ClearList();
ComboBoxData->Strings->forEach(DoAddForCB, this);
int SelIndex = FindExactString(ComboBoxData->Selection, -1);
if ( SelIndex > -1 )
SetSelIndex(SelIndex);
SetWindowText(HWindow, ComboBoxData->Selection);
}
return sizeof(PTComboBoxData);
}
/* Returns the appropriate Windows message int identifier for the
function identified by the supplied AnId. Allows instances
of TComboBox to inherit many TListBox methods */
WORD TComboBox::GetMsgID(WORD AnId)
{
WORD MsgXlat[] = {CB_ADDSTRING, CB_INSERTSTRING, CB_DELETESTRING,
CB_RESETCONTENT, CB_GETCOUNT, CB_GETLBTEXT,
CB_GETLBTEXTLEN, CB_SELECTSTRING, CB_SETCURSEL,
CB_GETCURSEL, CB_FINDSTRING };
return MsgXlat[AnId];
}
/* Limits the amount of text that the user can enter in the combo box's
edit control to the value of TextLen minus 1. */
void TComboBox::SetupWindow()
{
TListBox::SetupWindow();
if ( TextLen != 0 )
SendMessage(HWindow, CB_LIMITTEXT, TextLen - 1, 0);
}
/* Reads an instance of TComboBox from the supplied ipstream. */
void *TComboBox::read(Ripstream is)
{
TListBox::read(is);
is >> TextLen;
return this;
}
/* Writes the TComboBox to the supplied opstream. */
void TComboBox::write(Ropstream os)
{
TListBox::write(os);
os << TextLen;
}
PTStreamable TComboBox::build()
{
return new TComboBox(streamableInit);
}
TStreamableClass RegComboBox("TComboBox", TComboBox::build,
__DELTA(TComboBox));
| [
"g.andrew.stone@gmail.com"
] | g.andrew.stone@gmail.com |
a59a0894923282754e15e0e0cb6ff105a07369db | 41311be8620b1e78bc9e74c327f0110ced0663f2 | /src/Scene/Model.h | c21d5aacb1b09fb6c29c2f44001f237fa7b53c86 | [
"MIT"
] | permissive | Keiiko/OpenNFS | be2c5b87175aa61da6f9e61d6452b80c9c8cb280 | 9824ca7cb9025346d7d88837ff94d8b06cfdc324 | refs/heads/master | 2020-06-19T05:23:20.645200 | 2019-07-12T13:48:42 | 2019-07-12T13:48:42 | 196,577,315 | 1 | 0 | MIT | 2019-07-12T13:48:43 | 2019-07-12T12:41:03 | C++ | UTF-8 | C++ | false | false | 1,274 | h | #pragma once
#define GLM_ENABLE_EXPERIMENTAL
#include <utility>
#include <vector>
#include <cstdlib>
#include <string>
#include <glm/glm.hpp>
#include <GL/glew.h>
#include <glm/gtc/matrix_transform.hpp>
#include <BulletDynamics/Dynamics/btRigidBody.h>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>
#include <LinearMath/btDefaultMotionState.h>
class Model {
public:
Model(std::string name, std::vector<glm::vec3> verts, std::vector<glm::vec2> uvs, std::vector<glm::vec3> norms, std::vector<unsigned int> indices, bool removeVertexIndexing, glm::vec3 center_position);
std::string m_name;
std::vector<glm::vec3> m_vertices;
std::vector<glm::vec3> m_normals;
std::vector<glm::vec2> m_uvs;
std::vector<unsigned int> m_vertex_indices;
void enable();
virtual bool genBuffers()= 0;
virtual void update()= 0;
virtual void destroy()= 0;
virtual void render()= 0;
/*--------- Model State --------*/
//UI
bool enabled = false;
//Rendering
glm::mat4 ModelMatrix = glm::mat4(1.0);
glm::mat4 RotationMatrix;
glm::mat4 TranslationMatrix;
glm::vec3 position;
glm::vec3 initialPosition;
glm::vec3 orientation_vec;
glm::quat orientation;
protected:
GLuint VertexArrayID;
}; | [
"AmrikSadhra@gmail.com"
] | AmrikSadhra@gmail.com |
977ddbd68825bcad1c475ca896a7076a25df1d34 | 9285512a4465f6a07fe9e10c11645e1f88d2ee67 | /Source/Cycle2/lexicalanalyser.cpp | 5c2b57efdaea9bcf92e72ad99b05ffbe13945425 | [] | no_license | robinl3680/CD_LAB_S7 | 5d28673c9e3feff6505ae679a12ecab6b6a168d7 | 918f2d080334a53294631c402e057e9cc9857180 | refs/heads/master | 2020-04-08T05:05:17.980821 | 2018-11-25T15:33:56 | 2018-11-25T15:33:56 | 159,045,369 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,163 | cpp | #include<iostream>
#include<string.h>
#include<bits/stdc++.h>
using namespace std;
int main()
{
ifstream input("input.txt");
char c;
vector<int> Numbers;
vector<char> Special;
vector<string> Op;
vector<string> Key;
vector<string> Id;
vector<string> Lit;
string str="";
string str1="";
while(input.get(c))
{
if(isdigit(c))
{
int n = c-48;
input.get(c);
while(isdigit(c))
{
n = n*10 + (c-48);
input.get(c);
}
Numbers.push_back(n);
}
if(isalpha(c))
{
char st[10];
int j = 0;
st[j++] = c;
input.get(c);
while(c == '_' || c == '$' || isalpha(c) || isdigit(c))
{
st[j++] = c;
input.get(c);
}
input.unget();
st[j++] = '\0';
if(strcmp("void",st) == 0 || strcmp("int",st) == 0 || strcmp("for",st) == 0)
Key.push_back(st);
else
Id.push_back(st);
}
else if(c == '=' || c == '*' || c =='&')
{
str="";
Op.push_back(str+c);
}
else if(c == '+')
{
str="";
input.get(c);
str+=c;
if(c == '+')
{
str+=c;
Op.push_back(str);
}
else
{
input.unget();
Op.push_back(str);
}
}
else if( c == '<')
{
str="";
input.get(c);
str+=c;
if(c == '=')
{
str+=c;
}
else
{
input.unget();
}
Op.push_back(str);
}
else if(c == '"')
{
str1="";
str1+=c;
while(input.get(c))
{
str1+=c;
if(c == '"')
break;
}
Lit.push_back(str1);
str1="";
}
else if(c == ' ' || c == '\t' || c == '\n')
{
continue;
}
else
Special.push_back(c);
}
cout<<endl;
cout<<"Numbers : "<<endl;
for(int i=0; i<Numbers.size(); i++)
{
cout<<Numbers[i]<<endl;
}
cout<<endl<<"Keywords : "<<endl;
for(int i=0; i<Key.size(); i++)
{
cout<<Key[i]<<endl;
}
cout<<endl<<"Literals : "<<endl;
for(int i=0; i<Lit.size(); i++)
{
cout<<Lit[i]<<endl;
}
cout<<endl<<"Identifiers : "<<endl;
for(int i=0; i<Id.size(); i++)
{
cout<<Id[i]<<endl;
}
cout<<endl<<"Special symbols : "<<endl;
for(int i=0; i<Special.size(); i++)
{
cout<<Special[i]<<endl;
}
cout<<endl<<"Operators : "<<endl;
for(int i=0; i<Op.size(); i++)
{
cout<<Op[i]<<endl;
}
return 0;
} | [
"robinl3680@gmail.com"
] | robinl3680@gmail.com |
d787080ac4641e40790aae1eb903d4d97bc0c0c8 | 15d847c02b6fddd5de60d08fa9818a6010bf083d | /rangedialog.cpp | 56652f5551d760e921d48bf9ddb30b0dcae4db6d | [] | no_license | b0no1/KBookOCR | 384a268b6b87005bc38d588d1550f134af21d93d | 11dace893699649a84ad6185921661f04f7f919e | refs/heads/master | 2021-01-12T08:10:31.834831 | 2011-08-01T08:28:02 | 2011-08-01T08:28:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,431 | cpp | #include "rangedialog.h"
#include "ui_rangedialog.h"
RangeDialog::RangeDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::RangeDialog)
{
ui->setupUi(this);
}
RangeDialog::~RangeDialog()
{
delete ui;
}
bool RangeDialog::clear()
{
ui->spinBox->setValue(0);
ui->spinBox_2->setValue(0);
}
int RangeDialog::getMaximum() const
{
return this->maximum;
}
bool RangeDialog::setMaximum(int max)
{
if (max >= 0)
{
this->maximum = max;
return true;
}
return false;
}
void RangeDialog::on_spinBox_valueChanged(int arg1)
{
if (ui->spinBox->value() > this->getMaximum())
ui->spinBox->setValue(arg1);
if (ui->spinBox->value() > ui->spinBox_2->value())
ui->spinBox_2->setValue(arg1);
}
bool RangeDialog::validData() const
{
if (ui->spinBox->value() <= ui->spinBox_2->value() &&
ui->spinBox_2->value() <= this->getMaximum())
return true;
return false;
}
void RangeDialog::on_buttonBox_accepted()
{
if (this->validData())
{
emit this->rangeReady(ui->spinBox->value(),
ui->spinBox_2->value());
}
this->close();
}
void RangeDialog::on_spinBox_2_valueChanged(int arg1)
{
if (ui->spinBox_2->value() > this->getMaximum())
ui->spinBox_2->setValue(this->getMaximum());
if (ui->spinBox_2->value() < ui->spinBox->value())
ui->spinBox->setValue(arg1);
}
| [
"my2you@ya.ru"
] | my2you@ya.ru |
4713264dbc51417bd5461c6dd8b37c0153cf4d88 | aa07db86d2abb542f04f3652dbff85c2d3aecdbd | /Chimera/StatusControl.h | 4506a4489cacffc40c771141277d45087afd5b25 | [] | no_license | KaufmanLabJILA/Chimera-Control-Master | 3604ed5be843388e113ffe47aee48b4d41c2c0bf | 8ae17f4f562ca899838f6fbea71fc431981efe98 | refs/heads/master | 2023-08-21T10:24:30.614463 | 2022-01-18T22:42:35 | 2022-01-18T22:42:35 | 105,817,176 | 6 | 3 | null | 2019-08-15T16:57:10 | 2017-10-04T20:52:16 | C++ | UTF-8 | C++ | false | false | 668 | h | #pragma once
#include "Control.h"
class StatusControl
{
public:
void initialize(POINT &topLeftCorner, CWnd* parent, int& id, unsigned int size, std::string headerText,
COLORREF textColor, cToolTips& tooltips, UINT clearId );
void setDefaultColor(COLORREF color);
void addStatusText(std::string text);
void addStatusText(std::string text, bool noColor);
void clear();
void setColor();
void setColor(COLORREF color);
void appendTimebar();
void rearrange(int width, int height, fontMap fonts);
private:
Control<CStatic> header;
Control<CRichEditCtrl> edit;
Control<CButton> clearButton;
COLORREF defaultColor;
}; | [
"KaufmanLabJILA@gmail.com"
] | KaufmanLabJILA@gmail.com |
dbcffbc1f1067997761ef7202caca74d969b164c | 09a4962b93c196f2f8a70c2384757142793612fd | /Dripdoctors/build/Android/Preview/Dripdoctors/app/src/main/include/Fuse.Reactive.ThreadWorker.h | 523ea00a9d148032842fd793881536f7991f3a7c | [] | no_license | JimmyRodriguez/apps-fuse | 169779ff2827a6e35be91d9ff17e0c444ba7f8cd | 14114328c3cea08c1fd766bf085bbf5a67f698ae | refs/heads/master | 2020-12-03T09:25:26.566750 | 2016-09-24T14:24:49 | 2016-09-24T14:24:49 | 65,154,944 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,206 | h | // This file was generated based on C:\ProgramData\Uno\Packages\Fuse.Reactive\0.32.14\$.uno.
// WARNING: Changes might be lost if you edit this file directly.
#pragma once
#include <Uno.IDisposable.h>
#include <Uno.Object.h>
#include <Uno.Threading.IDispatcher.h>
namespace g{namespace Fuse{namespace Reactive{namespace FuseJS{struct Builtins;}}}}
namespace g{namespace Fuse{namespace Reactive{struct Observable__Operation;}}}
namespace g{namespace Fuse{namespace Reactive{struct ThreadWorker;}}}
namespace g{namespace Fuse{namespace Reactive{struct ThreadWorker__Flag;}}}
namespace g{namespace Fuse{namespace Reactive{struct ValueMirror;}}}
namespace g{namespace Fuse{namespace Scripting{struct Array;}}}
namespace g{namespace Fuse{namespace Scripting{struct Context;}}}
namespace g{namespace Fuse{namespace Scripting{struct Function;}}}
namespace g{namespace Fuse{namespace Scripting{struct ScriptClass;}}}
namespace g{namespace Uno{namespace Collections{struct Dictionary;}}}
namespace g{namespace Uno{namespace Collections{struct List;}}}
namespace g{namespace Uno{namespace Threading{struct ConcurrentQueue;}}}
namespace g{namespace Uno{namespace Threading{struct Mutex;}}}
namespace g{namespace Uno{struct EventArgs;}}
namespace g{namespace Uno{struct Exception;}}
namespace g{namespace Uno{struct Float2;}}
namespace g{namespace Uno{struct Float3;}}
namespace g{namespace Uno{struct Float4;}}
namespace g{namespace Uno{struct Int2;}}
namespace g{namespace Uno{struct Int3;}}
namespace g{namespace Uno{struct Int4;}}
namespace g{
namespace Fuse{
namespace Reactive{
// internal partial sealed class ThreadWorker :2419
// {
struct ThreadWorker_type : uType
{
::g::Uno::IDisposable interface0;
::g::Uno::Threading::IDispatcher interface1;
};
ThreadWorker_type* ThreadWorker_typeof();
void ThreadWorker__ctor__fn(ThreadWorker* __this);
void ThreadWorker__CheckAndThrow_fn(ThreadWorker* __this);
void ThreadWorker__get_Context_fn(ThreadWorker* __this, ::g::Fuse::Scripting::Context** __retval);
void ThreadWorker__CreateContext_fn(uObject* ownerThread, ::g::Fuse::Scripting::Context** __retval);
void ThreadWorker__CreateMirror_fn(ThreadWorker* __this, uObject* obj, ::g::Fuse::Reactive::ValueMirror** __retval);
void ThreadWorker__Dispose_fn(ThreadWorker* __this);
void ThreadWorker__Enqueue_fn(ThreadWorker* __this, ::g::Fuse::Reactive::Observable__Operation* op);
void ThreadWorker__get_FuseJS_fn(ThreadWorker* __this, ::g::Fuse::Reactive::FuseJS::Builtins** __retval);
void ThreadWorker__GetClass_fn(ThreadWorker* __this, ::g::Fuse::Scripting::ScriptClass* sc, ::g::Fuse::Scripting::Function** __retval);
void ThreadWorker__Invoke_fn(ThreadWorker* __this, uDelegate* action);
void ThreadWorker__Invoke1_fn(ThreadWorker* __this, uType* __type, uDelegate* action, void* arg);
void ThreadWorker__get_IsJavaScriptVMReady_fn(ThreadWorker* __this, bool* __retval);
void ThreadWorker__set_IsJavaScriptVMReady_fn(ThreadWorker* __this, bool* value);
void ThreadWorker__New1_fn(ThreadWorker** __retval);
void ThreadWorker__OnClosing_fn(ThreadWorker* __this, uObject* sender, ::g::Uno::EventArgs* args);
void ThreadWorker__PostFlag_fn(ThreadWorker* __this, ThreadWorker__Flag** __retval);
void ThreadWorker__ProcessUIMessages_fn(ThreadWorker* __this);
void ThreadWorker__Reflect_fn(ThreadWorker* __this, uObject* obj, uObject** __retval);
void ThreadWorker__RegisterClass_fn(ThreadWorker* __this, ::g::Fuse::Scripting::ScriptClass* sc, ::g::Fuse::Scripting::Function** __retval);
void ThreadWorker__Run_fn(ThreadWorker* __this);
void ThreadWorker__RunInner_fn(ThreadWorker* __this);
void ThreadWorker__TakeMessages_fn(ThreadWorker* __this, ::g::Uno::Collections::List** __retval);
void ThreadWorker__ToArray_fn(::g::Uno::Float2* v, ::g::Fuse::Scripting::Array** __retval);
void ThreadWorker__ToArray1_fn(::g::Uno::Float3* v, ::g::Fuse::Scripting::Array** __retval);
void ThreadWorker__ToArray2_fn(::g::Uno::Float4* v, ::g::Fuse::Scripting::Array** __retval);
void ThreadWorker__ToArray3_fn(::g::Uno::Int2* v, ::g::Fuse::Scripting::Array** __retval);
void ThreadWorker__ToArray4_fn(::g::Uno::Int3* v, ::g::Fuse::Scripting::Array** __retval);
void ThreadWorker__ToArray5_fn(::g::Uno::Int4* v, ::g::Fuse::Scripting::Array** __retval);
void ThreadWorker__Unwrap_fn(ThreadWorker* __this, uObject* dc, uObject** __retval);
void ThreadWorker__Wrap_fn(uObject* obj, uObject** __retval);
void ThreadWorker__WrapScriptClass_fn(ThreadWorker* __this, uObject* obj, uObject** __retval);
struct ThreadWorker : uObject
{
static uSStrong< ::g::Fuse::Scripting::Context*> _context_;
static uSStrong< ::g::Fuse::Scripting::Context*>& _context() { return ThreadWorker_typeof()->Init(), _context_; }
uStrong< ::g::Uno::Threading::ConcurrentQueue*> _exceptionQueue;
static uSStrong< ::g::Fuse::Reactive::FuseJS::Builtins*> _fuseJS_;
static uSStrong< ::g::Fuse::Reactive::FuseJS::Builtins*>& _fuseJS() { return ThreadWorker_typeof()->Init(), _fuseJS_; }
bool _isReady;
uStrong< ::g::Uno::Threading::Mutex*> _isReadyMutex;
uStrong< ::g::Uno::Collections::List*> _messages;
uStrong< ::g::Uno::Threading::Mutex*> _messagesMutex;
uStrong< ::g::Uno::Threading::ConcurrentQueue*> _queue;
int _reflectionDepth;
uStrong< ::g::Uno::Collections::Dictionary*> _registeredClasses;
uStrong< ::g::Fuse::Scripting::Function*> _setSuperclass;
bool _subscribedForClosing;
bool _terminate;
uStrong< ::g::Uno::Threading::Mutex*> CanExecuteJavaScript;
uStrong< ::g::Uno::Threading::Mutex*> Pause;
void ctor_();
void CheckAndThrow();
::g::Fuse::Scripting::Context* Context();
::g::Fuse::Reactive::ValueMirror* CreateMirror(uObject* obj);
void Dispose();
void Enqueue(::g::Fuse::Reactive::Observable__Operation* op);
::g::Fuse::Reactive::FuseJS::Builtins* FuseJS();
::g::Fuse::Scripting::Function* GetClass(::g::Fuse::Scripting::ScriptClass* sc);
void Invoke(uDelegate* action);
template<class T>
void Invoke1(uType* __type, uDelegate* action, T arg) { ThreadWorker__Invoke1_fn(this, __type, action, uConstrain(__type->U(0), arg)); }
bool IsJavaScriptVMReady();
void IsJavaScriptVMReady(bool value);
void OnClosing(uObject* sender, ::g::Uno::EventArgs* args);
ThreadWorker__Flag* PostFlag();
void ProcessUIMessages();
uObject* Reflect(uObject* obj);
::g::Fuse::Scripting::Function* RegisterClass(::g::Fuse::Scripting::ScriptClass* sc);
void Run();
void RunInner();
::g::Uno::Collections::List* TakeMessages();
uObject* Unwrap(uObject* dc);
uObject* WrapScriptClass(uObject* obj);
static ::g::Fuse::Scripting::Context* CreateContext(uObject* ownerThread);
static ThreadWorker* New1();
static ::g::Fuse::Scripting::Array* ToArray(::g::Uno::Float2 v);
static ::g::Fuse::Scripting::Array* ToArray1(::g::Uno::Float3 v);
static ::g::Fuse::Scripting::Array* ToArray2(::g::Uno::Float4 v);
static ::g::Fuse::Scripting::Array* ToArray3(::g::Uno::Int2 v);
static ::g::Fuse::Scripting::Array* ToArray4(::g::Uno::Int3 v);
static ::g::Fuse::Scripting::Array* ToArray5(::g::Uno::Int4 v);
static uObject* Wrap(uObject* obj);
};
// }
}}} // ::g::Fuse::Reactive
| [
"jimmy_sidney@hotmail.es"
] | jimmy_sidney@hotmail.es |
96aa57078cc860c02aabe30f06a0631893a71b6e | 9c62af23e0a1faea5aaa8dd328ba1d82688823a5 | /rl/branches/persistence2/engine/rules/src/FallDownMovement.cpp | 773025a74418c6763b50f578d8a82ab57c4dd5bf | [
"ClArtistic",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-public-domain"
] | permissive | jacmoe/dsa-hl-svn | 55b05b6f28b0b8b216eac7b0f9eedf650d116f85 | 97798e1f54df9d5785fb206c7165cd011c611560 | refs/heads/master | 2021-04-22T12:07:43.389214 | 2009-11-27T22:01:03 | 2009-11-27T22:01:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,816 | cpp | /* This source file is part of Rastullahs Lockenpracht.
* Copyright (C) 2003-2008 Team Pantheon. http://www.team-pantheon.de
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the Clarified Artistic License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* Clarified Artistic License for more details.
*
* You should have received a copy of the Clarified Artistic License
* along with this program; if not you can get it here
* http://www.jpaulmorrison.com/fbp/artistic2.htm.
*/
#include "stdinc.h" //precompiled header
#include "FallDownMovement.h"
#include "DsaManager.h"
using namespace std;
using namespace Ogre;
namespace rl
{
FallDownMovement::FallDownMovement(CreatureController *creature) :
AbstractMovement(creature)
{
mAnim = mMovingCreature->getCreature()->getAnimation("fallen");
//mAnim = mMovingCreature->getCreature()->getAnimation("fallen_anfang");
//mAnim = mMovingCreature->getCreature()->getAnimation("fallen_landung_aufgefangen");
//mAnim = mMovingCreature->getCreature()->getAnimation("fallen_landung_verletzt");
}
void FallDownMovement::activate()
{
mVel = 0;
}
void FallDownMovement::deactivate()
{
std::ostringstream oss;
oss << "Fallen v: " << mVel << " ermittelte Hoehe: " << mVel*mVel/(2* fabs(PhysicsManager::getSingleton().getGravity().y));
int h = int(mVel*mVel/(2* fabs(PhysicsManager::getSingleton().getGravity().y)));
oss << " verwendete Hoehe: " << h << "m";
if( h < 6 && h > 0 ) // nicht in den Regeln, aber angenehmer, bei gelunger GE-Probe noch aufgefangen
{
int probe = mMovingCreature->getCreature()->doEigenschaftsprobe("GE", 2*h-6);
if( probe == RESULT_PATZER )
{
h++;
oss << " GE-Patzer!";
}
else if( probe >= 0 )
{
h = 0;
oss << " Nochmal geschickt gelandet!";
}
}
if( h > 0 )
{
std::multiset<int> wuerfel;
for(int i = 0; i < h; i++)
wuerfel.insert( DsaManager::getSingleton().rollD6() );
int probenErschwernis = h;
if( probenErschwernis > 10 )
probenErschwernis = 10;
int taw = 0;
if( mMovingCreature->getCreature()->hasTalent("K�rperbeherrschung") )
{
taw = mMovingCreature->getCreature()->doTalentprobe("K�rperbeherrschung", probenErschwernis);
}
int abgefangenerSchaden = 0;
for( int i = 0; i < taw; i++)
{
if( wuerfel.size() <= 0 )
break;
abgefangenerSchaden += *(--(wuerfel.end()));
wuerfel.erase(--(wuerfel.end()));
}
int sum = 0;
for( std::multiset<int>::iterator it = wuerfel.begin(); it != wuerfel.end(); it++)
sum += *it;
mMovingCreature->getCreature()->damageLe(sum, Creature::LEDAMAGE_TP_A);
oss << " Schaden: " << sum << " abgefangener Schaden: " << abgefangenerSchaden;
}
LOG_MESSAGE(Logger::RULES, oss.str());
}
bool FallDownMovement::calculateBaseVelocity(Real &velocity)
{
velocity = 0.0f;
return isPossible();
}
bool FallDownMovement::isPossible() const
{
return
mMovingCreature->getAbstractLocation() == CreatureController::AL_AIRBORNE
&& !(mMovingCreature->getCreature()->getLifeState() & Effect::LS_IMMOBILE);
}
void FallDownMovement::calculateForceAndTorque(Vector3 &force, Vector3 &torque, Real timestep)
{
}
bool FallDownMovement::run(Ogre::Real elapsedTime, Ogre::Vector3 direction, Ogre::Vector3 rotation)
{
mVel = max(-mMovingCreature->getVelocity().y,mVel);
mMovingCreature->setAnimation(mAnim.first, mAnim.second, 0);
return true;
}
void FallDownMovement::applyAuChanges(Ogre::Real elapsedTime)
{
}
bool FallDownMovement::isDirectionPossible(Ogre::Vector3 &direction) const
{
direction = Vector3::ZERO;
return false;
}
bool FallDownMovement::isRotationPossible(Ogre::Vector3 &rotation) const
{
rotation = Vector3::ZERO;
return false;
}
}
| [
"timm@4c79e8ff-cfd4-0310-af45-a38c79f83013"
] | timm@4c79e8ff-cfd4-0310-af45-a38c79f83013 |
5f572dccd4fa4fb4772545a26552bbc286263060 | 5b32537f9f1e89724bde0b436a061d21a783796b | /skia/src/animator/SkDrawGroup.h | 9f555cc1b7c81c9385320c5e3b6bda731d614f33 | [] | no_license | erikalxq/RockUI | 1b73d0a2f8e5062695ab435882b65ba17c3a1c54 | 7e91d0c8e9a111b5d8a4ff4870a9b7eb123b033e | refs/heads/master | 2020-04-09T04:13:48.180851 | 2016-09-14T01:37:13 | 2016-09-14T01:37:13 | 68,161,733 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,491 | h |
/*
* Copyright 2006 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkDrawGroup_DEFINED
#define SkDrawGroup_DEFINED
#include "SkADrawable.h"
#include "SkIntArray.h"
#include "SkMemberInfo.h"
class SkGroup : public SkADrawable { //interface for schema element <g>
public:
DECLARE_MEMBER_INFO(Group);
SkGroup();
virtual ~SkGroup();
virtual bool addChild(SkAnimateMaker& , SkDisplayable* child) SK_OVERRIDE;
virtual bool contains(SkDisplayable* ) SK_OVERRIDE;
SkGroup* copy();
SkBool copySet(int index);
virtual SkDisplayable* deepCopy(SkAnimateMaker* ) SK_OVERRIDE;
virtual bool doEvent(SkDisplayEvent::Kind , SkEventState* state ) SK_OVERRIDE;
virtual bool draw(SkAnimateMaker& ) SK_OVERRIDE;
#ifdef SK_DUMP_ENABLED
virtual void dump(SkAnimateMaker* ) SK_OVERRIDE;
virtual void dumpDrawables(SkAnimateMaker* );
virtual void dumpEvents() SK_OVERRIDE;
#endif
int findGroup(SkADrawable* drawable, SkTDDrawableArray** list,
SkGroup** parent, SkGroup** found, SkTDDrawableArray** grandList);
virtual bool enable(SkAnimateMaker& ) SK_OVERRIDE;
SkTDDrawableArray* getChildren() { return &fChildren; }
SkGroup* getOriginal() { return fOriginal; }
virtual bool hasEnable() const SK_OVERRIDE;
virtual void initialize() SK_OVERRIDE;
SkBool isACopy() { return fOriginal != NULL; }
void markCopyClear(int index);
void markCopySet(int index);
void markCopySize(int index);
bool markedForDelete(int index) const { return (fCopies[index >> 5] & 1 << (index & 0x1f)) == 0; }
void reset();
bool resolveIDs(SkAnimateMaker& maker, SkDisplayable* original, SkApply* ) SK_OVERRIDE;
virtual void setSteps(int steps) SK_OVERRIDE;
#ifdef SK_DEBUG
virtual void validate() SK_OVERRIDE;
#endif
protected:
bool ifCondition(SkAnimateMaker& maker, SkADrawable* drawable,
SkString& conditionString);
SkString condition;
SkString enableCondition;
SkTDDrawableArray fChildren;
SkTDDrawableArray* fParentList;
SkTDIntArray fCopies;
SkGroup* fOriginal;
private:
typedef SkADrawable INHERITED;
};
class SkSave: public SkGroup {
DECLARE_MEMBER_INFO(Save);
virtual bool draw(SkAnimateMaker& ) SK_OVERRIDE;
private:
typedef SkGroup INHERITED;
};
#endif // SkDrawGroup_DEFINED
| [
"erika1@126.com"
] | erika1@126.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.