~ubuntu-branches/ubuntu/utopic/wxwidgets2.8/utopic-proposed : revision 47

1

/* ----------------------------------------------------------------------------

2

* This file was automatically generated by SWIG (http://www.swig.org).

3

* Version 1.3.29

4

*

5

* This file is not intended to be easily readable and contains a number of

6

* coding conventions designed to improve portability and efficiency. Do not make

7

* changes to this file unless you know what you are doing--modify the SWIG

8

* interface file instead.

9

* ----------------------------------------------------------------------------- */

10

11

#define SWIGPYTHON

12

#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

13

14

#ifdef __cplusplus

15

template<class T> class SwigValueWrapper {

16

T *tt;

17

public:

18

SwigValueWrapper() : tt(0) { }

19

SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }

20

SwigValueWrapper(const T& t) : tt(new T(t)) { }

21

~SwigValueWrapper() { delete tt; }

22

SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }

23

operator T&() const { return *tt; }

24

T *operator&() { return tt; }

25

private:

26

SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);

27

};

28

#endif

29

30

/* -----------------------------------------------------------------------------

31

* This section contains generic SWIG labels for method/variable

32

* declarations/attributes, and other compiler dependent labels.

33

* ----------------------------------------------------------------------------- */

34

35

/* template workaround for compilers that cannot correctly implement the C++ standard */

36

#ifndef SWIGTEMPLATEDISAMBIGUATOR

37

# if defined(__SUNPRO_CC)

38

# if (__SUNPRO_CC <= 0x560)

39

# define SWIGTEMPLATEDISAMBIGUATOR template

40

# else

41

# define SWIGTEMPLATEDISAMBIGUATOR

42

# endif

43

# else

44

# define SWIGTEMPLATEDISAMBIGUATOR

45

# endif

46

#endif

47

48

/* inline attribute */

49

#ifndef SWIGINLINE

50

# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))

51

# define SWIGINLINE inline

52

# else

53

# define SWIGINLINE

54

# endif

55

#endif

56

57

/* attribute recognised by some compilers to avoid 'unused' warnings */

58

#ifndef SWIGUNUSED

59

# if defined(__GNUC__)

60

# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))

61

# define SWIGUNUSED __attribute__ ((__unused__))

62

# else

63

# define SWIGUNUSED

64

# endif

65

# elif defined(__ICC)

66

# define SWIGUNUSED __attribute__ ((__unused__))

67

# else

68

# define SWIGUNUSED

69

# endif

70

#endif

71

72

#ifndef SWIGUNUSEDPARM

73

# ifdef __cplusplus

74

# define SWIGUNUSEDPARM(p)

75

# else

76

# define SWIGUNUSEDPARM(p) p SWIGUNUSED

77

# endif

78

#endif

79

80

/* internal SWIG method */

81

#ifndef SWIGINTERN

82

# define SWIGINTERN static SWIGUNUSED

83

#endif

84

85

/* internal inline SWIG method */

86

#ifndef SWIGINTERNINLINE

87

# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE

88

#endif

89

90

/* exporting methods */

91

#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)

92

# ifndef GCC_HASCLASSVISIBILITY

93

# define GCC_HASCLASSVISIBILITY

94

# endif

95

#endif

96

97

#ifndef SWIGEXPORT

98

# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

99

# if defined(STATIC_LINKED)

100

# define SWIGEXPORT

101

# else

102

# define SWIGEXPORT __declspec(dllexport)

103

# endif

104

# else

105

# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)

106

# define SWIGEXPORT __attribute__ ((visibility("default")))

107

# else

108

# define SWIGEXPORT

109

# endif

110

# endif

111

#endif

112

113

/* calling conventions for Windows */

114

#ifndef SWIGSTDCALL

115

# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

116

# define SWIGSTDCALL __stdcall

117

# else

118

# define SWIGSTDCALL

119

# endif

120

#endif

121

122

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */

123

#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)

124

# define _CRT_SECURE_NO_DEPRECATE

125

#endif

126

127

128

/* Python.h has to appear first */

129

#include <Python.h>

130

131

/* -----------------------------------------------------------------------------

132

* swigrun.swg

133

*

134

* This file contains generic CAPI SWIG runtime support for pointer

135

* type checking.

136

* ----------------------------------------------------------------------------- */

137

138

/* This should only be incremented when either the layout of swig_type_info changes,

139

or for whatever reason, the runtime changes incompatibly */

140

#define SWIG_RUNTIME_VERSION "2"

141

142

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */

143

#ifdef SWIG_TYPE_TABLE

144

# define SWIG_QUOTE_STRING(x) #x

145

# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)

146

# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)

147

#else

148

# define SWIG_TYPE_TABLE_NAME

149

#endif

150

151

/*

152

You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for

153

creating a static or dynamic library from the swig runtime code.

154

In 99.9% of the cases, swig just needs to declare them as 'static'.

155

156

But only do this if is strictly necessary, ie, if you have problems

157

with your compiler or so.

158

*/

159

160

#ifndef SWIGRUNTIME

161

# define SWIGRUNTIME SWIGINTERN

162

#endif

163

164

#ifndef SWIGRUNTIMEINLINE

165

# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE

166

#endif

167

168

/* Generic buffer size */

169

#ifndef SWIG_BUFFER_SIZE

170

# define SWIG_BUFFER_SIZE 1024

171

#endif

172

173

/* Flags for pointer conversions */

174

#define SWIG_POINTER_DISOWN 0x1

175

176

/* Flags for new pointer objects */

177

#define SWIG_POINTER_OWN 0x1

178

179

180

/*

181

Flags/methods for returning states.

182

183

The swig conversion methods, as ConvertPtr, return and integer

184

that tells if the conversion was successful or not. And if not,

185

an error code can be returned (see swigerrors.swg for the codes).

186

187

Use the following macros/flags to set or process the returning

188

states.

189

190

In old swig versions, you usually write code as:

191

192

if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {

193

// success code

194

} else {

195

//fail code

196

}

197

198

Now you can be more explicit as:

199

200

int res = SWIG_ConvertPtr(obj,vptr,ty.flags);

201

if (SWIG_IsOK(res)) {

202

// success code

203

} else {

204

// fail code

205

}

206

207

that seems to be the same, but now you can also do

208

209

Type *ptr;

210

int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);

211

if (SWIG_IsOK(res)) {

212

// success code

213

if (SWIG_IsNewObj(res) {

214

...

215

delete *ptr;

216

} else {

217

...

218

}

219

} else {

220

// fail code

221

}

222

223

I.e., now SWIG_ConvertPtr can return new objects and you can

224

identify the case and take care of the deallocation. Of course that

225

requires also to SWIG_ConvertPtr to return new result values, as

226

227

int SWIG_ConvertPtr(obj, ptr,...) {

228

if (<obj is ok>) {

229

if (<need new object>) {

230

*ptr = <ptr to new allocated object>;

231

return SWIG_NEWOBJ;

232

} else {

233

*ptr = <ptr to old object>;

234

return SWIG_OLDOBJ;

235

}

236

} else {

237

return SWIG_BADOBJ;

238

}

239

}

240

241

Of course, returning the plain '0(success)/-1(fail)' still works, but you can be

242

more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the

243

swig errors code.

244

245

Finally, if the SWIG_CASTRANK_MODE is enabled, the result code

246

allows to return the 'cast rank', for example, if you have this

247

248

int food(double)

249

int fooi(int);

250

251

and you call

252

253

food(1) // cast rank '1' (1 -> 1.0)

254

fooi(1) // cast rank '0'

255

256

just use the SWIG_AddCast()/SWIG_CheckState()

257

258

259

*/

260

#define SWIG_OK (0)

261

#define SWIG_ERROR (-1)

262

#define SWIG_IsOK(r) (r >= 0)

263

#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)

264

265

/* The CastRankLimit says how many bits are used for the cast rank */

266

#define SWIG_CASTRANKLIMIT (1 << 8)

267

/* The NewMask denotes the object was created (using new/malloc) */

268

#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)

269

/* The TmpMask is for in/out typemaps that use temporal objects */

270

#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)

271

/* Simple returning values */

272

#define SWIG_BADOBJ (SWIG_ERROR)

273

#define SWIG_OLDOBJ (SWIG_OK)

274

#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)

275

#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)

276

/* Check, add and del mask methods */

277

#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)

278

#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)

279

#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))

280

#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)

281

#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)

282

#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

283

284

285

/* Cast-Rank Mode */

286

#if defined(SWIG_CASTRANK_MODE)

287

# ifndef SWIG_TypeRank

288

# define SWIG_TypeRank unsigned long

289

# endif

290

# ifndef SWIG_MAXCASTRANK /* Default cast allowed */

291

# define SWIG_MAXCASTRANK (2)

292

# endif

293

# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)

294

# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)

295

SWIGINTERNINLINE int SWIG_AddCast(int r) {

296

return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;

297

}

298

SWIGINTERNINLINE int SWIG_CheckState(int r) {

299

return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;

300

}

301

#else /* no cast-rank mode */

302

# define SWIG_AddCast

303

# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)

304

#endif

305

306

307

308

309

#include <string.h>

310

311

#ifdef __cplusplus

312

extern "C" {

313

#endif

314

315

typedef void *(*swig_converter_func)(void *);

316

typedef struct swig_type_info *(*swig_dycast_func)(void **);

317

318

/* Structure to store inforomation on one type */

319

typedef struct swig_type_info {

320

const char *name; /* mangled name of this type */

321

const char *str; /* human readable name of this type */

322

swig_dycast_func dcast; /* dynamic cast function down a hierarchy */

323

struct swig_cast_info *cast; /* linked list of types that can cast into this type */

324

void *clientdata; /* language specific type data */

325

int owndata; /* flag if the structure owns the clientdata */

326

} swig_type_info;

327

328

/* Structure to store a type and conversion function used for casting */

329

typedef struct swig_cast_info {

330

swig_type_info *type; /* pointer to type that is equivalent to this type */

331

swig_converter_func converter; /* function to cast the void pointers */

332

struct swig_cast_info *next; /* pointer to next cast in linked list */

333

struct swig_cast_info *prev; /* pointer to the previous cast */

334

} swig_cast_info;

335

336

/* Structure used to store module information

337

* Each module generates one structure like this, and the runtime collects

338

* all of these structures and stores them in a circularly linked list.*/

339

typedef struct swig_module_info {

340

swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */

341

size_t size; /* Number of types in this module */

342

struct swig_module_info *next; /* Pointer to next element in circularly linked list */

343

swig_type_info **type_initial; /* Array of initially generated type structures */

344

swig_cast_info **cast_initial; /* Array of initially generated casting structures */

345

void *clientdata; /* Language specific module data */

346

} swig_module_info;

347

348

/*

349

Compare two type names skipping the space characters, therefore

350

"char*" == "char *" and "Class<int>" == "Class<int >", etc.

351

352

Return 0 when the two name types are equivalent, as in

353

strncmp, but skipping ' '.

354

*/

355

SWIGRUNTIME int

356

SWIG_TypeNameComp(const char *f1, const char *l1,

357

const char *f2, const char *l2) {

358

for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {

359

while ((*f1 == ' ') && (f1 != l1)) ++f1;

360

while ((*f2 == ' ') && (f2 != l2)) ++f2;

361

if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;

362

}

363

return (l1 - f1) - (l2 - f2);

364

}

365

366

/*

367

Check type equivalence in a name list like <name1>|<name2>|...

368

Return 0 if not equal, 1 if equal

369

*/

370

SWIGRUNTIME int

371

SWIG_TypeEquiv(const char *nb, const char *tb) {

372

int equiv = 0;

373

const char* te = tb + strlen(tb);

374

const char* ne = nb;

375

while (!equiv && *ne) {

376

for (nb = ne; *ne; ++ne) {

377

if (*ne == '|') break;

378

}

379

equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;

380

if (*ne) ++ne;

381

}

382

return equiv;

383

}

384

385

/*

386

Check type equivalence in a name list like <name1>|<name2>|...

387

Return 0 if equal, -1 if nb < tb, 1 if nb > tb

388

*/

389

SWIGRUNTIME int

390

SWIG_TypeCompare(const char *nb, const char *tb) {

391

int equiv = 0;

392

const char* te = tb + strlen(tb);

393

const char* ne = nb;

394

while (!equiv && *ne) {

395

for (nb = ne; *ne; ++ne) {

396

if (*ne == '|') break;

397

}

398

equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;

399

if (*ne) ++ne;

400

}

401

return equiv;

402

}

403

404

405

/* think of this as a c++ template<> or a scheme macro */

406

#define SWIG_TypeCheck_Template(comparison, ty) \

407

if (ty) { \

408

swig_cast_info *iter = ty->cast; \

409

while (iter) { \

410

if (comparison) { \

411

if (iter == ty->cast) return iter; \

412

/* Move iter to the top of the linked list */ \

413

iter->prev->next = iter->next; \

414

if (iter->next) \

415

iter->next->prev = iter->prev; \

416

iter->next = ty->cast; \

417

iter->prev = 0; \

418

if (ty->cast) ty->cast->prev = iter; \

419

ty->cast = iter; \

420

return iter; \

421

} \

422

iter = iter->next; \

423

} \

424

} \

425

return 0

426

427

/*

428

Check the typename

429

*/

430

SWIGRUNTIME swig_cast_info *

431

SWIG_TypeCheck(const char *c, swig_type_info *ty) {

432

SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);

433

}

434

435

/* Same as previous function, except strcmp is replaced with a pointer comparison */

436

SWIGRUNTIME swig_cast_info *

437

SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {

438

SWIG_TypeCheck_Template(iter->type == from, into);

439

}

440

441

/*

442

Cast a pointer up an inheritance hierarchy

443

*/

444

SWIGRUNTIMEINLINE void *

445

SWIG_TypeCast(swig_cast_info *ty, void *ptr) {

446

return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);

447

}

448

449

/*

450

Dynamic pointer casting. Down an inheritance hierarchy

451

*/

452

SWIGRUNTIME swig_type_info *

453

SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {

454

swig_type_info *lastty = ty;

455

if (!ty || !ty->dcast) return ty;

456

while (ty && (ty->dcast)) {

457

ty = (*ty->dcast)(ptr);

458

if (ty) lastty = ty;

459

}

460

return lastty;

461

}

462

463

/*

464

Return the name associated with this type

465

*/

466

SWIGRUNTIMEINLINE const char *

467

SWIG_TypeName(const swig_type_info *ty) {

468

return ty->name;

469

}

470

471

/*

472

Return the pretty name associated with this type,

473

that is an unmangled type name in a form presentable to the user.

474

*/

475

SWIGRUNTIME const char *

476

SWIG_TypePrettyName(const swig_type_info *type) {

477

/* The "str" field contains the equivalent pretty names of the

478

type, separated by vertical-bar characters. We choose

479

to print the last name, as it is often (?) the most

480

specific. */

481

if (!type) return NULL;

482

if (type->str != NULL) {

483

const char *last_name = type->str;

484

const char *s;

485

for (s = type->str; *s; s++)

486

if (*s == '|') last_name = s+1;

487

return last_name;

488

}

489

else

490

return type->name;

491

}

492

493

/*

494

Set the clientdata field for a type

495

*/

496

SWIGRUNTIME void

497

SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {

498

swig_cast_info *cast = ti->cast;

499

/* if (ti->clientdata == clientdata) return; */

500

ti->clientdata = clientdata;

501

502

while (cast) {

503

if (!cast->converter) {

504

swig_type_info *tc = cast->type;

505

if (!tc->clientdata) {

506

SWIG_TypeClientData(tc, clientdata);

507

}

508

}

509

cast = cast->next;

510

}

511

}

512

SWIGRUNTIME void

513

SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {

514

SWIG_TypeClientData(ti, clientdata);

515

ti->owndata = 1;

516

}

517

518

/*

519

Search for a swig_type_info structure only by mangled name

520

Search is a O(log #types)

521

522

We start searching at module start, and finish searching when start == end.

523

Note: if start == end at the beginning of the function, we go all the way around

524

the circular list.

525

*/

526

SWIGRUNTIME swig_type_info *

527

SWIG_MangledTypeQueryModule(swig_module_info *start,

528

swig_module_info *end,

529

const char *name) {

530

swig_module_info *iter = start;

531

do {

532

if (iter->size) {

533

register size_t l = 0;

534

register size_t r = iter->size - 1;

535

do {

536

/* since l+r >= 0, we can (>> 1) instead (/ 2) */

537

register size_t i = (l + r) >> 1;

538

const char *iname = iter->types[i]->name;

539

if (iname) {

540

register int compare = strcmp(name, iname);

541

if (compare == 0) {

542

return iter->types[i];

543

} else if (compare < 0) {

544

if (i) {

545

r = i - 1;

546

} else {

547

break;

548

}

549

} else if (compare > 0) {

550

l = i + 1;

551

}

552

} else {

553

break; /* should never happen */

554

}

555

} while (l <= r);

556

}

557

iter = iter->next;

558

} while (iter != end);

559

return 0;

560

}

561

562

/*

563

Search for a swig_type_info structure for either a mangled name or a human readable name.

564

It first searches the mangled names of the types, which is a O(log #types)

565

If a type is not found it then searches the human readable names, which is O(#types).

566

567

We start searching at module start, and finish searching when start == end.

568

Note: if start == end at the beginning of the function, we go all the way around

569

the circular list.

570

*/

571

SWIGRUNTIME swig_type_info *

572

SWIG_TypeQueryModule(swig_module_info *start,

573

swig_module_info *end,

574

const char *name) {

575

/* STEP 1: Search the name field using binary search */

576

swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);

577

if (ret) {

578

return ret;

579

} else {

580

/* STEP 2: If the type hasn't been found, do a complete search

581

of the str field (the human readable name) */

582

swig_module_info *iter = start;

583

do {

584

register size_t i = 0;

585

for (; i < iter->size; ++i) {

586

if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))

587

return iter->types[i];

588

}

589

iter = iter->next;

590

} while (iter != end);

591

}

592

593

/* neither found a match */

594

return 0;

595

}

596

597

/*

598

Pack binary data into a string

599

*/

600

SWIGRUNTIME char *

601

SWIG_PackData(char *c, void *ptr, size_t sz) {

602

static const char hex[17] = "0123456789abcdef";

603

register const unsigned char *u = (unsigned char *) ptr;

604

register const unsigned char *eu = u + sz;

605

for (; u != eu; ++u) {

606

register unsigned char uu = *u;

607

*(c++) = hex[(uu & 0xf0) >> 4];

608

*(c++) = hex[uu & 0xf];

609

}

610

return c;

611

}

612

613

/*

614

Unpack binary data from a string

615

*/

616

SWIGRUNTIME const char *

617

SWIG_UnpackData(const char *c, void *ptr, size_t sz) {

618

register unsigned char *u = (unsigned char *) ptr;

619

register const unsigned char *eu = u + sz;

620

for (; u != eu; ++u) {

621

register char d = *(c++);

622

register unsigned char uu;

623

if ((d >= '0') && (d <= '9'))

624

uu = ((d - '0') << 4);

625

else if ((d >= 'a') && (d <= 'f'))

626

uu = ((d - ('a'-10)) << 4);

627

else

628

return (char *) 0;

629

d = *(c++);

630

if ((d >= '0') && (d <= '9'))

631

uu |= (d - '0');

632

else if ((d >= 'a') && (d <= 'f'))

633

uu |= (d - ('a'-10));

634

else

635

return (char *) 0;

636

*u = uu;

637

}

638

return c;

639

}

640

641

/*

642

Pack 'void *' into a string buffer.

643

*/

644

SWIGRUNTIME char *

645

SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {

646

char *r = buff;

647

if ((2*sizeof(void *) + 2) > bsz) return 0;

648

*(r++) = '_';

649

r = SWIG_PackData(r,&ptr,sizeof(void *));

650

if (strlen(name) + 1 > (bsz - (r - buff))) return 0;

651

strcpy(r,name);

652

return buff;

653

}

654

655

SWIGRUNTIME const char *

656

SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {

657

if (*c != '_') {

658

if (strcmp(c,"NULL") == 0) {

659

*ptr = (void *) 0;

660

return name;

661

} else {

662

return 0;

663

}

664

}

665

return SWIG_UnpackData(++c,ptr,sizeof(void *));

666

}

667

668

SWIGRUNTIME char *

669

SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {

670

char *r = buff;

671

size_t lname = (name ? strlen(name) : 0);

672

if ((2*sz + 2 + lname) > bsz) return 0;

673

*(r++) = '_';

674

r = SWIG_PackData(r,ptr,sz);

675

if (lname) {

676

strncpy(r,name,lname+1);

677

} else {

678

*r = 0;

679

}

680

return buff;

681

}

682

683

SWIGRUNTIME const char *

684

SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {

685

if (*c != '_') {

686

if (strcmp(c,"NULL") == 0) {

687

memset(ptr,0,sz);

688

return name;

689

} else {

690

return 0;

691

}

692

}

693

return SWIG_UnpackData(++c,ptr,sz);

694

}

695

696

#ifdef __cplusplus

697

}

698

#endif

699

700

/* Errors in SWIG */

701

#define SWIG_UnknownError -1

702

#define SWIG_IOError -2

703

#define SWIG_RuntimeError -3

704

#define SWIG_IndexError -4

705

#define SWIG_TypeError -5

706

#define SWIG_DivisionByZero -6

707

#define SWIG_OverflowError -7

708

#define SWIG_SyntaxError -8

709

#define SWIG_ValueError -9

710

#define SWIG_SystemError -10

711

#define SWIG_AttributeError -11

712

#define SWIG_MemoryError -12

713

#define SWIG_NullReferenceError -13

714

715

716

717

/* Python.h has to appear first */

718

#include <Python.h>

719

720

/* Add PyOS_snprintf for old Pythons */

721

#if PY_VERSION_HEX < 0x02020000

722

# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)

723

# define PyOS_snprintf _snprintf

724

# else

725

# define PyOS_snprintf snprintf

726

# endif

727

#endif

728

729

/* A crude PyString_FromFormat implementation for old Pythons */

730

#if PY_VERSION_HEX < 0x02020000

731

732

#ifndef SWIG_PYBUFFER_SIZE

733

# define SWIG_PYBUFFER_SIZE 1024

734

#endif

735

736

static PyObject *

737

PyString_FromFormat(const char *fmt, ...) {

738

va_list ap;

739

char buf[SWIG_PYBUFFER_SIZE * 2];

740

int res;

741

va_start(ap, fmt);

742

res = vsnprintf(buf, sizeof(buf), fmt, ap);

743

va_end(ap);

744

return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);

745

}

746

#endif

747

748

/* Add PyObject_Del for old Pythons */

749

#if PY_VERSION_HEX < 0x01060000

750

# define PyObject_Del(op) PyMem_DEL((op))

751

#endif

752

#ifndef PyObject_DEL

753

# define PyObject_DEL PyObject_Del

754

#endif

755

756

/* A crude PyExc_StopIteration exception for old Pythons */

757

#if PY_VERSION_HEX < 0x02020000

758

# ifndef PyExc_StopIteration

759

# define PyExc_StopIteration PyExc_RuntimeError

760

# endif

761

# ifndef PyObject_GenericGetAttr

762

# define PyObject_GenericGetAttr 0

763

# endif

764

#endif

765

/* Py_NotImplemented is defined in 2.1 and up. */

766

#if PY_VERSION_HEX < 0x02010000

767

# ifndef Py_NotImplemented

768

# define Py_NotImplemented PyExc_RuntimeError

769

# endif

770

#endif

771

772

773

/* A crude PyString_AsStringAndSize implementation for old Pythons */

774

#if PY_VERSION_HEX < 0x02010000

775

# ifndef PyString_AsStringAndSize

776

# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}

777

# endif

778

#endif

779

780

/* PySequence_Size for old Pythons */

781

#if PY_VERSION_HEX < 0x02000000

782

# ifndef PySequence_Size

783

# define PySequence_Size PySequence_Length

784

# endif

785

#endif

786

787

788

/* PyBool_FromLong for old Pythons */

789

#if PY_VERSION_HEX < 0x02030000

790

static

791

PyObject *PyBool_FromLong(long ok)

792

{

793

PyObject *result = ok ? Py_True : Py_False;

794

Py_INCREF(result);

795

return result;

796

}

797

#endif

798

799

800

/* -----------------------------------------------------------------------------

801

* error manipulation

802

* ----------------------------------------------------------------------------- */

803

804

SWIGRUNTIME PyObject*

805

SWIG_Python_ErrorType(int code) {

806

PyObject* type = 0;

807

switch(code) {

808

case SWIG_MemoryError:

809

type = PyExc_MemoryError;

810

break;

811

case SWIG_IOError:

812

type = PyExc_IOError;

813

break;

814

case SWIG_RuntimeError:

815

type = PyExc_RuntimeError;

816

break;

817

case SWIG_IndexError:

818

type = PyExc_IndexError;

819

break;

820

case SWIG_TypeError:

821

type = PyExc_TypeError;

822

break;

823

case SWIG_DivisionByZero:

824

type = PyExc_ZeroDivisionError;

825

break;

826

case SWIG_OverflowError:

827

type = PyExc_OverflowError;

828

break;

829

case SWIG_SyntaxError:

830

type = PyExc_SyntaxError;

831

break;

832

case SWIG_ValueError:

833

type = PyExc_ValueError;

834

break;

835

case SWIG_SystemError:

836

type = PyExc_SystemError;

837

break;

838

case SWIG_AttributeError:

839

type = PyExc_AttributeError;

840

break;

841

default:

842

type = PyExc_RuntimeError;

843

}

844

return type;

845

}

846

847

848

SWIGRUNTIME void

849

SWIG_Python_AddErrorMsg(const char* mesg)

850

{

851

PyObject *type = 0;

852

PyObject *value = 0;

853

PyObject *traceback = 0;

854

855

if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);

856

if (value) {

857

PyObject *old_str = PyObject_Str(value);

858

PyErr_Clear();

859

Py_XINCREF(type);

860

PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);

861

Py_DECREF(old_str);

862

Py_DECREF(value);

863

} else {

864

PyErr_Format(PyExc_RuntimeError, mesg);

865

}

866

}

867

868

869

870

#if defined(SWIG_PYTHON_NO_THREADS)

871

# if defined(SWIG_PYTHON_THREADS)

872

# undef SWIG_PYTHON_THREADS

873

# endif

874

#endif

875

#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */

876

# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)

877

# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */

878

# define SWIG_PYTHON_USE_GIL

879

# endif

880

# endif

881

# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */

882

# ifndef SWIG_PYTHON_INITIALIZE_THREADS

883

# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()

884

# endif

885

# ifdef __cplusplus /* C++ code */

886

class SWIG_Python_Thread_Block {

887

bool status;

888

PyGILState_STATE state;

889

public:

890

void end() { if (status) { PyGILState_Release(state); status = false;} }

891

SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}

892

~SWIG_Python_Thread_Block() { end(); }

893

};

894

class SWIG_Python_Thread_Allow {

895

bool status;

896

PyThreadState *save;

897

public:

898

void end() { if (status) { PyEval_RestoreThread(save); status = false; }}

899

SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}

900

~SWIG_Python_Thread_Allow() { end(); }

901

};

902

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block

903

# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()

904

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow

905

# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()

906

# else /* C code */

907

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()

908

# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)

909

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()

910

# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)

911

# endif

912

# else /* Old thread way, not implemented, user must provide it */

913

# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)

914

# define SWIG_PYTHON_INITIALIZE_THREADS

915

# endif

916

# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)

917

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK

918

# endif

919

# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)

920

# define SWIG_PYTHON_THREAD_END_BLOCK

921

# endif

922

# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)

923

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW

924

# endif

925

# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)

926

# define SWIG_PYTHON_THREAD_END_ALLOW

927

# endif

928

# endif

929

#else /* No thread support */

930

# define SWIG_PYTHON_INITIALIZE_THREADS

931

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK

932

# define SWIG_PYTHON_THREAD_END_BLOCK

933

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW

934

# define SWIG_PYTHON_THREAD_END_ALLOW

935

#endif

936

937

/* -----------------------------------------------------------------------------

938

* Python API portion that goes into the runtime

939

* ----------------------------------------------------------------------------- */

940

941

#ifdef __cplusplus

942

extern "C" {

943

#if 0

944

} /* cc-mode */

945

#endif

946

#endif

947

948

/* -----------------------------------------------------------------------------

949

* Constant declarations

950

* ----------------------------------------------------------------------------- */

951

952

/* Constant Types */

953

#define SWIG_PY_POINTER 4

954

#define SWIG_PY_BINARY 5

955

956

/* Constant information structure */

957

typedef struct swig_const_info {

958

int type;

959

char *name;

960

long lvalue;

961

double dvalue;

962

void *pvalue;

963

swig_type_info **ptype;

964

} swig_const_info;

965

966

#ifdef __cplusplus

967

#if 0

968

{ /* cc-mode */

969

#endif

970

}

971

#endif

972

973

974

/* -----------------------------------------------------------------------------

975

* See the LICENSE file for information on copyright, usage and redistribution

976

* of SWIG, and the README file for authors - http://www.swig.org/release.html.

977

*

978

* pyrun.swg

979

*

980

* This file contains the runtime support for Python modules

981

* and includes code for managing global variables and pointer

982

* type checking.

983

*

984

* ----------------------------------------------------------------------------- */

985

986

/* Common SWIG API */

987

988

#if PY_VERSION_HEX < 0x02050000

989

typedef int Py_ssize_t;

990

#endif

991

992

/* for raw pointers */

993

#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)

994

#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)

995

#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

996

#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)

997

#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)

998

#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)

999

#define swig_owntype int

1000

1001

/* for raw packed data */

1002

#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)

1003

#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)

1004

1005

/* for class or struct pointers */

1006

#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)

1007

#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)

1008

1009

/* for C or C++ function pointers */

1010

#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)

1011

#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)

1012

1013

/* for C++ member pointers, ie, member methods */

1014

#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)

1015

#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)

1016

1017

1018

/* Runtime API */

1019

1020

#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()

1021

#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)

1022

#define SWIG_NewClientData(obj) PySwigClientData_New(obj)

1023

1024

#define SWIG_SetErrorObj SWIG_Python_SetErrorObj

1025

#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg

1026

#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)

1027

#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)

1028

#define SWIG_fail goto fail

1029

1030

1031

/* Runtime API implementation */

1032

1033

/* Error manipulation */

1034

1035

SWIGINTERN void

1036

SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {

1037

SWIG_PYTHON_THREAD_BEGIN_BLOCK;

1038

PyErr_SetObject(errtype, obj);

1039

Py_DECREF(obj);

1040

SWIG_PYTHON_THREAD_END_BLOCK;

1041

}

1042

1043

SWIGINTERN void

1044

SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {

1045

SWIG_PYTHON_THREAD_BEGIN_BLOCK;

1046

PyErr_SetString(errtype, (char *) msg);

1047

SWIG_PYTHON_THREAD_END_BLOCK;

1048

}

1049

1050

#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

1051

1052

/* Set a constant value */

1053

1054

SWIGINTERN void

1055

SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {

1056

PyDict_SetItemString(d, (char*) name, obj);

1057

Py_DECREF(obj);

1058

}

1059

1060

/* Append a value to the result obj */

1061

1062

SWIGINTERN PyObject*

1063

SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {

1064

#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)

1065

if (!result) {

1066

result = obj;

1067

} else if (result == Py_None) {

1068

Py_DECREF(result);

1069

result = obj;

1070

} else {

1071

if (!PyList_Check(result)) {

1072

PyObject *o2 = result;

1073

result = PyList_New(1);

1074

PyList_SetItem(result, 0, o2);

1075

}

1076

PyList_Append(result,obj);

1077

Py_DECREF(obj);

1078

}

1079

return result;

1080

#else

1081

PyObject* o2;

1082

PyObject* o3;

1083

if (!result) {

1084

result = obj;

1085

} else if (result == Py_None) {

1086

Py_DECREF(result);

1087

result = obj;

1088

} else {

1089

if (!PyTuple_Check(result)) {

1090

o2 = result;

1091

result = PyTuple_New(1);

1092

PyTuple_SET_ITEM(result, 0, o2);

1093

}

1094

o3 = PyTuple_New(1);

1095

PyTuple_SET_ITEM(o3, 0, obj);

1096

o2 = result;

1097

result = PySequence_Concat(o2, o3);

1098

Py_DECREF(o2);

1099

Py_DECREF(o3);

1100

}

1101

return result;

1102

#endif

1103

}

1104

1105

/* Unpack the argument tuple */

1106

1107

SWIGINTERN int

1108

SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)

1109

{

1110

if (!args) {

1111

if (!min && !max) {

1112

return 1;

1113

} else {

1114

PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",

1115

name, (min == max ? "" : "at least "), min);

1116

return 0;

1117

}

1118

}

1119

if (!PyTuple_Check(args)) {

1120

PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");

1121

return 0;

1122

} else {

1123

register int l = PyTuple_GET_SIZE(args);

1124

if (l < min) {

1125

PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",

1126

name, (min == max ? "" : "at least "), min, l);

1127

return 0;

1128

} else if (l > max) {

1129

PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",

1130

name, (min == max ? "" : "at most "), max, l);

1131

return 0;

1132

} else {

1133

register int i;

1134

for (i = 0; i < l; ++i) {

1135

objs[i] = PyTuple_GET_ITEM(args, i);

1136

}

1137

for (; l < max; ++l) {

1138

objs[l] = 0;

1139

}

1140

return i + 1;

1141

}

1142

}

1143

}

1144

1145

/* A functor is a function object with one single object argument */

1146

#if PY_VERSION_HEX >= 0x02020000

1147

#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);

1148

#else

1149

#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);

1150

#endif

1151

1152

/*

1153

Helper for static pointer initialization for both C and C++ code, for example

1154

static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);

1155

*/

1156

#ifdef __cplusplus

1157

#define SWIG_STATIC_POINTER(var) var

1158

#else

1159

#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var

1160

#endif

1161

1162

/* -----------------------------------------------------------------------------

1163

* Pointer declarations

1164

* ----------------------------------------------------------------------------- */

1165

1166

/* Flags for new pointer objects */

1167

#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)

1168

#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

1169

1170

#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)

1171

1172

#ifdef __cplusplus

1173

extern "C" {

1174

#if 0

1175

} /* cc-mode */

1176

#endif

1177

#endif

1178

1179

/* How to access Py_None */

1180

#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

1181

# ifndef SWIG_PYTHON_NO_BUILD_NONE

1182

# ifndef SWIG_PYTHON_BUILD_NONE

1183

# define SWIG_PYTHON_BUILD_NONE

1184

# endif

1185

# endif

1186

#endif

1187

1188

#ifdef SWIG_PYTHON_BUILD_NONE

1189

# ifdef Py_None

1190

# undef Py_None

1191

# define Py_None SWIG_Py_None()

1192

# endif

1193

SWIGRUNTIMEINLINE PyObject *

1194

_SWIG_Py_None(void)

1195

{

1196

PyObject *none = Py_BuildValue("");

1197

Py_DECREF(none);

1198

return none;

1199

}

1200

SWIGRUNTIME PyObject *

1201

SWIG_Py_None(void)

1202

{

1203

static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();

1204

return none;

1205

}

1206

#endif

1207

1208

/* The python void return value */

1209

1210

SWIGRUNTIMEINLINE PyObject *

1211

SWIG_Py_Void(void)

1212

{

1213

PyObject *none = Py_None;

1214

Py_INCREF(none);

1215

return none;

1216

}

1217

1218

/* PySwigClientData */

1219

1220

typedef struct {

1221

PyObject *klass;

1222

PyObject *newraw;

1223

PyObject *newargs;

1224

PyObject *destroy;

1225

int delargs;

1226

int implicitconv;

1227

} PySwigClientData;

1228

1229

SWIGRUNTIMEINLINE int

1230

SWIG_Python_CheckImplicit(swig_type_info *ty)

1231

{

1232

PySwigClientData *data = (PySwigClientData *)ty->clientdata;

1233

return data ? data->implicitconv : 0;

1234

}

1235

1236

SWIGRUNTIMEINLINE PyObject *

1237

SWIG_Python_ExceptionType(swig_type_info *desc) {

1238

PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;

1239

PyObject *klass = data ? data->klass : 0;

1240

return (klass ? klass : PyExc_RuntimeError);

1241

}

1242

1243

1244

SWIGRUNTIME PySwigClientData *

1245

PySwigClientData_New(PyObject* obj)

1246

{

1247

if (!obj) {

1248

return 0;

1249

} else {

1250

PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));

1251

/* the klass element */

1252

data->klass = obj;

1253

Py_INCREF(data->klass);

1254

/* the newraw method and newargs arguments used to create a new raw instance */

1255

if (PyClass_Check(obj)) {

1256

data->newraw = 0;

1257

data->newargs = obj;

1258

Py_INCREF(obj);

1259

} else {

1260

#if (PY_VERSION_HEX < 0x02020000)

1261

data->newraw = 0;

1262

#else

1263

data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");

1264

#endif

1265

if (data->newraw) {

1266

Py_INCREF(data->newraw);

1267

data->newargs = PyTuple_New(1);

1268

PyTuple_SetItem(data->newargs, 0, obj);

1269

} else {

1270

data->newargs = obj;

1271

}

1272

Py_INCREF(data->newargs);

1273

}

1274

/* the destroy method, aka as the C++ delete method */

1275

data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");

1276

if (PyErr_Occurred()) {

1277

PyErr_Clear();

1278

data->destroy = 0;

1279

}

1280

if (data->destroy) {

1281

int flags;

1282

Py_INCREF(data->destroy);

1283

flags = PyCFunction_GET_FLAGS(data->destroy);

1284

#ifdef METH_O

1285

data->delargs = !(flags & (METH_O));

1286

#else

1287

data->delargs = 0;

1288

#endif

1289

} else {

1290

data->delargs = 0;

1291

}

1292

data->implicitconv = 0;

1293

return data;

1294

}

1295

}

1296

1297

SWIGRUNTIME void

1298

PySwigClientData_Del(PySwigClientData* data)

1299

{

1300

Py_XDECREF(data->newraw);

1301

Py_XDECREF(data->newargs);

1302

Py_XDECREF(data->destroy);

1303

}

1304

1305

/* =============== PySwigObject =====================*/

1306

1307

typedef struct {

1308

PyObject_HEAD

1309

void *ptr;

1310

swig_type_info *ty;

1311

int own;

1312

PyObject *next;

1313

} PySwigObject;

1314

1315

SWIGRUNTIME PyObject *

1316

PySwigObject_long(PySwigObject *v)

1317

{

1318

return PyLong_FromVoidPtr(v->ptr);

1319

}

1320

1321

SWIGRUNTIME PyObject *

1322

PySwigObject_format(const char* fmt, PySwigObject *v)

1323

{

1324

PyObject *res = NULL;

1325

PyObject *args = PyTuple_New(1);

1326

if (args) {

1327

if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {

1328

PyObject *ofmt = PyString_FromString(fmt);

1329

if (ofmt) {

1330

res = PyString_Format(ofmt,args);

1331

Py_DECREF(ofmt);

1332

}

1333

Py_DECREF(args);

1334

}

1335

}

1336

return res;

1337

}

1338

1339

SWIGRUNTIME PyObject *

1340

PySwigObject_oct(PySwigObject *v)

1341

{

1342

return PySwigObject_format("%o",v);

1343

}

1344

1345

SWIGRUNTIME PyObject *

1346

PySwigObject_hex(PySwigObject *v)

1347

{

1348

return PySwigObject_format("%x",v);

1349

}

1350

1351

SWIGRUNTIME PyObject *

1352

#ifdef METH_NOARGS

1353

PySwigObject_repr(PySwigObject *v)

1354

#else

1355

PySwigObject_repr(PySwigObject *v, PyObject *args)

1356

#endif

1357

{

1358

const char *name = SWIG_TypePrettyName(v->ty);

1359

PyObject *hex = PySwigObject_hex(v);

1360

PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));

1361

Py_DECREF(hex);

1362

if (v->next) {

1363

#ifdef METH_NOARGS

1364

PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);

1365

#else

1366

PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);

1367

#endif

1368

PyString_ConcatAndDel(&repr,nrep);

1369

}

1370

return repr;

1371

}

1372

1373

SWIGRUNTIME int

1374

PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))

1375

{

1376

#ifdef METH_NOARGS

1377

PyObject *repr = PySwigObject_repr(v);

1378

#else

1379

PyObject *repr = PySwigObject_repr(v, NULL);

1380

#endif

1381

if (repr) {

1382

fputs(PyString_AsString(repr), fp);

1383

Py_DECREF(repr);

1384

return 0;

1385

} else {

1386

return 1;

1387

}

1388

}

1389

1390

SWIGRUNTIME PyObject *

1391

PySwigObject_str(PySwigObject *v)

1392

{

1393

char result[SWIG_BUFFER_SIZE];

1394

return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?

1395

PyString_FromString(result) : 0;

1396

}

1397

1398

SWIGRUNTIME int

1399

PySwigObject_compare(PySwigObject *v, PySwigObject *w)

1400

{

1401

void *i = v->ptr;

1402

void *j = w->ptr;

1403

return (i < j) ? -1 : ((i > j) ? 1 : 0);

1404

}

1405

1406

SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);

1407

1408

SWIGRUNTIME PyTypeObject*

1409

PySwigObject_type(void) {

1410

static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();

1411

return type;

1412

}

1413

1414

SWIGRUNTIMEINLINE int

1415

PySwigObject_Check(PyObject *op) {

1416

return ((op)->ob_type == PySwigObject_type())

1417

|| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);

1418

}

1419

1420

SWIGRUNTIME PyObject *

1421

PySwigObject_New(void *ptr, swig_type_info *ty, int own);

1422

1423

SWIGRUNTIME void

1424

PySwigObject_dealloc(PyObject *v)

1425

{

1426

PySwigObject *sobj = (PySwigObject *) v;

1427

PyObject *next = sobj->next;

1428

if (sobj->own) {

1429

swig_type_info *ty = sobj->ty;

1430

PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;

1431

PyObject *destroy = data ? data->destroy : 0;

1432

if (destroy) {

1433

/* destroy is always a VARARGS method */

1434

PyObject *res;

1435

if (data->delargs) {

1436

/* we need to create a temporal object to carry the destroy operation */

1437

PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);

1438

res = SWIG_Python_CallFunctor(destroy, tmp);

1439

Py_DECREF(tmp);

1440

} else {

1441

PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);

1442

PyObject *mself = PyCFunction_GET_SELF(destroy);

1443

res = ((*meth)(mself, v));

1444

}

1445

Py_XDECREF(res);

1446

} else {

1447

const char *name = SWIG_TypePrettyName(ty);

1448

#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)

1449

printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);

1450

#endif

1451

}

1452

}

1453

Py_XDECREF(next);

1454

PyObject_DEL(v);

1455

}

1456

1457

SWIGRUNTIME PyObject*

1458

PySwigObject_append(PyObject* v, PyObject* next)

1459

{

1460

PySwigObject *sobj = (PySwigObject *) v;

1461

#ifndef METH_O

1462

PyObject *tmp = 0;

1463

if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;

1464

next = tmp;

1465

#endif

1466

if (!PySwigObject_Check(next)) {

1467

return NULL;

1468

}

1469

sobj->next = next;

1470

Py_INCREF(next);

1471

return SWIG_Py_Void();

1472

}

1473

1474

SWIGRUNTIME PyObject*

1475

#ifdef METH_NOARGS

1476

PySwigObject_next(PyObject* v)

1477

#else

1478

PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))

1479

#endif

1480

{

1481

PySwigObject *sobj = (PySwigObject *) v;

1482

if (sobj->next) {

1483

Py_INCREF(sobj->next);

1484

return sobj->next;

1485

} else {

1486

return SWIG_Py_Void();

1487

}

1488

}

1489

1490

SWIGINTERN PyObject*

1491

#ifdef METH_NOARGS

1492

PySwigObject_disown(PyObject *v)

1493

#else

1494

PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))

1495

#endif

1496

{

1497

PySwigObject *sobj = (PySwigObject *)v;

1498

sobj->own = 0;

1499

return SWIG_Py_Void();

1500

}

1501

1502

SWIGINTERN PyObject*

1503

#ifdef METH_NOARGS

1504

PySwigObject_acquire(PyObject *v)

1505

#else

1506

PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))

1507

#endif

1508

{

1509

PySwigObject *sobj = (PySwigObject *)v;

1510

sobj->own = SWIG_POINTER_OWN;

1511

return SWIG_Py_Void();

1512

}

1513

1514

SWIGINTERN PyObject*

1515

PySwigObject_own(PyObject *v, PyObject *args)

1516

{

1517

PyObject *val = 0;

1518

#if (PY_VERSION_HEX < 0x02020000)

1519

if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))

1520

#else

1521

if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))

1522

#endif

1523

{

1524

return NULL;

1525

}

1526

else

1527

{

1528

PySwigObject *sobj = (PySwigObject *)v;

1529

PyObject *obj = PyBool_FromLong(sobj->own);

1530

if (val) {

1531

#ifdef METH_NOARGS

1532

if (PyObject_IsTrue(val)) {

1533

PySwigObject_acquire(v);

1534

} else {

1535

PySwigObject_disown(v);

1536

}

1537

#else

1538

if (PyObject_IsTrue(val)) {

1539

PySwigObject_acquire(v,args);

1540

} else {

1541

PySwigObject_disown(v,args);

1542

}

1543

#endif

1544

}

1545

return obj;

1546

}

1547

}

1548

1549

#ifdef METH_O

1550

static PyMethodDef

1551

swigobject_methods[] = {

1552

{(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},

1553

{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},

1554

{(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},

1555

{(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},

1556

{(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},

1557

{(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},

1558

{0, 0, 0, 0}

1559

};

1560

#else

1561

static PyMethodDef

1562

swigobject_methods[] = {

1563

{(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},

1564

{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},

1565

{(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},

1566

{(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},

1567

{(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},

1568

{(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},

1569

{0, 0, 0, 0}

1570

};

1571

#endif

1572

1573

#if PY_VERSION_HEX < 0x02020000

1574

SWIGINTERN PyObject *

1575

PySwigObject_getattr(PySwigObject *sobj,char *name)

1576

{

1577

return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);

1578

}

1579

#endif

1580

1581

SWIGRUNTIME PyTypeObject*

1582

_PySwigObject_type(void) {

1583

static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";

1584

1585

static PyNumberMethods PySwigObject_as_number = {

1586

(binaryfunc)0, /*nb_add*/

1587

(binaryfunc)0, /*nb_subtract*/

1588

(binaryfunc)0, /*nb_multiply*/

1589

(binaryfunc)0, /*nb_divide*/

1590

(binaryfunc)0, /*nb_remainder*/

1591

(binaryfunc)0, /*nb_divmod*/

1592

(ternaryfunc)0,/*nb_power*/

1593

(unaryfunc)0, /*nb_negative*/

1594

(unaryfunc)0, /*nb_positive*/

1595

(unaryfunc)0, /*nb_absolute*/

1596

(inquiry)0, /*nb_nonzero*/

1597

0, /*nb_invert*/

1598

0, /*nb_lshift*/

1599

0, /*nb_rshift*/

1600

0, /*nb_and*/

1601

0, /*nb_xor*/

1602

0, /*nb_or*/

1603

(coercion)0, /*nb_coerce*/

1604

(unaryfunc)PySwigObject_long, /*nb_int*/

1605

(unaryfunc)PySwigObject_long, /*nb_long*/

1606

(unaryfunc)0, /*nb_float*/

1607

(unaryfunc)PySwigObject_oct, /*nb_oct*/

1608

(unaryfunc)PySwigObject_hex, /*nb_hex*/

1609

#if PY_VERSION_HEX >= 0x02020000

1610

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */

1611

#elif PY_VERSION_HEX >= 0x02000000

1612

0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */

1613

#endif

1614

};

1615

1616

static PyTypeObject pyswigobject_type;

1617

static int type_init = 0;

1618

if (!type_init) {

1619

const PyTypeObject tmp

1620

= {

1621

PyObject_HEAD_INIT(NULL)

1622

0, /* ob_size */

1623

(char *)"PySwigObject", /* tp_name */

1624

sizeof(PySwigObject), /* tp_basicsize */

1625

0, /* tp_itemsize */

1626

(destructor)PySwigObject_dealloc, /* tp_dealloc */

1627

(printfunc)PySwigObject_print, /* tp_print */

1628

#if PY_VERSION_HEX < 0x02020000

1629

(getattrfunc)PySwigObject_getattr, /* tp_getattr */

1630

#else

1631

(getattrfunc)0, /* tp_getattr */

1632

#endif

1633

(setattrfunc)0, /* tp_setattr */

1634

(cmpfunc)PySwigObject_compare, /* tp_compare */

1635

(reprfunc)PySwigObject_repr, /* tp_repr */

1636

&PySwigObject_as_number, /* tp_as_number */

1637

0, /* tp_as_sequence */

1638

0, /* tp_as_mapping */

1639

(hashfunc)0, /* tp_hash */

1640

(ternaryfunc)0, /* tp_call */

1641

(reprfunc)PySwigObject_str, /* tp_str */

1642

PyObject_GenericGetAttr, /* tp_getattro */

1643

0, /* tp_setattro */

1644

0, /* tp_as_buffer */

1645

Py_TPFLAGS_DEFAULT, /* tp_flags */

1646

swigobject_doc, /* tp_doc */

1647

0, /* tp_traverse */

1648

0, /* tp_clear */

1649

0, /* tp_richcompare */

1650

0, /* tp_weaklistoffset */

1651

#if PY_VERSION_HEX >= 0x02020000

1652

0, /* tp_iter */

1653

0, /* tp_iternext */

1654

swigobject_methods, /* tp_methods */

1655

0, /* tp_members */

1656

0, /* tp_getset */

1657

0, /* tp_base */

1658

0, /* tp_dict */

1659

0, /* tp_descr_get */

1660

0, /* tp_descr_set */

1661

0, /* tp_dictoffset */

1662

0, /* tp_init */

1663

0, /* tp_alloc */

1664

0, /* tp_new */

1665

0, /* tp_free */

1666

0, /* tp_is_gc */

1667

0, /* tp_bases */

1668

0, /* tp_mro */

1669

0, /* tp_cache */

1670

0, /* tp_subclasses */

1671

0, /* tp_weaklist */

1672

#endif

1673

#if PY_VERSION_HEX >= 0x02030000

1674

0, /* tp_del */

1675

#endif

1676

#ifdef COUNT_ALLOCS

1677

0,0,0,0 /* tp_alloc -> tp_next */

1678

#endif

1679

};

1680

pyswigobject_type = tmp;

1681

pyswigobject_type.ob_type = &PyType_Type;

1682

type_init = 1;

1683

}

1684

return &pyswigobject_type;

1685

}

1686

1687

SWIGRUNTIME PyObject *

1688

PySwigObject_New(void *ptr, swig_type_info *ty, int own)

1689

{

1690

PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());

1691

if (sobj) {

1692

sobj->ptr = ptr;

1693

sobj->ty = ty;

1694

sobj->own = own;

1695

sobj->next = 0;

1696

}

1697

return (PyObject *)sobj;

1698

}

1699

1700

/* -----------------------------------------------------------------------------

1701

* Implements a simple Swig Packed type, and use it instead of string

1702

* ----------------------------------------------------------------------------- */

1703

1704

typedef struct {

1705

PyObject_HEAD

1706

void *pack;

1707

swig_type_info *ty;

1708

size_t size;

1709

} PySwigPacked;

1710

1711

SWIGRUNTIME int

1712

PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))

1713

{

1714

char result[SWIG_BUFFER_SIZE];

1715

fputs("<Swig Packed ", fp);

1716

if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {

1717

fputs("at ", fp);

1718

fputs(result, fp);

1719

}

1720

fputs(v->ty->name,fp);

1721

fputs(">", fp);

1722

return 0;

1723

}

1724

1725

SWIGRUNTIME PyObject *

1726

PySwigPacked_repr(PySwigPacked *v)

1727

{

1728

char result[SWIG_BUFFER_SIZE];

1729

if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {

1730

return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);

1731

} else {

1732

return PyString_FromFormat("<Swig Packed %s>", v->ty->name);

1733

}

1734

}

1735

1736

SWIGRUNTIME PyObject *

1737

PySwigPacked_str(PySwigPacked *v)

1738

{

1739

char result[SWIG_BUFFER_SIZE];

1740

if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){

1741

return PyString_FromFormat("%s%s", result, v->ty->name);

1742

} else {

1743

return PyString_FromString(v->ty->name);

1744

}

1745

}

1746

1747

SWIGRUNTIME int

1748

PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)

1749

{

1750

size_t i = v->size;

1751

size_t j = w->size;

1752

int s = (i < j) ? -1 : ((i > j) ? 1 : 0);

1753

return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);

1754

}

1755

1756

SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);

1757

1758

SWIGRUNTIME PyTypeObject*

1759

PySwigPacked_type(void) {

1760

static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();

1761

return type;

1762

}

1763

1764

SWIGRUNTIMEINLINE int

1765

PySwigPacked_Check(PyObject *op) {

1766

return ((op)->ob_type == _PySwigPacked_type())

1767

|| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);

1768

}

1769

1770

SWIGRUNTIME void

1771

PySwigPacked_dealloc(PyObject *v)

1772

{

1773

if (PySwigPacked_Check(v)) {

1774

PySwigPacked *sobj = (PySwigPacked *) v;

1775

free(sobj->pack);

1776

}

1777

PyObject_DEL(v);

1778

}

1779

1780

SWIGRUNTIME PyTypeObject*

1781

_PySwigPacked_type(void) {

1782

static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";

1783

static PyTypeObject pyswigpacked_type;

1784

static int type_init = 0;

1785

if (!type_init) {

1786

const PyTypeObject tmp

1787

= {

1788

PyObject_HEAD_INIT(NULL)

1789

0, /* ob_size */

1790

(char *)"PySwigPacked", /* tp_name */

1791

sizeof(PySwigPacked), /* tp_basicsize */

1792

0, /* tp_itemsize */

1793

(destructor)PySwigPacked_dealloc, /* tp_dealloc */

1794

(printfunc)PySwigPacked_print, /* tp_print */

1795

(getattrfunc)0, /* tp_getattr */

1796

(setattrfunc)0, /* tp_setattr */

1797

(cmpfunc)PySwigPacked_compare, /* tp_compare */

1798

(reprfunc)PySwigPacked_repr, /* tp_repr */

1799

0, /* tp_as_number */

1800

0, /* tp_as_sequence */

1801

0, /* tp_as_mapping */

1802

(hashfunc)0, /* tp_hash */

1803

(ternaryfunc)0, /* tp_call */

1804

(reprfunc)PySwigPacked_str, /* tp_str */

1805

PyObject_GenericGetAttr, /* tp_getattro */

1806

0, /* tp_setattro */

1807

0, /* tp_as_buffer */

1808

Py_TPFLAGS_DEFAULT, /* tp_flags */

1809

swigpacked_doc, /* tp_doc */

1810

0, /* tp_traverse */

1811

0, /* tp_clear */

1812

0, /* tp_richcompare */

1813

0, /* tp_weaklistoffset */

1814

#if PY_VERSION_HEX >= 0x02020000

1815

0, /* tp_iter */

1816

0, /* tp_iternext */

1817

0, /* tp_methods */

1818

0, /* tp_members */

1819

0, /* tp_getset */

1820

0, /* tp_base */

1821

0, /* tp_dict */

1822

0, /* tp_descr_get */

1823

0, /* tp_descr_set */

1824

0, /* tp_dictoffset */

1825

0, /* tp_init */

1826

0, /* tp_alloc */

1827

0, /* tp_new */

1828

0, /* tp_free */

1829

0, /* tp_is_gc */

1830

0, /* tp_bases */

1831

0, /* tp_mro */

1832

0, /* tp_cache */

1833

0, /* tp_subclasses */

1834

0, /* tp_weaklist */

1835

#endif

1836

#if PY_VERSION_HEX >= 0x02030000

1837

0, /* tp_del */

1838

#endif

1839

#ifdef COUNT_ALLOCS

1840

0,0,0,0 /* tp_alloc -> tp_next */

1841

#endif

1842

};

1843

pyswigpacked_type = tmp;

1844

pyswigpacked_type.ob_type = &PyType_Type;

1845

type_init = 1;

1846

}

1847

return &pyswigpacked_type;

1848

}

1849

1850

SWIGRUNTIME PyObject *

1851

PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)

1852

{

1853

PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());

1854

if (sobj) {

1855

void *pack = malloc(size);

1856

if (pack) {

1857

memcpy(pack, ptr, size);

1858

sobj->pack = pack;

1859

sobj->ty = ty;

1860

sobj->size = size;

1861

} else {

1862

PyObject_DEL((PyObject *) sobj);

1863

sobj = 0;

1864

}

1865

}

1866

return (PyObject *) sobj;

1867

}

1868

1869

SWIGRUNTIME swig_type_info *

1870

PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)

1871

{

1872

if (PySwigPacked_Check(obj)) {

1873

PySwigPacked *sobj = (PySwigPacked *)obj;

1874

if (sobj->size != size) return 0;

1875

memcpy(ptr, sobj->pack, size);

1876

return sobj->ty;

1877

} else {

1878

return 0;

1879

}

1880

}

1881

1882

/* -----------------------------------------------------------------------------

1883

* pointers/data manipulation

1884

* ----------------------------------------------------------------------------- */

1885

1886

SWIGRUNTIMEINLINE PyObject *

1887

_SWIG_This(void)

1888

{

1889

return PyString_FromString("this");

1890

}

1891

1892

SWIGRUNTIME PyObject *

1893

SWIG_This(void)

1894

{

1895

static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();

1896

return swig_this;

1897

}

1898

1899

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

1900

1901

SWIGRUNTIME PySwigObject *

1902

SWIG_Python_GetSwigThis(PyObject *pyobj)

1903

{

1904

if (PySwigObject_Check(pyobj)) {

1905

return (PySwigObject *) pyobj;

1906

} else {

1907

PyObject *obj = 0;

1908

#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))

1909

if (PyInstance_Check(pyobj)) {

1910

obj = _PyInstance_Lookup(pyobj, SWIG_This());

1911

} else {

1912

PyObject **dictptr = _PyObject_GetDictPtr(pyobj);

1913

if (dictptr != NULL) {

1914

PyObject *dict = *dictptr;

1915

obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;

1916

} else {

1917

#ifdef PyWeakref_CheckProxy

1918

if (PyWeakref_CheckProxy(pyobj)) {

1919

PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);

1920

return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;

1921

}

1922

#endif

1923

obj = PyObject_GetAttr(pyobj,SWIG_This());

1924

if (obj) {

1925

Py_DECREF(obj);

1926

} else {

1927

if (PyErr_Occurred()) PyErr_Clear();

1928

return 0;

1929

}

1930

}

1931

}

1932

#else

1933

obj = PyObject_GetAttr(pyobj,SWIG_This());

1934

if (obj) {

1935

Py_DECREF(obj);

1936

} else {

1937

if (PyErr_Occurred()) PyErr_Clear();

1938

return 0;

1939

}

1940

#endif

1941

if (obj && !PySwigObject_Check(obj)) {

1942

/* a PyObject is called 'this', try to get the 'real this'

1943

PySwigObject from it */

1944

return SWIG_Python_GetSwigThis(obj);

1945

}

1946

return (PySwigObject *)obj;

1947

}

1948

}

1949

1950

/* Acquire a pointer value */

1951

1952

SWIGRUNTIME int

1953

SWIG_Python_AcquirePtr(PyObject *obj, int own) {

1954

if (own) {

1955

PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);

1956

if (sobj) {

1957

int oldown = sobj->own;

1958

sobj->own = own;

1959

return oldown;

1960

}

1961

}

1962

return 0;

1963

}

1964

1965

/* Convert a pointer value */

1966

1967

SWIGRUNTIME int

1968

SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {

1969

if (!obj) return SWIG_ERROR;

1970

if (obj == Py_None) {

1971

if (ptr) *ptr = 0;

1972

return SWIG_OK;

1973

} else {

1974

PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);

1975

while (sobj) {

1976

void *vptr = sobj->ptr;

1977

if (ty) {

1978

swig_type_info *to = sobj->ty;

1979

if (to == ty) {

1980

/* no type cast needed */

1981

if (ptr) *ptr = vptr;

1982

break;

1983

} else {

1984

swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);

1985

if (!tc) {

1986

sobj = (PySwigObject *)sobj->next;

1987

} else {

1988

if (ptr) *ptr = SWIG_TypeCast(tc,vptr);

1989

break;

1990

}

1991

}

1992

} else {

1993

if (ptr) *ptr = vptr;

1994

break;

1995

}

1996

}

1997

if (sobj) {

1998

if (own) *own = sobj->own;

1999

if (flags & SWIG_POINTER_DISOWN) {

2000

sobj->own = 0;

2001

}

2002

return SWIG_OK;

2003

} else {

2004

int res = SWIG_ERROR;

2005

if (flags & SWIG_POINTER_IMPLICIT_CONV) {

2006

PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;

2007

if (data && !data->implicitconv) {

2008

PyObject *klass = data->klass;

2009

if (klass) {

2010

PyObject *impconv;

2011

data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/

2012

impconv = SWIG_Python_CallFunctor(klass, obj);

2013

data->implicitconv = 0;

2014

if (PyErr_Occurred()) {

2015

PyErr_Clear();

2016

impconv = 0;

2017

}

2018

if (impconv) {

2019

PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);

2020

if (iobj) {

2021

void *vptr;

2022

res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);

2023

if (SWIG_IsOK(res)) {

2024

if (ptr) {

2025

*ptr = vptr;

2026

/* transfer the ownership to 'ptr' */

2027

iobj->own = 0;

2028

res = SWIG_AddCast(res);

2029

res = SWIG_AddNewMask(res);

2030

} else {

2031

res = SWIG_AddCast(res);

2032

}

2033

}

2034

}

2035

Py_DECREF(impconv);

2036

}

2037

}

2038

}

2039

}

2040

return res;

2041

}

2042

}

2043

}

2044

2045

/* Convert a function ptr value */

2046

2047

SWIGRUNTIME int

2048

SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {

2049

if (!PyCFunction_Check(obj)) {

2050

return SWIG_ConvertPtr(obj, ptr, ty, 0);

2051

} else {

2052

void *vptr = 0;

2053

2054

/* here we get the method pointer for callbacks */

2055

const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);

2056

const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;

2057

if (desc) {

2058

desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;

2059

if (!desc) return SWIG_ERROR;

2060

}

2061

if (ty) {

2062

swig_cast_info *tc = SWIG_TypeCheck(desc,ty);

2063

if (!tc) return SWIG_ERROR;

2064

*ptr = SWIG_TypeCast(tc,vptr);

2065

} else {

2066

*ptr = vptr;

2067

}

2068

return SWIG_OK;

2069

}

2070

}

2071

2072

/* Convert a packed value value */

2073

2074

SWIGRUNTIME int

2075

SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {

2076

swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);

2077

if (!to) return SWIG_ERROR;

2078

if (ty) {

2079

if (to != ty) {

2080

/* check type cast? */

2081

swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);

2082

if (!tc) return SWIG_ERROR;

2083

}

2084

}

2085

return SWIG_OK;

2086

}

2087

2088

/* -----------------------------------------------------------------------------

2089

* Create a new pointer object

2090

* ----------------------------------------------------------------------------- */

2091

2092

/*

2093

Create a new instance object, whitout calling __init__, and set the

2094

'this' attribute.

2095

*/

2096

2097

SWIGRUNTIME PyObject*

2098

SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)

2099

{

2100

#if (PY_VERSION_HEX >= 0x02020000)

2101

PyObject *inst = 0;

2102

PyObject *newraw = data->newraw;

2103

if (newraw) {

2104

inst = PyObject_Call(newraw, data->newargs, NULL);

2105

if (inst) {

2106

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)

2107

PyObject **dictptr = _PyObject_GetDictPtr(inst);

2108

if (dictptr != NULL) {

2109

PyObject *dict = *dictptr;

2110

if (dict == NULL) {

2111

dict = PyDict_New();

2112

*dictptr = dict;

2113

PyDict_SetItem(dict, SWIG_This(), swig_this);

2114

}

2115

}

2116

#else

2117

PyObject *key = SWIG_This();

2118

PyObject_SetAttr(inst, key, swig_this);

2119

#endif

2120

}

2121

} else {

2122

PyObject *dict = PyDict_New();

2123

PyDict_SetItem(dict, SWIG_This(), swig_this);

2124

inst = PyInstance_NewRaw(data->newargs, dict);

2125

Py_DECREF(dict);

2126

}

2127

return inst;

2128

#else

2129

#if (PY_VERSION_HEX >= 0x02010000)

2130

PyObject *inst;

2131

PyObject *dict = PyDict_New();

2132

PyDict_SetItem(dict, SWIG_This(), swig_this);

2133

inst = PyInstance_NewRaw(data->newargs, dict);

2134

Py_DECREF(dict);

2135

return (PyObject *) inst;

2136

#else

2137

PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);

2138

if (inst == NULL) {

2139

return NULL;

2140

}

2141

inst->in_class = (PyClassObject *)data->newargs;

2142

Py_INCREF(inst->in_class);

2143

inst->in_dict = PyDict_New();

2144

if (inst->in_dict == NULL) {

2145

Py_DECREF(inst);

2146

return NULL;

2147

}

2148

#ifdef Py_TPFLAGS_HAVE_WEAKREFS

2149

inst->in_weakreflist = NULL;

2150

#endif

2151

#ifdef Py_TPFLAGS_GC

2152

PyObject_GC_Init(inst);

2153

#endif

2154

PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);

2155

return (PyObject *) inst;

2156

#endif

2157

#endif

2158

}

2159

2160

SWIGRUNTIME void

2161

SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)

2162

{

2163

PyObject *dict;

2164

#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)

2165

PyObject **dictptr = _PyObject_GetDictPtr(inst);

2166

if (dictptr != NULL) {

2167

dict = *dictptr;

2168

if (dict == NULL) {

2169

dict = PyDict_New();

2170

*dictptr = dict;

2171

}

2172

PyDict_SetItem(dict, SWIG_This(), swig_this);

2173

return;

2174

}

2175

#endif

2176

dict = PyObject_GetAttrString(inst, "__dict__");

2177

PyDict_SetItem(dict, SWIG_This(), swig_this);

2178

Py_DECREF(dict);

2179

}

2180

2181

2182

SWIGINTERN PyObject *

2183

SWIG_Python_InitShadowInstance(PyObject *args) {

2184

PyObject *obj[2];

2185

if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {

2186

return NULL;

2187

} else {

2188

PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);

2189

if (sthis) {

2190

PySwigObject_append((PyObject*) sthis, obj[1]);

2191

} else {

2192

SWIG_Python_SetSwigThis(obj[0], obj[1]);

2193

}

2194

return SWIG_Py_Void();

2195

}

2196

}

2197

2198

/* Create a new pointer object */

2199

2200

SWIGRUNTIME PyObject *

2201

SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {

2202

if (!ptr) {

2203

return SWIG_Py_Void();

2204

} else {

2205

int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;

2206

PyObject *robj = PySwigObject_New(ptr, type, own);

2207

PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;

2208

if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {

2209

PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);

2210

if (inst) {

2211

Py_DECREF(robj);

2212

robj = inst;

2213

}

2214

}

2215

return robj;

2216

}

2217

}

2218

2219

/* Create a new packed object */

2220

2221

SWIGRUNTIMEINLINE PyObject *

2222

SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {

2223

return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();

2224

}

2225

2226

/* -----------------------------------------------------------------------------*

2227

* Get type list

2228

* -----------------------------------------------------------------------------*/

2229

2230

#ifdef SWIG_LINK_RUNTIME

2231

void *SWIG_ReturnGlobalTypeList(void *);

2232

#endif

2233

2234

SWIGRUNTIME swig_module_info *

2235

SWIG_Python_GetModule(void) {

2236

static void *type_pointer = (void *)0;

2237

/* first check if module already created */

2238

if (!type_pointer) {

2239

#ifdef SWIG_LINK_RUNTIME

2240

type_pointer = SWIG_ReturnGlobalTypeList((void *)0);

2241

#else

2242

type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,

2243

(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);

2244

if (PyErr_Occurred()) {

2245

PyErr_Clear();

2246

type_pointer = (void *)0;

2247

}

2248

#endif

2249

}

2250

return (swig_module_info *) type_pointer;

2251

}

2252

2253

#if PY_MAJOR_VERSION < 2

2254

/* PyModule_AddObject function was introduced in Python 2.0. The following function

2255

is copied out of Python/modsupport.c in python version 2.3.4 */

2256

SWIGINTERN int

2257

PyModule_AddObject(PyObject *m, char *name, PyObject *o)

2258

{

2259

PyObject *dict;

2260

if (!PyModule_Check(m)) {

2261

PyErr_SetString(PyExc_TypeError,

2262

"PyModule_AddObject() needs module as first arg");

2263

return SWIG_ERROR;

2264

}

2265

if (!o) {

2266

PyErr_SetString(PyExc_TypeError,

2267

"PyModule_AddObject() needs non-NULL value");

2268

return SWIG_ERROR;

2269

}

2270

2271

dict = PyModule_GetDict(m);

2272

if (dict == NULL) {

2273

/* Internal error -- modules must have a dict! */

2274

PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",

2275

PyModule_GetName(m));

2276

return SWIG_ERROR;

2277

}

2278

if (PyDict_SetItemString(dict, name, o))

2279

return SWIG_ERROR;

2280

Py_DECREF(o);

2281

return SWIG_OK;

2282

}

2283

#endif

2284

2285

SWIGRUNTIME void

2286

SWIG_Python_DestroyModule(void *vptr)

2287

{

2288

swig_module_info *swig_module = (swig_module_info *) vptr;

2289

swig_type_info **types = swig_module->types;

2290

size_t i;

2291

for (i =0; i < swig_module->size; ++i) {

2292

swig_type_info *ty = types[i];

2293

if (ty->owndata) {

2294

PySwigClientData *data = (PySwigClientData *) ty->clientdata;

2295

if (data) PySwigClientData_Del(data);

2296

}

2297

}

2298

Py_DECREF(SWIG_This());

2299

}

2300

2301

SWIGRUNTIME void

2302

SWIG_Python_SetModule(swig_module_info *swig_module) {

2303

static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */

2304

2305

PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,

2306

swig_empty_runtime_method_table);

2307

PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);

2308

if (pointer && module) {

2309

PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);

2310

} else {

2311

Py_XDECREF(pointer);

2312

}

2313

}

2314

2315

/* The python cached type query */

2316

SWIGRUNTIME PyObject *

2317

SWIG_Python_TypeCache() {

2318

static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();

2319

return cache;

2320

}

2321

2322

SWIGRUNTIME swig_type_info *

2323

SWIG_Python_TypeQuery(const char *type)

2324

{

2325

PyObject *cache = SWIG_Python_TypeCache();

2326

PyObject *key = PyString_FromString(type);

2327

PyObject *obj = PyDict_GetItem(cache, key);

2328

swig_type_info *descriptor;

2329

if (obj) {

2330

descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);

2331

} else {

2332

swig_module_info *swig_module = SWIG_Python_GetModule();

2333

descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);

2334

if (descriptor) {

2335

obj = PyCObject_FromVoidPtr(descriptor, NULL);

2336

PyDict_SetItem(cache, key, obj);

2337

Py_DECREF(obj);

2338

}

2339

}

2340

Py_DECREF(key);

2341

return descriptor;

2342

}

2343

2344

/*

2345

For backward compatibility only

2346

*/

2347

#define SWIG_POINTER_EXCEPTION 0

2348

#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)

2349

#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)

2350

2351

SWIGRUNTIME int

2352

SWIG_Python_AddErrMesg(const char* mesg, int infront)

2353

{

2354

if (PyErr_Occurred()) {

2355

PyObject *type = 0;

2356

PyObject *value = 0;

2357

PyObject *traceback = 0;

2358

PyErr_Fetch(&type, &value, &traceback);

2359

if (value) {

2360

PyObject *old_str = PyObject_Str(value);

2361

Py_XINCREF(type);

2362

PyErr_Clear();

2363

if (infront) {

2364

PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));

2365

} else {

2366

PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);

2367

}

2368

Py_DECREF(old_str);

2369

}

2370

return 1;

2371

} else {

2372

return 0;

2373

}

2374

}

2375

2376

SWIGRUNTIME int

2377

SWIG_Python_ArgFail(int argnum)

2378

{

2379

if (PyErr_Occurred()) {

2380

/* add information about failing argument */

2381

char mesg[256];

2382

PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);

2383

return SWIG_Python_AddErrMesg(mesg, 1);

2384

} else {

2385

return 0;

2386

}

2387

}

2388

2389

SWIGRUNTIMEINLINE const char *

2390

PySwigObject_GetDesc(PyObject *self)

2391

{

2392

PySwigObject *v = (PySwigObject *)self;

2393

swig_type_info *ty = v ? v->ty : 0;

2394

return ty ? ty->str : (char*)"";

2395

}

2396

2397

SWIGRUNTIME void

2398

SWIG_Python_TypeError(const char *type, PyObject *obj)

2399

{

2400

if (type) {

2401

#if defined(SWIG_COBJECT_TYPES)

2402

if (obj && PySwigObject_Check(obj)) {

2403

const char *otype = (const char *) PySwigObject_GetDesc(obj);

2404

if (otype) {

2405

PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",

2406

type, otype);

2407

return;

2408

}

2409

} else

2410

#endif

2411

{

2412

const char *otype = (obj ? obj->ob_type->tp_name : 0);

2413

if (otype) {

2414

PyObject *str = PyObject_Str(obj);

2415

const char *cstr = str ? PyString_AsString(str) : 0;

2416

if (cstr) {

2417

PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",

2418

type, otype, cstr);

2419

} else {

2420

PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",

2421

type, otype);

2422

}

2423

Py_XDECREF(str);

2424

return;

2425

}

2426

}

2427

PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);

2428

} else {

2429

PyErr_Format(PyExc_TypeError, "unexpected type is received");

2430

}

2431

}

2432

2433

2434

/* Convert a pointer value, signal an exception on a type mismatch */

2435

SWIGRUNTIME void *

2436

SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {

2437

void *result;

2438

if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {

2439

PyErr_Clear();

2440

if (flags & SWIG_POINTER_EXCEPTION) {

2441

SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);

2442

SWIG_Python_ArgFail(argnum);

2443

}

2444

}

2445

return result;

2446

}

2447

2448

2449

#ifdef __cplusplus

2450

#if 0

2451

{ /* cc-mode */

2452

#endif

2453

}

2454

#endif

2455

2456

2457

2458

#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)

2459

2460

#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else

2461

2462

2463

2464

/* -------- TYPES TABLE (BEGIN) -------- */

2465

2466

#define SWIGTYPE_p_char swig_types[0]

2467

#define SWIGTYPE_p_double swig_types[1]

2468

#define SWIGTYPE_p_form_ops_t swig_types[2]

2469

#define SWIGTYPE_p_int swig_types[3]

2470

#define SWIGTYPE_p_unsigned_char swig_types[4]

2471

#define SWIGTYPE_p_unsigned_int swig_types[5]

2472

#define SWIGTYPE_p_unsigned_long swig_types[6]

2473

#define SWIGTYPE_p_wxANIHandler swig_types[7]

2474

#define SWIGTYPE_p_wxAcceleratorTable swig_types[8]

2475

#define SWIGTYPE_p_wxActivateEvent swig_types[9]

2476

#define SWIGTYPE_p_wxArrayString swig_types[10]

2477

#define SWIGTYPE_p_wxBMPHandler swig_types[11]

2478

#define SWIGTYPE_p_wxBitmap swig_types[12]

2479

#define SWIGTYPE_p_wxBitmapComboBox swig_types[13]

2480

#define SWIGTYPE_p_wxBoxSizer swig_types[14]

2481

#define SWIGTYPE_p_wxCURHandler swig_types[15]

2482

#define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[16]

2483

#define SWIGTYPE_p_wxChildFocusEvent swig_types[17]

2484

#define SWIGTYPE_p_wxClipboardTextEvent swig_types[18]

2485

#define SWIGTYPE_p_wxCloseEvent swig_types[19]

2486

#define SWIGTYPE_p_wxColourData swig_types[20]

2487

#define SWIGTYPE_p_wxColourDialog swig_types[21]

2488

#define SWIGTYPE_p_wxComboCtrlBase swig_types[22]

2489

#define SWIGTYPE_p_wxComboCtrlFeatures swig_types[23]

2490

#define SWIGTYPE_p_wxCommandEvent swig_types[24]

2491

#define SWIGTYPE_p_wxContextMenuEvent swig_types[25]

2492

#define SWIGTYPE_p_wxControl swig_types[26]

2493

#define SWIGTYPE_p_wxControlWithItems swig_types[27]

2494

#define SWIGTYPE_p_wxDC swig_types[28]

2495

#define SWIGTYPE_p_wxDateEvent swig_types[29]

2496

#define SWIGTYPE_p_wxDialog swig_types[30]

2497

#define SWIGTYPE_p_wxDirDialog swig_types[31]

2498

#define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]

2499

#define SWIGTYPE_p_wxDropFilesEvent swig_types[33]

2500

#define SWIGTYPE_p_wxDuplexMode swig_types[34]

2501

#define SWIGTYPE_p_wxEraseEvent swig_types[35]

2502

#define SWIGTYPE_p_wxEvent swig_types[36]

2503

#define SWIGTYPE_p_wxEvtHandler swig_types[37]

2504

#define SWIGTYPE_p_wxFSFile swig_types[38]

2505

#define SWIGTYPE_p_wxFileDialog swig_types[39]

2506

#define SWIGTYPE_p_wxFileSystem swig_types[40]

2507

#define SWIGTYPE_p_wxFindDialogEvent swig_types[41]

2508

#define SWIGTYPE_p_wxFindReplaceData swig_types[42]

2509

#define SWIGTYPE_p_wxFindReplaceDialog swig_types[43]

2510

#define SWIGTYPE_p_wxFlexGridSizer swig_types[44]

2511

#define SWIGTYPE_p_wxFocusEvent swig_types[45]

2512

#define SWIGTYPE_p_wxFontData swig_types[46]

2513

#define SWIGTYPE_p_wxFontDialog swig_types[47]

2514

#define SWIGTYPE_p_wxFrame swig_types[48]

2515

#define SWIGTYPE_p_wxGBSizerItem swig_types[49]

2516

#define SWIGTYPE_p_wxGIFHandler swig_types[50]

2517

#define SWIGTYPE_p_wxGridBagSizer swig_types[51]

2518

#define SWIGTYPE_p_wxGridSizer swig_types[52]

2519

#define SWIGTYPE_p_wxICOHandler swig_types[53]

2520

#define SWIGTYPE_p_wxIconizeEvent swig_types[54]

2521

#define SWIGTYPE_p_wxIdleEvent swig_types[55]

2522

#define SWIGTYPE_p_wxImage swig_types[56]

2523

#define SWIGTYPE_p_wxImageHandler swig_types[57]

2524

#define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[58]

2525

#define SWIGTYPE_p_wxInitDialogEvent swig_types[59]

2526

#define SWIGTYPE_p_wxItemContainer swig_types[60]

2527

#define SWIGTYPE_p_wxJPEGHandler swig_types[61]

2528

#define SWIGTYPE_p_wxKeyEvent swig_types[62]

2529

#define SWIGTYPE_p_wxLayoutAlgorithm swig_types[63]

2530

#define SWIGTYPE_p_wxLayoutConstraints swig_types[64]

2531

#define SWIGTYPE_p_wxMDIChildFrame swig_types[65]

2532

#define SWIGTYPE_p_wxMDIClientWindow swig_types[66]

2533

#define SWIGTYPE_p_wxMDIParentFrame swig_types[67]

2534

#define SWIGTYPE_p_wxMaximizeEvent swig_types[68]

2535

#define SWIGTYPE_p_wxMenu swig_types[69]

2536

#define SWIGTYPE_p_wxMenuBar swig_types[70]

2537

#define SWIGTYPE_p_wxMenuEvent swig_types[71]

2538

#define SWIGTYPE_p_wxMenuItem swig_types[72]

2539

#define SWIGTYPE_p_wxMessageDialog swig_types[73]

2540

#define SWIGTYPE_p_wxMiniFrame swig_types[74]

2541

#define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]

2542

#define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[76]

2543

#define SWIGTYPE_p_wxMouseEvent swig_types[77]

2544

#define SWIGTYPE_p_wxMoveEvent swig_types[78]

2545

#define SWIGTYPE_p_wxMultiChoiceDialog swig_types[79]

2546

#define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]

2547

#define SWIGTYPE_p_wxNcPaintEvent swig_types[81]

2548

#define SWIGTYPE_p_wxNotifyEvent swig_types[82]

2549

#define SWIGTYPE_p_wxNumberEntryDialog swig_types[83]

2550

#define SWIGTYPE_p_wxObject swig_types[84]

2551

#define SWIGTYPE_p_wxPCXHandler swig_types[85]

2552

#define SWIGTYPE_p_wxPNGHandler swig_types[86]

2553

#define SWIGTYPE_p_wxPNMHandler swig_types[87]

2554

#define SWIGTYPE_p_wxPageSetupDialog swig_types[88]

2555

#define SWIGTYPE_p_wxPageSetupDialogData swig_types[89]

2556

#define SWIGTYPE_p_wxPaintEvent swig_types[90]

2557

#define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]

2558

#define SWIGTYPE_p_wxPanel swig_types[92]

2559

#define SWIGTYPE_p_wxPaperSize swig_types[93]

2560

#define SWIGTYPE_p_wxPasswordEntryDialog swig_types[94]

2561

#define SWIGTYPE_p_wxPopupWindow swig_types[95]

2562

#define SWIGTYPE_p_wxPreviewCanvas swig_types[96]

2563

#define SWIGTYPE_p_wxPreviewControlBar swig_types[97]

2564

#define SWIGTYPE_p_wxPreviewFrame swig_types[98]

2565

#define SWIGTYPE_p_wxPrintData swig_types[99]

2566

#define SWIGTYPE_p_wxPrintDialog swig_types[100]

2567

#define SWIGTYPE_p_wxPrintDialogData swig_types[101]

2568

#define SWIGTYPE_p_wxPrintPreview swig_types[102]

2569

#define SWIGTYPE_p_wxPrinter swig_types[103]

2570

#define SWIGTYPE_p_wxProgressDialog swig_types[104]

2571

#define SWIGTYPE_p_wxPyApp swig_types[105]

2572

#define SWIGTYPE_p_wxPyComboCtrl swig_types[106]

2573

#define SWIGTYPE_p_wxPyComboPopup swig_types[107]

2574

#define SWIGTYPE_p_wxPyCommandEvent swig_types[108]

2575

#define SWIGTYPE_p_wxPyEvent swig_types[109]

2576

#define SWIGTYPE_p_wxPyEvtHandler swig_types[110]

2577

#define SWIGTYPE_p_wxPyHtmlListBox swig_types[111]

2578

#define SWIGTYPE_p_wxPyImageHandler swig_types[112]

2579

#define SWIGTYPE_p_wxPyOwnerDrawnComboBox swig_types[113]

2580

#define SWIGTYPE_p_wxPyPanel swig_types[114]

2581

#define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[115]

2582

#define SWIGTYPE_p_wxPyPreviewControlBar swig_types[116]

2583

#define SWIGTYPE_p_wxPyPreviewFrame swig_types[117]

2584

#define SWIGTYPE_p_wxPyPrintPreview swig_types[118]

2585

#define SWIGTYPE_p_wxPyPrintout swig_types[119]

2586

#define SWIGTYPE_p_wxPyScrolledWindow swig_types[120]

2587

#define SWIGTYPE_p_wxPySizer swig_types[121]

2588

#define SWIGTYPE_p_wxPyTaskBarIcon swig_types[122]

2589

#define SWIGTYPE_p_wxPyVListBox swig_types[123]

2590

#define SWIGTYPE_p_wxPyVScrolledWindow swig_types[124]

2591

#define SWIGTYPE_p_wxPyValidator swig_types[125]

2592

#define SWIGTYPE_p_wxPyWindow swig_types[126]

2593

#define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[127]

2594

#define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[128]

2595

#define SWIGTYPE_p_wxRect swig_types[129]

2596

#define SWIGTYPE_p_wxSashEvent swig_types[130]

2597

#define SWIGTYPE_p_wxSashLayoutWindow swig_types[131]

2598

#define SWIGTYPE_p_wxSashWindow swig_types[132]

2599

#define SWIGTYPE_p_wxScrollEvent swig_types[133]

2600

#define SWIGTYPE_p_wxScrollWinEvent swig_types[134]

2601

#define SWIGTYPE_p_wxScrolledWindow swig_types[135]

2602

#define SWIGTYPE_p_wxSetCursorEvent swig_types[136]

2603

#define SWIGTYPE_p_wxShowEvent swig_types[137]

2604

#define SWIGTYPE_p_wxSimpleHtmlListBox swig_types[138]

2605

#define SWIGTYPE_p_wxSingleChoiceDialog swig_types[139]

2606

#define SWIGTYPE_p_wxSize swig_types[140]

2607

#define SWIGTYPE_p_wxSizeEvent swig_types[141]

2608

#define SWIGTYPE_p_wxSizer swig_types[142]

2609

#define SWIGTYPE_p_wxSizerItem swig_types[143]

2610

#define SWIGTYPE_p_wxSplashScreen swig_types[144]

2611

#define SWIGTYPE_p_wxSplashScreenWindow swig_types[145]

2612

#define SWIGTYPE_p_wxSplitterEvent swig_types[146]

2613

#define SWIGTYPE_p_wxSplitterWindow swig_types[147]

2614

#define SWIGTYPE_p_wxStaticBoxSizer swig_types[148]

2615

#define SWIGTYPE_p_wxStatusBar swig_types[149]

2616

#define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[150]

2617

#define SWIGTYPE_p_wxSysColourChangedEvent swig_types[151]

2618

#define SWIGTYPE_p_wxTGAHandler swig_types[152]

2619

#define SWIGTYPE_p_wxTIFFHandler swig_types[153]

2620

#define SWIGTYPE_p_wxTaskBarIconEvent swig_types[154]

2621

#define SWIGTYPE_p_wxTextEntryDialog swig_types[155]

2622

#define SWIGTYPE_p_wxTipWindow swig_types[156]

2623

#define SWIGTYPE_p_wxTopLevelWindow swig_types[157]

2624

#define SWIGTYPE_p_wxUpdateUIEvent swig_types[158]

2625

#define SWIGTYPE_p_wxValidator swig_types[159]

2626

#define SWIGTYPE_p_wxWindow swig_types[160]

2627

#define SWIGTYPE_p_wxWindowCreateEvent swig_types[161]

2628

#define SWIGTYPE_p_wxWindowDestroyEvent swig_types[162]

2629

#define SWIGTYPE_p_wxXPMHandler swig_types[163]

2630

static swig_type_info *swig_types[165];

2631

static swig_module_info swig_module = {swig_types, 164, 0, 0, 0, 0};

2632

#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)

2633

#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

2634

2635

/* -------- TYPES TABLE (END) -------- */

2636

2637

#if (PY_VERSION_HEX <= 0x02000000)

2638

# if !defined(SWIG_PYTHON_CLASSIC)

2639

# error "This python version requires to use swig with the '-classic' option"

2640

# endif

2641

#endif

2642

#if (PY_VERSION_HEX <= 0x02020000)

2643

# error "This python version requires to use swig with the '-nomodern' option"

2644

#endif

2645

#if (PY_VERSION_HEX <= 0x02020000)

2646

# error "This python version requires to use swig with the '-nomodernargs' option"

2647

#endif

2648

#ifndef METH_O

2649

# error "This python version requires to use swig with the '-nofastunpack' option"

2650

#endif

2651

2652

/*-----------------------------------------------

2653

@(target):= _combo.so

2654

------------------------------------------------*/

2655

#define SWIG_init init_combo

2656

2657

#define SWIG_name "_combo"

2658

2659

#define SWIGVERSION 0x010329

2660

2661

2662

#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))

2663

#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))

2664

2665

2666

#include <stdexcept>

2667

2668

2669

namespace swig {

2670

class PyObject_ptr {

2671

protected:

2672

PyObject *_obj;

2673

2674

public:

2675

PyObject_ptr() :_obj(0)

2676

{

2677

}

2678

2679

PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)

2680

{

2681

Py_XINCREF(_obj);

2682

}

2683

2684

PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)

2685

{

2686

if (initial_ref) Py_XINCREF(_obj);

2687

}

2688

2689

PyObject_ptr & operator=(const PyObject_ptr& item)

2690

{

2691

Py_XINCREF(item._obj);

2692

Py_XDECREF(_obj);

2693

_obj = item._obj;

2694

return *this;

2695

}

2696

2697

~PyObject_ptr()

2698

{

2699

Py_XDECREF(_obj);

2700

}

2701

2702

operator PyObject *() const

2703

{

2704

return _obj;

2705

}

2706

2707

PyObject *operator->() const

2708

{

2709

return _obj;

2710

}

2711

};

2712

}

2713

2714

2715

namespace swig {

2716

struct PyObject_var : PyObject_ptr {

2717

PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }

2718

2719

PyObject_var & operator = (PyObject* obj)

2720

{

2721

Py_XDECREF(_obj);

2722

_obj = obj;

2723

return *this;

2724

}

2725

};

2726

}

2727

2728

2729

#include "wx/wxPython/wxPython.h"

2730

#include "wx/wxPython/pyclasses.h"

2731

2732

#include <wx/combo.h>

2733

#include <wx/odcombo.h>

2734

2735

static const wxString wxPyComboBoxNameStr(wxComboBoxNameStr);

2736

static const wxString wxPyEmptyString(wxEmptyString);

2737

2738

const wxArrayString wxPyEmptyStringArray;

2739

2740

2741

#define SWIG_From_long PyInt_FromLong

2742

2743

2744

SWIGINTERNINLINE PyObject *

2745

SWIG_From_int (int value)

2746

{

2747

return SWIG_From_long (value);

2748

}

2749

2750

2751

class wxPyComboCtrl : public wxComboCtrl

2752

{

2753

DECLARE_ABSTRACT_CLASS(wxPyComboCtrl)

2754

public:

2755

wxPyComboCtrl() : wxComboCtrl() {}

2756

wxPyComboCtrl(wxWindow *parent,

2757

wxWindowID id = wxID_ANY,

2758

const wxString& value = wxEmptyString,

2759

const wxPoint& pos = wxDefaultPosition,

2760

const wxSize& size = wxDefaultSize,

2761

long style = 0,

2762

const wxValidator& validator = wxDefaultValidator,

2763

const wxString& name = wxPyComboBoxNameStr)

2764

: wxComboCtrl(parent, id, value, pos, size, style, validator, name)

2765

{}

2766

2767

void DoSetPopupControl(wxComboPopup* popup)

2768

{

2769

bool found;

2770

wxPyBlock_t blocked = wxPyBeginBlockThreads();

2771

if ((found = wxPyCBH_findCallback(m_myInst, "DoSetPopupControl"))) {

2772

PyObject* obj = wxPyConstructObject(popup, wxT("wxComboPopup"), false);

2773

wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)",obj));

2774

Py_DECREF(obj);

2775

}

2776

wxPyEndBlockThreads(blocked);

2777

if (! found)

2778

wxComboCtrl::DoSetPopupControl(popup);

2779

}

2780

2781

virtual bool IsKeyPopupToggle( const wxKeyEvent& event ) const

2782

{

2783

bool found;

2784

bool rval = false;

2785

wxPyBlock_t blocked = wxPyBeginBlockThreads();

2786

if ((found = wxPyCBH_findCallback(m_myInst, "OnComboKeyEvent"))) {

2787

PyObject* oevt = wxPyConstructObject((void*)&event, wxT("wxKeyEvent"), 0);

2788

rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", oevt));

2789

Py_DECREF(oevt);

2790

}

2791

wxPyEndBlockThreads(blocked);

2792

if (! found)

2793

rval = wxComboCtrl::IsKeyPopupToggle(event);

2794

return rval;

2795

}

2796

2797

2798

virtual wxWindow *GetMainWindowOfCompositeControl()

2799

{

2800

return wxComboCtrl::GetMainWindowOfCompositeControl();

2801

}

2802

2803

void DestroyPopup()

2804

{

2805

wxComboCtrlBase::DestroyPopup();

2806

}

2807

2808

2809

enum

2810

{

2811

ShowBelow = 0x0000, // Showing popup below the control

2812

ShowAbove = 0x0001, // Showing popup above the control

2813

CanDeferShow = 0x0002 // Can only return true from AnimateShow if this is set

2814

};

2815

2816

2817

DEC_PYCALLBACK_VOID_(ShowPopup);

2818

DEC_PYCALLBACK_VOID_(HidePopup);

2819

DEC_PYCALLBACK_VOID_(OnButtonClick);

2820

DEC_PYCALLBACK__RECTINT(DoShowPopup);

2821

DEC_PYCALLBACK_BOOL_RECTINT(AnimateShow);

2822

2823

PYPRIVATE;

2824

};

2825

2826

IMPLEMENT_ABSTRACT_CLASS(wxPyComboCtrl, wxComboCtrl);

2827

2828

IMP_PYCALLBACK_VOID_(wxPyComboCtrl, wxComboCtrl, ShowPopup);

2829

IMP_PYCALLBACK_VOID_(wxPyComboCtrl, wxComboCtrl, HidePopup);

2830

IMP_PYCALLBACK_VOID_(wxPyComboCtrl, wxComboCtrl, OnButtonClick);

2831

IMP_PYCALLBACK__RECTINT(wxPyComboCtrl, wxComboCtrl, DoShowPopup);

2832

IMP_PYCALLBACK_BOOL_RECTINT(wxPyComboCtrl, wxComboCtrl, AnimateShow);

2833

2834

2835

2836

#include <limits.h>

2837

#ifndef LLONG_MIN

2838

# define LLONG_MIN LONG_LONG_MIN

2839

#endif

2840

#ifndef LLONG_MAX

2841

# define LLONG_MAX LONG_LONG_MAX

2842

#endif

2843

#ifndef ULLONG_MAX

2844

# define ULLONG_MAX ULONG_LONG_MAX

2845

#endif

2846

2847

2848

SWIGINTERN int

2849

SWIG_AsVal_long (PyObject* obj, long* val)

2850

{

2851

if (PyNumber_Check(obj)) {

2852

if (val) *val = PyInt_AsLong(obj);

2853

return SWIG_OK;

2854

}

2855

return SWIG_TypeError;

2856

}

2857

2858

2859

SWIGINTERN int

2860

SWIG_AsVal_int (PyObject * obj, int *val)

2861

{

2862

long v;

2863

int res = SWIG_AsVal_long (obj, &v);

2864

if (SWIG_IsOK(res)) {

2865

if ((v < INT_MIN || v > INT_MAX)) {

2866

return SWIG_OverflowError;

2867

} else {

2868

if (val) *val = static_cast< int >(v);

2869

}

2870

}

2871

return res;

2872

}

2873

2874

2875

SWIGINTERN int

2876

SWIG_AsVal_bool (PyObject *obj, bool *val)

2877

{

2878

if (obj == Py_True) {

2879

if (val) *val = true;

2880

return SWIG_OK;

2881

} else if (obj == Py_False) {

2882

if (val) *val = false;

2883

return SWIG_OK;

2884

} else {

2885

long v = 0;

2886

int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));

2887

if (SWIG_IsOK(res) && val) *val = v ? true : false;

2888

return res;

2889

}

2890

}

2891

2892

2893

SWIGINTERNINLINE PyObject*

2894

SWIG_From_unsigned_SS_long (unsigned long value)

2895

{

2896

return (value > LONG_MAX) ?

2897

PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));

2898

}

2899

2900

2901

SWIGINTERNINLINE PyObject *

2902

SWIG_From_unsigned_SS_int (unsigned int value)

2903

{

2904

return SWIG_From_unsigned_SS_long (value);

2905

}

2906

2907

2908

class wxPyComboPopup : public wxComboPopup

2909

{

2910

public:

2911

wxPyComboPopup() : wxComboPopup() {}

2912

~wxPyComboPopup() {}

2913

2914

2915

DEC_PYCALLBACK_VOID_(Init);

2916

DEC_PYCALLBACK_BOOL_WXWIN_pure(Create);

2917

DEC_PYCALLBACK_VOID_(OnPopup);

2918

DEC_PYCALLBACK_VOID_(OnDismiss);

2919

DEC_PYCALLBACK__STRING(SetStringValue);

2920

DEC_PYCALLBACK_STRING__constpure(GetStringValue);

2921

DEC_PYCALLBACK_VOID_(OnComboDoubleClick);

2922

DEC_PYCALLBACK_BOOL_(LazyCreate);

2923

2924

virtual wxWindow *GetControl()

2925

{

2926

wxWindow* rval = NULL;

2927

const char* errmsg = "GetControl should return an object derived from wx.Window.";

2928

wxPyBlock_t blocked = wxPyBeginBlockThreads();

2929

if (wxPyCBH_findCallback(m_myInst, "GetControl")) {

2930

PyObject* ro;

2931

ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));

2932

if (ro) {

2933

if (!wxPyConvertSwigPtr(ro, (void**)&rval, wxT("wxWindow")))

2934

PyErr_SetString(PyExc_TypeError, errmsg);

2935

Py_DECREF(ro);

2936

}

2937

}

2938

else

2939

PyErr_SetString(PyExc_TypeError, errmsg);

2940

wxPyEndBlockThreads(blocked);

2941

return rval;

2942

}

2943

2944

2945

virtual void PaintComboControl( wxDC& dc, const wxRect& rect )

2946

{

2947

bool found;

2948

wxPyBlock_t blocked = wxPyBeginBlockThreads();

2949

if ((found = wxPyCBH_findCallback(m_myInst, "PaintComboControl"))) {

2950

PyObject* odc = wxPyMake_wxObject(&dc,false);

2951

PyObject* orect = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);

2952

wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", odc, orect));

2953

Py_DECREF(odc);

2954

Py_DECREF(orect);

2955

}

2956

wxPyEndBlockThreads(blocked);

2957

if (! found)

2958

wxComboPopup::PaintComboControl(dc, rect);

2959

}

2960

2961

2962

virtual void OnComboKeyEvent( wxKeyEvent& event )

2963

{

2964

bool found;

2965

wxPyBlock_t blocked = wxPyBeginBlockThreads();

2966

if ((found = wxPyCBH_findCallback(m_myInst, "OnComboKeyEvent"))) {

2967

PyObject* oevt = wxPyConstructObject((void*)&event, wxT("wxKeyEvent"), 0);

2968

wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", oevt));

2969

Py_DECREF(oevt);

2970

}

2971

wxPyEndBlockThreads(blocked);

2972

if (! found)

2973

wxComboPopup::OnComboKeyEvent(event);

2974

}

2975

2976

2977

virtual wxSize GetAdjustedSize( int minWidth, int prefHeight, int maxHeight )

2978

{

2979

const char* errmsg = "GetAdjustedSize should return a wx.Size or a 2-tuple of integers.";

2980

bool found;

2981

wxSize rval(0,0);

2982

wxSize* rptr = &rval;

2983

wxPyBlock_t blocked = wxPyBeginBlockThreads();

2984

if ((found = wxPyCBH_findCallback(m_myInst, "GetAdjustedSize"))) {

2985

PyObject* ro;

2986

ro = wxPyCBH_callCallbackObj(

2987

m_myInst, Py_BuildValue("(iii)", minWidth, prefHeight, maxHeight));

2988

if (ro) {

2989

if (! wxSize_helper(ro, &rptr))

2990

PyErr_SetString(PyExc_TypeError, errmsg);

2991

else

2992

rval = *rptr;

2993

Py_DECREF(ro);

2994

}

2995

}

2996

wxPyEndBlockThreads(blocked);

2997

if (! found)

2998

rval = wxComboPopup::GetAdjustedSize(minWidth, prefHeight, maxHeight);

2999

return rval;

3000

}

3001

3002

wxComboCtrl* GetCombo() { return (wxComboCtrl*)m_combo; }

3003

3004

PYPRIVATE;

3005

};

3006

3007

3008

IMP_PYCALLBACK_VOID_(wxPyComboPopup, wxComboPopup, Init);

3009

IMP_PYCALLBACK_BOOL_WXWIN_pure(wxPyComboPopup, wxComboPopup, Create);

3010

IMP_PYCALLBACK_VOID_(wxPyComboPopup, wxComboPopup, OnPopup);

3011

IMP_PYCALLBACK_VOID_(wxPyComboPopup, wxComboPopup, OnDismiss);

3012

IMP_PYCALLBACK__STRING(wxPyComboPopup, wxComboPopup, SetStringValue);

3013

IMP_PYCALLBACK_STRING__constpure(wxPyComboPopup, wxComboPopup, GetStringValue);

3014

IMP_PYCALLBACK_VOID_(wxPyComboPopup, wxComboPopup, OnComboDoubleClick);

3015

IMP_PYCALLBACK_BOOL_(wxPyComboPopup, wxComboPopup, LazyCreate);

3016

3017

3018

3019

class wxPyOwnerDrawnComboBox : public wxOwnerDrawnComboBox

3020

{

3021

public:

3022

wxPyOwnerDrawnComboBox() : wxOwnerDrawnComboBox() {}

3023

wxPyOwnerDrawnComboBox(wxWindow *parent,

3024

wxWindowID id,

3025

const wxString& value,

3026

const wxPoint& pos,

3027

const wxSize& size,

3028

const wxArrayString& choices,

3029

long style,

3030

const wxValidator& validator = wxDefaultValidator,

3031

const wxString& name = wxPyComboBoxNameStr)

3032

: wxOwnerDrawnComboBox(parent, id, value, pos, size, choices, style,

3033

validator, name)

3034

{}

3035

3036

DEC_PYCALLBACK__DCRECTINTINT_const(OnDrawItem);

3037

DEC_PYCALLBACK_COORD_SIZET_const(OnMeasureItem);

3038

DEC_PYCALLBACK_COORD_SIZET_const(OnMeasureItemWidth);

3039

DEC_PYCALLBACK__DCRECTINTINT_const(OnDrawBackground);

3040

3041

3042

PYPRIVATE;

3043

};

3044

3045

IMP_PYCALLBACK__DCRECTINTINT_const(wxPyOwnerDrawnComboBox, wxOwnerDrawnComboBox, OnDrawItem);

3046

IMP_PYCALLBACK_COORD_SIZET_const(wxPyOwnerDrawnComboBox, wxOwnerDrawnComboBox, OnMeasureItem);

3047

IMP_PYCALLBACK_COORD_SIZET_const(wxPyOwnerDrawnComboBox, wxOwnerDrawnComboBox, OnMeasureItemWidth);

3048

IMP_PYCALLBACK__DCRECTINTINT_const(wxPyOwnerDrawnComboBox, wxOwnerDrawnComboBox, OnDrawBackground);

3049

3050

3051

3052

SWIGINTERN int

3053

SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)

3054

{

3055

long v = 0;

3056

int res = SWIG_AsVal_long(obj, &v);

3057

if (SWIG_IsOK(res)) {

3058

if ( v < 0) {

3059

return SWIG_ValueError;

3060

}

3061

else if (val)

3062

*val = (unsigned long)v;

3063

}

3064

return res;

3065

}

3066

3067

3068

SWIGINTERNINLINE int

3069

SWIG_AsVal_size_t (PyObject * obj, size_t *val)

3070

{

3071

unsigned long v;

3072

int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);

3073

if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);

3074

return res;

3075

}

3076

3077

3078

#include <wx/bmpcbox.h>

3079

3080

SWIGINTERN int wxBitmapComboBox_Append(wxBitmapComboBox *self,wxString const &item,wxBitmap const &bitmap=wxNullBitmap,PyObject *clientData=NULL){

3081

if (clientData) {

3082

wxPyClientData* data = new wxPyClientData(clientData);

3083

return self->Append(item, bitmap, data);

3084

} else

3085

return self->Append(item, bitmap);

3086

}

3087

SWIGINTERN int wxBitmapComboBox_Insert(wxBitmapComboBox *self,wxString const &item,wxBitmap const &bitmap,int pos,PyObject *clientData=NULL){

3088

if (clientData) {

3089

wxPyClientData* data = new wxPyClientData(clientData);

3090

return self->Insert(item, bitmap, pos, data);

3091

} else

3092

return self->Insert(item, bitmap, pos);

3093

}

3094

#ifdef __cplusplus

3095

extern "C" {

3096

#endif

3097

SWIGINTERN PyObject *ComboCtrlFeatures_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3098

PyObject *obj;

3099

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

3100

SWIG_TypeNewClientData(SWIGTYPE_p_wxComboCtrlFeatures, SWIG_NewClientData(obj));

3101

return SWIG_Py_Void();

3102

}

3103

3104

SWIGINTERN PyObject *_wrap_new_ComboCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

3105

PyObject *resultobj = 0;

3106

wxWindow *arg1 = (wxWindow *) 0 ;

3107

int arg2 = (int) wxID_ANY ;

3108

wxString const &arg3_defvalue = wxEmptyString ;

3109

wxString *arg3 = (wxString *) &arg3_defvalue ;

3110

wxPoint const &arg4_defvalue = wxDefaultPosition ;

3111

wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;

3112

wxSize const &arg5_defvalue = wxDefaultSize ;

3113

wxSize *arg5 = (wxSize *) &arg5_defvalue ;

3114

long arg6 = (long) 0 ;

3115

wxValidator const &arg7_defvalue = wxDefaultValidator ;

3116

wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;

3117

wxString const &arg8_defvalue = wxPyComboBoxNameStr ;

3118

wxString *arg8 = (wxString *) &arg8_defvalue ;

3119

wxPyComboCtrl *result = 0 ;

3120

void *argp1 = 0 ;

3121

int res1 = 0 ;

3122

int val2 ;

3123

int ecode2 = 0 ;

3124

bool temp3 = false ;

3125

wxPoint temp4 ;

3126

wxSize temp5 ;

3127

long val6 ;

3128

int ecode6 = 0 ;

3129

void *argp7 = 0 ;

3130

int res7 = 0 ;

3131

bool temp8 = false ;

3132

PyObject * obj0 = 0 ;

3133

PyObject * obj1 = 0 ;

3134

PyObject * obj2 = 0 ;

3135

PyObject * obj3 = 0 ;

3136

PyObject * obj4 = 0 ;

3137

PyObject * obj5 = 0 ;

3138

PyObject * obj6 = 0 ;

3139

PyObject * obj7 = 0 ;

3140

char * kwnames[] = {

3141

(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL

3142

};

3143

3144

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_ComboCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;

3145

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );

3146

if (!SWIG_IsOK(res1)) {

3147

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComboCtrl" "', expected argument " "1"" of type '" "wxWindow *""'");

3148

}

3149

arg1 = reinterpret_cast< wxWindow * >(argp1);

3150

if (obj1) {

3151

ecode2 = SWIG_AsVal_int(obj1, &val2);

3152

if (!SWIG_IsOK(ecode2)) {

3153

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ComboCtrl" "', expected argument " "2"" of type '" "int""'");

3154

}

3155

arg2 = static_cast< int >(val2);

3156

}

3157

if (obj2) {

3158

{

3159

arg3 = wxString_in_helper(obj2);

3160

if (arg3 == NULL) SWIG_fail;

3161

temp3 = true;

3162

}

3163

}

3164

if (obj3) {

3165

{

3166

arg4 = &temp4;

3167

if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;

3168

}

3169

}

3170

if (obj4) {

3171

{

3172

arg5 = &temp5;

3173

if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;

3174

}

3175

}

3176

if (obj5) {

3177

ecode6 = SWIG_AsVal_long(obj5, &val6);

3178

if (!SWIG_IsOK(ecode6)) {

3179

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ComboCtrl" "', expected argument " "6"" of type '" "long""'");

3180

}

3181

arg6 = static_cast< long >(val6);

3182

}

3183

if (obj6) {

3184

res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);

3185

if (!SWIG_IsOK(res7)) {

3186

SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ComboCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'");

3187

}

3188

if (!argp7) {

3189

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComboCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'");

3190

}

3191

arg7 = reinterpret_cast< wxValidator * >(argp7);

3192

}

3193

if (obj7) {

3194

{

3195

arg8 = wxString_in_helper(obj7);

3196

if (arg8 == NULL) SWIG_fail;

3197

temp8 = true;

3198

}

3199

}

3200

{

3201

if (!wxPyCheckForApp()) SWIG_fail;

3202

PyThreadState* __tstate = wxPyBeginAllowThreads();

3203

result = (wxPyComboCtrl *)new wxPyComboCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);

3204

wxPyEndAllowThreads(__tstate);

3205

if (PyErr_Occurred()) SWIG_fail;

3206

}

3207

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyComboCtrl, SWIG_POINTER_NEW | 0 );

3208

{

3209

if (temp3)

3210

delete arg3;

3211

}

3212

{

3213

if (temp8)

3214

delete arg8;

3215

}

3216

return resultobj;

3217

fail:

3218

{

3219

if (temp3)

3220

delete arg3;

3221

}

3222

{

3223

if (temp8)

3224

delete arg8;

3225

}

3226

return NULL;

3227

}

3228

3229

3230

SWIGINTERN PyObject *_wrap_new_PreComboCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3231

PyObject *resultobj = 0;

3232

wxPyComboCtrl *result = 0 ;

3233

3234

if (!SWIG_Python_UnpackTuple(args,"new_PreComboCtrl",0,0,0)) SWIG_fail;

3235

{

3236

if (!wxPyCheckForApp()) SWIG_fail;

3237

PyThreadState* __tstate = wxPyBeginAllowThreads();

3238

result = (wxPyComboCtrl *)new wxPyComboCtrl();

3239

wxPyEndAllowThreads(__tstate);

3240

if (PyErr_Occurred()) SWIG_fail;

3241

}

3242

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyComboCtrl, SWIG_POINTER_OWN | 0 );

3243

return resultobj;

3244

fail:

3245

return NULL;

3246

}

3247

3248

3249

SWIGINTERN PyObject *_wrap_ComboCtrl__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

3250

PyObject *resultobj = 0;

3251

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3252

PyObject *arg2 = (PyObject *) 0 ;

3253

PyObject *arg3 = (PyObject *) 0 ;

3254

void *argp1 = 0 ;

3255

int res1 = 0 ;

3256

PyObject * obj0 = 0 ;

3257

PyObject * obj1 = 0 ;

3258

PyObject * obj2 = 0 ;

3259

char * kwnames[] = {

3260

(char *) "self",(char *) "self",(char *) "_class", NULL

3261

};

3262

3263

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboCtrl__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

3264

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3265

if (!SWIG_IsOK(res1)) {

3266

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3267

}

3268

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3269

arg2 = obj1;

3270

arg3 = obj2;

3271

{

3272

PyThreadState* __tstate = wxPyBeginAllowThreads();

3273

(arg1)->_setCallbackInfo(arg2,arg3);

3274

wxPyEndAllowThreads(__tstate);

3275

if (PyErr_Occurred()) SWIG_fail;

3276

}

3277

resultobj = SWIG_Py_Void();

3278

return resultobj;

3279

fail:

3280

return NULL;

3281

}

3282

3283

3284

SWIGINTERN PyObject *_wrap_ComboCtrl_ShowPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3285

PyObject *resultobj = 0;

3286

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3287

void *argp1 = 0 ;

3288

int res1 = 0 ;

3289

PyObject *swig_obj[1] ;

3290

3291

if (!args) SWIG_fail;

3292

swig_obj[0] = args;

3293

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3294

if (!SWIG_IsOK(res1)) {

3295

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_ShowPopup" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3296

}

3297

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3298

{

3299

PyThreadState* __tstate = wxPyBeginAllowThreads();

3300

(arg1)->ShowPopup();

3301

wxPyEndAllowThreads(__tstate);

3302

if (PyErr_Occurred()) SWIG_fail;

3303

}

3304

resultobj = SWIG_Py_Void();

3305

return resultobj;

3306

fail:

3307

return NULL;

3308

}

3309

3310

3311

SWIGINTERN PyObject *_wrap_ComboCtrl_HidePopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3312

PyObject *resultobj = 0;

3313

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3314

void *argp1 = 0 ;

3315

int res1 = 0 ;

3316

PyObject *swig_obj[1] ;

3317

3318

if (!args) SWIG_fail;

3319

swig_obj[0] = args;

3320

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3321

if (!SWIG_IsOK(res1)) {

3322

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_HidePopup" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3323

}

3324

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3325

{

3326

PyThreadState* __tstate = wxPyBeginAllowThreads();

3327

(arg1)->HidePopup();

3328

wxPyEndAllowThreads(__tstate);

3329

if (PyErr_Occurred()) SWIG_fail;

3330

}

3331

resultobj = SWIG_Py_Void();

3332

return resultobj;

3333

fail:

3334

return NULL;

3335

}

3336

3337

3338

SWIGINTERN PyObject *_wrap_ComboCtrl_OnButtonClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3339

PyObject *resultobj = 0;

3340

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3341

void *argp1 = 0 ;

3342

int res1 = 0 ;

3343

PyObject *swig_obj[1] ;

3344

3345

if (!args) SWIG_fail;

3346

swig_obj[0] = args;

3347

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3348

if (!SWIG_IsOK(res1)) {

3349

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_OnButtonClick" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3350

}

3351

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3352

{

3353

PyThreadState* __tstate = wxPyBeginAllowThreads();

3354

(arg1)->OnButtonClick();

3355

wxPyEndAllowThreads(__tstate);

3356

if (PyErr_Occurred()) SWIG_fail;

3357

}

3358

resultobj = SWIG_Py_Void();

3359

return resultobj;

3360

fail:

3361

return NULL;

3362

}

3363

3364

3365

SWIGINTERN PyObject *_wrap_ComboCtrl_IsPopupShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3366

PyObject *resultobj = 0;

3367

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3368

bool result;

3369

void *argp1 = 0 ;

3370

int res1 = 0 ;

3371

PyObject *swig_obj[1] ;

3372

3373

if (!args) SWIG_fail;

3374

swig_obj[0] = args;

3375

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3376

if (!SWIG_IsOK(res1)) {

3377

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_IsPopupShown" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

3378

}

3379

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3380

{

3381

PyThreadState* __tstate = wxPyBeginAllowThreads();

3382

result = (bool)((wxPyComboCtrl const *)arg1)->IsPopupShown();

3383

wxPyEndAllowThreads(__tstate);

3384

if (PyErr_Occurred()) SWIG_fail;

3385

}

3386

{

3387

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

3388

}

3389

return resultobj;

3390

fail:

3391

return NULL;

3392

}

3393

3394

3395

SWIGINTERN PyObject *_wrap_ComboCtrl_SetPopupControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

3396

PyObject *resultobj = 0;

3397

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3398

wxPyComboPopup *arg2 = (wxPyComboPopup *) 0 ;

3399

void *argp1 = 0 ;

3400

int res1 = 0 ;

3401

int res2 = 0 ;

3402

PyObject * obj0 = 0 ;

3403

PyObject * obj1 = 0 ;

3404

char * kwnames[] = {

3405

(char *) "self",(char *) "popup", NULL

3406

};

3407

3408

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_SetPopupControl",kwnames,&obj0,&obj1)) SWIG_fail;

3409

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3410

if (!SWIG_IsOK(res1)) {

3411

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetPopupControl" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3412

}

3413

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3414

res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyComboPopup, SWIG_POINTER_DISOWN | 0 );

3415

if (!SWIG_IsOK(res2)) {

3416

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComboCtrl_SetPopupControl" "', expected argument " "2"" of type '" "wxPyComboPopup *""'");

3417

}

3418

{

3419

PyThreadState* __tstate = wxPyBeginAllowThreads();

3420

(arg1)->SetPopupControl(arg2);

3421

wxPyEndAllowThreads(__tstate);

3422

if (PyErr_Occurred()) SWIG_fail;

3423

}

3424

resultobj = SWIG_Py_Void();

3425

return resultobj;

3426

fail:

3427

return NULL;

3428

}

3429

3430

3431

SWIGINTERN PyObject *_wrap_ComboCtrl_GetPopupControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3432

PyObject *resultobj = 0;

3433

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3434

wxPyComboPopup *result = 0 ;

3435

void *argp1 = 0 ;

3436

int res1 = 0 ;

3437

PyObject *swig_obj[1] ;

3438

3439

if (!args) SWIG_fail;

3440

swig_obj[0] = args;

3441

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3442

if (!SWIG_IsOK(res1)) {

3443

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetPopupControl" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3444

}

3445

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3446

{

3447

PyThreadState* __tstate = wxPyBeginAllowThreads();

3448

result = (wxPyComboPopup *)(arg1)->GetPopupControl();

3449

wxPyEndAllowThreads(__tstate);

3450

if (PyErr_Occurred()) SWIG_fail;

3451

}

3452

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

3453

return resultobj;

3454

fail:

3455

return NULL;

3456

}

3457

3458

3459

SWIGINTERN PyObject *_wrap_ComboCtrl_GetPopupWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3460

PyObject *resultobj = 0;

3461

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3462

wxWindow *result = 0 ;

3463

void *argp1 = 0 ;

3464

int res1 = 0 ;

3465

PyObject *swig_obj[1] ;

3466

3467

if (!args) SWIG_fail;

3468

swig_obj[0] = args;

3469

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3470

if (!SWIG_IsOK(res1)) {

3471

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetPopupWindow" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

3472

}

3473

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3474

{

3475

PyThreadState* __tstate = wxPyBeginAllowThreads();

3476

result = (wxWindow *)((wxPyComboCtrl const *)arg1)->GetPopupWindow();

3477

wxPyEndAllowThreads(__tstate);

3478

if (PyErr_Occurred()) SWIG_fail;

3479

}

3480

{

3481

resultobj = wxPyMake_wxObject(result, 0);

3482

}

3483

return resultobj;

3484

fail:

3485

return NULL;

3486

}

3487

3488

3489

SWIGINTERN PyObject *_wrap_ComboCtrl_GetTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3490

PyObject *resultobj = 0;

3491

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3492

wxTextCtrl *result = 0 ;

3493

void *argp1 = 0 ;

3494

int res1 = 0 ;

3495

PyObject *swig_obj[1] ;

3496

3497

if (!args) SWIG_fail;

3498

swig_obj[0] = args;

3499

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3500

if (!SWIG_IsOK(res1)) {

3501

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetTextCtrl" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

3502

}

3503

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3504

{

3505

PyThreadState* __tstate = wxPyBeginAllowThreads();

3506

result = (wxTextCtrl *)((wxPyComboCtrl const *)arg1)->GetTextCtrl();

3507

wxPyEndAllowThreads(__tstate);

3508

if (PyErr_Occurred()) SWIG_fail;

3509

}

3510

{

3511

resultobj = wxPyMake_wxObject(result, (bool)0);

3512

}

3513

return resultobj;

3514

fail:

3515

return NULL;

3516

}

3517

3518

3519

SWIGINTERN PyObject *_wrap_ComboCtrl_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3520

PyObject *resultobj = 0;

3521

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3522

wxWindow *result = 0 ;

3523

void *argp1 = 0 ;

3524

int res1 = 0 ;

3525

PyObject *swig_obj[1] ;

3526

3527

if (!args) SWIG_fail;

3528

swig_obj[0] = args;

3529

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3530

if (!SWIG_IsOK(res1)) {

3531

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetButton" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

3532

}

3533

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3534

{

3535

PyThreadState* __tstate = wxPyBeginAllowThreads();

3536

result = (wxWindow *)((wxPyComboCtrl const *)arg1)->GetButton();

3537

wxPyEndAllowThreads(__tstate);

3538

if (PyErr_Occurred()) SWIG_fail;

3539

}

3540

{

3541

resultobj = wxPyMake_wxObject(result, 0);

3542

}

3543

return resultobj;

3544

fail:

3545

return NULL;

3546

}

3547

3548

3549

SWIGINTERN PyObject *_wrap_ComboCtrl_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3550

PyObject *resultobj = 0;

3551

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3552

wxString result;

3553

void *argp1 = 0 ;

3554

int res1 = 0 ;

3555

PyObject *swig_obj[1] ;

3556

3557

if (!args) SWIG_fail;

3558

swig_obj[0] = args;

3559

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3560

if (!SWIG_IsOK(res1)) {

3561

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetValue" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

3562

}

3563

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3564

{

3565

PyThreadState* __tstate = wxPyBeginAllowThreads();

3566

result = ((wxPyComboCtrl const *)arg1)->GetValue();

3567

wxPyEndAllowThreads(__tstate);

3568

if (PyErr_Occurred()) SWIG_fail;

3569

}

3570

{

3571

#if wxUSE_UNICODE

3572

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

3573

#else

3574

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

3575

#endif

3576

}

3577

return resultobj;

3578

fail:

3579

return NULL;

3580

}

3581

3582

3583

SWIGINTERN PyObject *_wrap_ComboCtrl_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

3584

PyObject *resultobj = 0;

3585

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3586

wxString *arg2 = 0 ;

3587

void *argp1 = 0 ;

3588

int res1 = 0 ;

3589

bool temp2 = false ;

3590

PyObject * obj0 = 0 ;

3591

PyObject * obj1 = 0 ;

3592

char * kwnames[] = {

3593

(char *) "self",(char *) "value", NULL

3594

};

3595

3596

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;

3597

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3598

if (!SWIG_IsOK(res1)) {

3599

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetValue" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3600

}

3601

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3602

{

3603

arg2 = wxString_in_helper(obj1);

3604

if (arg2 == NULL) SWIG_fail;

3605

temp2 = true;

3606

}

3607

{

3608

PyThreadState* __tstate = wxPyBeginAllowThreads();

3609

(arg1)->SetValue((wxString const &)*arg2);

3610

wxPyEndAllowThreads(__tstate);

3611

if (PyErr_Occurred()) SWIG_fail;

3612

}

3613

resultobj = SWIG_Py_Void();

3614

{

3615

if (temp2)

3616

delete arg2;

3617

}

3618

return resultobj;

3619

fail:

3620

{

3621

if (temp2)

3622

delete arg2;

3623

}

3624

return NULL;

3625

}

3626

3627

3628

SWIGINTERN PyObject *_wrap_ComboCtrl_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3629

PyObject *resultobj = 0;

3630

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3631

void *argp1 = 0 ;

3632

int res1 = 0 ;

3633

PyObject *swig_obj[1] ;

3634

3635

if (!args) SWIG_fail;

3636

swig_obj[0] = args;

3637

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3638

if (!SWIG_IsOK(res1)) {

3639

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_Copy" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3640

}

3641

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3642

{

3643

PyThreadState* __tstate = wxPyBeginAllowThreads();

3644

(arg1)->Copy();

3645

wxPyEndAllowThreads(__tstate);

3646

if (PyErr_Occurred()) SWIG_fail;

3647

}

3648

resultobj = SWIG_Py_Void();

3649

return resultobj;

3650

fail:

3651

return NULL;

3652

}

3653

3654

3655

SWIGINTERN PyObject *_wrap_ComboCtrl_Cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3656

PyObject *resultobj = 0;

3657

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3658

void *argp1 = 0 ;

3659

int res1 = 0 ;

3660

PyObject *swig_obj[1] ;

3661

3662

if (!args) SWIG_fail;

3663

swig_obj[0] = args;

3664

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3665

if (!SWIG_IsOK(res1)) {

3666

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_Cut" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3667

}

3668

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3669

{

3670

PyThreadState* __tstate = wxPyBeginAllowThreads();

3671

(arg1)->Cut();

3672

wxPyEndAllowThreads(__tstate);

3673

if (PyErr_Occurred()) SWIG_fail;

3674

}

3675

resultobj = SWIG_Py_Void();

3676

return resultobj;

3677

fail:

3678

return NULL;

3679

}

3680

3681

3682

SWIGINTERN PyObject *_wrap_ComboCtrl_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3683

PyObject *resultobj = 0;

3684

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3685

void *argp1 = 0 ;

3686

int res1 = 0 ;

3687

PyObject *swig_obj[1] ;

3688

3689

if (!args) SWIG_fail;

3690

swig_obj[0] = args;

3691

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3692

if (!SWIG_IsOK(res1)) {

3693

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_Paste" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3694

}

3695

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3696

{

3697

PyThreadState* __tstate = wxPyBeginAllowThreads();

3698

(arg1)->Paste();

3699

wxPyEndAllowThreads(__tstate);

3700

if (PyErr_Occurred()) SWIG_fail;

3701

}

3702

resultobj = SWIG_Py_Void();

3703

return resultobj;

3704

fail:

3705

return NULL;

3706

}

3707

3708

3709

SWIGINTERN PyObject *_wrap_ComboCtrl_SetInsertionPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

3710

PyObject *resultobj = 0;

3711

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3712

long arg2 ;

3713

void *argp1 = 0 ;

3714

int res1 = 0 ;

3715

long val2 ;

3716

int ecode2 = 0 ;

3717

PyObject * obj0 = 0 ;

3718

PyObject * obj1 = 0 ;

3719

char * kwnames[] = {

3720

(char *) "self",(char *) "pos", NULL

3721

};

3722

3723

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_SetInsertionPoint",kwnames,&obj0,&obj1)) SWIG_fail;

3724

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3725

if (!SWIG_IsOK(res1)) {

3726

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetInsertionPoint" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3727

}

3728

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3729

ecode2 = SWIG_AsVal_long(obj1, &val2);

3730

if (!SWIG_IsOK(ecode2)) {

3731

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_SetInsertionPoint" "', expected argument " "2"" of type '" "long""'");

3732

}

3733

arg2 = static_cast< long >(val2);

3734

{

3735

PyThreadState* __tstate = wxPyBeginAllowThreads();

3736

(arg1)->SetInsertionPoint(arg2);

3737

wxPyEndAllowThreads(__tstate);

3738

if (PyErr_Occurred()) SWIG_fail;

3739

}

3740

resultobj = SWIG_Py_Void();

3741

return resultobj;

3742

fail:

3743

return NULL;

3744

}

3745

3746

3747

SWIGINTERN PyObject *_wrap_ComboCtrl_SetInsertionPointEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3748

PyObject *resultobj = 0;

3749

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3750

void *argp1 = 0 ;

3751

int res1 = 0 ;

3752

PyObject *swig_obj[1] ;

3753

3754

if (!args) SWIG_fail;

3755

swig_obj[0] = args;

3756

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3757

if (!SWIG_IsOK(res1)) {

3758

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetInsertionPointEnd" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3759

}

3760

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3761

{

3762

PyThreadState* __tstate = wxPyBeginAllowThreads();

3763

(arg1)->SetInsertionPointEnd();

3764

wxPyEndAllowThreads(__tstate);

3765

if (PyErr_Occurred()) SWIG_fail;

3766

}

3767

resultobj = SWIG_Py_Void();

3768

return resultobj;

3769

fail:

3770

return NULL;

3771

}

3772

3773

3774

SWIGINTERN PyObject *_wrap_ComboCtrl_GetInsertionPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3775

PyObject *resultobj = 0;

3776

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3777

long result;

3778

void *argp1 = 0 ;

3779

int res1 = 0 ;

3780

PyObject *swig_obj[1] ;

3781

3782

if (!args) SWIG_fail;

3783

swig_obj[0] = args;

3784

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3785

if (!SWIG_IsOK(res1)) {

3786

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetInsertionPoint" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

3787

}

3788

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3789

{

3790

PyThreadState* __tstate = wxPyBeginAllowThreads();

3791

result = (long)((wxPyComboCtrl const *)arg1)->GetInsertionPoint();

3792

wxPyEndAllowThreads(__tstate);

3793

if (PyErr_Occurred()) SWIG_fail;

3794

}

3795

resultobj = SWIG_From_long(static_cast< long >(result));

3796

return resultobj;

3797

fail:

3798

return NULL;

3799

}

3800

3801

3802

SWIGINTERN PyObject *_wrap_ComboCtrl_GetLastPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3803

PyObject *resultobj = 0;

3804

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3805

long result;

3806

void *argp1 = 0 ;

3807

int res1 = 0 ;

3808

PyObject *swig_obj[1] ;

3809

3810

if (!args) SWIG_fail;

3811

swig_obj[0] = args;

3812

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3813

if (!SWIG_IsOK(res1)) {

3814

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetLastPosition" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

3815

}

3816

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3817

{

3818

PyThreadState* __tstate = wxPyBeginAllowThreads();

3819

result = (long)((wxPyComboCtrl const *)arg1)->GetLastPosition();

3820

wxPyEndAllowThreads(__tstate);

3821

if (PyErr_Occurred()) SWIG_fail;

3822

}

3823

resultobj = SWIG_From_long(static_cast< long >(result));

3824

return resultobj;

3825

fail:

3826

return NULL;

3827

}

3828

3829

3830

SWIGINTERN PyObject *_wrap_ComboCtrl_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

3831

PyObject *resultobj = 0;

3832

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3833

long arg2 ;

3834

long arg3 ;

3835

wxString *arg4 = 0 ;

3836

void *argp1 = 0 ;

3837

int res1 = 0 ;

3838

long val2 ;

3839

int ecode2 = 0 ;

3840

long val3 ;

3841

int ecode3 = 0 ;

3842

bool temp4 = false ;

3843

PyObject * obj0 = 0 ;

3844

PyObject * obj1 = 0 ;

3845

PyObject * obj2 = 0 ;

3846

PyObject * obj3 = 0 ;

3847

char * kwnames[] = {

3848

(char *) "self",(char *) "from",(char *) "to",(char *) "value", NULL

3849

};

3850

3851

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ComboCtrl_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

3852

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3853

if (!SWIG_IsOK(res1)) {

3854

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_Replace" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3855

}

3856

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3857

ecode2 = SWIG_AsVal_long(obj1, &val2);

3858

if (!SWIG_IsOK(ecode2)) {

3859

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_Replace" "', expected argument " "2"" of type '" "long""'");

3860

}

3861

arg2 = static_cast< long >(val2);

3862

ecode3 = SWIG_AsVal_long(obj2, &val3);

3863

if (!SWIG_IsOK(ecode3)) {

3864

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboCtrl_Replace" "', expected argument " "3"" of type '" "long""'");

3865

}

3866

arg3 = static_cast< long >(val3);

3867

{

3868

arg4 = wxString_in_helper(obj3);

3869

if (arg4 == NULL) SWIG_fail;

3870

temp4 = true;

3871

}

3872

{

3873

PyThreadState* __tstate = wxPyBeginAllowThreads();

3874

(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);

3875

wxPyEndAllowThreads(__tstate);

3876

if (PyErr_Occurred()) SWIG_fail;

3877

}

3878

resultobj = SWIG_Py_Void();

3879

{

3880

if (temp4)

3881

delete arg4;

3882

}

3883

return resultobj;

3884

fail:

3885

{

3886

if (temp4)

3887

delete arg4;

3888

}

3889

return NULL;

3890

}

3891

3892

3893

SWIGINTERN PyObject *_wrap_ComboCtrl_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

3894

PyObject *resultobj = 0;

3895

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3896

long arg2 ;

3897

long arg3 ;

3898

void *argp1 = 0 ;

3899

int res1 = 0 ;

3900

long val2 ;

3901

int ecode2 = 0 ;

3902

long val3 ;

3903

int ecode3 = 0 ;

3904

PyObject * obj0 = 0 ;

3905

PyObject * obj1 = 0 ;

3906

PyObject * obj2 = 0 ;

3907

char * kwnames[] = {

3908

(char *) "self",(char *) "from",(char *) "to", NULL

3909

};

3910

3911

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboCtrl_Remove",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

3912

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3913

if (!SWIG_IsOK(res1)) {

3914

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_Remove" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3915

}

3916

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3917

ecode2 = SWIG_AsVal_long(obj1, &val2);

3918

if (!SWIG_IsOK(ecode2)) {

3919

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_Remove" "', expected argument " "2"" of type '" "long""'");

3920

}

3921

arg2 = static_cast< long >(val2);

3922

ecode3 = SWIG_AsVal_long(obj2, &val3);

3923

if (!SWIG_IsOK(ecode3)) {

3924

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboCtrl_Remove" "', expected argument " "3"" of type '" "long""'");

3925

}

3926

arg3 = static_cast< long >(val3);

3927

{

3928

PyThreadState* __tstate = wxPyBeginAllowThreads();

3929

(arg1)->Remove(arg2,arg3);

3930

wxPyEndAllowThreads(__tstate);

3931

if (PyErr_Occurred()) SWIG_fail;

3932

}

3933

resultobj = SWIG_Py_Void();

3934

return resultobj;

3935

fail:

3936

return NULL;

3937

}

3938

3939

3940

SWIGINTERN PyObject *_wrap_ComboCtrl_Undo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

3941

PyObject *resultobj = 0;

3942

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3943

void *argp1 = 0 ;

3944

int res1 = 0 ;

3945

PyObject *swig_obj[1] ;

3946

3947

if (!args) SWIG_fail;

3948

swig_obj[0] = args;

3949

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3950

if (!SWIG_IsOK(res1)) {

3951

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_Undo" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3952

}

3953

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3954

{

3955

PyThreadState* __tstate = wxPyBeginAllowThreads();

3956

(arg1)->Undo();

3957

wxPyEndAllowThreads(__tstate);

3958

if (PyErr_Occurred()) SWIG_fail;

3959

}

3960

resultobj = SWIG_Py_Void();

3961

return resultobj;

3962

fail:

3963

return NULL;

3964

}

3965

3966

3967

SWIGINTERN PyObject *_wrap_ComboCtrl_SetMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

3968

PyObject *resultobj = 0;

3969

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

3970

long arg2 ;

3971

long arg3 ;

3972

void *argp1 = 0 ;

3973

int res1 = 0 ;

3974

long val2 ;

3975

int ecode2 = 0 ;

3976

long val3 ;

3977

int ecode3 = 0 ;

3978

PyObject * obj0 = 0 ;

3979

PyObject * obj1 = 0 ;

3980

PyObject * obj2 = 0 ;

3981

char * kwnames[] = {

3982

(char *) "self",(char *) "from",(char *) "to", NULL

3983

};

3984

3985

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboCtrl_SetMark",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

3986

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

3987

if (!SWIG_IsOK(res1)) {

3988

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetMark" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

3989

}

3990

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

3991

ecode2 = SWIG_AsVal_long(obj1, &val2);

3992

if (!SWIG_IsOK(ecode2)) {

3993

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_SetMark" "', expected argument " "2"" of type '" "long""'");

3994

}

3995

arg2 = static_cast< long >(val2);

3996

ecode3 = SWIG_AsVal_long(obj2, &val3);

3997

if (!SWIG_IsOK(ecode3)) {

3998

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboCtrl_SetMark" "', expected argument " "3"" of type '" "long""'");

3999

}

4000

arg3 = static_cast< long >(val3);

4001

{

4002

PyThreadState* __tstate = wxPyBeginAllowThreads();

4003

(arg1)->SetSelection(arg2,arg3);

4004

wxPyEndAllowThreads(__tstate);

4005

if (PyErr_Occurred()) SWIG_fail;

4006

}

4007

resultobj = SWIG_Py_Void();

4008

return resultobj;

4009

fail:

4010

return NULL;

4011

}

4012

4013

4014

SWIGINTERN PyObject *_wrap_ComboCtrl_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4015

PyObject *resultobj = 0;

4016

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4017

wxString *arg2 = 0 ;

4018

void *argp1 = 0 ;

4019

int res1 = 0 ;

4020

bool temp2 = false ;

4021

PyObject * obj0 = 0 ;

4022

PyObject * obj1 = 0 ;

4023

char * kwnames[] = {

4024

(char *) "self",(char *) "value", NULL

4025

};

4026

4027

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_SetText",kwnames,&obj0,&obj1)) SWIG_fail;

4028

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4029

if (!SWIG_IsOK(res1)) {

4030

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetText" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4031

}

4032

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4033

{

4034

arg2 = wxString_in_helper(obj1);

4035

if (arg2 == NULL) SWIG_fail;

4036

temp2 = true;

4037

}

4038

{

4039

PyThreadState* __tstate = wxPyBeginAllowThreads();

4040

(arg1)->SetText((wxString const &)*arg2);

4041

wxPyEndAllowThreads(__tstate);

4042

if (PyErr_Occurred()) SWIG_fail;

4043

}

4044

resultobj = SWIG_Py_Void();

4045

{

4046

if (temp2)

4047

delete arg2;

4048

}

4049

return resultobj;

4050

fail:

4051

{

4052

if (temp2)

4053

delete arg2;

4054

}

4055

return NULL;

4056

}

4057

4058

4059

SWIGINTERN PyObject *_wrap_ComboCtrl_SetValueWithEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4060

PyObject *resultobj = 0;

4061

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4062

wxString *arg2 = 0 ;

4063

bool arg3 = (bool) true ;

4064

void *argp1 = 0 ;

4065

int res1 = 0 ;

4066

bool temp2 = false ;

4067

bool val3 ;

4068

int ecode3 = 0 ;

4069

PyObject * obj0 = 0 ;

4070

PyObject * obj1 = 0 ;

4071

PyObject * obj2 = 0 ;

4072

char * kwnames[] = {

4073

(char *) "self",(char *) "value",(char *) "withEvent", NULL

4074

};

4075

4076

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ComboCtrl_SetValueWithEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

4077

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4078

if (!SWIG_IsOK(res1)) {

4079

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetValueWithEvent" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4080

}

4081

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4082

{

4083

arg2 = wxString_in_helper(obj1);

4084

if (arg2 == NULL) SWIG_fail;

4085

temp2 = true;

4086

}

4087

if (obj2) {

4088

ecode3 = SWIG_AsVal_bool(obj2, &val3);

4089

if (!SWIG_IsOK(ecode3)) {

4090

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboCtrl_SetValueWithEvent" "', expected argument " "3"" of type '" "bool""'");

4091

}

4092

arg3 = static_cast< bool >(val3);

4093

}

4094

{

4095

PyThreadState* __tstate = wxPyBeginAllowThreads();

4096

(arg1)->SetValueWithEvent((wxString const &)*arg2,arg3);

4097

wxPyEndAllowThreads(__tstate);

4098

if (PyErr_Occurred()) SWIG_fail;

4099

}

4100

resultobj = SWIG_Py_Void();

4101

{

4102

if (temp2)

4103

delete arg2;

4104

}

4105

return resultobj;

4106

fail:

4107

{

4108

if (temp2)

4109

delete arg2;

4110

}

4111

return NULL;

4112

}

4113

4114

4115

SWIGINTERN PyObject *_wrap_ComboCtrl_SetPopupMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4116

PyObject *resultobj = 0;

4117

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4118

int arg2 ;

4119

void *argp1 = 0 ;

4120

int res1 = 0 ;

4121

int val2 ;

4122

int ecode2 = 0 ;

4123

PyObject * obj0 = 0 ;

4124

PyObject * obj1 = 0 ;

4125

char * kwnames[] = {

4126

(char *) "self",(char *) "width", NULL

4127

};

4128

4129

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_SetPopupMinWidth",kwnames,&obj0,&obj1)) SWIG_fail;

4130

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4131

if (!SWIG_IsOK(res1)) {

4132

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetPopupMinWidth" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4133

}

4134

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4135

ecode2 = SWIG_AsVal_int(obj1, &val2);

4136

if (!SWIG_IsOK(ecode2)) {

4137

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_SetPopupMinWidth" "', expected argument " "2"" of type '" "int""'");

4138

}

4139

arg2 = static_cast< int >(val2);

4140

{

4141

PyThreadState* __tstate = wxPyBeginAllowThreads();

4142

(arg1)->SetPopupMinWidth(arg2);

4143

wxPyEndAllowThreads(__tstate);

4144

if (PyErr_Occurred()) SWIG_fail;

4145

}

4146

resultobj = SWIG_Py_Void();

4147

return resultobj;

4148

fail:

4149

return NULL;

4150

}

4151

4152

4153

SWIGINTERN PyObject *_wrap_ComboCtrl_SetPopupMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4154

PyObject *resultobj = 0;

4155

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4156

int arg2 ;

4157

void *argp1 = 0 ;

4158

int res1 = 0 ;

4159

int val2 ;

4160

int ecode2 = 0 ;

4161

PyObject * obj0 = 0 ;

4162

PyObject * obj1 = 0 ;

4163

char * kwnames[] = {

4164

(char *) "self",(char *) "height", NULL

4165

};

4166

4167

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_SetPopupMaxHeight",kwnames,&obj0,&obj1)) SWIG_fail;

4168

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4169

if (!SWIG_IsOK(res1)) {

4170

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetPopupMaxHeight" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4171

}

4172

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4173

ecode2 = SWIG_AsVal_int(obj1, &val2);

4174

if (!SWIG_IsOK(ecode2)) {

4175

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_SetPopupMaxHeight" "', expected argument " "2"" of type '" "int""'");

4176

}

4177

arg2 = static_cast< int >(val2);

4178

{

4179

PyThreadState* __tstate = wxPyBeginAllowThreads();

4180

(arg1)->SetPopupMaxHeight(arg2);

4181

wxPyEndAllowThreads(__tstate);

4182

if (PyErr_Occurred()) SWIG_fail;

4183

}

4184

resultobj = SWIG_Py_Void();

4185

return resultobj;

4186

fail:

4187

return NULL;

4188

}

4189

4190

4191

SWIGINTERN PyObject *_wrap_ComboCtrl_SetPopupExtents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4192

PyObject *resultobj = 0;

4193

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4194

int arg2 ;

4195

int arg3 ;

4196

void *argp1 = 0 ;

4197

int res1 = 0 ;

4198

int val2 ;

4199

int ecode2 = 0 ;

4200

int val3 ;

4201

int ecode3 = 0 ;

4202

PyObject * obj0 = 0 ;

4203

PyObject * obj1 = 0 ;

4204

PyObject * obj2 = 0 ;

4205

char * kwnames[] = {

4206

(char *) "self",(char *) "extLeft",(char *) "extRight", NULL

4207

};

4208

4209

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboCtrl_SetPopupExtents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

4210

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4211

if (!SWIG_IsOK(res1)) {

4212

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetPopupExtents" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4213

}

4214

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4215

ecode2 = SWIG_AsVal_int(obj1, &val2);

4216

if (!SWIG_IsOK(ecode2)) {

4217

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_SetPopupExtents" "', expected argument " "2"" of type '" "int""'");

4218

}

4219

arg2 = static_cast< int >(val2);

4220

ecode3 = SWIG_AsVal_int(obj2, &val3);

4221

if (!SWIG_IsOK(ecode3)) {

4222

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboCtrl_SetPopupExtents" "', expected argument " "3"" of type '" "int""'");

4223

}

4224

arg3 = static_cast< int >(val3);

4225

{

4226

PyThreadState* __tstate = wxPyBeginAllowThreads();

4227

(arg1)->SetPopupExtents(arg2,arg3);

4228

wxPyEndAllowThreads(__tstate);

4229

if (PyErr_Occurred()) SWIG_fail;

4230

}

4231

resultobj = SWIG_Py_Void();

4232

return resultobj;

4233

fail:

4234

return NULL;

4235

}

4236

4237

4238

SWIGINTERN PyObject *_wrap_ComboCtrl_SetCustomPaintWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4239

PyObject *resultobj = 0;

4240

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4241

int arg2 ;

4242

void *argp1 = 0 ;

4243

int res1 = 0 ;

4244

int val2 ;

4245

int ecode2 = 0 ;

4246

PyObject * obj0 = 0 ;

4247

PyObject * obj1 = 0 ;

4248

char * kwnames[] = {

4249

(char *) "self",(char *) "width", NULL

4250

};

4251

4252

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_SetCustomPaintWidth",kwnames,&obj0,&obj1)) SWIG_fail;

4253

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4254

if (!SWIG_IsOK(res1)) {

4255

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetCustomPaintWidth" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4256

}

4257

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4258

ecode2 = SWIG_AsVal_int(obj1, &val2);

4259

if (!SWIG_IsOK(ecode2)) {

4260

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_SetCustomPaintWidth" "', expected argument " "2"" of type '" "int""'");

4261

}

4262

arg2 = static_cast< int >(val2);

4263

{

4264

PyThreadState* __tstate = wxPyBeginAllowThreads();

4265

(arg1)->SetCustomPaintWidth(arg2);

4266

wxPyEndAllowThreads(__tstate);

4267

if (PyErr_Occurred()) SWIG_fail;

4268

}

4269

resultobj = SWIG_Py_Void();

4270

return resultobj;

4271

fail:

4272

return NULL;

4273

}

4274

4275

4276

SWIGINTERN PyObject *_wrap_ComboCtrl_GetCustomPaintWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

4277

PyObject *resultobj = 0;

4278

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4279

int result;

4280

void *argp1 = 0 ;

4281

int res1 = 0 ;

4282

PyObject *swig_obj[1] ;

4283

4284

if (!args) SWIG_fail;

4285

swig_obj[0] = args;

4286

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4287

if (!SWIG_IsOK(res1)) {

4288

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetCustomPaintWidth" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4289

}

4290

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4291

{

4292

PyThreadState* __tstate = wxPyBeginAllowThreads();

4293

result = (int)((wxPyComboCtrl const *)arg1)->GetCustomPaintWidth();

4294

wxPyEndAllowThreads(__tstate);

4295

if (PyErr_Occurred()) SWIG_fail;

4296

}

4297

resultobj = SWIG_From_int(static_cast< int >(result));

4298

return resultobj;

4299

fail:

4300

return NULL;

4301

}

4302

4303

4304

SWIGINTERN PyObject *_wrap_ComboCtrl_SetPopupAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4305

PyObject *resultobj = 0;

4306

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4307

int arg2 ;

4308

void *argp1 = 0 ;

4309

int res1 = 0 ;

4310

int val2 ;

4311

int ecode2 = 0 ;

4312

PyObject * obj0 = 0 ;

4313

PyObject * obj1 = 0 ;

4314

char * kwnames[] = {

4315

(char *) "self",(char *) "anchorSide", NULL

4316

};

4317

4318

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_SetPopupAnchor",kwnames,&obj0,&obj1)) SWIG_fail;

4319

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4320

if (!SWIG_IsOK(res1)) {

4321

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetPopupAnchor" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4322

}

4323

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4324

ecode2 = SWIG_AsVal_int(obj1, &val2);

4325

if (!SWIG_IsOK(ecode2)) {

4326

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_SetPopupAnchor" "', expected argument " "2"" of type '" "int""'");

4327

}

4328

arg2 = static_cast< int >(val2);

4329

{

4330

PyThreadState* __tstate = wxPyBeginAllowThreads();

4331

(arg1)->SetPopupAnchor(arg2);

4332

wxPyEndAllowThreads(__tstate);

4333

if (PyErr_Occurred()) SWIG_fail;

4334

}

4335

resultobj = SWIG_Py_Void();

4336

return resultobj;

4337

fail:

4338

return NULL;

4339

}

4340

4341

4342

SWIGINTERN PyObject *_wrap_ComboCtrl_SetButtonPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4343

PyObject *resultobj = 0;

4344

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4345

int arg2 = (int) -1 ;

4346

int arg3 = (int) -1 ;

4347

int arg4 = (int) wxRIGHT ;

4348

int arg5 = (int) 0 ;

4349

void *argp1 = 0 ;

4350

int res1 = 0 ;

4351

int val2 ;

4352

int ecode2 = 0 ;

4353

int val3 ;

4354

int ecode3 = 0 ;

4355

int val4 ;

4356

int ecode4 = 0 ;

4357

int val5 ;

4358

int ecode5 = 0 ;

4359

PyObject * obj0 = 0 ;

4360

PyObject * obj1 = 0 ;

4361

PyObject * obj2 = 0 ;

4362

PyObject * obj3 = 0 ;

4363

PyObject * obj4 = 0 ;

4364

char * kwnames[] = {

4365

(char *) "self",(char *) "width",(char *) "height",(char *) "side",(char *) "spacingX", NULL

4366

};

4367

4368

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:ComboCtrl_SetButtonPosition",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

4369

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4370

if (!SWIG_IsOK(res1)) {

4371

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetButtonPosition" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4372

}

4373

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4374

if (obj1) {

4375

ecode2 = SWIG_AsVal_int(obj1, &val2);

4376

if (!SWIG_IsOK(ecode2)) {

4377

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_SetButtonPosition" "', expected argument " "2"" of type '" "int""'");

4378

}

4379

arg2 = static_cast< int >(val2);

4380

}

4381

if (obj2) {

4382

ecode3 = SWIG_AsVal_int(obj2, &val3);

4383

if (!SWIG_IsOK(ecode3)) {

4384

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboCtrl_SetButtonPosition" "', expected argument " "3"" of type '" "int""'");

4385

}

4386

arg3 = static_cast< int >(val3);

4387

}

4388

if (obj3) {

4389

ecode4 = SWIG_AsVal_int(obj3, &val4);

4390

if (!SWIG_IsOK(ecode4)) {

4391

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ComboCtrl_SetButtonPosition" "', expected argument " "4"" of type '" "int""'");

4392

}

4393

arg4 = static_cast< int >(val4);

4394

}

4395

if (obj4) {

4396

ecode5 = SWIG_AsVal_int(obj4, &val5);

4397

if (!SWIG_IsOK(ecode5)) {

4398

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ComboCtrl_SetButtonPosition" "', expected argument " "5"" of type '" "int""'");

4399

}

4400

arg5 = static_cast< int >(val5);

4401

}

4402

{

4403

PyThreadState* __tstate = wxPyBeginAllowThreads();

4404

(arg1)->SetButtonPosition(arg2,arg3,arg4,arg5);

4405

wxPyEndAllowThreads(__tstate);

4406

if (PyErr_Occurred()) SWIG_fail;

4407

}

4408

resultobj = SWIG_Py_Void();

4409

return resultobj;

4410

fail:

4411

return NULL;

4412

}

4413

4414

4415

SWIGINTERN PyObject *_wrap_ComboCtrl_GetButtonSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

4416

PyObject *resultobj = 0;

4417

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4418

wxSize result;

4419

void *argp1 = 0 ;

4420

int res1 = 0 ;

4421

PyObject *swig_obj[1] ;

4422

4423

if (!args) SWIG_fail;

4424

swig_obj[0] = args;

4425

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4426

if (!SWIG_IsOK(res1)) {

4427

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetButtonSize" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4428

}

4429

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4430

{

4431

PyThreadState* __tstate = wxPyBeginAllowThreads();

4432

result = (arg1)->GetButtonSize();

4433

wxPyEndAllowThreads(__tstate);

4434

if (PyErr_Occurred()) SWIG_fail;

4435

}

4436

resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );

4437

return resultobj;

4438

fail:

4439

return NULL;

4440

}

4441

4442

4443

SWIGINTERN PyObject *_wrap_ComboCtrl_SetButtonBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4444

PyObject *resultobj = 0;

4445

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4446

wxBitmap *arg2 = 0 ;

4447

bool arg3 = (bool) false ;

4448

wxBitmap const &arg4_defvalue = wxNullBitmap ;

4449

wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;

4450

wxBitmap const &arg5_defvalue = wxNullBitmap ;

4451

wxBitmap *arg5 = (wxBitmap *) &arg5_defvalue ;

4452

wxBitmap const &arg6_defvalue = wxNullBitmap ;

4453

wxBitmap *arg6 = (wxBitmap *) &arg6_defvalue ;

4454

void *argp1 = 0 ;

4455

int res1 = 0 ;

4456

void *argp2 = 0 ;

4457

int res2 = 0 ;

4458

bool val3 ;

4459

int ecode3 = 0 ;

4460

void *argp4 = 0 ;

4461

int res4 = 0 ;

4462

void *argp5 = 0 ;

4463

int res5 = 0 ;

4464

void *argp6 = 0 ;

4465

int res6 = 0 ;

4466

PyObject * obj0 = 0 ;

4467

PyObject * obj1 = 0 ;

4468

PyObject * obj2 = 0 ;

4469

PyObject * obj3 = 0 ;

4470

PyObject * obj4 = 0 ;

4471

PyObject * obj5 = 0 ;

4472

char * kwnames[] = {

4473

(char *) "self",(char *) "bmpNormal",(char *) "pushButtonBg",(char *) "bmpPressed",(char *) "bmpHover",(char *) "bmpDisabled", NULL

4474

};

4475

4476

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:ComboCtrl_SetButtonBitmaps",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;

4477

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4478

if (!SWIG_IsOK(res1)) {

4479

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetButtonBitmaps" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4480

}

4481

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4482

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);

4483

if (!SWIG_IsOK(res2)) {

4484

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComboCtrl_SetButtonBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");

4485

}

4486

if (!argp2) {

4487

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComboCtrl_SetButtonBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");

4488

}

4489

arg2 = reinterpret_cast< wxBitmap * >(argp2);

4490

if (obj2) {

4491

ecode3 = SWIG_AsVal_bool(obj2, &val3);

4492

if (!SWIG_IsOK(ecode3)) {

4493

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboCtrl_SetButtonBitmaps" "', expected argument " "3"" of type '" "bool""'");

4494

}

4495

arg3 = static_cast< bool >(val3);

4496

}

4497

if (obj3) {

4498

res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap, 0 | 0);

4499

if (!SWIG_IsOK(res4)) {

4500

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ComboCtrl_SetButtonBitmaps" "', expected argument " "4"" of type '" "wxBitmap const &""'");

4501

}

4502

if (!argp4) {

4503

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComboCtrl_SetButtonBitmaps" "', expected argument " "4"" of type '" "wxBitmap const &""'");

4504

}

4505

arg4 = reinterpret_cast< wxBitmap * >(argp4);

4506

}

4507

if (obj4) {

4508

res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxBitmap, 0 | 0);

4509

if (!SWIG_IsOK(res5)) {

4510

SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ComboCtrl_SetButtonBitmaps" "', expected argument " "5"" of type '" "wxBitmap const &""'");

4511

}

4512

if (!argp5) {

4513

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComboCtrl_SetButtonBitmaps" "', expected argument " "5"" of type '" "wxBitmap const &""'");

4514

}

4515

arg5 = reinterpret_cast< wxBitmap * >(argp5);

4516

}

4517

if (obj5) {

4518

res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxBitmap, 0 | 0);

4519

if (!SWIG_IsOK(res6)) {

4520

SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ComboCtrl_SetButtonBitmaps" "', expected argument " "6"" of type '" "wxBitmap const &""'");

4521

}

4522

if (!argp6) {

4523

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComboCtrl_SetButtonBitmaps" "', expected argument " "6"" of type '" "wxBitmap const &""'");

4524

}

4525

arg6 = reinterpret_cast< wxBitmap * >(argp6);

4526

}

4527

{

4528

PyThreadState* __tstate = wxPyBeginAllowThreads();

4529

(arg1)->SetButtonBitmaps((wxBitmap const &)*arg2,arg3,(wxBitmap const &)*arg4,(wxBitmap const &)*arg5,(wxBitmap const &)*arg6);

4530

wxPyEndAllowThreads(__tstate);

4531

if (PyErr_Occurred()) SWIG_fail;

4532

}

4533

resultobj = SWIG_Py_Void();

4534

return resultobj;

4535

fail:

4536

return NULL;

4537

}

4538

4539

4540

SWIGINTERN PyObject *_wrap_ComboCtrl_SetTextIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4541

PyObject *resultobj = 0;

4542

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4543

int arg2 ;

4544

void *argp1 = 0 ;

4545

int res1 = 0 ;

4546

int val2 ;

4547

int ecode2 = 0 ;

4548

PyObject * obj0 = 0 ;

4549

PyObject * obj1 = 0 ;

4550

char * kwnames[] = {

4551

(char *) "self",(char *) "indent", NULL

4552

};

4553

4554

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_SetTextIndent",kwnames,&obj0,&obj1)) SWIG_fail;

4555

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4556

if (!SWIG_IsOK(res1)) {

4557

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetTextIndent" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4558

}

4559

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4560

ecode2 = SWIG_AsVal_int(obj1, &val2);

4561

if (!SWIG_IsOK(ecode2)) {

4562

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_SetTextIndent" "', expected argument " "2"" of type '" "int""'");

4563

}

4564

arg2 = static_cast< int >(val2);

4565

{

4566

PyThreadState* __tstate = wxPyBeginAllowThreads();

4567

(arg1)->SetTextIndent(arg2);

4568

wxPyEndAllowThreads(__tstate);

4569

if (PyErr_Occurred()) SWIG_fail;

4570

}

4571

resultobj = SWIG_Py_Void();

4572

return resultobj;

4573

fail:

4574

return NULL;

4575

}

4576

4577

4578

SWIGINTERN PyObject *_wrap_ComboCtrl_GetTextIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

4579

PyObject *resultobj = 0;

4580

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4581

int result;

4582

void *argp1 = 0 ;

4583

int res1 = 0 ;

4584

PyObject *swig_obj[1] ;

4585

4586

if (!args) SWIG_fail;

4587

swig_obj[0] = args;

4588

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4589

if (!SWIG_IsOK(res1)) {

4590

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetTextIndent" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4591

}

4592

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4593

{

4594

PyThreadState* __tstate = wxPyBeginAllowThreads();

4595

result = (int)((wxPyComboCtrl const *)arg1)->GetTextIndent();

4596

wxPyEndAllowThreads(__tstate);

4597

if (PyErr_Occurred()) SWIG_fail;

4598

}

4599

resultobj = SWIG_From_int(static_cast< int >(result));

4600

return resultobj;

4601

fail:

4602

return NULL;

4603

}

4604

4605

4606

SWIGINTERN PyObject *_wrap_ComboCtrl_GetTextRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

4607

PyObject *resultobj = 0;

4608

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4609

wxRect *result = 0 ;

4610

void *argp1 = 0 ;

4611

int res1 = 0 ;

4612

PyObject *swig_obj[1] ;

4613

4614

if (!args) SWIG_fail;

4615

swig_obj[0] = args;

4616

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4617

if (!SWIG_IsOK(res1)) {

4618

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetTextRect" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4619

}

4620

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4621

{

4622

PyThreadState* __tstate = wxPyBeginAllowThreads();

4623

{

4624

wxRect const &_result_ref = ((wxPyComboCtrl const *)arg1)->GetTextRect();

4625

result = (wxRect *) &_result_ref;

4626

}

4627

wxPyEndAllowThreads(__tstate);

4628

if (PyErr_Occurred()) SWIG_fail;

4629

}

4630

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );

4631

return resultobj;

4632

fail:

4633

return NULL;

4634

}

4635

4636

4637

SWIGINTERN PyObject *_wrap_ComboCtrl_UseAltPopupWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4638

PyObject *resultobj = 0;

4639

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4640

bool arg2 = (bool) true ;

4641

void *argp1 = 0 ;

4642

int res1 = 0 ;

4643

bool val2 ;

4644

int ecode2 = 0 ;

4645

PyObject * obj0 = 0 ;

4646

PyObject * obj1 = 0 ;

4647

char * kwnames[] = {

4648

(char *) "self",(char *) "enable", NULL

4649

};

4650

4651

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ComboCtrl_UseAltPopupWindow",kwnames,&obj0,&obj1)) SWIG_fail;

4652

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4653

if (!SWIG_IsOK(res1)) {

4654

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_UseAltPopupWindow" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4655

}

4656

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4657

if (obj1) {

4658

ecode2 = SWIG_AsVal_bool(obj1, &val2);

4659

if (!SWIG_IsOK(ecode2)) {

4660

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_UseAltPopupWindow" "', expected argument " "2"" of type '" "bool""'");

4661

}

4662

arg2 = static_cast< bool >(val2);

4663

}

4664

{

4665

PyThreadState* __tstate = wxPyBeginAllowThreads();

4666

(arg1)->UseAltPopupWindow(arg2);

4667

wxPyEndAllowThreads(__tstate);

4668

if (PyErr_Occurred()) SWIG_fail;

4669

}

4670

resultobj = SWIG_Py_Void();

4671

return resultobj;

4672

fail:

4673

return NULL;

4674

}

4675

4676

4677

SWIGINTERN PyObject *_wrap_ComboCtrl_EnablePopupAnimation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4678

PyObject *resultobj = 0;

4679

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4680

bool arg2 = (bool) true ;

4681

void *argp1 = 0 ;

4682

int res1 = 0 ;

4683

bool val2 ;

4684

int ecode2 = 0 ;

4685

PyObject * obj0 = 0 ;

4686

PyObject * obj1 = 0 ;

4687

char * kwnames[] = {

4688

(char *) "self",(char *) "enable", NULL

4689

};

4690

4691

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ComboCtrl_EnablePopupAnimation",kwnames,&obj0,&obj1)) SWIG_fail;

4692

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4693

if (!SWIG_IsOK(res1)) {

4694

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_EnablePopupAnimation" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

4695

}

4696

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4697

if (obj1) {

4698

ecode2 = SWIG_AsVal_bool(obj1, &val2);

4699

if (!SWIG_IsOK(ecode2)) {

4700

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_EnablePopupAnimation" "', expected argument " "2"" of type '" "bool""'");

4701

}

4702

arg2 = static_cast< bool >(val2);

4703

}

4704

{

4705

PyThreadState* __tstate = wxPyBeginAllowThreads();

4706

(arg1)->EnablePopupAnimation(arg2);

4707

wxPyEndAllowThreads(__tstate);

4708

if (PyErr_Occurred()) SWIG_fail;

4709

}

4710

resultobj = SWIG_Py_Void();

4711

return resultobj;

4712

fail:

4713

return NULL;

4714

}

4715

4716

4717

SWIGINTERN PyObject *_wrap_ComboCtrl_IsKeyPopupToggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4718

PyObject *resultobj = 0;

4719

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4720

wxKeyEvent *arg2 = 0 ;

4721

bool result;

4722

void *argp1 = 0 ;

4723

int res1 = 0 ;

4724

void *argp2 = 0 ;

4725

int res2 = 0 ;

4726

PyObject * obj0 = 0 ;

4727

PyObject * obj1 = 0 ;

4728

char * kwnames[] = {

4729

(char *) "self",(char *) "event", NULL

4730

};

4731

4732

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_IsKeyPopupToggle",kwnames,&obj0,&obj1)) SWIG_fail;

4733

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4734

if (!SWIG_IsOK(res1)) {

4735

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_IsKeyPopupToggle" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4736

}

4737

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4738

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 | 0);

4739

if (!SWIG_IsOK(res2)) {

4740

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComboCtrl_IsKeyPopupToggle" "', expected argument " "2"" of type '" "wxKeyEvent const &""'");

4741

}

4742

if (!argp2) {

4743

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComboCtrl_IsKeyPopupToggle" "', expected argument " "2"" of type '" "wxKeyEvent const &""'");

4744

}

4745

arg2 = reinterpret_cast< wxKeyEvent * >(argp2);

4746

{

4747

PyThreadState* __tstate = wxPyBeginAllowThreads();

4748

result = (bool)((wxPyComboCtrl const *)arg1)->IsKeyPopupToggle((wxKeyEvent const &)*arg2);

4749

wxPyEndAllowThreads(__tstate);

4750

if (PyErr_Occurred()) SWIG_fail;

4751

}

4752

{

4753

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

4754

}

4755

return resultobj;

4756

fail:

4757

return NULL;

4758

}

4759

4760

4761

SWIGINTERN PyObject *_wrap_ComboCtrl_PrepareBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

4762

PyObject *resultobj = 0;

4763

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4764

wxDC *arg2 = 0 ;

4765

wxRect *arg3 = 0 ;

4766

int arg4 ;

4767

void *argp1 = 0 ;

4768

int res1 = 0 ;

4769

void *argp2 = 0 ;

4770

int res2 = 0 ;

4771

wxRect temp3 ;

4772

int val4 ;

4773

int ecode4 = 0 ;

4774

PyObject * obj0 = 0 ;

4775

PyObject * obj1 = 0 ;

4776

PyObject * obj2 = 0 ;

4777

PyObject * obj3 = 0 ;

4778

char * kwnames[] = {

4779

(char *) "self",(char *) "dc",(char *) "rect",(char *) "flags", NULL

4780

};

4781

4782

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ComboCtrl_PrepareBackground",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

4783

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4784

if (!SWIG_IsOK(res1)) {

4785

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_PrepareBackground" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4786

}

4787

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4788

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );

4789

if (!SWIG_IsOK(res2)) {

4790

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComboCtrl_PrepareBackground" "', expected argument " "2"" of type '" "wxDC &""'");

4791

}

4792

if (!argp2) {

4793

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComboCtrl_PrepareBackground" "', expected argument " "2"" of type '" "wxDC &""'");

4794

}

4795

arg2 = reinterpret_cast< wxDC * >(argp2);

4796

{

4797

arg3 = &temp3;

4798

if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;

4799

}

4800

ecode4 = SWIG_AsVal_int(obj3, &val4);

4801

if (!SWIG_IsOK(ecode4)) {

4802

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ComboCtrl_PrepareBackground" "', expected argument " "4"" of type '" "int""'");

4803

}

4804

arg4 = static_cast< int >(val4);

4805

{

4806

PyThreadState* __tstate = wxPyBeginAllowThreads();

4807

((wxPyComboCtrl const *)arg1)->PrepareBackground(*arg2,(wxRect const &)*arg3,arg4);

4808

wxPyEndAllowThreads(__tstate);

4809

if (PyErr_Occurred()) SWIG_fail;

4810

}

4811

resultobj = SWIG_Py_Void();

4812

return resultobj;

4813

fail:

4814

return NULL;

4815

}

4816

4817

4818

SWIGINTERN PyObject *_wrap_ComboCtrl_ShouldDrawFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

4819

PyObject *resultobj = 0;

4820

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4821

bool result;

4822

void *argp1 = 0 ;

4823

int res1 = 0 ;

4824

PyObject *swig_obj[1] ;

4825

4826

if (!args) SWIG_fail;

4827

swig_obj[0] = args;

4828

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4829

if (!SWIG_IsOK(res1)) {

4830

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_ShouldDrawFocus" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4831

}

4832

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4833

{

4834

PyThreadState* __tstate = wxPyBeginAllowThreads();

4835

result = (bool)((wxPyComboCtrl const *)arg1)->ShouldDrawFocus();

4836

wxPyEndAllowThreads(__tstate);

4837

if (PyErr_Occurred()) SWIG_fail;

4838

}

4839

{

4840

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

4841

}

4842

return resultobj;

4843

fail:

4844

return NULL;

4845

}

4846

4847

4848

SWIGINTERN PyObject *_wrap_ComboCtrl_GetBitmapNormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

4849

PyObject *resultobj = 0;

4850

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4851

wxBitmap *result = 0 ;

4852

void *argp1 = 0 ;

4853

int res1 = 0 ;

4854

PyObject *swig_obj[1] ;

4855

4856

if (!args) SWIG_fail;

4857

swig_obj[0] = args;

4858

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4859

if (!SWIG_IsOK(res1)) {

4860

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetBitmapNormal" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4861

}

4862

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4863

{

4864

PyThreadState* __tstate = wxPyBeginAllowThreads();

4865

{

4866

wxBitmap const &_result_ref = ((wxPyComboCtrl const *)arg1)->GetBitmapNormal();

4867

result = (wxBitmap *) &_result_ref;

4868

}

4869

wxPyEndAllowThreads(__tstate);

4870

if (PyErr_Occurred()) SWIG_fail;

4871

}

4872

{

4873

wxBitmap* resultptr = new wxBitmap(*result);

4874

resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);

4875

}

4876

return resultobj;

4877

fail:

4878

return NULL;

4879

}

4880

4881

4882

SWIGINTERN PyObject *_wrap_ComboCtrl_GetBitmapPressed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

4883

PyObject *resultobj = 0;

4884

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4885

wxBitmap *result = 0 ;

4886

void *argp1 = 0 ;

4887

int res1 = 0 ;

4888

PyObject *swig_obj[1] ;

4889

4890

if (!args) SWIG_fail;

4891

swig_obj[0] = args;

4892

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4893

if (!SWIG_IsOK(res1)) {

4894

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetBitmapPressed" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4895

}

4896

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4897

{

4898

PyThreadState* __tstate = wxPyBeginAllowThreads();

4899

{

4900

wxBitmap const &_result_ref = ((wxPyComboCtrl const *)arg1)->GetBitmapPressed();

4901

result = (wxBitmap *) &_result_ref;

4902

}

4903

wxPyEndAllowThreads(__tstate);

4904

if (PyErr_Occurred()) SWIG_fail;

4905

}

4906

{

4907

wxBitmap* resultptr = new wxBitmap(*result);

4908

resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);

4909

}

4910

return resultobj;

4911

fail:

4912

return NULL;

4913

}

4914

4915

4916

SWIGINTERN PyObject *_wrap_ComboCtrl_GetBitmapHover(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

4917

PyObject *resultobj = 0;

4918

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4919

wxBitmap *result = 0 ;

4920

void *argp1 = 0 ;

4921

int res1 = 0 ;

4922

PyObject *swig_obj[1] ;

4923

4924

if (!args) SWIG_fail;

4925

swig_obj[0] = args;

4926

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4927

if (!SWIG_IsOK(res1)) {

4928

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetBitmapHover" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4929

}

4930

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4931

{

4932

PyThreadState* __tstate = wxPyBeginAllowThreads();

4933

{

4934

wxBitmap const &_result_ref = ((wxPyComboCtrl const *)arg1)->GetBitmapHover();

4935

result = (wxBitmap *) &_result_ref;

4936

}

4937

wxPyEndAllowThreads(__tstate);

4938

if (PyErr_Occurred()) SWIG_fail;

4939

}

4940

{

4941

wxBitmap* resultptr = new wxBitmap(*result);

4942

resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);

4943

}

4944

return resultobj;

4945

fail:

4946

return NULL;

4947

}

4948

4949

4950

SWIGINTERN PyObject *_wrap_ComboCtrl_GetBitmapDisabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

4951

PyObject *resultobj = 0;

4952

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4953

wxBitmap *result = 0 ;

4954

void *argp1 = 0 ;

4955

int res1 = 0 ;

4956

PyObject *swig_obj[1] ;

4957

4958

if (!args) SWIG_fail;

4959

swig_obj[0] = args;

4960

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4961

if (!SWIG_IsOK(res1)) {

4962

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetBitmapDisabled" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4963

}

4964

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4965

{

4966

PyThreadState* __tstate = wxPyBeginAllowThreads();

4967

{

4968

wxBitmap const &_result_ref = ((wxPyComboCtrl const *)arg1)->GetBitmapDisabled();

4969

result = (wxBitmap *) &_result_ref;

4970

}

4971

wxPyEndAllowThreads(__tstate);

4972

if (PyErr_Occurred()) SWIG_fail;

4973

}

4974

{

4975

wxBitmap* resultptr = new wxBitmap(*result);

4976

resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);

4977

}

4978

return resultobj;

4979

fail:

4980

return NULL;

4981

}

4982

4983

4984

SWIGINTERN PyObject *_wrap_ComboCtrl_GetInternalFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

4985

PyObject *resultobj = 0;

4986

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

4987

unsigned int result;

4988

void *argp1 = 0 ;

4989

int res1 = 0 ;

4990

PyObject *swig_obj[1] ;

4991

4992

if (!args) SWIG_fail;

4993

swig_obj[0] = args;

4994

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

4995

if (!SWIG_IsOK(res1)) {

4996

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetInternalFlags" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

4997

}

4998

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

4999

{

5000

PyThreadState* __tstate = wxPyBeginAllowThreads();

5001

result = (unsigned int)((wxPyComboCtrl const *)arg1)->GetInternalFlags();

5002

wxPyEndAllowThreads(__tstate);

5003

if (PyErr_Occurred()) SWIG_fail;

5004

}

5005

resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));

5006

return resultobj;

5007

fail:

5008

return NULL;

5009

}

5010

5011

5012

SWIGINTERN PyObject *_wrap_ComboCtrl_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5013

PyObject *resultobj = 0;

5014

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

5015

bool result;

5016

void *argp1 = 0 ;

5017

int res1 = 0 ;

5018

PyObject *swig_obj[1] ;

5019

5020

if (!args) SWIG_fail;

5021

swig_obj[0] = args;

5022

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

5023

if (!SWIG_IsOK(res1)) {

5024

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_IsCreated" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

5025

}

5026

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

5027

{

5028

PyThreadState* __tstate = wxPyBeginAllowThreads();

5029

result = (bool)((wxPyComboCtrl const *)arg1)->IsCreated();

5030

wxPyEndAllowThreads(__tstate);

5031

if (PyErr_Occurred()) SWIG_fail;

5032

}

5033

{

5034

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

5035

}

5036

return resultobj;

5037

fail:

5038

return NULL;

5039

}

5040

5041

5042

SWIGINTERN PyObject *_wrap_ComboCtrl_OnPopupDismiss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5043

PyObject *resultobj = 0;

5044

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

5045

void *argp1 = 0 ;

5046

int res1 = 0 ;

5047

PyObject *swig_obj[1] ;

5048

5049

if (!args) SWIG_fail;

5050

swig_obj[0] = args;

5051

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

5052

if (!SWIG_IsOK(res1)) {

5053

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_OnPopupDismiss" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

5054

}

5055

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

5056

{

5057

PyThreadState* __tstate = wxPyBeginAllowThreads();

5058

(arg1)->OnPopupDismiss();

5059

wxPyEndAllowThreads(__tstate);

5060

if (PyErr_Occurred()) SWIG_fail;

5061

}

5062

resultobj = SWIG_Py_Void();

5063

return resultobj;

5064

fail:

5065

return NULL;

5066

}

5067

5068

5069

SWIGINTERN PyObject *_wrap_ComboCtrl_IsPopupWindowState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5070

PyObject *resultobj = 0;

5071

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

5072

int arg2 ;

5073

bool result;

5074

void *argp1 = 0 ;

5075

int res1 = 0 ;

5076

int val2 ;

5077

int ecode2 = 0 ;

5078

PyObject * obj0 = 0 ;

5079

PyObject * obj1 = 0 ;

5080

char * kwnames[] = {

5081

(char *) "self",(char *) "state", NULL

5082

};

5083

5084

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_IsPopupWindowState",kwnames,&obj0,&obj1)) SWIG_fail;

5085

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

5086

if (!SWIG_IsOK(res1)) {

5087

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_IsPopupWindowState" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

5088

}

5089

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

5090

ecode2 = SWIG_AsVal_int(obj1, &val2);

5091

if (!SWIG_IsOK(ecode2)) {

5092

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboCtrl_IsPopupWindowState" "', expected argument " "2"" of type '" "int""'");

5093

}

5094

arg2 = static_cast< int >(val2);

5095

{

5096

PyThreadState* __tstate = wxPyBeginAllowThreads();

5097

result = (bool)((wxPyComboCtrl const *)arg1)->IsPopupWindowState(arg2);

5098

wxPyEndAllowThreads(__tstate);

5099

if (PyErr_Occurred()) SWIG_fail;

5100

}

5101

{

5102

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

5103

}

5104

return resultobj;

5105

fail:

5106

return NULL;

5107

}

5108

5109

5110

SWIGINTERN PyObject *_wrap_ComboCtrl_GetPopupWindowState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5111

PyObject *resultobj = 0;

5112

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

5113

int result;

5114

void *argp1 = 0 ;

5115

int res1 = 0 ;

5116

PyObject *swig_obj[1] ;

5117

5118

if (!args) SWIG_fail;

5119

swig_obj[0] = args;

5120

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

5121

if (!SWIG_IsOK(res1)) {

5122

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetPopupWindowState" "', expected argument " "1"" of type '" "wxPyComboCtrl const *""'");

5123

}

5124

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

5125

{

5126

PyThreadState* __tstate = wxPyBeginAllowThreads();

5127

result = (int)((wxPyComboCtrl const *)arg1)->GetPopupWindowState();

5128

wxPyEndAllowThreads(__tstate);

5129

if (PyErr_Occurred()) SWIG_fail;

5130

}

5131

resultobj = SWIG_From_int(static_cast< int >(result));

5132

return resultobj;

5133

fail:

5134

return NULL;

5135

}

5136

5137

5138

SWIGINTERN PyObject *_wrap_ComboCtrl_SetCtrlMainWnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5139

PyObject *resultobj = 0;

5140

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

5141

wxWindow *arg2 = (wxWindow *) 0 ;

5142

void *argp1 = 0 ;

5143

int res1 = 0 ;

5144

void *argp2 = 0 ;

5145

int res2 = 0 ;

5146

PyObject * obj0 = 0 ;

5147

PyObject * obj1 = 0 ;

5148

char * kwnames[] = {

5149

(char *) "self",(char *) "wnd", NULL

5150

};

5151

5152

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboCtrl_SetCtrlMainWnd",kwnames,&obj0,&obj1)) SWIG_fail;

5153

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

5154

if (!SWIG_IsOK(res1)) {

5155

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_SetCtrlMainWnd" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

5156

}

5157

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

5158

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );

5159

if (!SWIG_IsOK(res2)) {

5160

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComboCtrl_SetCtrlMainWnd" "', expected argument " "2"" of type '" "wxWindow *""'");

5161

}

5162

arg2 = reinterpret_cast< wxWindow * >(argp2);

5163

{

5164

PyThreadState* __tstate = wxPyBeginAllowThreads();

5165

(arg1)->SetCtrlMainWnd(arg2);

5166

wxPyEndAllowThreads(__tstate);

5167

if (PyErr_Occurred()) SWIG_fail;

5168

}

5169

resultobj = SWIG_Py_Void();

5170

return resultobj;

5171

fail:

5172

return NULL;

5173

}

5174

5175

5176

SWIGINTERN PyObject *_wrap_ComboCtrl_GetMainWindowOfCompositeControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5177

PyObject *resultobj = 0;

5178

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

5179

wxWindow *result = 0 ;

5180

void *argp1 = 0 ;

5181

int res1 = 0 ;

5182

PyObject *swig_obj[1] ;

5183

5184

if (!args) SWIG_fail;

5185

swig_obj[0] = args;

5186

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

5187

if (!SWIG_IsOK(res1)) {

5188

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_GetMainWindowOfCompositeControl" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

5189

}

5190

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

5191

{

5192

PyThreadState* __tstate = wxPyBeginAllowThreads();

5193

result = (wxWindow *)(arg1)->GetMainWindowOfCompositeControl();

5194

wxPyEndAllowThreads(__tstate);

5195

if (PyErr_Occurred()) SWIG_fail;

5196

}

5197

{

5198

resultobj = wxPyMake_wxObject(result, 0);

5199

}

5200

return resultobj;

5201

fail:

5202

return NULL;

5203

}

5204

5205

5206

SWIGINTERN PyObject *_wrap_ComboCtrl_DestroyPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5207

PyObject *resultobj = 0;

5208

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

5209

void *argp1 = 0 ;

5210

int res1 = 0 ;

5211

PyObject *swig_obj[1] ;

5212

5213

if (!args) SWIG_fail;

5214

swig_obj[0] = args;

5215

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

5216

if (!SWIG_IsOK(res1)) {

5217

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_DestroyPopup" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

5218

}

5219

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

5220

{

5221

PyThreadState* __tstate = wxPyBeginAllowThreads();

5222

(arg1)->DestroyPopup();

5223

wxPyEndAllowThreads(__tstate);

5224

if (PyErr_Occurred()) SWIG_fail;

5225

}

5226

resultobj = SWIG_Py_Void();

5227

return resultobj;

5228

fail:

5229

return NULL;

5230

}

5231

5232

5233

SWIGINTERN PyObject *_wrap_ComboCtrl_GetFeatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5234

PyObject *resultobj = 0;

5235

int result;

5236

5237

if (!SWIG_Python_UnpackTuple(args,"ComboCtrl_GetFeatures",0,0,0)) SWIG_fail;

5238

{

5239

PyThreadState* __tstate = wxPyBeginAllowThreads();

5240

result = (int)wxPyComboCtrl::GetFeatures();

5241

wxPyEndAllowThreads(__tstate);

5242

if (PyErr_Occurred()) SWIG_fail;

5243

}

5244

resultobj = SWIG_From_int(static_cast< int >(result));

5245

return resultobj;

5246

fail:

5247

return NULL;

5248

}

5249

5250

5251

SWIGINTERN PyObject *_wrap_ComboCtrl_DoShowPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5252

PyObject *resultobj = 0;

5253

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

5254

wxRect *arg2 = 0 ;

5255

int arg3 ;

5256

void *argp1 = 0 ;

5257

int res1 = 0 ;

5258

wxRect temp2 ;

5259

int val3 ;

5260

int ecode3 = 0 ;

5261

PyObject * obj0 = 0 ;

5262

PyObject * obj1 = 0 ;

5263

PyObject * obj2 = 0 ;

5264

char * kwnames[] = {

5265

(char *) "self",(char *) "rect",(char *) "flags", NULL

5266

};

5267

5268

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboCtrl_DoShowPopup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

5269

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

5270

if (!SWIG_IsOK(res1)) {

5271

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_DoShowPopup" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

5272

}

5273

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

5274

{

5275

arg2 = &temp2;

5276

if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;

5277

}

5278

ecode3 = SWIG_AsVal_int(obj2, &val3);

5279

if (!SWIG_IsOK(ecode3)) {

5280

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboCtrl_DoShowPopup" "', expected argument " "3"" of type '" "int""'");

5281

}

5282

arg3 = static_cast< int >(val3);

5283

{

5284

PyThreadState* __tstate = wxPyBeginAllowThreads();

5285

(arg1)->DoShowPopup((wxRect const &)*arg2,arg3);

5286

wxPyEndAllowThreads(__tstate);

5287

if (PyErr_Occurred()) SWIG_fail;

5288

}

5289

resultobj = SWIG_Py_Void();

5290

return resultobj;

5291

fail:

5292

return NULL;

5293

}

5294

5295

5296

SWIGINTERN PyObject *_wrap_ComboCtrl_AnimateShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5297

PyObject *resultobj = 0;

5298

wxPyComboCtrl *arg1 = (wxPyComboCtrl *) 0 ;

5299

wxRect *arg2 = 0 ;

5300

int arg3 ;

5301

bool result;

5302

void *argp1 = 0 ;

5303

int res1 = 0 ;

5304

wxRect temp2 ;

5305

int val3 ;

5306

int ecode3 = 0 ;

5307

PyObject * obj0 = 0 ;

5308

PyObject * obj1 = 0 ;

5309

PyObject * obj2 = 0 ;

5310

char * kwnames[] = {

5311

(char *) "self",(char *) "rect",(char *) "flags", NULL

5312

};

5313

5314

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboCtrl_AnimateShow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

5315

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboCtrl, 0 | 0 );

5316

if (!SWIG_IsOK(res1)) {

5317

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboCtrl_AnimateShow" "', expected argument " "1"" of type '" "wxPyComboCtrl *""'");

5318

}

5319

arg1 = reinterpret_cast< wxPyComboCtrl * >(argp1);

5320

{

5321

arg2 = &temp2;

5322

if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;

5323

}

5324

ecode3 = SWIG_AsVal_int(obj2, &val3);

5325

if (!SWIG_IsOK(ecode3)) {

5326

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboCtrl_AnimateShow" "', expected argument " "3"" of type '" "int""'");

5327

}

5328

arg3 = static_cast< int >(val3);

5329

{

5330

PyThreadState* __tstate = wxPyBeginAllowThreads();

5331

result = (bool)(arg1)->AnimateShow((wxRect const &)*arg2,arg3);

5332

wxPyEndAllowThreads(__tstate);

5333

if (PyErr_Occurred()) SWIG_fail;

5334

}

5335

{

5336

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

5337

}

5338

return resultobj;

5339

fail:

5340

return NULL;

5341

}

5342

5343

5344

SWIGINTERN PyObject *ComboCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5345

PyObject *obj;

5346

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

5347

SWIG_TypeNewClientData(SWIGTYPE_p_wxPyComboCtrl, SWIG_NewClientData(obj));

5348

return SWIG_Py_Void();

5349

}

5350

5351

SWIGINTERN PyObject *ComboCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5352

return SWIG_Python_InitShadowInstance(args);

5353

}

5354

5355

SWIGINTERN PyObject *_wrap_new_ComboPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5356

PyObject *resultobj = 0;

5357

wxPyComboPopup *result = 0 ;

5358

5359

if (!SWIG_Python_UnpackTuple(args,"new_ComboPopup",0,0,0)) SWIG_fail;

5360

{

5361

if (!wxPyCheckForApp()) SWIG_fail;

5362

PyThreadState* __tstate = wxPyBeginAllowThreads();

5363

result = (wxPyComboPopup *)new wxPyComboPopup();

5364

wxPyEndAllowThreads(__tstate);

5365

if (PyErr_Occurred()) SWIG_fail;

5366

}

5367

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyComboPopup, SWIG_POINTER_NEW | 0 );

5368

return resultobj;

5369

fail:

5370

return NULL;

5371

}

5372

5373

5374

SWIGINTERN PyObject *_wrap_delete_ComboPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5375

PyObject *resultobj = 0;

5376

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5377

void *argp1 = 0 ;

5378

int res1 = 0 ;

5379

PyObject *swig_obj[1] ;

5380

5381

if (!args) SWIG_fail;

5382

swig_obj[0] = args;

5383

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, SWIG_POINTER_DISOWN | 0 );

5384

if (!SWIG_IsOK(res1)) {

5385

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComboPopup" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5386

}

5387

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5388

{

5389

PyThreadState* __tstate = wxPyBeginAllowThreads();

5390

delete arg1;

5391

5392

wxPyEndAllowThreads(__tstate);

5393

if (PyErr_Occurred()) SWIG_fail;

5394

}

5395

resultobj = SWIG_Py_Void();

5396

return resultobj;

5397

fail:

5398

return NULL;

5399

}

5400

5401

5402

SWIGINTERN PyObject *_wrap_ComboPopup__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5403

PyObject *resultobj = 0;

5404

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5405

PyObject *arg2 = (PyObject *) 0 ;

5406

PyObject *arg3 = (PyObject *) 0 ;

5407

void *argp1 = 0 ;

5408

int res1 = 0 ;

5409

PyObject * obj0 = 0 ;

5410

PyObject * obj1 = 0 ;

5411

PyObject * obj2 = 0 ;

5412

char * kwnames[] = {

5413

(char *) "self",(char *) "self",(char *) "_class", NULL

5414

};

5415

5416

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboPopup__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

5417

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5418

if (!SWIG_IsOK(res1)) {

5419

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5420

}

5421

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5422

arg2 = obj1;

5423

arg3 = obj2;

5424

{

5425

PyThreadState* __tstate = wxPyBeginAllowThreads();

5426

(arg1)->_setCallbackInfo(arg2,arg3);

5427

wxPyEndAllowThreads(__tstate);

5428

if (PyErr_Occurred()) SWIG_fail;

5429

}

5430

resultobj = SWIG_Py_Void();

5431

return resultobj;

5432

fail:

5433

return NULL;

5434

}

5435

5436

5437

SWIGINTERN PyObject *_wrap_ComboPopup_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5438

PyObject *resultobj = 0;

5439

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5440

void *argp1 = 0 ;

5441

int res1 = 0 ;

5442

PyObject *swig_obj[1] ;

5443

5444

if (!args) SWIG_fail;

5445

swig_obj[0] = args;

5446

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5447

if (!SWIG_IsOK(res1)) {

5448

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_Init" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5449

}

5450

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5451

{

5452

PyThreadState* __tstate = wxPyBeginAllowThreads();

5453

(arg1)->Init();

5454

wxPyEndAllowThreads(__tstate);

5455

if (PyErr_Occurred()) SWIG_fail;

5456

}

5457

resultobj = SWIG_Py_Void();

5458

return resultobj;

5459

fail:

5460

return NULL;

5461

}

5462

5463

5464

SWIGINTERN PyObject *_wrap_ComboPopup_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5465

PyObject *resultobj = 0;

5466

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5467

wxWindow *arg2 = (wxWindow *) 0 ;

5468

bool result;

5469

void *argp1 = 0 ;

5470

int res1 = 0 ;

5471

void *argp2 = 0 ;

5472

int res2 = 0 ;

5473

PyObject * obj0 = 0 ;

5474

PyObject * obj1 = 0 ;

5475

char * kwnames[] = {

5476

(char *) "self",(char *) "parent", NULL

5477

};

5478

5479

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboPopup_Create",kwnames,&obj0,&obj1)) SWIG_fail;

5480

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5481

if (!SWIG_IsOK(res1)) {

5482

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_Create" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5483

}

5484

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5485

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );

5486

if (!SWIG_IsOK(res2)) {

5487

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComboPopup_Create" "', expected argument " "2"" of type '" "wxWindow *""'");

5488

}

5489

arg2 = reinterpret_cast< wxWindow * >(argp2);

5490

{

5491

PyThreadState* __tstate = wxPyBeginAllowThreads();

5492

result = (bool)(arg1)->Create(arg2);

5493

wxPyEndAllowThreads(__tstate);

5494

if (PyErr_Occurred()) SWIG_fail;

5495

}

5496

{

5497

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

5498

}

5499

return resultobj;

5500

fail:

5501

return NULL;

5502

}

5503

5504

5505

SWIGINTERN PyObject *_wrap_ComboPopup_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5506

PyObject *resultobj = 0;

5507

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5508

wxWindow *result = 0 ;

5509

void *argp1 = 0 ;

5510

int res1 = 0 ;

5511

PyObject *swig_obj[1] ;

5512

5513

if (!args) SWIG_fail;

5514

swig_obj[0] = args;

5515

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5516

if (!SWIG_IsOK(res1)) {

5517

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_GetControl" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5518

}

5519

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5520

{

5521

PyThreadState* __tstate = wxPyBeginAllowThreads();

5522

result = (wxWindow *)(arg1)->GetControl();

5523

wxPyEndAllowThreads(__tstate);

5524

if (PyErr_Occurred()) SWIG_fail;

5525

}

5526

{

5527

resultobj = wxPyMake_wxObject(result, 0);

5528

}

5529

return resultobj;

5530

fail:

5531

return NULL;

5532

}

5533

5534

5535

SWIGINTERN PyObject *_wrap_ComboPopup_OnPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5536

PyObject *resultobj = 0;

5537

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5538

void *argp1 = 0 ;

5539

int res1 = 0 ;

5540

PyObject *swig_obj[1] ;

5541

5542

if (!args) SWIG_fail;

5543

swig_obj[0] = args;

5544

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5545

if (!SWIG_IsOK(res1)) {

5546

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_OnPopup" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5547

}

5548

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5549

{

5550

PyThreadState* __tstate = wxPyBeginAllowThreads();

5551

(arg1)->OnPopup();

5552

wxPyEndAllowThreads(__tstate);

5553

if (PyErr_Occurred()) SWIG_fail;

5554

}

5555

resultobj = SWIG_Py_Void();

5556

return resultobj;

5557

fail:

5558

return NULL;

5559

}

5560

5561

5562

SWIGINTERN PyObject *_wrap_ComboPopup_OnDismiss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5563

PyObject *resultobj = 0;

5564

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5565

void *argp1 = 0 ;

5566

int res1 = 0 ;

5567

PyObject *swig_obj[1] ;

5568

5569

if (!args) SWIG_fail;

5570

swig_obj[0] = args;

5571

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5572

if (!SWIG_IsOK(res1)) {

5573

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_OnDismiss" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5574

}

5575

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5576

{

5577

PyThreadState* __tstate = wxPyBeginAllowThreads();

5578

(arg1)->OnDismiss();

5579

wxPyEndAllowThreads(__tstate);

5580

if (PyErr_Occurred()) SWIG_fail;

5581

}

5582

resultobj = SWIG_Py_Void();

5583

return resultobj;

5584

fail:

5585

return NULL;

5586

}

5587

5588

5589

SWIGINTERN PyObject *_wrap_ComboPopup_SetStringValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5590

PyObject *resultobj = 0;

5591

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5592

wxString *arg2 = 0 ;

5593

void *argp1 = 0 ;

5594

int res1 = 0 ;

5595

bool temp2 = false ;

5596

PyObject * obj0 = 0 ;

5597

PyObject * obj1 = 0 ;

5598

char * kwnames[] = {

5599

(char *) "self",(char *) "value", NULL

5600

};

5601

5602

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboPopup_SetStringValue",kwnames,&obj0,&obj1)) SWIG_fail;

5603

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5604

if (!SWIG_IsOK(res1)) {

5605

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_SetStringValue" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5606

}

5607

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5608

{

5609

arg2 = wxString_in_helper(obj1);

5610

if (arg2 == NULL) SWIG_fail;

5611

temp2 = true;

5612

}

5613

{

5614

PyThreadState* __tstate = wxPyBeginAllowThreads();

5615

(arg1)->SetStringValue((wxString const &)*arg2);

5616

wxPyEndAllowThreads(__tstate);

5617

if (PyErr_Occurred()) SWIG_fail;

5618

}

5619

resultobj = SWIG_Py_Void();

5620

{

5621

if (temp2)

5622

delete arg2;

5623

}

5624

return resultobj;

5625

fail:

5626

{

5627

if (temp2)

5628

delete arg2;

5629

}

5630

return NULL;

5631

}

5632

5633

5634

SWIGINTERN PyObject *_wrap_ComboPopup_GetStringValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5635

PyObject *resultobj = 0;

5636

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5637

wxString result;

5638

void *argp1 = 0 ;

5639

int res1 = 0 ;

5640

PyObject *swig_obj[1] ;

5641

5642

if (!args) SWIG_fail;

5643

swig_obj[0] = args;

5644

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5645

if (!SWIG_IsOK(res1)) {

5646

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_GetStringValue" "', expected argument " "1"" of type '" "wxPyComboPopup const *""'");

5647

}

5648

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5649

{

5650

PyThreadState* __tstate = wxPyBeginAllowThreads();

5651

result = ((wxPyComboPopup const *)arg1)->GetStringValue();

5652

wxPyEndAllowThreads(__tstate);

5653

if (PyErr_Occurred()) SWIG_fail;

5654

}

5655

{

5656

#if wxUSE_UNICODE

5657

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

5658

#else

5659

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

5660

#endif

5661

}

5662

return resultobj;

5663

fail:

5664

return NULL;

5665

}

5666

5667

5668

SWIGINTERN PyObject *_wrap_ComboPopup_PaintComboControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5669

PyObject *resultobj = 0;

5670

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5671

wxDC *arg2 = 0 ;

5672

wxRect *arg3 = 0 ;

5673

void *argp1 = 0 ;

5674

int res1 = 0 ;

5675

void *argp2 = 0 ;

5676

int res2 = 0 ;

5677

wxRect temp3 ;

5678

PyObject * obj0 = 0 ;

5679

PyObject * obj1 = 0 ;

5680

PyObject * obj2 = 0 ;

5681

char * kwnames[] = {

5682

(char *) "self",(char *) "dc",(char *) "rect", NULL

5683

};

5684

5685

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboPopup_PaintComboControl",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

5686

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5687

if (!SWIG_IsOK(res1)) {

5688

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_PaintComboControl" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5689

}

5690

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5691

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );

5692

if (!SWIG_IsOK(res2)) {

5693

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComboPopup_PaintComboControl" "', expected argument " "2"" of type '" "wxDC &""'");

5694

}

5695

if (!argp2) {

5696

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComboPopup_PaintComboControl" "', expected argument " "2"" of type '" "wxDC &""'");

5697

}

5698

arg2 = reinterpret_cast< wxDC * >(argp2);

5699

{

5700

arg3 = &temp3;

5701

if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;

5702

}

5703

{

5704

PyThreadState* __tstate = wxPyBeginAllowThreads();

5705

(arg1)->PaintComboControl(*arg2,(wxRect const &)*arg3);

5706

wxPyEndAllowThreads(__tstate);

5707

if (PyErr_Occurred()) SWIG_fail;

5708

}

5709

resultobj = SWIG_Py_Void();

5710

return resultobj;

5711

fail:

5712

return NULL;

5713

}

5714

5715

5716

SWIGINTERN PyObject *_wrap_ComboPopup_OnComboKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5717

PyObject *resultobj = 0;

5718

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5719

wxKeyEvent *arg2 = 0 ;

5720

void *argp1 = 0 ;

5721

int res1 = 0 ;

5722

void *argp2 = 0 ;

5723

int res2 = 0 ;

5724

PyObject * obj0 = 0 ;

5725

PyObject * obj1 = 0 ;

5726

char * kwnames[] = {

5727

(char *) "self",(char *) "event", NULL

5728

};

5729

5730

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ComboPopup_OnComboKeyEvent",kwnames,&obj0,&obj1)) SWIG_fail;

5731

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5732

if (!SWIG_IsOK(res1)) {

5733

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_OnComboKeyEvent" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5734

}

5735

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5736

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );

5737

if (!SWIG_IsOK(res2)) {

5738

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComboPopup_OnComboKeyEvent" "', expected argument " "2"" of type '" "wxKeyEvent &""'");

5739

}

5740

if (!argp2) {

5741

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComboPopup_OnComboKeyEvent" "', expected argument " "2"" of type '" "wxKeyEvent &""'");

5742

}

5743

arg2 = reinterpret_cast< wxKeyEvent * >(argp2);

5744

{

5745

PyThreadState* __tstate = wxPyBeginAllowThreads();

5746

(arg1)->OnComboKeyEvent(*arg2);

5747

wxPyEndAllowThreads(__tstate);

5748

if (PyErr_Occurred()) SWIG_fail;

5749

}

5750

resultobj = SWIG_Py_Void();

5751

return resultobj;

5752

fail:

5753

return NULL;

5754

}

5755

5756

5757

SWIGINTERN PyObject *_wrap_ComboPopup_OnComboDoubleClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5758

PyObject *resultobj = 0;

5759

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5760

void *argp1 = 0 ;

5761

int res1 = 0 ;

5762

PyObject *swig_obj[1] ;

5763

5764

if (!args) SWIG_fail;

5765

swig_obj[0] = args;

5766

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5767

if (!SWIG_IsOK(res1)) {

5768

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_OnComboDoubleClick" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5769

}

5770

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5771

{

5772

PyThreadState* __tstate = wxPyBeginAllowThreads();

5773

(arg1)->OnComboDoubleClick();

5774

wxPyEndAllowThreads(__tstate);

5775

if (PyErr_Occurred()) SWIG_fail;

5776

}

5777

resultobj = SWIG_Py_Void();

5778

return resultobj;

5779

fail:

5780

return NULL;

5781

}

5782

5783

5784

SWIGINTERN PyObject *_wrap_ComboPopup_GetAdjustedSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5785

PyObject *resultobj = 0;

5786

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5787

int arg2 ;

5788

int arg3 ;

5789

int arg4 ;

5790

wxSize result;

5791

void *argp1 = 0 ;

5792

int res1 = 0 ;

5793

int val2 ;

5794

int ecode2 = 0 ;

5795

int val3 ;

5796

int ecode3 = 0 ;

5797

int val4 ;

5798

int ecode4 = 0 ;

5799

PyObject * obj0 = 0 ;

5800

PyObject * obj1 = 0 ;

5801

PyObject * obj2 = 0 ;

5802

PyObject * obj3 = 0 ;

5803

char * kwnames[] = {

5804

(char *) "self",(char *) "minWidth",(char *) "prefHeight",(char *) "maxHeight", NULL

5805

};

5806

5807

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ComboPopup_GetAdjustedSize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

5808

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5809

if (!SWIG_IsOK(res1)) {

5810

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_GetAdjustedSize" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5811

}

5812

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5813

ecode2 = SWIG_AsVal_int(obj1, &val2);

5814

if (!SWIG_IsOK(ecode2)) {

5815

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ComboPopup_GetAdjustedSize" "', expected argument " "2"" of type '" "int""'");

5816

}

5817

arg2 = static_cast< int >(val2);

5818

ecode3 = SWIG_AsVal_int(obj2, &val3);

5819

if (!SWIG_IsOK(ecode3)) {

5820

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ComboPopup_GetAdjustedSize" "', expected argument " "3"" of type '" "int""'");

5821

}

5822

arg3 = static_cast< int >(val3);

5823

ecode4 = SWIG_AsVal_int(obj3, &val4);

5824

if (!SWIG_IsOK(ecode4)) {

5825

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ComboPopup_GetAdjustedSize" "', expected argument " "4"" of type '" "int""'");

5826

}

5827

arg4 = static_cast< int >(val4);

5828

{

5829

PyThreadState* __tstate = wxPyBeginAllowThreads();

5830

result = (arg1)->GetAdjustedSize(arg2,arg3,arg4);

5831

wxPyEndAllowThreads(__tstate);

5832

if (PyErr_Occurred()) SWIG_fail;

5833

}

5834

resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );

5835

return resultobj;

5836

fail:

5837

return NULL;

5838

}

5839

5840

5841

SWIGINTERN PyObject *_wrap_ComboPopup_LazyCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5842

PyObject *resultobj = 0;

5843

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5844

bool result;

5845

void *argp1 = 0 ;

5846

int res1 = 0 ;

5847

PyObject *swig_obj[1] ;

5848

5849

if (!args) SWIG_fail;

5850

swig_obj[0] = args;

5851

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5852

if (!SWIG_IsOK(res1)) {

5853

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_LazyCreate" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5854

}

5855

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5856

{

5857

PyThreadState* __tstate = wxPyBeginAllowThreads();

5858

result = (bool)(arg1)->LazyCreate();

5859

wxPyEndAllowThreads(__tstate);

5860

if (PyErr_Occurred()) SWIG_fail;

5861

}

5862

{

5863

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

5864

}

5865

return resultobj;

5866

fail:

5867

return NULL;

5868

}

5869

5870

5871

SWIGINTERN PyObject *_wrap_ComboPopup_Dismiss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5872

PyObject *resultobj = 0;

5873

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5874

void *argp1 = 0 ;

5875

int res1 = 0 ;

5876

PyObject *swig_obj[1] ;

5877

5878

if (!args) SWIG_fail;

5879

swig_obj[0] = args;

5880

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5881

if (!SWIG_IsOK(res1)) {

5882

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_Dismiss" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5883

}

5884

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5885

{

5886

PyThreadState* __tstate = wxPyBeginAllowThreads();

5887

(arg1)->Dismiss();

5888

wxPyEndAllowThreads(__tstate);

5889

if (PyErr_Occurred()) SWIG_fail;

5890

}

5891

resultobj = SWIG_Py_Void();

5892

return resultobj;

5893

fail:

5894

return NULL;

5895

}

5896

5897

5898

SWIGINTERN PyObject *_wrap_ComboPopup_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5899

PyObject *resultobj = 0;

5900

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5901

bool result;

5902

void *argp1 = 0 ;

5903

int res1 = 0 ;

5904

PyObject *swig_obj[1] ;

5905

5906

if (!args) SWIG_fail;

5907

swig_obj[0] = args;

5908

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5909

if (!SWIG_IsOK(res1)) {

5910

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_IsCreated" "', expected argument " "1"" of type '" "wxPyComboPopup const *""'");

5911

}

5912

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5913

{

5914

PyThreadState* __tstate = wxPyBeginAllowThreads();

5915

result = (bool)((wxPyComboPopup const *)arg1)->IsCreated();

5916

wxPyEndAllowThreads(__tstate);

5917

if (PyErr_Occurred()) SWIG_fail;

5918

}

5919

{

5920

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

5921

}

5922

return resultobj;

5923

fail:

5924

return NULL;

5925

}

5926

5927

5928

SWIGINTERN PyObject *_wrap_ComboPopup_DefaultPaintComboControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

5929

PyObject *resultobj = 0;

5930

wxComboCtrlBase *arg1 = (wxComboCtrlBase *) 0 ;

5931

wxDC *arg2 = 0 ;

5932

wxRect *arg3 = 0 ;

5933

void *argp1 = 0 ;

5934

int res1 = 0 ;

5935

void *argp2 = 0 ;

5936

int res2 = 0 ;

5937

wxRect temp3 ;

5938

PyObject * obj0 = 0 ;

5939

PyObject * obj1 = 0 ;

5940

PyObject * obj2 = 0 ;

5941

char * kwnames[] = {

5942

(char *) "combo",(char *) "dc",(char *) "rect", NULL

5943

};

5944

5945

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ComboPopup_DefaultPaintComboControl",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

5946

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxComboCtrlBase, 0 | 0 );

5947

if (!SWIG_IsOK(res1)) {

5948

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_DefaultPaintComboControl" "', expected argument " "1"" of type '" "wxComboCtrlBase *""'");

5949

}

5950

arg1 = reinterpret_cast< wxComboCtrlBase * >(argp1);

5951

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );

5952

if (!SWIG_IsOK(res2)) {

5953

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComboPopup_DefaultPaintComboControl" "', expected argument " "2"" of type '" "wxDC &""'");

5954

}

5955

if (!argp2) {

5956

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComboPopup_DefaultPaintComboControl" "', expected argument " "2"" of type '" "wxDC &""'");

5957

}

5958

arg2 = reinterpret_cast< wxDC * >(argp2);

5959

{

5960

arg3 = &temp3;

5961

if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;

5962

}

5963

{

5964

PyThreadState* __tstate = wxPyBeginAllowThreads();

5965

wxPyComboPopup::DefaultPaintComboControl(arg1,*arg2,(wxRect const &)*arg3);

5966

wxPyEndAllowThreads(__tstate);

5967

if (PyErr_Occurred()) SWIG_fail;

5968

}

5969

resultobj = SWIG_Py_Void();

5970

return resultobj;

5971

fail:

5972

return NULL;

5973

}

5974

5975

5976

SWIGINTERN PyObject *_wrap_ComboPopup_GetCombo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5977

PyObject *resultobj = 0;

5978

wxPyComboPopup *arg1 = (wxPyComboPopup *) 0 ;

5979

wxPyComboCtrl *result = 0 ;

5980

void *argp1 = 0 ;

5981

int res1 = 0 ;

5982

PyObject *swig_obj[1] ;

5983

5984

if (!args) SWIG_fail;

5985

swig_obj[0] = args;

5986

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyComboPopup, 0 | 0 );

5987

if (!SWIG_IsOK(res1)) {

5988

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComboPopup_GetCombo" "', expected argument " "1"" of type '" "wxPyComboPopup *""'");

5989

}

5990

arg1 = reinterpret_cast< wxPyComboPopup * >(argp1);

5991

{

5992

PyThreadState* __tstate = wxPyBeginAllowThreads();

5993

result = (wxPyComboCtrl *)(arg1)->GetCombo();

5994

wxPyEndAllowThreads(__tstate);

5995

if (PyErr_Occurred()) SWIG_fail;

5996

}

5997

{

5998

resultobj = wxPyMake_wxObject(result, (bool)0);

5999

}

6000

return resultobj;

6001

fail:

6002

return NULL;

6003

}

6004

6005

6006

SWIGINTERN PyObject *ComboPopup_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6007

PyObject *obj;

6008

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

6009

SWIG_TypeNewClientData(SWIGTYPE_p_wxPyComboPopup, SWIG_NewClientData(obj));

6010

return SWIG_Py_Void();

6011

}

6012

6013

SWIGINTERN PyObject *ComboPopup_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6014

return SWIG_Python_InitShadowInstance(args);

6015

}

6016

6017

SWIGINTERN PyObject *_wrap_new_OwnerDrawnComboBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6018

PyObject *resultobj = 0;

6019

wxWindow *arg1 = (wxWindow *) 0 ;

6020

int arg2 = (int) -1 ;

6021

wxString const &arg3_defvalue = wxPyEmptyString ;

6022

wxString *arg3 = (wxString *) &arg3_defvalue ;

6023

wxPoint const &arg4_defvalue = wxDefaultPosition ;

6024

wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;

6025

wxSize const &arg5_defvalue = wxDefaultSize ;

6026

wxSize *arg5 = (wxSize *) &arg5_defvalue ;

6027

wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;

6028

wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;

6029

long arg7 = (long) 0 ;

6030

wxValidator const &arg8_defvalue = wxDefaultValidator ;

6031

wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;

6032

wxString const &arg9_defvalue = wxPyComboBoxNameStr ;

6033

wxString *arg9 = (wxString *) &arg9_defvalue ;

6034

wxPyOwnerDrawnComboBox *result = 0 ;

6035

void *argp1 = 0 ;

6036

int res1 = 0 ;

6037

int val2 ;

6038

int ecode2 = 0 ;

6039

bool temp3 = false ;

6040

wxPoint temp4 ;

6041

wxSize temp5 ;

6042

bool temp6 = false ;

6043

long val7 ;

6044

int ecode7 = 0 ;

6045

void *argp8 = 0 ;

6046

int res8 = 0 ;

6047

bool temp9 = false ;

6048

PyObject * obj0 = 0 ;

6049

PyObject * obj1 = 0 ;

6050

PyObject * obj2 = 0 ;

6051

PyObject * obj3 = 0 ;

6052

PyObject * obj4 = 0 ;

6053

PyObject * obj5 = 0 ;

6054

PyObject * obj6 = 0 ;

6055

PyObject * obj7 = 0 ;

6056

PyObject * obj8 = 0 ;

6057

char * kwnames[] = {

6058

(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL

6059

};

6060

6061

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_OwnerDrawnComboBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;

6062

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );

6063

if (!SWIG_IsOK(res1)) {

6064

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OwnerDrawnComboBox" "', expected argument " "1"" of type '" "wxWindow *""'");

6065

}

6066

arg1 = reinterpret_cast< wxWindow * >(argp1);

6067

if (obj1) {

6068

ecode2 = SWIG_AsVal_int(obj1, &val2);

6069

if (!SWIG_IsOK(ecode2)) {

6070

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OwnerDrawnComboBox" "', expected argument " "2"" of type '" "int""'");

6071

}

6072

arg2 = static_cast< int >(val2);

6073

}

6074

if (obj2) {

6075

{

6076

arg3 = wxString_in_helper(obj2);

6077

if (arg3 == NULL) SWIG_fail;

6078

temp3 = true;

6079

}

6080

}

6081

if (obj3) {

6082

{

6083

arg4 = &temp4;

6084

if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;

6085

}

6086

}

6087

if (obj4) {

6088

{

6089

arg5 = &temp5;

6090

if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;

6091

}

6092

}

6093

if (obj5) {

6094

{

6095

if (! PySequence_Check(obj5)) {

6096

PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");

6097

SWIG_fail;

6098

}

6099

arg6 = new wxArrayString;

6100

temp6 = true;

6101

int i, len=PySequence_Length(obj5);

6102

for (i=0; i<len; i++) {

6103

PyObject* item = PySequence_GetItem(obj5, i);

6104

wxString* s = wxString_in_helper(item);

6105

if (PyErr_Occurred()) SWIG_fail;

6106

arg6->Add(*s);

6107

delete s;

6108

Py_DECREF(item);

6109

}

6110

}

6111

}

6112

if (obj6) {

6113

ecode7 = SWIG_AsVal_long(obj6, &val7);

6114

if (!SWIG_IsOK(ecode7)) {

6115

SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OwnerDrawnComboBox" "', expected argument " "7"" of type '" "long""'");

6116

}

6117

arg7 = static_cast< long >(val7);

6118

}

6119

if (obj7) {

6120

res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator, 0 | 0);

6121

if (!SWIG_IsOK(res8)) {

6122

SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OwnerDrawnComboBox" "', expected argument " "8"" of type '" "wxValidator const &""'");

6123

}

6124

if (!argp8) {

6125

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OwnerDrawnComboBox" "', expected argument " "8"" of type '" "wxValidator const &""'");

6126

}

6127

arg8 = reinterpret_cast< wxValidator * >(argp8);

6128

}

6129

if (obj8) {

6130

{

6131

arg9 = wxString_in_helper(obj8);

6132

if (arg9 == NULL) SWIG_fail;

6133

temp9 = true;

6134

}

6135

}

6136

{

6137

if (!wxPyCheckForApp()) SWIG_fail;

6138

PyThreadState* __tstate = wxPyBeginAllowThreads();

6139

result = (wxPyOwnerDrawnComboBox *)new wxPyOwnerDrawnComboBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);

6140

wxPyEndAllowThreads(__tstate);

6141

if (PyErr_Occurred()) SWIG_fail;

6142

}

6143

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyOwnerDrawnComboBox, SWIG_POINTER_NEW | 0 );

6144

{

6145

if (temp3)

6146

delete arg3;

6147

}

6148

{

6149

if (temp6) delete arg6;

6150

}

6151

{

6152

if (temp9)

6153

delete arg9;

6154

}

6155

return resultobj;

6156

fail:

6157

{

6158

if (temp3)

6159

delete arg3;

6160

}

6161

{

6162

if (temp6) delete arg6;

6163

}

6164

{

6165

if (temp9)

6166

delete arg9;

6167

}

6168

return NULL;

6169

}

6170

6171

6172

SWIGINTERN PyObject *_wrap_new_PreOwnerDrawnComboBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6173

PyObject *resultobj = 0;

6174

wxPyOwnerDrawnComboBox *result = 0 ;

6175

6176

if (!SWIG_Python_UnpackTuple(args,"new_PreOwnerDrawnComboBox",0,0,0)) SWIG_fail;

6177

{

6178

if (!wxPyCheckForApp()) SWIG_fail;

6179

PyThreadState* __tstate = wxPyBeginAllowThreads();

6180

result = (wxPyOwnerDrawnComboBox *)new wxPyOwnerDrawnComboBox();

6181

wxPyEndAllowThreads(__tstate);

6182

if (PyErr_Occurred()) SWIG_fail;

6183

}

6184

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyOwnerDrawnComboBox, SWIG_POINTER_OWN | 0 );

6185

return resultobj;

6186

fail:

6187

return NULL;

6188

}

6189

6190

6191

SWIGINTERN PyObject *_wrap_OwnerDrawnComboBox__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6192

PyObject *resultobj = 0;

6193

wxPyOwnerDrawnComboBox *arg1 = (wxPyOwnerDrawnComboBox *) 0 ;

6194

PyObject *arg2 = (PyObject *) 0 ;

6195

PyObject *arg3 = (PyObject *) 0 ;

6196

void *argp1 = 0 ;

6197

int res1 = 0 ;

6198

PyObject * obj0 = 0 ;

6199

PyObject * obj1 = 0 ;

6200

PyObject * obj2 = 0 ;

6201

char * kwnames[] = {

6202

(char *) "self",(char *) "self",(char *) "_class", NULL

6203

};

6204

6205

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:OwnerDrawnComboBox__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

6206

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyOwnerDrawnComboBox, 0 | 0 );

6207

if (!SWIG_IsOK(res1)) {

6208

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OwnerDrawnComboBox__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyOwnerDrawnComboBox *""'");

6209

}

6210

arg1 = reinterpret_cast< wxPyOwnerDrawnComboBox * >(argp1);

6211

arg2 = obj1;

6212

arg3 = obj2;

6213

{

6214

PyThreadState* __tstate = wxPyBeginAllowThreads();

6215

(arg1)->_setCallbackInfo(arg2,arg3);

6216

wxPyEndAllowThreads(__tstate);

6217

if (PyErr_Occurred()) SWIG_fail;

6218

}

6219

resultobj = SWIG_Py_Void();

6220

return resultobj;

6221

fail:

6222

return NULL;

6223

}

6224

6225

6226

SWIGINTERN PyObject *_wrap_OwnerDrawnComboBox_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6227

PyObject *resultobj = 0;

6228

wxPyOwnerDrawnComboBox *arg1 = (wxPyOwnerDrawnComboBox *) 0 ;

6229

wxWindow *arg2 = (wxWindow *) 0 ;

6230

int arg3 = (int) -1 ;

6231

wxString const &arg4_defvalue = wxPyEmptyString ;

6232

wxString *arg4 = (wxString *) &arg4_defvalue ;

6233

wxPoint const &arg5_defvalue = wxDefaultPosition ;

6234

wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;

6235

wxSize const &arg6_defvalue = wxDefaultSize ;

6236

wxSize *arg6 = (wxSize *) &arg6_defvalue ;

6237

wxArrayString const &arg7_defvalue = wxPyEmptyStringArray ;

6238

wxArrayString *arg7 = (wxArrayString *) &arg7_defvalue ;

6239

long arg8 = (long) 0 ;

6240

wxValidator const &arg9_defvalue = wxDefaultValidator ;

6241

wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;

6242

wxString const &arg10_defvalue = wxPyComboBoxNameStr ;

6243

wxString *arg10 = (wxString *) &arg10_defvalue ;

6244

bool result;

6245

void *argp1 = 0 ;

6246

int res1 = 0 ;

6247

void *argp2 = 0 ;

6248

int res2 = 0 ;

6249

int val3 ;

6250

int ecode3 = 0 ;

6251

bool temp4 = false ;

6252

wxPoint temp5 ;

6253

wxSize temp6 ;

6254

bool temp7 = false ;

6255

long val8 ;

6256

int ecode8 = 0 ;

6257

void *argp9 = 0 ;

6258

int res9 = 0 ;

6259

bool temp10 = false ;

6260

PyObject * obj0 = 0 ;

6261

PyObject * obj1 = 0 ;

6262

PyObject * obj2 = 0 ;

6263

PyObject * obj3 = 0 ;

6264

PyObject * obj4 = 0 ;

6265

PyObject * obj5 = 0 ;

6266

PyObject * obj6 = 0 ;

6267

PyObject * obj7 = 0 ;

6268

PyObject * obj8 = 0 ;

6269

PyObject * obj9 = 0 ;

6270

char * kwnames[] = {

6271

(char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL

6272

};

6273

6274

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:OwnerDrawnComboBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;

6275

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyOwnerDrawnComboBox, 0 | 0 );

6276

if (!SWIG_IsOK(res1)) {

6277

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OwnerDrawnComboBox_Create" "', expected argument " "1"" of type '" "wxPyOwnerDrawnComboBox *""'");

6278

}

6279

arg1 = reinterpret_cast< wxPyOwnerDrawnComboBox * >(argp1);

6280

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );

6281

if (!SWIG_IsOK(res2)) {

6282

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OwnerDrawnComboBox_Create" "', expected argument " "2"" of type '" "wxWindow *""'");

6283

}

6284

arg2 = reinterpret_cast< wxWindow * >(argp2);

6285

if (obj2) {

6286

ecode3 = SWIG_AsVal_int(obj2, &val3);

6287

if (!SWIG_IsOK(ecode3)) {

6288

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OwnerDrawnComboBox_Create" "', expected argument " "3"" of type '" "int""'");

6289

}

6290

arg3 = static_cast< int >(val3);

6291

}

6292

if (obj3) {

6293

{

6294

arg4 = wxString_in_helper(obj3);

6295

if (arg4 == NULL) SWIG_fail;

6296

temp4 = true;

6297

}

6298

}

6299

if (obj4) {

6300

{

6301

arg5 = &temp5;

6302

if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;

6303

}

6304

}

6305

if (obj5) {

6306

{

6307

arg6 = &temp6;

6308

if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;

6309

}

6310

}

6311

if (obj6) {

6312

{

6313

if (! PySequence_Check(obj6)) {

6314

PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");

6315

SWIG_fail;

6316

}

6317

arg7 = new wxArrayString;

6318

temp7 = true;

6319

int i, len=PySequence_Length(obj6);

6320

for (i=0; i<len; i++) {

6321

PyObject* item = PySequence_GetItem(obj6, i);

6322

wxString* s = wxString_in_helper(item);

6323

if (PyErr_Occurred()) SWIG_fail;

6324

arg7->Add(*s);

6325

delete s;

6326

Py_DECREF(item);

6327

}

6328

}

6329

}

6330

if (obj7) {

6331

ecode8 = SWIG_AsVal_long(obj7, &val8);

6332

if (!SWIG_IsOK(ecode8)) {

6333

SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "OwnerDrawnComboBox_Create" "', expected argument " "8"" of type '" "long""'");

6334

}

6335

arg8 = static_cast< long >(val8);

6336

}

6337

if (obj8) {

6338

res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_wxValidator, 0 | 0);

6339

if (!SWIG_IsOK(res9)) {

6340

SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "OwnerDrawnComboBox_Create" "', expected argument " "9"" of type '" "wxValidator const &""'");

6341

}

6342

if (!argp9) {

6343

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OwnerDrawnComboBox_Create" "', expected argument " "9"" of type '" "wxValidator const &""'");

6344

}

6345

arg9 = reinterpret_cast< wxValidator * >(argp9);

6346

}

6347

if (obj9) {

6348

{

6349

arg10 = wxString_in_helper(obj9);

6350

if (arg10 == NULL) SWIG_fail;

6351

temp10 = true;

6352

}

6353

}

6354

{

6355

PyThreadState* __tstate = wxPyBeginAllowThreads();

6356

result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,(wxArrayString const &)*arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);

6357

wxPyEndAllowThreads(__tstate);

6358

if (PyErr_Occurred()) SWIG_fail;

6359

}

6360

{

6361

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6362

}

6363

{

6364

if (temp4)

6365

delete arg4;

6366

}

6367

{

6368

if (temp7) delete arg7;

6369

}

6370

{

6371

if (temp10)

6372

delete arg10;

6373

}

6374

return resultobj;

6375

fail:

6376

{

6377

if (temp4)

6378

delete arg4;

6379

}

6380

{

6381

if (temp7) delete arg7;

6382

}

6383

{

6384

if (temp10)

6385

delete arg10;

6386

}

6387

return NULL;

6388

}

6389

6390

6391

SWIGINTERN PyObject *_wrap_OwnerDrawnComboBox_GetWidestItemWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6392

PyObject *resultobj = 0;

6393

wxPyOwnerDrawnComboBox *arg1 = (wxPyOwnerDrawnComboBox *) 0 ;

6394

int result;

6395

void *argp1 = 0 ;

6396

int res1 = 0 ;

6397

PyObject *swig_obj[1] ;

6398

6399

if (!args) SWIG_fail;

6400

swig_obj[0] = args;

6401

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyOwnerDrawnComboBox, 0 | 0 );

6402

if (!SWIG_IsOK(res1)) {

6403

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OwnerDrawnComboBox_GetWidestItemWidth" "', expected argument " "1"" of type '" "wxPyOwnerDrawnComboBox *""'");

6404

}

6405

arg1 = reinterpret_cast< wxPyOwnerDrawnComboBox * >(argp1);

6406

{

6407

PyThreadState* __tstate = wxPyBeginAllowThreads();

6408

result = (int)(arg1)->GetWidestItemWidth();

6409

wxPyEndAllowThreads(__tstate);

6410

if (PyErr_Occurred()) SWIG_fail;

6411

}

6412

resultobj = SWIG_From_int(static_cast< int >(result));

6413

return resultobj;

6414

fail:

6415

return NULL;

6416

}

6417

6418

6419

SWIGINTERN PyObject *_wrap_OwnerDrawnComboBox_GetWidestItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6420

PyObject *resultobj = 0;

6421

wxPyOwnerDrawnComboBox *arg1 = (wxPyOwnerDrawnComboBox *) 0 ;

6422

int result;

6423

void *argp1 = 0 ;

6424

int res1 = 0 ;

6425

PyObject *swig_obj[1] ;

6426

6427

if (!args) SWIG_fail;

6428

swig_obj[0] = args;

6429

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyOwnerDrawnComboBox, 0 | 0 );

6430

if (!SWIG_IsOK(res1)) {

6431

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OwnerDrawnComboBox_GetWidestItem" "', expected argument " "1"" of type '" "wxPyOwnerDrawnComboBox *""'");

6432

}

6433

arg1 = reinterpret_cast< wxPyOwnerDrawnComboBox * >(argp1);

6434

{

6435

PyThreadState* __tstate = wxPyBeginAllowThreads();

6436

result = (int)(arg1)->GetWidestItem();

6437

wxPyEndAllowThreads(__tstate);

6438

if (PyErr_Occurred()) SWIG_fail;

6439

}

6440

resultobj = SWIG_From_int(static_cast< int >(result));

6441

return resultobj;

6442

fail:

6443

return NULL;

6444

}

6445

6446

6447

SWIGINTERN PyObject *_wrap_OwnerDrawnComboBox_SetMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6448

PyObject *resultobj = 0;

6449

wxPyOwnerDrawnComboBox *arg1 = (wxPyOwnerDrawnComboBox *) 0 ;

6450

long arg2 ;

6451

long arg3 ;

6452

void *argp1 = 0 ;

6453

int res1 = 0 ;

6454

long val2 ;

6455

int ecode2 = 0 ;

6456

long val3 ;

6457

int ecode3 = 0 ;

6458

PyObject * obj0 = 0 ;

6459

PyObject * obj1 = 0 ;

6460

PyObject * obj2 = 0 ;

6461

char * kwnames[] = {

6462

(char *) "self",(char *) "from",(char *) "to", NULL

6463

};

6464

6465

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:OwnerDrawnComboBox_SetMark",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

6466

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyOwnerDrawnComboBox, 0 | 0 );

6467

if (!SWIG_IsOK(res1)) {

6468

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OwnerDrawnComboBox_SetMark" "', expected argument " "1"" of type '" "wxPyOwnerDrawnComboBox *""'");

6469

}

6470

arg1 = reinterpret_cast< wxPyOwnerDrawnComboBox * >(argp1);

6471

ecode2 = SWIG_AsVal_long(obj1, &val2);

6472

if (!SWIG_IsOK(ecode2)) {

6473

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OwnerDrawnComboBox_SetMark" "', expected argument " "2"" of type '" "long""'");

6474

}

6475

arg2 = static_cast< long >(val2);

6476

ecode3 = SWIG_AsVal_long(obj2, &val3);

6477

if (!SWIG_IsOK(ecode3)) {

6478

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OwnerDrawnComboBox_SetMark" "', expected argument " "3"" of type '" "long""'");

6479

}

6480

arg3 = static_cast< long >(val3);

6481

{

6482

PyThreadState* __tstate = wxPyBeginAllowThreads();

6483

(arg1)->SetSelection(arg2,arg3);

6484

wxPyEndAllowThreads(__tstate);

6485

if (PyErr_Occurred()) SWIG_fail;

6486

}

6487

resultobj = SWIG_Py_Void();

6488

return resultobj;

6489

fail:

6490

return NULL;

6491

}

6492

6493

6494

SWIGINTERN PyObject *_wrap_OwnerDrawnComboBox_OnDrawItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6495

PyObject *resultobj = 0;

6496

wxPyOwnerDrawnComboBox *arg1 = (wxPyOwnerDrawnComboBox *) 0 ;

6497

wxDC *arg2 = 0 ;

6498

wxRect *arg3 = 0 ;

6499

int arg4 ;

6500

int arg5 ;

6501

void *argp1 = 0 ;

6502

int res1 = 0 ;

6503

void *argp2 = 0 ;

6504

int res2 = 0 ;

6505

wxRect temp3 ;

6506

int val4 ;

6507

int ecode4 = 0 ;

6508

int val5 ;

6509

int ecode5 = 0 ;

6510

PyObject * obj0 = 0 ;

6511

PyObject * obj1 = 0 ;

6512

PyObject * obj2 = 0 ;

6513

PyObject * obj3 = 0 ;

6514

PyObject * obj4 = 0 ;

6515

char * kwnames[] = {

6516

(char *) "self",(char *) "dc",(char *) "rect",(char *) "item",(char *) "flags", NULL

6517

};

6518

6519

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:OwnerDrawnComboBox_OnDrawItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

6520

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyOwnerDrawnComboBox, 0 | 0 );

6521

if (!SWIG_IsOK(res1)) {

6522

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OwnerDrawnComboBox_OnDrawItem" "', expected argument " "1"" of type '" "wxPyOwnerDrawnComboBox const *""'");

6523

}

6524

arg1 = reinterpret_cast< wxPyOwnerDrawnComboBox * >(argp1);

6525

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );

6526

if (!SWIG_IsOK(res2)) {

6527

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OwnerDrawnComboBox_OnDrawItem" "', expected argument " "2"" of type '" "wxDC &""'");

6528

}

6529

if (!argp2) {

6530

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OwnerDrawnComboBox_OnDrawItem" "', expected argument " "2"" of type '" "wxDC &""'");

6531

}

6532

arg2 = reinterpret_cast< wxDC * >(argp2);

6533

{

6534

arg3 = &temp3;

6535

if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;

6536

}

6537

ecode4 = SWIG_AsVal_int(obj3, &val4);

6538

if (!SWIG_IsOK(ecode4)) {

6539

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OwnerDrawnComboBox_OnDrawItem" "', expected argument " "4"" of type '" "int""'");

6540

}

6541

arg4 = static_cast< int >(val4);

6542

ecode5 = SWIG_AsVal_int(obj4, &val5);

6543

if (!SWIG_IsOK(ecode5)) {

6544

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "OwnerDrawnComboBox_OnDrawItem" "', expected argument " "5"" of type '" "int""'");

6545

}

6546

arg5 = static_cast< int >(val5);

6547

{

6548

PyThreadState* __tstate = wxPyBeginAllowThreads();

6549

((wxPyOwnerDrawnComboBox const *)arg1)->OnDrawItem(*arg2,(wxRect const &)*arg3,arg4,arg5);

6550

wxPyEndAllowThreads(__tstate);

6551

if (PyErr_Occurred()) SWIG_fail;

6552

}

6553

resultobj = SWIG_Py_Void();

6554

return resultobj;

6555

fail:

6556

return NULL;

6557

}

6558

6559

6560

SWIGINTERN PyObject *_wrap_OwnerDrawnComboBox_OnMeasureItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6561

PyObject *resultobj = 0;

6562

wxPyOwnerDrawnComboBox *arg1 = (wxPyOwnerDrawnComboBox *) 0 ;

6563

size_t arg2 ;

6564

int result;

6565

void *argp1 = 0 ;

6566

int res1 = 0 ;

6567

size_t val2 ;

6568

int ecode2 = 0 ;

6569

PyObject * obj0 = 0 ;

6570

PyObject * obj1 = 0 ;

6571

char * kwnames[] = {

6572

(char *) "self",(char *) "item", NULL

6573

};

6574

6575

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OwnerDrawnComboBox_OnMeasureItem",kwnames,&obj0,&obj1)) SWIG_fail;

6576

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyOwnerDrawnComboBox, 0 | 0 );

6577

if (!SWIG_IsOK(res1)) {

6578

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OwnerDrawnComboBox_OnMeasureItem" "', expected argument " "1"" of type '" "wxPyOwnerDrawnComboBox const *""'");

6579

}

6580

arg1 = reinterpret_cast< wxPyOwnerDrawnComboBox * >(argp1);

6581

ecode2 = SWIG_AsVal_size_t(obj1, &val2);

6582

if (!SWIG_IsOK(ecode2)) {

6583

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OwnerDrawnComboBox_OnMeasureItem" "', expected argument " "2"" of type '" "size_t""'");

6584

}

6585

arg2 = static_cast< size_t >(val2);

6586

{

6587

PyThreadState* __tstate = wxPyBeginAllowThreads();

6588

result = (int)((wxPyOwnerDrawnComboBox const *)arg1)->OnMeasureItem(arg2);

6589

wxPyEndAllowThreads(__tstate);

6590

if (PyErr_Occurred()) SWIG_fail;

6591

}

6592

resultobj = SWIG_From_int(static_cast< int >(result));

6593

return resultobj;

6594

fail:

6595

return NULL;

6596

}

6597

6598

6599

SWIGINTERN PyObject *_wrap_OwnerDrawnComboBox_OnMeasureItemWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6600

PyObject *resultobj = 0;

6601

wxPyOwnerDrawnComboBox *arg1 = (wxPyOwnerDrawnComboBox *) 0 ;

6602

size_t arg2 ;

6603

int result;

6604

void *argp1 = 0 ;

6605

int res1 = 0 ;

6606

size_t val2 ;

6607

int ecode2 = 0 ;

6608

PyObject * obj0 = 0 ;

6609

PyObject * obj1 = 0 ;

6610

char * kwnames[] = {

6611

(char *) "self",(char *) "item", NULL

6612

};

6613

6614

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OwnerDrawnComboBox_OnMeasureItemWidth",kwnames,&obj0,&obj1)) SWIG_fail;

6615

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyOwnerDrawnComboBox, 0 | 0 );

6616

if (!SWIG_IsOK(res1)) {

6617

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OwnerDrawnComboBox_OnMeasureItemWidth" "', expected argument " "1"" of type '" "wxPyOwnerDrawnComboBox const *""'");

6618

}

6619

arg1 = reinterpret_cast< wxPyOwnerDrawnComboBox * >(argp1);

6620

ecode2 = SWIG_AsVal_size_t(obj1, &val2);

6621

if (!SWIG_IsOK(ecode2)) {

6622

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OwnerDrawnComboBox_OnMeasureItemWidth" "', expected argument " "2"" of type '" "size_t""'");

6623

}

6624

arg2 = static_cast< size_t >(val2);

6625

{

6626

PyThreadState* __tstate = wxPyBeginAllowThreads();

6627

result = (int)((wxPyOwnerDrawnComboBox const *)arg1)->OnMeasureItemWidth(arg2);

6628

wxPyEndAllowThreads(__tstate);

6629

if (PyErr_Occurred()) SWIG_fail;

6630

}

6631

resultobj = SWIG_From_int(static_cast< int >(result));

6632

return resultobj;

6633

fail:

6634

return NULL;

6635

}

6636

6637

6638

SWIGINTERN PyObject *_wrap_OwnerDrawnComboBox_OnDrawBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6639

PyObject *resultobj = 0;

6640

wxPyOwnerDrawnComboBox *arg1 = (wxPyOwnerDrawnComboBox *) 0 ;

6641

wxDC *arg2 = 0 ;

6642

wxRect *arg3 = 0 ;

6643

int arg4 ;

6644

int arg5 ;

6645

void *argp1 = 0 ;

6646

int res1 = 0 ;

6647

void *argp2 = 0 ;

6648

int res2 = 0 ;

6649

wxRect temp3 ;

6650

int val4 ;

6651

int ecode4 = 0 ;

6652

int val5 ;

6653

int ecode5 = 0 ;

6654

PyObject * obj0 = 0 ;

6655

PyObject * obj1 = 0 ;

6656

PyObject * obj2 = 0 ;

6657

PyObject * obj3 = 0 ;

6658

PyObject * obj4 = 0 ;

6659

char * kwnames[] = {

6660

(char *) "self",(char *) "dc",(char *) "rect",(char *) "item",(char *) "flags", NULL

6661

};

6662

6663

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:OwnerDrawnComboBox_OnDrawBackground",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

6664

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyOwnerDrawnComboBox, 0 | 0 );

6665

if (!SWIG_IsOK(res1)) {

6666

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OwnerDrawnComboBox_OnDrawBackground" "', expected argument " "1"" of type '" "wxPyOwnerDrawnComboBox const *""'");

6667

}

6668

arg1 = reinterpret_cast< wxPyOwnerDrawnComboBox * >(argp1);

6669

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );

6670

if (!SWIG_IsOK(res2)) {

6671

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OwnerDrawnComboBox_OnDrawBackground" "', expected argument " "2"" of type '" "wxDC &""'");

6672

}

6673

if (!argp2) {

6674

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OwnerDrawnComboBox_OnDrawBackground" "', expected argument " "2"" of type '" "wxDC &""'");

6675

}

6676

arg2 = reinterpret_cast< wxDC * >(argp2);

6677

{

6678

arg3 = &temp3;

6679

if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;

6680

}

6681

ecode4 = SWIG_AsVal_int(obj3, &val4);

6682

if (!SWIG_IsOK(ecode4)) {

6683

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OwnerDrawnComboBox_OnDrawBackground" "', expected argument " "4"" of type '" "int""'");

6684

}

6685

arg4 = static_cast< int >(val4);

6686

ecode5 = SWIG_AsVal_int(obj4, &val5);

6687

if (!SWIG_IsOK(ecode5)) {

6688

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "OwnerDrawnComboBox_OnDrawBackground" "', expected argument " "5"" of type '" "int""'");

6689

}

6690

arg5 = static_cast< int >(val5);

6691

{

6692

PyThreadState* __tstate = wxPyBeginAllowThreads();

6693

((wxPyOwnerDrawnComboBox const *)arg1)->OnDrawBackground(*arg2,(wxRect const &)*arg3,arg4,arg5);

6694

wxPyEndAllowThreads(__tstate);

6695

if (PyErr_Occurred()) SWIG_fail;

6696

}

6697

resultobj = SWIG_Py_Void();

6698

return resultobj;

6699

fail:

6700

return NULL;

6701

}

6702

6703

6704

SWIGINTERN PyObject *OwnerDrawnComboBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6705

PyObject *obj;

6706

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

6707

SWIG_TypeNewClientData(SWIGTYPE_p_wxPyOwnerDrawnComboBox, SWIG_NewClientData(obj));

6708

return SWIG_Py_Void();

6709

}

6710

6711

SWIGINTERN PyObject *OwnerDrawnComboBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6712

return SWIG_Python_InitShadowInstance(args);

6713

}

6714

6715

SWIGINTERN PyObject *_wrap_new_BitmapComboBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6716

PyObject *resultobj = 0;

6717

wxWindow *arg1 = (wxWindow *) 0 ;

6718

int arg2 = (int) -1 ;

6719

wxString const &arg3_defvalue = wxPyEmptyString ;

6720

wxString *arg3 = (wxString *) &arg3_defvalue ;

6721

wxPoint const &arg4_defvalue = wxDefaultPosition ;

6722

wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;

6723

wxSize const &arg5_defvalue = wxDefaultSize ;

6724

wxSize *arg5 = (wxSize *) &arg5_defvalue ;

6725

wxArrayString const &arg6_defvalue = wxPyEmptyStringArray ;

6726

wxArrayString *arg6 = (wxArrayString *) &arg6_defvalue ;

6727

long arg7 = (long) 0 ;

6728

wxValidator const &arg8_defvalue = wxDefaultValidator ;

6729

wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;

6730

wxString const &arg9_defvalue = wxBitmapComboBoxNameStr ;

6731

wxString *arg9 = (wxString *) &arg9_defvalue ;

6732

wxBitmapComboBox *result = 0 ;

6733

void *argp1 = 0 ;

6734

int res1 = 0 ;

6735

int val2 ;

6736

int ecode2 = 0 ;

6737

bool temp3 = false ;

6738

wxPoint temp4 ;

6739

wxSize temp5 ;

6740

bool temp6 = false ;

6741

long val7 ;

6742

int ecode7 = 0 ;

6743

void *argp8 = 0 ;

6744

int res8 = 0 ;

6745

bool temp9 = false ;

6746

PyObject * obj0 = 0 ;

6747

PyObject * obj1 = 0 ;

6748

PyObject * obj2 = 0 ;

6749

PyObject * obj3 = 0 ;

6750

PyObject * obj4 = 0 ;

6751

PyObject * obj5 = 0 ;

6752

PyObject * obj6 = 0 ;

6753

PyObject * obj7 = 0 ;

6754

PyObject * obj8 = 0 ;

6755

char * kwnames[] = {

6756

(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL

6757

};

6758

6759

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOOO:new_BitmapComboBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;

6760

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );

6761

if (!SWIG_IsOK(res1)) {

6762

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapComboBox" "', expected argument " "1"" of type '" "wxWindow *""'");

6763

}

6764

arg1 = reinterpret_cast< wxWindow * >(argp1);

6765

if (obj1) {

6766

ecode2 = SWIG_AsVal_int(obj1, &val2);

6767

if (!SWIG_IsOK(ecode2)) {

6768

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapComboBox" "', expected argument " "2"" of type '" "int""'");

6769

}

6770

arg2 = static_cast< int >(val2);

6771

}

6772

if (obj2) {

6773

{

6774

arg3 = wxString_in_helper(obj2);

6775

if (arg3 == NULL) SWIG_fail;

6776

temp3 = true;

6777

}

6778

}

6779

if (obj3) {

6780

{

6781

arg4 = &temp4;

6782

if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;

6783

}

6784

}

6785

if (obj4) {

6786

{

6787

arg5 = &temp5;

6788

if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;

6789

}

6790

}

6791

if (obj5) {

6792

{

6793

if (! PySequence_Check(obj5)) {

6794

PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");

6795

SWIG_fail;

6796

}

6797

arg6 = new wxArrayString;

6798

temp6 = true;

6799

int i, len=PySequence_Length(obj5);

6800

for (i=0; i<len; i++) {

6801

PyObject* item = PySequence_GetItem(obj5, i);

6802

wxString* s = wxString_in_helper(item);

6803

if (PyErr_Occurred()) SWIG_fail;

6804

arg6->Add(*s);

6805

delete s;

6806

Py_DECREF(item);

6807

}

6808

}

6809

}

6810

if (obj6) {

6811

ecode7 = SWIG_AsVal_long(obj6, &val7);

6812

if (!SWIG_IsOK(ecode7)) {

6813

SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_BitmapComboBox" "', expected argument " "7"" of type '" "long""'");

6814

}

6815

arg7 = static_cast< long >(val7);

6816

}

6817

if (obj7) {

6818

res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator, 0 | 0);

6819

if (!SWIG_IsOK(res8)) {

6820

SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_BitmapComboBox" "', expected argument " "8"" of type '" "wxValidator const &""'");

6821

}

6822

if (!argp8) {

6823

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapComboBox" "', expected argument " "8"" of type '" "wxValidator const &""'");

6824

}

6825

arg8 = reinterpret_cast< wxValidator * >(argp8);

6826

}

6827

if (obj8) {

6828

{

6829

arg9 = wxString_in_helper(obj8);

6830

if (arg9 == NULL) SWIG_fail;

6831

temp9 = true;

6832

}

6833

}

6834

{

6835

if (!wxPyCheckForApp()) SWIG_fail;

6836

PyThreadState* __tstate = wxPyBeginAllowThreads();

6837

result = (wxBitmapComboBox *)new wxBitmapComboBox(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,(wxArrayString const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);

6838

wxPyEndAllowThreads(__tstate);

6839

if (PyErr_Occurred()) SWIG_fail;

6840

}

6841

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapComboBox, SWIG_POINTER_NEW | 0 );

6842

{

6843

if (temp3)

6844

delete arg3;

6845

}

6846

{

6847

if (temp6) delete arg6;

6848

}

6849

{

6850

if (temp9)

6851

delete arg9;

6852

}

6853

return resultobj;

6854

fail:

6855

{

6856

if (temp3)

6857

delete arg3;

6858

}

6859

{

6860

if (temp6) delete arg6;

6861

}

6862

{

6863

if (temp9)

6864

delete arg9;

6865

}

6866

return NULL;

6867

}

6868

6869

6870

SWIGINTERN PyObject *_wrap_new_PreBitmapComboBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6871

PyObject *resultobj = 0;

6872

wxBitmapComboBox *result = 0 ;

6873

6874

if (!SWIG_Python_UnpackTuple(args,"new_PreBitmapComboBox",0,0,0)) SWIG_fail;

6875

{

6876

if (!wxPyCheckForApp()) SWIG_fail;

6877

PyThreadState* __tstate = wxPyBeginAllowThreads();

6878

result = (wxBitmapComboBox *)new wxBitmapComboBox();

6879

wxPyEndAllowThreads(__tstate);

6880

if (PyErr_Occurred()) SWIG_fail;

6881

}

6882

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapComboBox, SWIG_POINTER_OWN | 0 );

6883

return resultobj;

6884

fail:

6885

return NULL;

6886

}

6887

6888

6889

SWIGINTERN PyObject *_wrap_BitmapComboBox_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6890

PyObject *resultobj = 0;

6891

wxBitmapComboBox *arg1 = (wxBitmapComboBox *) 0 ;

6892

wxWindow *arg2 = (wxWindow *) 0 ;

6893

int arg3 = (int) -1 ;

6894

wxString const &arg4_defvalue = wxPyEmptyString ;

6895

wxString *arg4 = (wxString *) &arg4_defvalue ;

6896

wxPoint const &arg5_defvalue = wxDefaultPosition ;

6897

wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;

6898

wxSize const &arg6_defvalue = wxDefaultSize ;

6899

wxSize *arg6 = (wxSize *) &arg6_defvalue ;

6900

wxArrayString const &arg7_defvalue = wxPyEmptyStringArray ;

6901

wxArrayString *arg7 = (wxArrayString *) &arg7_defvalue ;

6902

long arg8 = (long) 0 ;

6903

wxValidator const &arg9_defvalue = wxDefaultValidator ;

6904

wxValidator *arg9 = (wxValidator *) &arg9_defvalue ;

6905

wxString const &arg10_defvalue = wxBitmapComboBoxNameStr ;

6906

wxString *arg10 = (wxString *) &arg10_defvalue ;

6907

bool result;

6908

void *argp1 = 0 ;

6909

int res1 = 0 ;

6910

void *argp2 = 0 ;

6911

int res2 = 0 ;

6912

int val3 ;

6913

int ecode3 = 0 ;

6914

bool temp4 = false ;

6915

wxPoint temp5 ;

6916

wxSize temp6 ;

6917

bool temp7 = false ;

6918

long val8 ;

6919

int ecode8 = 0 ;

6920

void *argp9 = 0 ;

6921

int res9 = 0 ;

6922

bool temp10 = false ;

6923

PyObject * obj0 = 0 ;

6924

PyObject * obj1 = 0 ;

6925

PyObject * obj2 = 0 ;

6926

PyObject * obj3 = 0 ;

6927

PyObject * obj4 = 0 ;

6928

PyObject * obj5 = 0 ;

6929

PyObject * obj6 = 0 ;

6930

PyObject * obj7 = 0 ;

6931

PyObject * obj8 = 0 ;

6932

PyObject * obj9 = 0 ;

6933

char * kwnames[] = {

6934

(char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "choices",(char *) "style",(char *) "validator",(char *) "name", NULL

6935

};

6936

6937

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOOO:BitmapComboBox_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;

6938

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapComboBox, 0 | 0 );

6939

if (!SWIG_IsOK(res1)) {

6940

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapComboBox_Create" "', expected argument " "1"" of type '" "wxBitmapComboBox *""'");

6941

}

6942

arg1 = reinterpret_cast< wxBitmapComboBox * >(argp1);

6943

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );

6944

if (!SWIG_IsOK(res2)) {

6945

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapComboBox_Create" "', expected argument " "2"" of type '" "wxWindow *""'");

6946

}

6947

arg2 = reinterpret_cast< wxWindow * >(argp2);

6948

if (obj2) {

6949

ecode3 = SWIG_AsVal_int(obj2, &val3);

6950

if (!SWIG_IsOK(ecode3)) {

6951

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BitmapComboBox_Create" "', expected argument " "3"" of type '" "int""'");

6952

}

6953

arg3 = static_cast< int >(val3);

6954

}

6955

if (obj3) {

6956

{

6957

arg4 = wxString_in_helper(obj3);

6958

if (arg4 == NULL) SWIG_fail;

6959

temp4 = true;

6960

}

6961

}

6962

if (obj4) {

6963

{

6964

arg5 = &temp5;

6965

if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;

6966

}

6967

}

6968

if (obj5) {

6969

{

6970

arg6 = &temp6;

6971

if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;

6972

}

6973

}

6974

if (obj6) {

6975

{

6976

if (! PySequence_Check(obj6)) {

6977

PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");

6978

SWIG_fail;

6979

}

6980

arg7 = new wxArrayString;

6981

temp7 = true;

6982

int i, len=PySequence_Length(obj6);

6983

for (i=0; i<len; i++) {

6984

PyObject* item = PySequence_GetItem(obj6, i);

6985

wxString* s = wxString_in_helper(item);

6986

if (PyErr_Occurred()) SWIG_fail;

6987

arg7->Add(*s);

6988

delete s;

6989

Py_DECREF(item);

6990

}

6991

}

6992

}

6993

if (obj7) {

6994

ecode8 = SWIG_AsVal_long(obj7, &val8);

6995

if (!SWIG_IsOK(ecode8)) {

6996

SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BitmapComboBox_Create" "', expected argument " "8"" of type '" "long""'");

6997

}

6998

arg8 = static_cast< long >(val8);

6999

}

7000

if (obj8) {

7001

res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_wxValidator, 0 | 0);

7002

if (!SWIG_IsOK(res9)) {

7003

SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "BitmapComboBox_Create" "', expected argument " "9"" of type '" "wxValidator const &""'");

7004

}

7005

if (!argp9) {

7006

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapComboBox_Create" "', expected argument " "9"" of type '" "wxValidator const &""'");

7007

}

7008

arg9 = reinterpret_cast< wxValidator * >(argp9);

7009

}

7010

if (obj9) {

7011

{

7012

arg10 = wxString_in_helper(obj9);

7013

if (arg10 == NULL) SWIG_fail;

7014

temp10 = true;

7015

}

7016

}

7017

{

7018

PyThreadState* __tstate = wxPyBeginAllowThreads();

7019

result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,(wxArrayString const &)*arg7,arg8,(wxValidator const &)*arg9,(wxString const &)*arg10);

7020

wxPyEndAllowThreads(__tstate);

7021

if (PyErr_Occurred()) SWIG_fail;

7022

}

7023

{

7024

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

7025

}

7026

{

7027

if (temp4)

7028

delete arg4;

7029

}

7030

{

7031

if (temp7) delete arg7;

7032

}

7033

{

7034

if (temp10)

7035

delete arg10;

7036

}

7037

return resultobj;

7038

fail:

7039

{

7040

if (temp4)

7041

delete arg4;

7042

}

7043

{

7044

if (temp7) delete arg7;

7045

}

7046

{

7047

if (temp10)

7048

delete arg10;

7049

}

7050

return NULL;

7051

}

7052

7053

7054

SWIGINTERN PyObject *_wrap_BitmapComboBox_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7055

PyObject *resultobj = 0;

7056

wxBitmapComboBox *arg1 = (wxBitmapComboBox *) 0 ;

7057

wxString *arg2 = 0 ;

7058

wxBitmap const &arg3_defvalue = wxNullBitmap ;

7059

wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;

7060

PyObject *arg4 = (PyObject *) NULL ;

7061

int result;

7062

void *argp1 = 0 ;

7063

int res1 = 0 ;

7064

bool temp2 = false ;

7065

void *argp3 = 0 ;

7066

int res3 = 0 ;

7067

PyObject * obj0 = 0 ;

7068

PyObject * obj1 = 0 ;

7069

PyObject * obj2 = 0 ;

7070

PyObject * obj3 = 0 ;

7071

char * kwnames[] = {

7072

(char *) "self",(char *) "item",(char *) "bitmap",(char *) "clientData", NULL

7073

};

7074

7075

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:BitmapComboBox_Append",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

7076

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapComboBox, 0 | 0 );

7077

if (!SWIG_IsOK(res1)) {

7078

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapComboBox_Append" "', expected argument " "1"" of type '" "wxBitmapComboBox *""'");

7079

}

7080

arg1 = reinterpret_cast< wxBitmapComboBox * >(argp1);

7081

{

7082

arg2 = wxString_in_helper(obj1);

7083

if (arg2 == NULL) SWIG_fail;

7084

temp2 = true;

7085

}

7086

if (obj2) {

7087

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);

7088

if (!SWIG_IsOK(res3)) {

7089

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BitmapComboBox_Append" "', expected argument " "3"" of type '" "wxBitmap const &""'");

7090

}

7091

if (!argp3) {

7092

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapComboBox_Append" "', expected argument " "3"" of type '" "wxBitmap const &""'");

7093

}

7094

arg3 = reinterpret_cast< wxBitmap * >(argp3);

7095

}

7096

if (obj3) {

7097

arg4 = obj3;

7098

}

7099

{

7100

PyThreadState* __tstate = wxPyBeginAllowThreads();

7101

result = (int)wxBitmapComboBox_Append(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,arg4);

7102

wxPyEndAllowThreads(__tstate);

7103

if (PyErr_Occurred()) SWIG_fail;

7104

}

7105

resultobj = SWIG_From_int(static_cast< int >(result));

7106

{

7107

if (temp2)

7108

delete arg2;

7109

}

7110

return resultobj;

7111

fail:

7112

{

7113

if (temp2)

7114

delete arg2;

7115

}

7116

return NULL;

7117

}

7118

7119

7120

SWIGINTERN PyObject *_wrap_BitmapComboBox_GetItemBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7121

PyObject *resultobj = 0;

7122

wxBitmapComboBox *arg1 = (wxBitmapComboBox *) 0 ;

7123

int arg2 ;

7124

wxBitmap result;

7125

void *argp1 = 0 ;

7126

int res1 = 0 ;

7127

int val2 ;

7128

int ecode2 = 0 ;

7129

PyObject * obj0 = 0 ;

7130

PyObject * obj1 = 0 ;

7131

char * kwnames[] = {

7132

(char *) "self",(char *) "n", NULL

7133

};

7134

7135

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapComboBox_GetItemBitmap",kwnames,&obj0,&obj1)) SWIG_fail;

7136

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapComboBox, 0 | 0 );

7137

if (!SWIG_IsOK(res1)) {

7138

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapComboBox_GetItemBitmap" "', expected argument " "1"" of type '" "wxBitmapComboBox const *""'");

7139

}

7140

arg1 = reinterpret_cast< wxBitmapComboBox * >(argp1);

7141

ecode2 = SWIG_AsVal_int(obj1, &val2);

7142

if (!SWIG_IsOK(ecode2)) {

7143

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BitmapComboBox_GetItemBitmap" "', expected argument " "2"" of type '" "int""'");

7144

}

7145

arg2 = static_cast< int >(val2);

7146

{

7147

PyThreadState* __tstate = wxPyBeginAllowThreads();

7148

result = ((wxBitmapComboBox const *)arg1)->GetItemBitmap(arg2);

7149

wxPyEndAllowThreads(__tstate);

7150

if (PyErr_Occurred()) SWIG_fail;

7151

}

7152

resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );

7153

return resultobj;

7154

fail:

7155

return NULL;

7156

}

7157

7158

7159

SWIGINTERN PyObject *_wrap_BitmapComboBox_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7160

PyObject *resultobj = 0;

7161

wxBitmapComboBox *arg1 = (wxBitmapComboBox *) 0 ;

7162

wxString *arg2 = 0 ;

7163

wxBitmap *arg3 = 0 ;

7164

int arg4 ;

7165

PyObject *arg5 = (PyObject *) NULL ;

7166

int result;

7167

void *argp1 = 0 ;

7168

int res1 = 0 ;

7169

bool temp2 = false ;

7170

void *argp3 = 0 ;

7171

int res3 = 0 ;

7172

int val4 ;

7173

int ecode4 = 0 ;

7174

PyObject * obj0 = 0 ;

7175

PyObject * obj1 = 0 ;

7176

PyObject * obj2 = 0 ;

7177

PyObject * obj3 = 0 ;

7178

PyObject * obj4 = 0 ;

7179

char * kwnames[] = {

7180

(char *) "self",(char *) "item",(char *) "bitmap",(char *) "pos",(char *) "clientData", NULL

7181

};

7182

7183

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:BitmapComboBox_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

7184

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapComboBox, 0 | 0 );

7185

if (!SWIG_IsOK(res1)) {

7186

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapComboBox_Insert" "', expected argument " "1"" of type '" "wxBitmapComboBox *""'");

7187

}

7188

arg1 = reinterpret_cast< wxBitmapComboBox * >(argp1);

7189

{

7190

arg2 = wxString_in_helper(obj1);

7191

if (arg2 == NULL) SWIG_fail;

7192

temp2 = true;

7193

}

7194

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);

7195

if (!SWIG_IsOK(res3)) {

7196

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BitmapComboBox_Insert" "', expected argument " "3"" of type '" "wxBitmap const &""'");

7197

}

7198

if (!argp3) {

7199

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapComboBox_Insert" "', expected argument " "3"" of type '" "wxBitmap const &""'");

7200

}

7201

arg3 = reinterpret_cast< wxBitmap * >(argp3);

7202

ecode4 = SWIG_AsVal_int(obj3, &val4);

7203

if (!SWIG_IsOK(ecode4)) {

7204

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BitmapComboBox_Insert" "', expected argument " "4"" of type '" "int""'");

7205

}

7206

arg4 = static_cast< int >(val4);

7207

if (obj4) {

7208

arg5 = obj4;

7209

}

7210

{

7211

PyThreadState* __tstate = wxPyBeginAllowThreads();

7212

result = (int)wxBitmapComboBox_Insert(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,arg4,arg5);

7213

wxPyEndAllowThreads(__tstate);

7214

if (PyErr_Occurred()) SWIG_fail;

7215

}

7216

resultobj = SWIG_From_int(static_cast< int >(result));

7217

{

7218

if (temp2)

7219

delete arg2;

7220

}

7221

return resultobj;

7222

fail:

7223

{

7224

if (temp2)

7225

delete arg2;

7226

}

7227

return NULL;

7228

}

7229

7230

7231

SWIGINTERN PyObject *_wrap_BitmapComboBox_SetItemBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7232

PyObject *resultobj = 0;

7233

wxBitmapComboBox *arg1 = (wxBitmapComboBox *) 0 ;

7234

int arg2 ;

7235

wxBitmap *arg3 = 0 ;

7236

void *argp1 = 0 ;

7237

int res1 = 0 ;

7238

int val2 ;

7239

int ecode2 = 0 ;

7240

void *argp3 = 0 ;

7241

int res3 = 0 ;

7242

PyObject * obj0 = 0 ;

7243

PyObject * obj1 = 0 ;

7244

PyObject * obj2 = 0 ;

7245

char * kwnames[] = {

7246

(char *) "self",(char *) "n",(char *) "bitmap", NULL

7247

};

7248

7249

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BitmapComboBox_SetItemBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

7250

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapComboBox, 0 | 0 );

7251

if (!SWIG_IsOK(res1)) {

7252

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapComboBox_SetItemBitmap" "', expected argument " "1"" of type '" "wxBitmapComboBox *""'");

7253

}

7254

arg1 = reinterpret_cast< wxBitmapComboBox * >(argp1);

7255

ecode2 = SWIG_AsVal_int(obj1, &val2);

7256

if (!SWIG_IsOK(ecode2)) {

7257

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BitmapComboBox_SetItemBitmap" "', expected argument " "2"" of type '" "int""'");

7258

}

7259

arg2 = static_cast< int >(val2);

7260

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);

7261

if (!SWIG_IsOK(res3)) {

7262

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BitmapComboBox_SetItemBitmap" "', expected argument " "3"" of type '" "wxBitmap const &""'");

7263

}

7264

if (!argp3) {

7265

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapComboBox_SetItemBitmap" "', expected argument " "3"" of type '" "wxBitmap const &""'");

7266

}

7267

arg3 = reinterpret_cast< wxBitmap * >(argp3);

7268

{

7269

PyThreadState* __tstate = wxPyBeginAllowThreads();

7270

(arg1)->SetItemBitmap(arg2,(wxBitmap const &)*arg3);

7271

wxPyEndAllowThreads(__tstate);

7272

if (PyErr_Occurred()) SWIG_fail;

7273

}

7274

resultobj = SWIG_Py_Void();

7275

return resultobj;

7276

fail:

7277

return NULL;

7278

}

7279

7280

7281

SWIGINTERN PyObject *_wrap_BitmapComboBox_GetBitmapSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7282

PyObject *resultobj = 0;

7283

wxBitmapComboBox *arg1 = (wxBitmapComboBox *) 0 ;

7284

wxSize result;

7285

void *argp1 = 0 ;

7286

int res1 = 0 ;

7287

PyObject *swig_obj[1] ;

7288

7289

if (!args) SWIG_fail;

7290

swig_obj[0] = args;

7291

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapComboBox, 0 | 0 );

7292

if (!SWIG_IsOK(res1)) {

7293

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapComboBox_GetBitmapSize" "', expected argument " "1"" of type '" "wxBitmapComboBox const *""'");

7294

}

7295

arg1 = reinterpret_cast< wxBitmapComboBox * >(argp1);

7296

{

7297

PyThreadState* __tstate = wxPyBeginAllowThreads();

7298

result = ((wxBitmapComboBox const *)arg1)->GetBitmapSize();

7299

wxPyEndAllowThreads(__tstate);

7300

if (PyErr_Occurred()) SWIG_fail;

7301

}

7302

resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );

7303

return resultobj;

7304

fail:

7305

return NULL;

7306

}

7307

7308

7309

SWIGINTERN PyObject *BitmapComboBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7310

PyObject *obj;

7311

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

7312

SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapComboBox, SWIG_NewClientData(obj));

7313

return SWIG_Py_Void();

7314

}

7315

7316

SWIGINTERN PyObject *BitmapComboBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7317

return SWIG_Python_InitShadowInstance(args);

7318

}

7319

7320

static PyMethodDef SwigMethods[] = {

7321

{ (char *)"ComboCtrlFeatures_swigregister", ComboCtrlFeatures_swigregister, METH_VARARGS, NULL},

7322

{ (char *)"new_ComboCtrl", (PyCFunction) _wrap_new_ComboCtrl, METH_VARARGS | METH_KEYWORDS, NULL},

7323

{ (char *)"new_PreComboCtrl", (PyCFunction)_wrap_new_PreComboCtrl, METH_NOARGS, NULL},

7324

{ (char *)"ComboCtrl__setCallbackInfo", (PyCFunction) _wrap_ComboCtrl__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},

7325

{ (char *)"ComboCtrl_ShowPopup", (PyCFunction)_wrap_ComboCtrl_ShowPopup, METH_O, NULL},

7326

{ (char *)"ComboCtrl_HidePopup", (PyCFunction)_wrap_ComboCtrl_HidePopup, METH_O, NULL},

7327

{ (char *)"ComboCtrl_OnButtonClick", (PyCFunction)_wrap_ComboCtrl_OnButtonClick, METH_O, NULL},

7328

{ (char *)"ComboCtrl_IsPopupShown", (PyCFunction)_wrap_ComboCtrl_IsPopupShown, METH_O, NULL},

7329

{ (char *)"ComboCtrl_SetPopupControl", (PyCFunction) _wrap_ComboCtrl_SetPopupControl, METH_VARARGS | METH_KEYWORDS, NULL},

7330

{ (char *)"ComboCtrl_GetPopupControl", (PyCFunction)_wrap_ComboCtrl_GetPopupControl, METH_O, NULL},

7331

{ (char *)"ComboCtrl_GetPopupWindow", (PyCFunction)_wrap_ComboCtrl_GetPopupWindow, METH_O, NULL},

7332

{ (char *)"ComboCtrl_GetTextCtrl", (PyCFunction)_wrap_ComboCtrl_GetTextCtrl, METH_O, NULL},

7333

{ (char *)"ComboCtrl_GetButton", (PyCFunction)_wrap_ComboCtrl_GetButton, METH_O, NULL},

7334

{ (char *)"ComboCtrl_GetValue", (PyCFunction)_wrap_ComboCtrl_GetValue, METH_O, NULL},

7335

{ (char *)"ComboCtrl_SetValue", (PyCFunction) _wrap_ComboCtrl_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},

7336

{ (char *)"ComboCtrl_Copy", (PyCFunction)_wrap_ComboCtrl_Copy, METH_O, NULL},

7337

{ (char *)"ComboCtrl_Cut", (PyCFunction)_wrap_ComboCtrl_Cut, METH_O, NULL},

7338

{ (char *)"ComboCtrl_Paste", (PyCFunction)_wrap_ComboCtrl_Paste, METH_O, NULL},

7339

{ (char *)"ComboCtrl_SetInsertionPoint", (PyCFunction) _wrap_ComboCtrl_SetInsertionPoint, METH_VARARGS | METH_KEYWORDS, NULL},

7340

{ (char *)"ComboCtrl_SetInsertionPointEnd", (PyCFunction)_wrap_ComboCtrl_SetInsertionPointEnd, METH_O, NULL},

7341

{ (char *)"ComboCtrl_GetInsertionPoint", (PyCFunction)_wrap_ComboCtrl_GetInsertionPoint, METH_O, NULL},

7342

{ (char *)"ComboCtrl_GetLastPosition", (PyCFunction)_wrap_ComboCtrl_GetLastPosition, METH_O, NULL},

7343

{ (char *)"ComboCtrl_Replace", (PyCFunction) _wrap_ComboCtrl_Replace, METH_VARARGS | METH_KEYWORDS, NULL},

7344

{ (char *)"ComboCtrl_Remove", (PyCFunction) _wrap_ComboCtrl_Remove, METH_VARARGS | METH_KEYWORDS, NULL},

7345

{ (char *)"ComboCtrl_Undo", (PyCFunction)_wrap_ComboCtrl_Undo, METH_O, NULL},

7346

{ (char *)"ComboCtrl_SetMark", (PyCFunction) _wrap_ComboCtrl_SetMark, METH_VARARGS | METH_KEYWORDS, NULL},

7347

{ (char *)"ComboCtrl_SetText", (PyCFunction) _wrap_ComboCtrl_SetText, METH_VARARGS | METH_KEYWORDS, NULL},

7348

{ (char *)"ComboCtrl_SetValueWithEvent", (PyCFunction) _wrap_ComboCtrl_SetValueWithEvent, METH_VARARGS | METH_KEYWORDS, NULL},

7349

{ (char *)"ComboCtrl_SetPopupMinWidth", (PyCFunction) _wrap_ComboCtrl_SetPopupMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},

7350

{ (char *)"ComboCtrl_SetPopupMaxHeight", (PyCFunction) _wrap_ComboCtrl_SetPopupMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},

7351

{ (char *)"ComboCtrl_SetPopupExtents", (PyCFunction) _wrap_ComboCtrl_SetPopupExtents, METH_VARARGS | METH_KEYWORDS, NULL},

7352

{ (char *)"ComboCtrl_SetCustomPaintWidth", (PyCFunction) _wrap_ComboCtrl_SetCustomPaintWidth, METH_VARARGS | METH_KEYWORDS, NULL},

7353

{ (char *)"ComboCtrl_GetCustomPaintWidth", (PyCFunction)_wrap_ComboCtrl_GetCustomPaintWidth, METH_O, NULL},

7354

{ (char *)"ComboCtrl_SetPopupAnchor", (PyCFunction) _wrap_ComboCtrl_SetPopupAnchor, METH_VARARGS | METH_KEYWORDS, NULL},

7355

{ (char *)"ComboCtrl_SetButtonPosition", (PyCFunction) _wrap_ComboCtrl_SetButtonPosition, METH_VARARGS | METH_KEYWORDS, NULL},

7356

{ (char *)"ComboCtrl_GetButtonSize", (PyCFunction)_wrap_ComboCtrl_GetButtonSize, METH_O, NULL},

7357

{ (char *)"ComboCtrl_SetButtonBitmaps", (PyCFunction) _wrap_ComboCtrl_SetButtonBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},

7358

{ (char *)"ComboCtrl_SetTextIndent", (PyCFunction) _wrap_ComboCtrl_SetTextIndent, METH_VARARGS | METH_KEYWORDS, NULL},

7359

{ (char *)"ComboCtrl_GetTextIndent", (PyCFunction)_wrap_ComboCtrl_GetTextIndent, METH_O, NULL},

7360

{ (char *)"ComboCtrl_GetTextRect", (PyCFunction)_wrap_ComboCtrl_GetTextRect, METH_O, NULL},

7361

{ (char *)"ComboCtrl_UseAltPopupWindow", (PyCFunction) _wrap_ComboCtrl_UseAltPopupWindow, METH_VARARGS | METH_KEYWORDS, NULL},

7362

{ (char *)"ComboCtrl_EnablePopupAnimation", (PyCFunction) _wrap_ComboCtrl_EnablePopupAnimation, METH_VARARGS | METH_KEYWORDS, NULL},

7363

{ (char *)"ComboCtrl_IsKeyPopupToggle", (PyCFunction) _wrap_ComboCtrl_IsKeyPopupToggle, METH_VARARGS | METH_KEYWORDS, NULL},

7364

{ (char *)"ComboCtrl_PrepareBackground", (PyCFunction) _wrap_ComboCtrl_PrepareBackground, METH_VARARGS | METH_KEYWORDS, NULL},

7365

{ (char *)"ComboCtrl_ShouldDrawFocus", (PyCFunction)_wrap_ComboCtrl_ShouldDrawFocus, METH_O, NULL},

7366

{ (char *)"ComboCtrl_GetBitmapNormal", (PyCFunction)_wrap_ComboCtrl_GetBitmapNormal, METH_O, NULL},

7367

{ (char *)"ComboCtrl_GetBitmapPressed", (PyCFunction)_wrap_ComboCtrl_GetBitmapPressed, METH_O, NULL},

7368

{ (char *)"ComboCtrl_GetBitmapHover", (PyCFunction)_wrap_ComboCtrl_GetBitmapHover, METH_O, NULL},

7369

{ (char *)"ComboCtrl_GetBitmapDisabled", (PyCFunction)_wrap_ComboCtrl_GetBitmapDisabled, METH_O, NULL},

7370

{ (char *)"ComboCtrl_GetInternalFlags", (PyCFunction)_wrap_ComboCtrl_GetInternalFlags, METH_O, NULL},

7371

{ (char *)"ComboCtrl_IsCreated", (PyCFunction)_wrap_ComboCtrl_IsCreated, METH_O, NULL},

7372

{ (char *)"ComboCtrl_OnPopupDismiss", (PyCFunction)_wrap_ComboCtrl_OnPopupDismiss, METH_O, NULL},

7373

{ (char *)"ComboCtrl_IsPopupWindowState", (PyCFunction) _wrap_ComboCtrl_IsPopupWindowState, METH_VARARGS | METH_KEYWORDS, NULL},

7374

{ (char *)"ComboCtrl_GetPopupWindowState", (PyCFunction)_wrap_ComboCtrl_GetPopupWindowState, METH_O, NULL},

7375

{ (char *)"ComboCtrl_SetCtrlMainWnd", (PyCFunction) _wrap_ComboCtrl_SetCtrlMainWnd, METH_VARARGS | METH_KEYWORDS, NULL},

7376

{ (char *)"ComboCtrl_GetMainWindowOfCompositeControl", (PyCFunction)_wrap_ComboCtrl_GetMainWindowOfCompositeControl, METH_O, NULL},

7377

{ (char *)"ComboCtrl_DestroyPopup", (PyCFunction)_wrap_ComboCtrl_DestroyPopup, METH_O, NULL},

7378

{ (char *)"ComboCtrl_GetFeatures", (PyCFunction)_wrap_ComboCtrl_GetFeatures, METH_NOARGS, NULL},

7379

{ (char *)"ComboCtrl_DoShowPopup", (PyCFunction) _wrap_ComboCtrl_DoShowPopup, METH_VARARGS | METH_KEYWORDS, NULL},

7380

{ (char *)"ComboCtrl_AnimateShow", (PyCFunction) _wrap_ComboCtrl_AnimateShow, METH_VARARGS | METH_KEYWORDS, NULL},

7381

{ (char *)"ComboCtrl_swigregister", ComboCtrl_swigregister, METH_VARARGS, NULL},

7382

{ (char *)"ComboCtrl_swiginit", ComboCtrl_swiginit, METH_VARARGS, NULL},

7383

{ (char *)"new_ComboPopup", (PyCFunction)_wrap_new_ComboPopup, METH_NOARGS, NULL},

7384

{ (char *)"delete_ComboPopup", (PyCFunction)_wrap_delete_ComboPopup, METH_O, NULL},

7385

{ (char *)"ComboPopup__setCallbackInfo", (PyCFunction) _wrap_ComboPopup__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},

7386

{ (char *)"ComboPopup_Init", (PyCFunction)_wrap_ComboPopup_Init, METH_O, NULL},

7387

{ (char *)"ComboPopup_Create", (PyCFunction) _wrap_ComboPopup_Create, METH_VARARGS | METH_KEYWORDS, NULL},

7388

{ (char *)"ComboPopup_GetControl", (PyCFunction)_wrap_ComboPopup_GetControl, METH_O, NULL},

7389

{ (char *)"ComboPopup_OnPopup", (PyCFunction)_wrap_ComboPopup_OnPopup, METH_O, NULL},

7390

{ (char *)"ComboPopup_OnDismiss", (PyCFunction)_wrap_ComboPopup_OnDismiss, METH_O, NULL},

7391

{ (char *)"ComboPopup_SetStringValue", (PyCFunction) _wrap_ComboPopup_SetStringValue, METH_VARARGS | METH_KEYWORDS, NULL},

7392

{ (char *)"ComboPopup_GetStringValue", (PyCFunction)_wrap_ComboPopup_GetStringValue, METH_O, NULL},

7393

{ (char *)"ComboPopup_PaintComboControl", (PyCFunction) _wrap_ComboPopup_PaintComboControl, METH_VARARGS | METH_KEYWORDS, NULL},

7394

{ (char *)"ComboPopup_OnComboKeyEvent", (PyCFunction) _wrap_ComboPopup_OnComboKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},

7395

{ (char *)"ComboPopup_OnComboDoubleClick", (PyCFunction)_wrap_ComboPopup_OnComboDoubleClick, METH_O, NULL},

7396

{ (char *)"ComboPopup_GetAdjustedSize", (PyCFunction) _wrap_ComboPopup_GetAdjustedSize, METH_VARARGS | METH_KEYWORDS, NULL},

7397

{ (char *)"ComboPopup_LazyCreate", (PyCFunction)_wrap_ComboPopup_LazyCreate, METH_O, NULL},

7398

{ (char *)"ComboPopup_Dismiss", (PyCFunction)_wrap_ComboPopup_Dismiss, METH_O, NULL},

7399

{ (char *)"ComboPopup_IsCreated", (PyCFunction)_wrap_ComboPopup_IsCreated, METH_O, NULL},

7400

{ (char *)"ComboPopup_DefaultPaintComboControl", (PyCFunction) _wrap_ComboPopup_DefaultPaintComboControl, METH_VARARGS | METH_KEYWORDS, NULL},

7401

{ (char *)"ComboPopup_GetCombo", (PyCFunction)_wrap_ComboPopup_GetCombo, METH_O, NULL},

7402

{ (char *)"ComboPopup_swigregister", ComboPopup_swigregister, METH_VARARGS, NULL},

7403

{ (char *)"ComboPopup_swiginit", ComboPopup_swiginit, METH_VARARGS, NULL},

7404

{ (char *)"new_OwnerDrawnComboBox", (PyCFunction) _wrap_new_OwnerDrawnComboBox, METH_VARARGS | METH_KEYWORDS, NULL},

7405

{ (char *)"new_PreOwnerDrawnComboBox", (PyCFunction)_wrap_new_PreOwnerDrawnComboBox, METH_NOARGS, NULL},

7406

{ (char *)"OwnerDrawnComboBox__setCallbackInfo", (PyCFunction) _wrap_OwnerDrawnComboBox__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},

7407

{ (char *)"OwnerDrawnComboBox_Create", (PyCFunction) _wrap_OwnerDrawnComboBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},

7408

{ (char *)"OwnerDrawnComboBox_GetWidestItemWidth", (PyCFunction)_wrap_OwnerDrawnComboBox_GetWidestItemWidth, METH_O, NULL},

7409

{ (char *)"OwnerDrawnComboBox_GetWidestItem", (PyCFunction)_wrap_OwnerDrawnComboBox_GetWidestItem, METH_O, NULL},

7410

{ (char *)"OwnerDrawnComboBox_SetMark", (PyCFunction) _wrap_OwnerDrawnComboBox_SetMark, METH_VARARGS | METH_KEYWORDS, NULL},

7411

{ (char *)"OwnerDrawnComboBox_OnDrawItem", (PyCFunction) _wrap_OwnerDrawnComboBox_OnDrawItem, METH_VARARGS | METH_KEYWORDS, NULL},

7412

{ (char *)"OwnerDrawnComboBox_OnMeasureItem", (PyCFunction) _wrap_OwnerDrawnComboBox_OnMeasureItem, METH_VARARGS | METH_KEYWORDS, NULL},

7413

{ (char *)"OwnerDrawnComboBox_OnMeasureItemWidth", (PyCFunction) _wrap_OwnerDrawnComboBox_OnMeasureItemWidth, METH_VARARGS | METH_KEYWORDS, NULL},

7414

{ (char *)"OwnerDrawnComboBox_OnDrawBackground", (PyCFunction) _wrap_OwnerDrawnComboBox_OnDrawBackground, METH_VARARGS | METH_KEYWORDS, NULL},

7415

{ (char *)"OwnerDrawnComboBox_swigregister", OwnerDrawnComboBox_swigregister, METH_VARARGS, NULL},

7416

{ (char *)"OwnerDrawnComboBox_swiginit", OwnerDrawnComboBox_swiginit, METH_VARARGS, NULL},

7417

{ (char *)"new_BitmapComboBox", (PyCFunction) _wrap_new_BitmapComboBox, METH_VARARGS | METH_KEYWORDS, NULL},

7418

{ (char *)"new_PreBitmapComboBox", (PyCFunction)_wrap_new_PreBitmapComboBox, METH_NOARGS, NULL},

7419

{ (char *)"BitmapComboBox_Create", (PyCFunction) _wrap_BitmapComboBox_Create, METH_VARARGS | METH_KEYWORDS, NULL},

7420

{ (char *)"BitmapComboBox_Append", (PyCFunction) _wrap_BitmapComboBox_Append, METH_VARARGS | METH_KEYWORDS, NULL},

7421

{ (char *)"BitmapComboBox_GetItemBitmap", (PyCFunction) _wrap_BitmapComboBox_GetItemBitmap, METH_VARARGS | METH_KEYWORDS, NULL},

7422

{ (char *)"BitmapComboBox_Insert", (PyCFunction) _wrap_BitmapComboBox_Insert, METH_VARARGS | METH_KEYWORDS, NULL},

7423

{ (char *)"BitmapComboBox_SetItemBitmap", (PyCFunction) _wrap_BitmapComboBox_SetItemBitmap, METH_VARARGS | METH_KEYWORDS, NULL},

7424

{ (char *)"BitmapComboBox_GetBitmapSize", (PyCFunction)_wrap_BitmapComboBox_GetBitmapSize, METH_O, NULL},

7425

{ (char *)"BitmapComboBox_swigregister", BitmapComboBox_swigregister, METH_VARARGS, NULL},

7426

{ (char *)"BitmapComboBox_swiginit", BitmapComboBox_swiginit, METH_VARARGS, NULL},

7427

{ NULL, NULL, 0, NULL }

7428

};

7429

7430

7431

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

7432

7433

static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {

7434

return (void *)((wxObject *) ((wxLayoutConstraints *) x));

7435

}

7436

static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {

7437

return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));

7438

}

7439

static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {

7440

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));

7441

}

7442

static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {

7443

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));

7444

}

7445

static void *_p_wxSizerItemTo_p_wxObject(void *x) {

7446

return (void *)((wxObject *) ((wxSizerItem *) x));

7447

}

7448

static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {

7449

return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));

7450

}

7451

static void *_p_wxScrollEventTo_p_wxObject(void *x) {

7452

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));

7453

}

7454

static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {

7455

return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));

7456

}

7457

static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {

7458

return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));

7459

}

7460

static void *_p_wxBoxSizerTo_p_wxObject(void *x) {

7461

return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));

7462

}

7463

static void *_p_wxSizerTo_p_wxObject(void *x) {

7464

return (void *)((wxObject *) ((wxSizer *) x));

7465

}

7466

static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {

7467

return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));

7468

}

7469

static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {

7470

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));

7471

}

7472

static void *_p_wxPyPanelTo_p_wxObject(void *x) {

7473

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));

7474

}

7475

static void *_p_wxEventTo_p_wxObject(void *x) {

7476

return (void *)((wxObject *) ((wxEvent *) x));

7477

}

7478

static void *_p_wxFontDataTo_p_wxObject(void *x) {

7479

return (void *)((wxObject *) ((wxFontData *) x));

7480

}

7481

static void *_p_wxPrintDataTo_p_wxObject(void *x) {

7482

return (void *)((wxObject *) ((wxPrintData *) x));

7483

}

7484

static void *_p_wxGridSizerTo_p_wxObject(void *x) {

7485

return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));

7486

}

7487

static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {

7488

return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));

7489

}

7490

static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {

7491

return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));

7492

}

7493

static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {

7494

return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));

7495

}

7496

static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {

7497

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));

7498

}

7499

static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {

7500

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));

7501

}

7502

static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {

7503

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));

7504

}

7505

static void *_p_wxPaintEventTo_p_wxObject(void *x) {

7506

return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));

7507

}

7508

static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {

7509

return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));

7510

}

7511

static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {

7512

return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));

7513

}

7514

static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {

7515

return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));

7516

}

7517

static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {

7518

return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));

7519

}

7520

static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {

7521

return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));

7522

}

7523

static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {

7524

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));

7525

}

7526

static void *_p_wxControlTo_p_wxObject(void *x) {

7527

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));

7528

}

7529

static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {

7530

return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));

7531

}

7532

static void *_p_wxSplitterEventTo_p_wxObject(void *x) {

7533

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));

7534

}

7535

static void *_p_wxFSFileTo_p_wxObject(void *x) {

7536

return (void *)((wxObject *) ((wxFSFile *) x));

7537

}

7538

static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {

7539

return (void *)((wxObject *) ((wxFindReplaceData *) x));

7540

}

7541

static void *_p_wxPySizerTo_p_wxObject(void *x) {

7542

return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));

7543

}

7544

static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {

7545

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));

7546

}

7547

static void *_p_wxColourDataTo_p_wxObject(void *x) {

7548

return (void *)((wxObject *) ((wxColourData *) x));

7549

}

7550

static void *_p_wxPyEventTo_p_wxObject(void *x) {

7551

return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));

7552

}

7553

static void *_p_wxNotifyEventTo_p_wxObject(void *x) {

7554

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));

7555

}

7556

static void *_p_wxPyWindowTo_p_wxObject(void *x) {

7557

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));

7558

}

7559

static void *_p_wxSplashScreenTo_p_wxObject(void *x) {

7560

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));

7561

}

7562

static void *_p_wxFileDialogTo_p_wxObject(void *x) {

7563

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));

7564

}

7565

static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {

7566

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));

7567

}

7568

static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {

7569

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));

7570

}

7571

static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {

7572

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));

7573

}

7574

static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {

7575

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));

7576

}

7577

static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {

7578

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));

7579

}

7580

static void *_p_wxMessageDialogTo_p_wxObject(void *x) {

7581

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));

7582

}

7583

static void *_p_wxProgressDialogTo_p_wxObject(void *x) {

7584

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxProgressDialog *) x));

7585

}

7586

static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {

7587

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));

7588

}

7589

static void *_p_wxShowEventTo_p_wxObject(void *x) {

7590

return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));

7591

}

7592

static void *_p_wxPrinterTo_p_wxObject(void *x) {

7593

return (void *)((wxObject *) ((wxPrinter *) x));

7594

}

7595

static void *_p_wxMenuItemTo_p_wxObject(void *x) {

7596

return (void *)((wxObject *) ((wxMenuItem *) x));

7597

}

7598

static void *_p_wxDateEventTo_p_wxObject(void *x) {

7599

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));

7600

}

7601

static void *_p_wxIdleEventTo_p_wxObject(void *x) {

7602

return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));

7603

}

7604

static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {

7605

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));

7606

}

7607

static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {

7608

return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));

7609

}

7610

static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {

7611

return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));

7612

}

7613

static void *_p_wxIconizeEventTo_p_wxObject(void *x) {

7614

return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));

7615

}

7616

static void *_p_wxActivateEventTo_p_wxObject(void *x) {

7617

return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));

7618

}

7619

static void *_p_wxSizeEventTo_p_wxObject(void *x) {

7620

return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));

7621

}

7622

static void *_p_wxMoveEventTo_p_wxObject(void *x) {

7623

return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));

7624

}

7625

static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {

7626

return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));

7627

}

7628

static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {

7629

return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));

7630

}

7631

static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {

7632

return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));

7633

}

7634

static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {

7635

return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));

7636

}

7637

static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {

7638

return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));

7639

}

7640

static void *_p_wxANIHandlerTo_p_wxObject(void *x) {

7641

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));

7642

}

7643

static void *_p_wxCURHandlerTo_p_wxObject(void *x) {

7644

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));

7645

}

7646

static void *_p_wxICOHandlerTo_p_wxObject(void *x) {

7647

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));

7648

}

7649

static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {

7650

return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));

7651

}

7652

static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {

7653

return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));

7654

}

7655

static void *_p_wxImageHandlerTo_p_wxObject(void *x) {

7656

return (void *)((wxObject *) ((wxImageHandler *) x));

7657

}

7658

static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {

7659

return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));

7660

}

7661

static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {

7662

return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));

7663

}

7664

static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {

7665

return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));

7666

}

7667

static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {

7668

return (void *)((wxObject *) ((wxEvtHandler *) x));

7669

}

7670

static void *_p_wxPyEvtHandlerTo_p_wxObject(void *x) {

7671

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyEvtHandler *) x));

7672

}

7673

static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {

7674

return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));

7675

}

7676

static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {

7677

return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));

7678

}

7679

static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {

7680

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));

7681

}

7682

static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {

7683

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));

7684

}

7685

static void *_p_wxSimpleHtmlListBoxTo_p_wxObject(void *x) {

7686

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));

7687

}

7688

static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {

7689

return (void *)((wxObject *) ((wxAcceleratorTable *) x));

7690

}

7691

static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {

7692

return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));

7693

}

7694

static void *_p_wxPyOwnerDrawnComboBoxTo_p_wxObject(void *x) {

7695

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxPyComboCtrl *) ((wxPyOwnerDrawnComboBox *) x));

7696

}

7697

static void *_p_wxBitmapComboBoxTo_p_wxObject(void *x) {

7698

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxPyComboCtrl *)(wxPyOwnerDrawnComboBox *) ((wxBitmapComboBox *) x));

7699

}

7700

static void *_p_wxMiniFrameTo_p_wxObject(void *x) {

7701

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));

7702

}

7703

static void *_p_wxPyComboCtrlTo_p_wxObject(void *x) {

7704

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxPyComboCtrl *) x));

7705

}

7706

static void *_p_wxImageTo_p_wxObject(void *x) {

7707

return (void *)((wxObject *) ((wxImage *) x));

7708

}

7709

static void *_p_wxFrameTo_p_wxObject(void *x) {

7710

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));

7711

}

7712

static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {

7713

return (void *)((wxObject *) ((wxPyPrintout *) x));

7714

}

7715

static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {

7716

return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));

7717

}

7718

static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {

7719

return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));

7720

}

7721

static void *_p_wxStatusBarTo_p_wxObject(void *x) {

7722

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));

7723

}

7724

static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {

7725

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));

7726

}

7727

static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {

7728

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));

7729

}

7730

static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {

7731

return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));

7732

}

7733

static void *_p_wxKeyEventTo_p_wxObject(void *x) {

7734

return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));

7735

}

7736

static void *_p_wxWindowTo_p_wxObject(void *x) {

7737

return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));

7738

}

7739

static void *_p_wxMenuTo_p_wxObject(void *x) {

7740

return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));

7741

}

7742

static void *_p_wxMenuBarTo_p_wxObject(void *x) {

7743

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));

7744

}

7745

static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {

7746

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));

7747

}

7748

static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {

7749

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));

7750

}

7751

static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {

7752

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));

7753

}

7754

static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {

7755

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));

7756

}

7757

static void *_p_wxSashWindowTo_p_wxObject(void *x) {

7758

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));

7759

}

7760

static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {

7761

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));

7762

}

7763

static void *_p_wxPopupWindowTo_p_wxObject(void *x) {

7764

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));

7765

}

7766

static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {

7767

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));

7768

}

7769

static void *_p_wxTipWindowTo_p_wxObject(void *x) {

7770

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));

7771

}

7772

static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {

7773

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));

7774

}

7775

static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {

7776

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));

7777

}

7778

static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {

7779

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));

7780

}

7781

static void *_p_wxSashEventTo_p_wxObject(void *x) {

7782

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));

7783

}

7784

static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {

7785

return (void *)((wxObject *) ((wxPrintPreview *) x));

7786

}

7787

static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {

7788

return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));

7789

}

7790

static void *_p_wxPanelTo_p_wxObject(void *x) {

7791

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));

7792

}

7793

static void *_p_wxDialogTo_p_wxObject(void *x) {

7794

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));

7795

}

7796

static void *_p_wxColourDialogTo_p_wxObject(void *x) {

7797

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));

7798

}

7799

static void *_p_wxDirDialogTo_p_wxObject(void *x) {

7800

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));

7801

}

7802

static void *_p_wxFontDialogTo_p_wxObject(void *x) {

7803

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));

7804

}

7805

static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {

7806

return (void *)((wxObject *) ((wxPageSetupDialog *) x));

7807

}

7808

static void *_p_wxPrintDialogTo_p_wxObject(void *x) {

7809

return (void *)((wxObject *) ((wxPrintDialog *) x));

7810

}

7811

static void *_p_wxFileSystemTo_p_wxObject(void *x) {

7812

return (void *)((wxObject *) ((wxFileSystem *) x));

7813

}

7814

static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {

7815

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));

7816

}

7817

static void *_p_wxMenuEventTo_p_wxObject(void *x) {

7818

return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));

7819

}

7820

static void *_p_wxPyAppTo_p_wxObject(void *x) {

7821

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));

7822

}

7823

static void *_p_wxCloseEventTo_p_wxObject(void *x) {

7824

return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));

7825

}

7826

static void *_p_wxMouseEventTo_p_wxObject(void *x) {

7827

return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));

7828

}

7829

static void *_p_wxEraseEventTo_p_wxObject(void *x) {

7830

return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));

7831

}

7832

static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {

7833

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));

7834

}

7835

static void *_p_wxCommandEventTo_p_wxObject(void *x) {

7836

return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));

7837

}

7838

static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {

7839

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));

7840

}

7841

static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {

7842

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));

7843

}

7844

static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {

7845

return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));

7846

}

7847

static void *_p_wxFocusEventTo_p_wxObject(void *x) {

7848

return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));

7849

}

7850

static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {

7851

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));

7852

}

7853

static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {

7854

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));

7855

}

7856

static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {

7857

return (void *)((wxObject *) ((wxPageSetupDialogData *) x));

7858

}

7859

static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {

7860

return (void *)((wxObject *) ((wxPrintDialogData *) x));

7861

}

7862

static void *_p_wxPyValidatorTo_p_wxObject(void *x) {

7863

return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));

7864

}

7865

static void *_p_wxValidatorTo_p_wxObject(void *x) {

7866

return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));

7867

}

7868

static void *_p_wxBitmapComboBoxTo_p_wxPyOwnerDrawnComboBox(void *x) {

7869

return (void *)((wxPyOwnerDrawnComboBox *) ((wxBitmapComboBox *) x));

7870

}

7871

static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {

7872

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));

7873

}

7874

static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {

7875

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));

7876

}

7877

static void *_p_wxPyPanelTo_p_wxWindow(void *x) {

7878

return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));

7879

}

7880

static void *_p_wxMenuBarTo_p_wxWindow(void *x) {

7881

return (void *)((wxWindow *) ((wxMenuBar *) x));

7882

}

7883

static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {

7884

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));

7885

}

7886

static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {

7887

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxProgressDialog *) x));

7888

}

7889

static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {

7890

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));

7891

}

7892

static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {

7893

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));

7894

}

7895

static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {

7896

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));

7897

}

7898

static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {

7899

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));

7900

}

7901

static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {

7902

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));

7903

}

7904

static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {

7905

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));

7906

}

7907

static void *_p_wxFileDialogTo_p_wxWindow(void *x) {

7908

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));

7909

}

7910

static void *_p_wxPanelTo_p_wxWindow(void *x) {

7911

return (void *)((wxWindow *) ((wxPanel *) x));

7912

}

7913

static void *_p_wxStatusBarTo_p_wxWindow(void *x) {

7914

return (void *)((wxWindow *) ((wxStatusBar *) x));

7915

}

7916

static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {

7917

return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));

7918

}

7919

static void *_p_wxTipWindowTo_p_wxWindow(void *x) {

7920

return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));

7921

}

7922

static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {

7923

return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));

7924

}

7925

static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {

7926

return (void *)((wxWindow *) ((wxPopupWindow *) x));

7927

}

7928

static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {

7929

return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));

7930

}

7931

static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {

7932

return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));

7933

}

7934

static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {

7935

return (void *)((wxWindow *) ((wxTopLevelWindow *) x));

7936

}

7937

static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {

7938

return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));

7939

}

7940

static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {

7941

return (void *)((wxWindow *) ((wxSplitterWindow *) x));

7942

}

7943

static void *_p_wxSashWindowTo_p_wxWindow(void *x) {

7944

return (void *)((wxWindow *) ((wxSashWindow *) x));

7945

}

7946

static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {

7947

return (void *)((wxWindow *) ((wxMDIClientWindow *) x));

7948

}

7949

static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {

7950

return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));

7951

}

7952

static void *_p_wxControlTo_p_wxWindow(void *x) {

7953

return (void *)((wxWindow *) ((wxControl *) x));

7954

}

7955

static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {

7956

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));

7957

}

7958

static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {

7959

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));

7960

}

7961

static void *_p_wxPyOwnerDrawnComboBoxTo_p_wxWindow(void *x) {

7962

return (void *)((wxWindow *) (wxControl *)(wxPyComboCtrl *) ((wxPyOwnerDrawnComboBox *) x));

7963

}

7964

static void *_p_wxBitmapComboBoxTo_p_wxWindow(void *x) {

7965

return (void *)((wxWindow *) (wxControl *)(wxPyComboCtrl *)(wxPyOwnerDrawnComboBox *) ((wxBitmapComboBox *) x));

7966

}

7967

static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {

7968

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));

7969

}

7970

static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {

7971

return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));

7972

}

7973

static void *_p_wxPyWindowTo_p_wxWindow(void *x) {

7974

return (void *)((wxWindow *) ((wxPyWindow *) x));

7975

}

7976

static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {

7977

return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));

7978

}

7979

static void *_p_wxPyComboCtrlTo_p_wxWindow(void *x) {

7980

return (void *)((wxWindow *) (wxControl *) ((wxPyComboCtrl *) x));

7981

}

7982

static void *_p_wxSimpleHtmlListBoxTo_p_wxWindow(void *x) {

7983

return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));

7984

}

7985

static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {

7986

return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));

7987

}

7988

static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {

7989

return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));

7990

}

7991

static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {

7992

return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));

7993

}

7994

static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {

7995

return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));

7996

}

7997

static void *_p_wxFrameTo_p_wxWindow(void *x) {

7998

return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));

7999

}

8000

static void *_p_wxFontDialogTo_p_wxWindow(void *x) {

8001

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));

8002

}

8003

static void *_p_wxDirDialogTo_p_wxWindow(void *x) {

8004

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));

8005

}

8006

static void *_p_wxColourDialogTo_p_wxWindow(void *x) {

8007

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));

8008

}

8009

static void *_p_wxDialogTo_p_wxWindow(void *x) {

8010

return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));

8011

}

8012

static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {

8013

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));

8014

}

8015

static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {

8016

return (void *)((wxValidator *) ((wxPyValidator *) x));

8017

}

8018

static void *_p_wxPyOwnerDrawnComboBoxTo_p_wxPyComboCtrl(void *x) {

8019

return (void *)((wxPyComboCtrl *) ((wxPyOwnerDrawnComboBox *) x));

8020

}

8021

static void *_p_wxBitmapComboBoxTo_p_wxPyComboCtrl(void *x) {

8022

return (void *)((wxPyComboCtrl *) (wxPyOwnerDrawnComboBox *) ((wxBitmapComboBox *) x));

8023

}

8024

static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {

8025

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));

8026

}

8027

static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {

8028

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));

8029

}

8030

static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {

8031

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));

8032

}

8033

static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {

8034

return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));

8035

}

8036

static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {

8037

return (void *)((wxEvtHandler *) ((wxValidator *) x));

8038

}

8039

static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {

8040

return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));

8041

}

8042

static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {

8043

return (void *)((wxEvtHandler *) ((wxMenu *) x));

8044

}

8045

static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {

8046

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));

8047

}

8048

static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {

8049

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));

8050

}

8051

static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {

8052

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));

8053

}

8054

static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {

8055

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));

8056

}

8057

static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {

8058

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));

8059

}

8060

static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {

8061

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));

8062

}

8063

static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {

8064

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));

8065

}

8066

static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {

8067

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxProgressDialog *) x));

8068

}

8069

static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {

8070

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));

8071

}

8072

static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {

8073

return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));

8074

}

8075

static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {

8076

return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));

8077

}

8078

static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {

8079

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));

8080

}

8081

static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {

8082

return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));

8083

}

8084

static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {

8085

return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));

8086

}

8087

static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {

8088

return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));

8089

}

8090

static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {

8091

return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));

8092

}

8093

static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {

8094

return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));

8095

}

8096

static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {

8097

return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));

8098

}

8099

static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {

8100

return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));

8101

}

8102

static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {

8103

return (void *)((wxEvtHandler *) ((wxWindow *) x));

8104

}

8105

static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {

8106

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));

8107

}

8108

static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {

8109

return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));

8110

}

8111

static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {

8112

return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));

8113

}

8114

static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {

8115

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));

8116

}

8117

static void *_p_wxControlTo_p_wxEvtHandler(void *x) {

8118

return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));

8119

}

8120

static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {

8121

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));

8122

}

8123

static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {

8124

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));

8125

}

8126

static void *_p_wxPyOwnerDrawnComboBoxTo_p_wxEvtHandler(void *x) {

8127

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxPyComboCtrl *) ((wxPyOwnerDrawnComboBox *) x));

8128

}

8129

static void *_p_wxBitmapComboBoxTo_p_wxEvtHandler(void *x) {

8130

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxPyComboCtrl *)(wxPyOwnerDrawnComboBox *) ((wxBitmapComboBox *) x));

8131

}

8132

static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {

8133

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));

8134

}

8135

static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {

8136

return (void *)((wxEvtHandler *) ((wxPyApp *) x));

8137

}

8138

static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {

8139

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));

8140

}

8141

static void *_p_wxPyEvtHandlerTo_p_wxEvtHandler(void *x) {

8142

return (void *)((wxEvtHandler *) ((wxPyEvtHandler *) x));

8143

}

8144

static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {

8145

return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));

8146

}

8147

static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {

8148

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));

8149

}

8150

static void *_p_wxPyComboCtrlTo_p_wxEvtHandler(void *x) {

8151

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxPyComboCtrl *) x));

8152

}

8153

static void *_p_wxSimpleHtmlListBoxTo_p_wxEvtHandler(void *x) {

8154

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));

8155

}

8156

static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {

8157

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));

8158

}

8159

static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {

8160

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));

8161

}

8162

static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {

8163

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));

8164

}

8165

static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {

8166

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));

8167

}

8168

static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {

8169

return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));

8170

}

8171

static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {

8172

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));

8173

}

8174

static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {

8175

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));

8176

}

8177

static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {

8178

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));

8179

}

8180

static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {

8181

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));

8182

}

8183

static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {

8184

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));

8185

}

8186

static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {

8187

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));

8188

}

8189

static void *_p_wxPyOwnerDrawnComboBoxTo_p_wxItemContainer(void *x) {

8190

return (void *)((wxItemContainer *) ((wxPyOwnerDrawnComboBox *) x));

8191

}

8192

static void *_p_wxBitmapComboBoxTo_p_wxItemContainer(void *x) {

8193

return (void *)((wxItemContainer *) (wxPyOwnerDrawnComboBox *) ((wxBitmapComboBox *) x));

8194

}

8195

static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {

8196

return (void *)((wxItemContainer *) ((wxControlWithItems *) x));

8197

}

8198

static void *_p_wxSimpleHtmlListBoxTo_p_wxItemContainer(void *x) {

8199

return (void *)((wxItemContainer *) ((wxSimpleHtmlListBox *) x));

8200

}

8201

static void *_p_wxPyOwnerDrawnComboBoxTo_p_wxControl(void *x) {

8202

return (void *)((wxControl *) (wxPyComboCtrl *) ((wxPyOwnerDrawnComboBox *) x));

8203

}

8204

static void *_p_wxBitmapComboBoxTo_p_wxControl(void *x) {

8205

return (void *)((wxControl *) (wxPyComboCtrl *)(wxPyOwnerDrawnComboBox *) ((wxBitmapComboBox *) x));

8206

}

8207

static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {

8208

return (void *)((wxControl *) ((wxControlWithItems *) x));

8209

}

8210

static void *_p_wxPyComboCtrlTo_p_wxControl(void *x) {

8211

return (void *)((wxControl *) ((wxPyComboCtrl *) x));

8212

}

8213

static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};

8214

static swig_type_info _swigt__p_double = {"_p_double", "double *|wxDouble *", 0, 0, (void*)0, 0};

8215

static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, (void*)0, 0};

8216

static swig_type_info _swigt__p_int = {"_p_int", "int *|wxEventType *", 0, 0, (void*)0, 0};

8217

static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};

8218

static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};

8219

static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};

8220

static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};

8221

static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};

8222

static swig_type_info _swigt__p_wxBitmapComboBox = {"_p_wxBitmapComboBox", "wxBitmapComboBox *", 0, 0, (void*)0, 0};

8223

static swig_type_info _swigt__p_wxComboCtrlBase = {"_p_wxComboCtrlBase", "wxComboCtrlBase *", 0, 0, (void*)0, 0};

8224

static swig_type_info _swigt__p_wxComboCtrlFeatures = {"_p_wxComboCtrlFeatures", "wxComboCtrlFeatures *", 0, 0, (void*)0, 0};

8225

static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};

8226

static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};

8227

static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};

8228

static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};

8229

static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};

8230

static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};

8231

static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};

8232

static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};

8233

static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};

8234

static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};

8235

static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};

8236

static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};

8237

static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};

8238

static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};

8239

static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};

8240

static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};

8241

static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};

8242

static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};

8243

static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};

8244

static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", 0, 0, 0, 0, 0};

8245

static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};

8246

static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};

8247

static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};

8248

static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};

8249

static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};

8250

static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};

8251

static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};

8252

static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};

8253

static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};

8254

static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", 0, 0, 0, 0, 0};

8255

static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};

8256

static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};

8257

static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};

8258

static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};

8259

static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};

8260

static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};

8261

static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};

8262

static swig_type_info _swigt__p_wxPyEvtHandler = {"_p_wxPyEvtHandler", 0, 0, 0, 0, 0};

8263

static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};

8264

static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};

8265

static swig_type_info _swigt__p_wxSimpleHtmlListBox = {"_p_wxSimpleHtmlListBox", 0, 0, 0, 0, 0};

8266

static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};

8267

static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};

8268

static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};

8269

static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};

8270

static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};

8271

static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};

8272

static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};

8273

static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};

8274

static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};

8275

static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};

8276

static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};

8277

static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};

8278

static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};

8279

static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};

8280

static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};

8281

static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};

8282

static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};

8283

static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};

8284

static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};

8285

static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};

8286

static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};

8287

static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};

8288

static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};

8289

static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};

8290

static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};

8291

static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};

8292

static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};

8293

static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};

8294

static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", 0, 0, 0, 0, 0};

8295

static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};

8296

static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};

8297

static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};

8298

static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};

8299

static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};

8300

static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};

8301

static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};

8302

static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};

8303

static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};

8304

static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};

8305

static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};

8306

static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};

8307

static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};

8308

static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};

8309

static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};

8310

static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};

8311

static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};

8312

static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};

8313

static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};

8314

static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};

8315

static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};

8316

static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};

8317

static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};

8318

static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};

8319

static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};

8320

static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};

8321

static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};

8322

static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};

8323

static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};

8324

static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};

8325

static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};

8326

static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};

8327

static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};

8328

static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};

8329

static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};

8330

static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};

8331

static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};

8332

static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};

8333

static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};

8334

static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};

8335

static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};

8336

static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};

8337

static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};

8338

static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};

8339

static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};

8340

static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};

8341

static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};

8342

static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};

8343

static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};

8344

static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};

8345

static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};

8346

static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};

8347

static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};

8348

static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};

8349

static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};

8350

static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};

8351

static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};

8352

static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};

8353

static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};

8354

static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};

8355

static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};

8356

static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};

8357

static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};

8358

static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};

8359

static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};

8360

static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};

8361

static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};

8362

static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};

8363

static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};

8364

static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};

8365

static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};

8366

static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};

8367

static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};

8368

static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};

8369

static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};

8370

static swig_type_info _swigt__p_wxPyComboCtrl = {"_p_wxPyComboCtrl", "wxPyComboCtrl *", 0, 0, (void*)0, 0};

8371

static swig_type_info _swigt__p_wxPyComboPopup = {"_p_wxPyComboPopup", "wxPyComboPopup *", 0, 0, (void*)0, 0};

8372

static swig_type_info _swigt__p_wxPyOwnerDrawnComboBox = {"_p_wxPyOwnerDrawnComboBox", "wxPyOwnerDrawnComboBox *", 0, 0, (void*)0, 0};

8373

static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};

8374

static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};

8375

static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};

8376

static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};

8377

8378

static swig_type_info *swig_type_initial[] = {

8379

&_swigt__p_char,

8380

&_swigt__p_double,

8381

&_swigt__p_form_ops_t,

8382

&_swigt__p_int,

8383

&_swigt__p_unsigned_char,

8384

&_swigt__p_unsigned_int,

8385

&_swigt__p_unsigned_long,

8386

&_swigt__p_wxANIHandler,

8387

&_swigt__p_wxAcceleratorTable,

8388

&_swigt__p_wxActivateEvent,

8389

&_swigt__p_wxArrayString,

8390

&_swigt__p_wxBMPHandler,

8391

&_swigt__p_wxBitmap,

8392

&_swigt__p_wxBitmapComboBox,

8393

&_swigt__p_wxBoxSizer,

8394

&_swigt__p_wxCURHandler,

8395

&_swigt__p_wxCalculateLayoutEvent,

8396

&_swigt__p_wxChildFocusEvent,

8397

&_swigt__p_wxClipboardTextEvent,

8398

&_swigt__p_wxCloseEvent,

8399

&_swigt__p_wxColourData,

8400

&_swigt__p_wxColourDialog,

8401

&_swigt__p_wxComboCtrlBase,

8402

&_swigt__p_wxComboCtrlFeatures,

8403

&_swigt__p_wxCommandEvent,

8404

&_swigt__p_wxContextMenuEvent,

8405

&_swigt__p_wxControl,

8406

&_swigt__p_wxControlWithItems,

8407

&_swigt__p_wxDC,

8408

&_swigt__p_wxDateEvent,

8409

&_swigt__p_wxDialog,

8410

&_swigt__p_wxDirDialog,

8411

&_swigt__p_wxDisplayChangedEvent,

8412

&_swigt__p_wxDropFilesEvent,

8413

&_swigt__p_wxDuplexMode,

8414

&_swigt__p_wxEraseEvent,

8415

&_swigt__p_wxEvent,

8416

&_swigt__p_wxEvtHandler,

8417

&_swigt__p_wxFSFile,

8418

&_swigt__p_wxFileDialog,

8419

&_swigt__p_wxFileSystem,

8420

&_swigt__p_wxFindDialogEvent,

8421

&_swigt__p_wxFindReplaceData,

8422

&_swigt__p_wxFindReplaceDialog,

8423

&_swigt__p_wxFlexGridSizer,

8424

&_swigt__p_wxFocusEvent,

8425

&_swigt__p_wxFontData,

8426

&_swigt__p_wxFontDialog,

8427

&_swigt__p_wxFrame,

8428

&_swigt__p_wxGBSizerItem,

8429

&_swigt__p_wxGIFHandler,

8430

&_swigt__p_wxGridBagSizer,

8431

&_swigt__p_wxGridSizer,

8432

&_swigt__p_wxICOHandler,

8433

&_swigt__p_wxIconizeEvent,

8434

&_swigt__p_wxIdleEvent,

8435

&_swigt__p_wxImage,

8436

&_swigt__p_wxImageHandler,

8437

&_swigt__p_wxIndividualLayoutConstraint,

8438

&_swigt__p_wxInitDialogEvent,

8439

&_swigt__p_wxItemContainer,

8440

&_swigt__p_wxJPEGHandler,

8441

&_swigt__p_wxKeyEvent,

8442

&_swigt__p_wxLayoutAlgorithm,

8443

&_swigt__p_wxLayoutConstraints,

8444

&_swigt__p_wxMDIChildFrame,

8445

&_swigt__p_wxMDIClientWindow,

8446

&_swigt__p_wxMDIParentFrame,

8447

&_swigt__p_wxMaximizeEvent,

8448

&_swigt__p_wxMenu,

8449

&_swigt__p_wxMenuBar,

8450

&_swigt__p_wxMenuEvent,

8451

&_swigt__p_wxMenuItem,

8452

&_swigt__p_wxMessageDialog,

8453

&_swigt__p_wxMiniFrame,

8454

&_swigt__p_wxMouseCaptureChangedEvent,

8455

&_swigt__p_wxMouseCaptureLostEvent,

8456

&_swigt__p_wxMouseEvent,

8457

&_swigt__p_wxMoveEvent,

8458

&_swigt__p_wxMultiChoiceDialog,

8459

&_swigt__p_wxNavigationKeyEvent,

8460

&_swigt__p_wxNcPaintEvent,

8461

&_swigt__p_wxNotifyEvent,

8462

&_swigt__p_wxNumberEntryDialog,

8463

&_swigt__p_wxObject,

8464

&_swigt__p_wxPCXHandler,

8465

&_swigt__p_wxPNGHandler,

8466

&_swigt__p_wxPNMHandler,

8467

&_swigt__p_wxPageSetupDialog,

8468

&_swigt__p_wxPageSetupDialogData,

8469

&_swigt__p_wxPaintEvent,

8470

&_swigt__p_wxPaletteChangedEvent,

8471

&_swigt__p_wxPanel,

8472

&_swigt__p_wxPaperSize,

8473

&_swigt__p_wxPasswordEntryDialog,

8474

&_swigt__p_wxPopupWindow,

8475

&_swigt__p_wxPreviewCanvas,

8476

&_swigt__p_wxPreviewControlBar,

8477

&_swigt__p_wxPreviewFrame,

8478

&_swigt__p_wxPrintData,

8479

&_swigt__p_wxPrintDialog,

8480

&_swigt__p_wxPrintDialogData,

8481

&_swigt__p_wxPrintPreview,

8482

&_swigt__p_wxPrinter,

8483

&_swigt__p_wxProgressDialog,

8484

&_swigt__p_wxPyApp,

8485

&_swigt__p_wxPyComboCtrl,

8486

&_swigt__p_wxPyComboPopup,

8487

&_swigt__p_wxPyCommandEvent,

8488

&_swigt__p_wxPyEvent,

8489

&_swigt__p_wxPyEvtHandler,

8490

&_swigt__p_wxPyHtmlListBox,

8491

&_swigt__p_wxPyImageHandler,

8492

&_swigt__p_wxPyOwnerDrawnComboBox,

8493

&_swigt__p_wxPyPanel,

8494

&_swigt__p_wxPyPopupTransientWindow,

8495

&_swigt__p_wxPyPreviewControlBar,

8496

&_swigt__p_wxPyPreviewFrame,

8497

&_swigt__p_wxPyPrintPreview,

8498

&_swigt__p_wxPyPrintout,

8499

&_swigt__p_wxPyScrolledWindow,

8500

&_swigt__p_wxPySizer,

8501

&_swigt__p_wxPyTaskBarIcon,

8502

&_swigt__p_wxPyVListBox,

8503

&_swigt__p_wxPyVScrolledWindow,

8504

&_swigt__p_wxPyValidator,

8505

&_swigt__p_wxPyWindow,

8506

&_swigt__p_wxQueryLayoutInfoEvent,

8507

&_swigt__p_wxQueryNewPaletteEvent,

8508

&_swigt__p_wxRect,

8509

&_swigt__p_wxSashEvent,

8510

&_swigt__p_wxSashLayoutWindow,

8511

&_swigt__p_wxSashWindow,

8512

&_swigt__p_wxScrollEvent,

8513

&_swigt__p_wxScrollWinEvent,

8514

&_swigt__p_wxScrolledWindow,

8515

&_swigt__p_wxSetCursorEvent,

8516

&_swigt__p_wxShowEvent,

8517

&_swigt__p_wxSimpleHtmlListBox,

8518

&_swigt__p_wxSingleChoiceDialog,

8519

&_swigt__p_wxSize,

8520

&_swigt__p_wxSizeEvent,

8521

&_swigt__p_wxSizer,

8522

&_swigt__p_wxSizerItem,

8523

&_swigt__p_wxSplashScreen,

8524

&_swigt__p_wxSplashScreenWindow,

8525

&_swigt__p_wxSplitterEvent,

8526

&_swigt__p_wxSplitterWindow,

8527

&_swigt__p_wxStaticBoxSizer,

8528

&_swigt__p_wxStatusBar,

8529

&_swigt__p_wxStdDialogButtonSizer,

8530

&_swigt__p_wxSysColourChangedEvent,

8531

&_swigt__p_wxTGAHandler,

8532

&_swigt__p_wxTIFFHandler,

8533

&_swigt__p_wxTaskBarIconEvent,

8534

&_swigt__p_wxTextEntryDialog,

8535

&_swigt__p_wxTipWindow,

8536

&_swigt__p_wxTopLevelWindow,

8537

&_swigt__p_wxUpdateUIEvent,

8538

&_swigt__p_wxValidator,

8539

&_swigt__p_wxWindow,

8540

&_swigt__p_wxWindowCreateEvent,

8541

&_swigt__p_wxWindowDestroyEvent,

8542

&_swigt__p_wxXPMHandler,

8543

};

8544

8545

static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};

8546

static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};

8547

static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};

8548

static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};

8549

static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};

8550

static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};

8551

static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};

8552

static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};

8553

static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};

8554

static swig_cast_info _swigc__p_wxBitmapComboBox[] = { {&_swigt__p_wxBitmapComboBox, 0, 0, 0},{0, 0, 0, 0}};

8555

static swig_cast_info _swigc__p_wxComboCtrlBase[] = { {&_swigt__p_wxComboCtrlBase, 0, 0, 0},{0, 0, 0, 0}};

8556

static swig_cast_info _swigc__p_wxComboCtrlFeatures[] = { {&_swigt__p_wxComboCtrlFeatures, 0, 0, 0},{0, 0, 0, 0}};

8557

static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};

8558

static swig_cast_info _swigc__p_wxControl[] = { {&_swigt__p_wxPyOwnerDrawnComboBox, _p_wxPyOwnerDrawnComboBoxTo_p_wxControl, 0, 0}, {&_swigt__p_wxBitmapComboBox, _p_wxBitmapComboBoxTo_p_wxControl, 0, 0}, {&_swigt__p_wxControl, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxControl, 0, 0}, {&_swigt__p_wxPyComboCtrl, _p_wxPyComboCtrlTo_p_wxControl, 0, 0},{0, 0, 0, 0}};

8559

static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};

8560

static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};

8561

static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};

8562

static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};

8563

static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};

8564

static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};

8565

static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};

8566

static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};

8567

static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};

8568

static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};

8569

static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};

8570

static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};

8571

static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};

8572

static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};

8573

static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};

8574

static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};

8575

static swig_cast_info _swigc__p_wxPanel[] = {{&_swigt__p_wxPanel, 0, 0, 0},{0, 0, 0, 0}};

8576

static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};

8577

static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};

8578

static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};

8579

static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};

8580

static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};

8581

static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};

8582

static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};

8583

static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};

8584

static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};

8585

static swig_cast_info _swigc__p_wxScrolledWindow[] = {{&_swigt__p_wxScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};

8586

static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};

8587

static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};

8588

static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};

8589

static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};

8590

static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};

8591

static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};

8592

static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};

8593

static swig_cast_info _swigc__p_wxPyEvtHandler[] = {{&_swigt__p_wxPyEvtHandler, 0, 0, 0},{0, 0, 0, 0}};

8594

static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};

8595

static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};

8596

static swig_cast_info _swigc__p_wxSimpleHtmlListBox[] = {{&_swigt__p_wxSimpleHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};

8597

static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};

8598

static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};

8599

static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};

8600

static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};

8601

static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};

8602

static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};

8603

static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};

8604

static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};

8605

static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};

8606

static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};

8607

static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};

8608

static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};

8609

static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyOwnerDrawnComboBox, _p_wxPyOwnerDrawnComboBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxBitmapComboBox, _p_wxBitmapComboBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyEvtHandler, _p_wxPyEvtHandlerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyComboCtrl, _p_wxPyComboCtrlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};

8610

static swig_cast_info _swigc__p_wxItemContainer[] = { {&_swigt__p_wxPyOwnerDrawnComboBox, _p_wxPyOwnerDrawnComboBoxTo_p_wxItemContainer, 0, 0}, {&_swigt__p_wxBitmapComboBox, _p_wxBitmapComboBoxTo_p_wxItemContainer, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxItemContainer, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxItemContainer, 0, 0}, {&_swigt__p_wxItemContainer, 0, 0, 0},{0, 0, 0, 0}};

8611

static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};

8612

static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};

8613

static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};

8614

static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};

8615

static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};

8616

static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};

8617

static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};

8618

static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};

8619

static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};

8620

static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};

8621

static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};

8622

static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};

8623

static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};

8624

static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};

8625

static swig_cast_info _swigc__p_wxEvent[] = {{&_swigt__p_wxEvent, 0, 0, 0},{0, 0, 0, 0}};

8626

static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};

8627

static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};

8628

static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};

8629

static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};

8630

static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};

8631

static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};

8632

static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};

8633

static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};

8634

static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

8635

static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

8636

static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

8637

static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

8638

static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};

8639

static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};

8640

static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};

8641

static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};

8642

static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};

8643

static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};

8644

static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};

8645

static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};

8646

static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};

8647

static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};

8648

static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};

8649

static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};

8650

static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};

8651

static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};

8652

static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};

8653

static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};

8654

static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};

8655

static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};

8656

static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};

8657

static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};

8658

static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};

8659

static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};

8660

static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};

8661

static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};

8662

static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};

8663

static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};

8664

static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};

8665

static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};

8666

static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};

8667

static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};

8668

static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};

8669

static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};

8670

static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};

8671

static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};

8672

static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};

8673

static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};

8674

static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};

8675

static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};

8676

static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};

8677

static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};

8678

static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};

8679

static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};

8680

static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};

8681

static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};

8682

static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};

8683

static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};

8684

static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};

8685

static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};

8686

static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};

8687

static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};

8688

static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};

8689

static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};

8690

static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};

8691

static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};

8692

static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};

8693

static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};

8694

static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};

8695

static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};

8696

static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};

8697

static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};

8698

static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};

8699

static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};

8700

static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvtHandler, _p_wxPyEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBitmapComboBox, _p_wxBitmapComboBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyOwnerDrawnComboBox, _p_wxPyOwnerDrawnComboBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyComboCtrl, _p_wxPyComboCtrlTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};

8701

static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};

8702

static swig_cast_info _swigc__p_wxPyComboCtrl[] = { {&_swigt__p_wxPyOwnerDrawnComboBox, _p_wxPyOwnerDrawnComboBoxTo_p_wxPyComboCtrl, 0, 0}, {&_swigt__p_wxBitmapComboBox, _p_wxBitmapComboBoxTo_p_wxPyComboCtrl, 0, 0}, {&_swigt__p_wxPyComboCtrl, 0, 0, 0},{0, 0, 0, 0}};

8703

static swig_cast_info _swigc__p_wxPyComboPopup[] = { {&_swigt__p_wxPyComboPopup, 0, 0, 0},{0, 0, 0, 0}};

8704

static swig_cast_info _swigc__p_wxPyOwnerDrawnComboBox[] = { {&_swigt__p_wxPyOwnerDrawnComboBox, 0, 0, 0}, {&_swigt__p_wxBitmapComboBox, _p_wxBitmapComboBoxTo_p_wxPyOwnerDrawnComboBox, 0, 0},{0, 0, 0, 0}};

8705

static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};

8706

static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};

8707

static swig_cast_info _swigc__p_wxValidator[] = { {&_swigt__p_wxValidator, 0, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxValidator, 0, 0},{0, 0, 0, 0}};

8708

static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxBitmapComboBox, _p_wxBitmapComboBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyOwnerDrawnComboBox, _p_wxPyOwnerDrawnComboBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyComboCtrl, _p_wxPyComboCtrlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};

8709

8710

static swig_cast_info *swig_cast_initial[] = {

8711

_swigc__p_char,

8712

_swigc__p_double,

8713

_swigc__p_form_ops_t,

8714

_swigc__p_int,

8715

_swigc__p_unsigned_char,

8716

_swigc__p_unsigned_int,

8717

_swigc__p_unsigned_long,

8718

_swigc__p_wxANIHandler,

8719

_swigc__p_wxAcceleratorTable,

8720

_swigc__p_wxActivateEvent,

8721

_swigc__p_wxArrayString,

8722

_swigc__p_wxBMPHandler,

8723

_swigc__p_wxBitmap,

8724

_swigc__p_wxBitmapComboBox,

8725

_swigc__p_wxBoxSizer,

8726

_swigc__p_wxCURHandler,

8727

_swigc__p_wxCalculateLayoutEvent,

8728

_swigc__p_wxChildFocusEvent,

8729

_swigc__p_wxClipboardTextEvent,

8730

_swigc__p_wxCloseEvent,

8731

_swigc__p_wxColourData,

8732

_swigc__p_wxColourDialog,

8733

_swigc__p_wxComboCtrlBase,

8734

_swigc__p_wxComboCtrlFeatures,

8735

_swigc__p_wxCommandEvent,

8736

_swigc__p_wxContextMenuEvent,

8737

_swigc__p_wxControl,

8738

_swigc__p_wxControlWithItems,

8739

_swigc__p_wxDC,

8740

_swigc__p_wxDateEvent,

8741

_swigc__p_wxDialog,

8742

_swigc__p_wxDirDialog,

8743

_swigc__p_wxDisplayChangedEvent,

8744

_swigc__p_wxDropFilesEvent,

8745

_swigc__p_wxDuplexMode,

8746

_swigc__p_wxEraseEvent,

8747

_swigc__p_wxEvent,

8748

_swigc__p_wxEvtHandler,

8749

_swigc__p_wxFSFile,

8750

_swigc__p_wxFileDialog,

8751

_swigc__p_wxFileSystem,

8752

_swigc__p_wxFindDialogEvent,

8753

_swigc__p_wxFindReplaceData,

8754

_swigc__p_wxFindReplaceDialog,

8755

_swigc__p_wxFlexGridSizer,

8756

_swigc__p_wxFocusEvent,

8757

_swigc__p_wxFontData,

8758

_swigc__p_wxFontDialog,

8759

_swigc__p_wxFrame,

8760

_swigc__p_wxGBSizerItem,

8761

_swigc__p_wxGIFHandler,

8762

_swigc__p_wxGridBagSizer,

8763

_swigc__p_wxGridSizer,

8764

_swigc__p_wxICOHandler,

8765

_swigc__p_wxIconizeEvent,

8766

_swigc__p_wxIdleEvent,

8767

_swigc__p_wxImage,

8768

_swigc__p_wxImageHandler,

8769

_swigc__p_wxIndividualLayoutConstraint,

8770

_swigc__p_wxInitDialogEvent,

8771

_swigc__p_wxItemContainer,

8772

_swigc__p_wxJPEGHandler,

8773

_swigc__p_wxKeyEvent,

8774

_swigc__p_wxLayoutAlgorithm,

8775

_swigc__p_wxLayoutConstraints,

8776

_swigc__p_wxMDIChildFrame,

8777

_swigc__p_wxMDIClientWindow,

8778

_swigc__p_wxMDIParentFrame,

8779

_swigc__p_wxMaximizeEvent,

8780

_swigc__p_wxMenu,

8781

_swigc__p_wxMenuBar,

8782

_swigc__p_wxMenuEvent,

8783

_swigc__p_wxMenuItem,

8784

_swigc__p_wxMessageDialog,

8785

_swigc__p_wxMiniFrame,

8786

_swigc__p_wxMouseCaptureChangedEvent,

8787

_swigc__p_wxMouseCaptureLostEvent,

8788

_swigc__p_wxMouseEvent,

8789

_swigc__p_wxMoveEvent,

8790

_swigc__p_wxMultiChoiceDialog,

8791

_swigc__p_wxNavigationKeyEvent,

8792

_swigc__p_wxNcPaintEvent,

8793

_swigc__p_wxNotifyEvent,

8794

_swigc__p_wxNumberEntryDialog,

8795

_swigc__p_wxObject,

8796

_swigc__p_wxPCXHandler,

8797

_swigc__p_wxPNGHandler,

8798

_swigc__p_wxPNMHandler,

8799

_swigc__p_wxPageSetupDialog,

8800

_swigc__p_wxPageSetupDialogData,

8801

_swigc__p_wxPaintEvent,

8802

_swigc__p_wxPaletteChangedEvent,

8803

_swigc__p_wxPanel,

8804

_swigc__p_wxPaperSize,

8805

_swigc__p_wxPasswordEntryDialog,

8806

_swigc__p_wxPopupWindow,

8807

_swigc__p_wxPreviewCanvas,

8808

_swigc__p_wxPreviewControlBar,

8809

_swigc__p_wxPreviewFrame,

8810

_swigc__p_wxPrintData,

8811

_swigc__p_wxPrintDialog,

8812

_swigc__p_wxPrintDialogData,

8813

_swigc__p_wxPrintPreview,

8814

_swigc__p_wxPrinter,

8815

_swigc__p_wxProgressDialog,

8816

_swigc__p_wxPyApp,

8817

_swigc__p_wxPyComboCtrl,

8818

_swigc__p_wxPyComboPopup,

8819

_swigc__p_wxPyCommandEvent,

8820

_swigc__p_wxPyEvent,

8821

_swigc__p_wxPyEvtHandler,

8822

_swigc__p_wxPyHtmlListBox,

8823

_swigc__p_wxPyImageHandler,

8824

_swigc__p_wxPyOwnerDrawnComboBox,

8825

_swigc__p_wxPyPanel,

8826

_swigc__p_wxPyPopupTransientWindow,

8827

_swigc__p_wxPyPreviewControlBar,

8828

_swigc__p_wxPyPreviewFrame,

8829

_swigc__p_wxPyPrintPreview,

8830

_swigc__p_wxPyPrintout,

8831

_swigc__p_wxPyScrolledWindow,

8832

_swigc__p_wxPySizer,

8833

_swigc__p_wxPyTaskBarIcon,

8834

_swigc__p_wxPyVListBox,

8835

_swigc__p_wxPyVScrolledWindow,

8836

_swigc__p_wxPyValidator,

8837

_swigc__p_wxPyWindow,

8838

_swigc__p_wxQueryLayoutInfoEvent,

8839

_swigc__p_wxQueryNewPaletteEvent,

8840

_swigc__p_wxRect,

8841

_swigc__p_wxSashEvent,

8842

_swigc__p_wxSashLayoutWindow,

8843

_swigc__p_wxSashWindow,

8844

_swigc__p_wxScrollEvent,

8845

_swigc__p_wxScrollWinEvent,

8846

_swigc__p_wxScrolledWindow,

8847

_swigc__p_wxSetCursorEvent,

8848

_swigc__p_wxShowEvent,

8849

_swigc__p_wxSimpleHtmlListBox,

8850

_swigc__p_wxSingleChoiceDialog,

8851

_swigc__p_wxSize,

8852

_swigc__p_wxSizeEvent,

8853

_swigc__p_wxSizer,

8854

_swigc__p_wxSizerItem,

8855

_swigc__p_wxSplashScreen,

8856

_swigc__p_wxSplashScreenWindow,

8857

_swigc__p_wxSplitterEvent,

8858

_swigc__p_wxSplitterWindow,

8859

_swigc__p_wxStaticBoxSizer,

8860

_swigc__p_wxStatusBar,

8861

_swigc__p_wxStdDialogButtonSizer,

8862

_swigc__p_wxSysColourChangedEvent,

8863

_swigc__p_wxTGAHandler,

8864

_swigc__p_wxTIFFHandler,

8865

_swigc__p_wxTaskBarIconEvent,

8866

_swigc__p_wxTextEntryDialog,

8867

_swigc__p_wxTipWindow,

8868

_swigc__p_wxTopLevelWindow,

8869

_swigc__p_wxUpdateUIEvent,

8870

_swigc__p_wxValidator,

8871

_swigc__p_wxWindow,

8872

_swigc__p_wxWindowCreateEvent,

8873

_swigc__p_wxWindowDestroyEvent,

8874

_swigc__p_wxXPMHandler,

8875

};

8876

8877

8878

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

8879

8880

static swig_const_info swig_const_table[] = {

8881

{0, 0, 0, 0.0, 0, 0}};

8882

8883

#ifdef __cplusplus

8884

}

8885

#endif

8886

/* -----------------------------------------------------------------------------

8887

* Type initialization:

8888

* This problem is tough by the requirement that no dynamic

8889

* memory is used. Also, since swig_type_info structures store pointers to

8890

* swig_cast_info structures and swig_cast_info structures store pointers back

8891

* to swig_type_info structures, we need some lookup code at initialization.

8892

* The idea is that swig generates all the structures that are needed.

8893

* The runtime then collects these partially filled structures.

8894

* The SWIG_InitializeModule function takes these initial arrays out of

8895

* swig_module, and does all the lookup, filling in the swig_module.types

8896

* array with the correct data and linking the correct swig_cast_info

8897

* structures together.

8898

*

8899

* The generated swig_type_info structures are assigned staticly to an initial

8900

* array. We just loop though that array, and handle each type individually.

8901

* First we lookup if this type has been already loaded, and if so, use the

8902

* loaded structure instead of the generated one. Then we have to fill in the

8903

* cast linked list. The cast data is initially stored in something like a

8904

* two-dimensional array. Each row corresponds to a type (there are the same

8905

* number of rows as there are in the swig_type_initial array). Each entry in

8906

* a column is one of the swig_cast_info structures for that type.

8907

* The cast_initial array is actually an array of arrays, because each row has

8908

* a variable number of columns. So to actually build the cast linked list,

8909

* we find the array of casts associated with the type, and loop through it

8910

* adding the casts to the list. The one last trick we need to do is making

8911

* sure the type pointer in the swig_cast_info struct is correct.

8912

*

8913

* First off, we lookup the cast->type name to see if it is already loaded.

8914

* There are three cases to handle:

8915

* 1) If the cast->type has already been loaded AND the type we are adding

8916

* casting info to has not been loaded (it is in this module), THEN we

8917

* replace the cast->type pointer with the type pointer that has already

8918

* been loaded.

8919

* 2) If BOTH types (the one we are adding casting info to, and the

8920

* cast->type) are loaded, THEN the cast info has already been loaded by

8921

* the previous module so we just ignore it.

8922

* 3) Finally, if cast->type has not already been loaded, then we add that

8923

* swig_cast_info to the linked list (because the cast->type) pointer will

8924

* be correct.

8925

* ----------------------------------------------------------------------------- */

8926

8927

#ifdef __cplusplus

8928

extern "C" {

8929

#if 0

8930

} /* c-mode */

8931

#endif

8932

#endif

8933

8934

#if 0

8935

#define SWIGRUNTIME_DEBUG

8936

#endif

8937

8938

SWIGRUNTIME void

8939

SWIG_InitializeModule(void *clientdata) {

8940

size_t i;

8941

swig_module_info *module_head;

8942

static int init_run = 0;

8943

8944

clientdata = clientdata;

8945

8946

if (init_run) return;

8947

init_run = 1;

8948

8949

/* Initialize the swig_module */

8950

swig_module.type_initial = swig_type_initial;

8951

swig_module.cast_initial = swig_cast_initial;

8952

8953

/* Try and load any already created modules */

8954

module_head = SWIG_GetModule(clientdata);

8955

if (module_head) {

8956

swig_module.next = module_head->next;

8957

module_head->next = &swig_module;

8958

} else {

8959

/* This is the first module loaded */

8960

swig_module.next = &swig_module;

8961

SWIG_SetModule(clientdata, &swig_module);

8962

}

8963

8964

/* Now work on filling in swig_module.types */

8965

#ifdef SWIGRUNTIME_DEBUG

8966

printf("SWIG_InitializeModule: size %d\n", swig_module.size);

8967

#endif

8968

for (i = 0; i < swig_module.size; ++i) {

8969

swig_type_info *type = 0;

8970

swig_type_info *ret;

8971

swig_cast_info *cast;

8972

8973

#ifdef SWIGRUNTIME_DEBUG

8974

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

8975

#endif

8976

8977

/* if there is another module already loaded */

8978

if (swig_module.next != &swig_module) {

8979

type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);

8980

}

8981

if (type) {

8982

/* Overwrite clientdata field */

8983

#ifdef SWIGRUNTIME_DEBUG

8984

printf("SWIG_InitializeModule: found type %s\n", type->name);

8985

#endif

8986

if (swig_module.type_initial[i]->clientdata) {

8987

type->clientdata = swig_module.type_initial[i]->clientdata;

8988

#ifdef SWIGRUNTIME_DEBUG

8989

printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);

8990

#endif

8991

}

8992

} else {

8993

type = swig_module.type_initial[i];

8994

}

8995

8996

/* Insert casting types */

8997

cast = swig_module.cast_initial[i];

8998

while (cast->type) {

8999

/* Don't need to add information already in the list */

9000

ret = 0;

9001

#ifdef SWIGRUNTIME_DEBUG

9002

printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);

9003

#endif

9004

if (swig_module.next != &swig_module) {

9005

ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);

9006

#ifdef SWIGRUNTIME_DEBUG

9007

if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);

9008

#endif

9009

}

9010

if (ret) {

9011

if (type == swig_module.type_initial[i]) {

9012

#ifdef SWIGRUNTIME_DEBUG

9013

printf("SWIG_InitializeModule: skip old type %s\n", ret->name);

9014

#endif

9015

cast->type = ret;

9016

ret = 0;

9017

} else {

9018

/* Check for casting already in the list */

9019

swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);

9020

#ifdef SWIGRUNTIME_DEBUG

9021

if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);

9022

#endif

9023

if (!ocast) ret = 0;

9024

}

9025

}

9026

9027

if (!ret) {

9028

#ifdef SWIGRUNTIME_DEBUG

9029

printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);

9030

#endif

9031

if (type->cast) {

9032

type->cast->prev = cast;

9033

cast->next = type->cast;

9034

}

9035

type->cast = cast;

9036

}

9037

cast++;

9038

}

9039

/* Set entry in modules->types array equal to the type */

9040

swig_module.types[i] = type;

9041

}

9042

swig_module.types[i] = 0;

9043

9044

#ifdef SWIGRUNTIME_DEBUG

9045

printf("**** SWIG_InitializeModule: Cast List ******\n");

9046

for (i = 0; i < swig_module.size; ++i) {

9047

int j = 0;

9048

swig_cast_info *cast = swig_module.cast_initial[i];

9049

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

9050

while (cast->type) {

9051

printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);

9052

cast++;

9053

++j;

9054

}

9055

printf("---- Total casts: %d\n",j);

9056

}

9057

printf("**** SWIG_InitializeModule: Cast List ******\n");

9058

#endif

9059

}

9060

9061

/* This function will propagate the clientdata field of type to

9062

* any new swig_type_info structures that have been added into the list

9063

* of equivalent types. It is like calling

9064

* SWIG_TypeClientData(type, clientdata) a second time.

9065

*/

9066

SWIGRUNTIME void

9067

SWIG_PropagateClientData(void) {

9068

size_t i;

9069

swig_cast_info *equiv;

9070

static int init_run = 0;

9071

9072

if (init_run) return;

9073

init_run = 1;

9074

9075

for (i = 0; i < swig_module.size; i++) {

9076

if (swig_module.types[i]->clientdata) {

9077

equiv = swig_module.types[i]->cast;

9078

while (equiv) {

9079

if (!equiv->converter) {

9080

if (equiv->type && !equiv->type->clientdata)

9081

SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);

9082

}

9083

equiv = equiv->next;

9084

}

9085

}

9086

}

9087

}

9088

9089

#ifdef __cplusplus

9090

#if 0

9091

{

9092

/* c-mode */

9093

#endif

9094

}

9095

#endif

9096

9097

9098

9099

#ifdef __cplusplus

9100

extern "C" {

9101

#endif

9102

9103

/* Python-specific SWIG API */

9104

#define SWIG_newvarlink() SWIG_Python_newvarlink()

9105

#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)

9106

#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)

9107

9108

/* -----------------------------------------------------------------------------

9109

* global variable support code.

9110

* ----------------------------------------------------------------------------- */

9111

9112

typedef struct swig_globalvar {

9113

char *name; /* Name of global variable */

9114

PyObject *(*get_attr)(void); /* Return the current value */

9115

int (*set_attr)(PyObject *); /* Set the value */

9116

struct swig_globalvar *next;

9117

} swig_globalvar;

9118

9119

typedef struct swig_varlinkobject {

9120

PyObject_HEAD

9121

swig_globalvar *vars;

9122

} swig_varlinkobject;

9123

9124

SWIGINTERN PyObject *

9125

swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {

9126

return PyString_FromString("<Swig global variables>");

9127

}

9128

9129

SWIGINTERN PyObject *

9130

swig_varlink_str(swig_varlinkobject *v) {

9131

PyObject *str = PyString_FromString("(");

9132

swig_globalvar *var;

9133

for (var = v->vars; var; var=var->next) {

9134

PyString_ConcatAndDel(&str,PyString_FromString(var->name));

9135

if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));

9136

}

9137

PyString_ConcatAndDel(&str,PyString_FromString(")"));

9138

return str;

9139

}

9140

9141

SWIGINTERN int

9142

swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {

9143

PyObject *str = swig_varlink_str(v);

9144

fprintf(fp,"Swig global variables ");

9145

fprintf(fp,"%s\n", PyString_AsString(str));

9146

Py_DECREF(str);

9147

return 0;

9148

}

9149

9150

SWIGINTERN void

9151

swig_varlink_dealloc(swig_varlinkobject *v) {

9152

swig_globalvar *var = v->vars;

9153

while (var) {

9154

swig_globalvar *n = var->next;

9155

free(var->name);

9156

free(var);

9157

var = n;

9158

}

9159

}

9160

9161

SWIGINTERN PyObject *

9162

swig_varlink_getattr(swig_varlinkobject *v, char *n) {

9163

PyObject *res = NULL;

9164

swig_globalvar *var = v->vars;

9165

while (var) {

9166

if (strcmp(var->name,n) == 0) {

9167

res = (*var->get_attr)();

9168

break;

9169

}

9170

var = var->next;

9171

}

9172

if (res == NULL && !PyErr_Occurred()) {

9173

PyErr_SetString(PyExc_NameError,"Unknown C global variable");

9174

}

9175

return res;

9176

}

9177

9178

SWIGINTERN int

9179

swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {

9180

int res = 1;

9181

swig_globalvar *var = v->vars;

9182

while (var) {

9183

if (strcmp(var->name,n) == 0) {

9184

res = (*var->set_attr)(p);

9185

break;

9186

}

9187

var = var->next;

9188

}

9189

if (res == 1 && !PyErr_Occurred()) {

9190

PyErr_SetString(PyExc_NameError,"Unknown C global variable");

9191

}

9192

return res;

9193

}

9194

9195

SWIGINTERN PyTypeObject*

9196

swig_varlink_type(void) {

9197

static char varlink__doc__[] = "Swig var link object";

9198

static PyTypeObject varlink_type;

9199

static int type_init = 0;

9200

if (!type_init) {

9201

const PyTypeObject tmp

9202

= {

9203

PyObject_HEAD_INIT(NULL)

9204

0, /* Number of items in variable part (ob_size) */

9205

(char *)"swigvarlink", /* Type name (tp_name) */

9206

sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */

9207

0, /* Itemsize (tp_itemsize) */

9208

(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */

9209

(printfunc) swig_varlink_print, /* Print (tp_print) */

9210

(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */

9211

(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */

9212

0, /* tp_compare */

9213

(reprfunc) swig_varlink_repr, /* tp_repr */

9214

0, /* tp_as_number */

9215

0, /* tp_as_sequence */

9216

0, /* tp_as_mapping */

9217

0, /* tp_hash */

9218

0, /* tp_call */

9219

(reprfunc)swig_varlink_str, /* tp_str */

9220

0, /* tp_getattro */

9221

0, /* tp_setattro */

9222

0, /* tp_as_buffer */

9223

0, /* tp_flags */

9224

varlink__doc__, /* tp_doc */

9225

0, /* tp_traverse */

9226

0, /* tp_clear */

9227

0, /* tp_richcompare */

9228

0, /* tp_weaklistoffset */

9229

#if PY_VERSION_HEX >= 0x02020000

9230

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */

9231

#endif

9232

#if PY_VERSION_HEX >= 0x02030000

9233

0, /* tp_del */

9234

#endif

9235

#ifdef COUNT_ALLOCS

9236

0,0,0,0 /* tp_alloc -> tp_next */

9237

#endif

9238

};

9239

varlink_type = tmp;

9240

varlink_type.ob_type = &PyType_Type;

9241

type_init = 1;

9242

}

9243

return &varlink_type;

9244

}

9245

9246

/* Create a variable linking object for use later */

9247

SWIGINTERN PyObject *

9248

SWIG_Python_newvarlink(void) {

9249

swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());

9250

if (result) {

9251

result->vars = 0;

9252

}

9253

return ((PyObject*) result);

9254

}

9255

9256

SWIGINTERN void

9257

SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {

9258

swig_varlinkobject *v = (swig_varlinkobject *) p;

9259

swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));

9260

if (gv) {

9261

size_t size = strlen(name)+1;

9262

gv->name = (char *)malloc(size);

9263

if (gv->name) {

9264

strncpy(gv->name,name,size);

9265

gv->get_attr = get_attr;

9266

gv->set_attr = set_attr;

9267

gv->next = v->vars;

9268

}

9269

}

9270

v->vars = gv;

9271

}

9272

9273

SWIGINTERN PyObject *

9274

SWIG_globals() {

9275

static PyObject *_SWIG_globals = 0;

9276

if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();

9277

return _SWIG_globals;

9278

}

9279

9280

/* -----------------------------------------------------------------------------

9281

* constants/methods manipulation

9282

* ----------------------------------------------------------------------------- */

9283

9284

/* Install Constants */

9285

SWIGINTERN void

9286

SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {

9287

PyObject *obj = 0;

9288

size_t i;

9289

for (i = 0; constants[i].type; ++i) {

9290

switch(constants[i].type) {

9291

case SWIG_PY_POINTER:

9292

obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);

9293

break;

9294

case SWIG_PY_BINARY:

9295

obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));

9296

break;

9297

default:

9298

obj = 0;

9299

break;

9300

}

9301

if (obj) {

9302

PyDict_SetItemString(d, constants[i].name, obj);

9303

Py_DECREF(obj);

9304

}

9305

}

9306

}

9307

9308

/* -----------------------------------------------------------------------------*/

9309

/* Fix SwigMethods to carry the callback ptrs when needed */

9310

/* -----------------------------------------------------------------------------*/

9311

9312

SWIGINTERN void

9313

SWIG_Python_FixMethods(PyMethodDef *methods,

9314

swig_const_info *const_table,

9315

swig_type_info **types,

9316

swig_type_info **types_initial) {

9317

size_t i;

9318

for (i = 0; methods[i].ml_name; ++i) {

9319

const char *c = methods[i].ml_doc;

9320

if (c && (c = strstr(c, "swig_ptr: "))) {

9321

int j;

9322

swig_const_info *ci = 0;

9323

const char *name = c + 10;

9324

for (j = 0; const_table[j].type; ++j) {

9325

if (strncmp(const_table[j].name, name,

9326

strlen(const_table[j].name)) == 0) {

9327

ci = &(const_table[j]);

9328

break;

9329

}

9330

}

9331

if (ci) {

9332

size_t shift = (ci->ptype) - types;

9333

swig_type_info *ty = types_initial[shift];

9334

size_t ldoc = (c - methods[i].ml_doc);

9335

size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;

9336

char *ndoc = (char*)malloc(ldoc + lptr + 10);

9337

if (ndoc) {

9338

char *buff = ndoc;

9339

void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;

9340

if (ptr) {

9341

strncpy(buff, methods[i].ml_doc, ldoc);

9342

buff += ldoc;

9343

strncpy(buff, "swig_ptr: ", 10);

9344

buff += 10;

9345

SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);

9346

methods[i].ml_doc = ndoc;

9347

}

9348

}

9349

}

9350

}

9351

}

9352

}

9353

9354

#ifdef __cplusplus

9355

}

9356

#endif

9357

9358

/* -----------------------------------------------------------------------------*

9359

* Partial Init method

9360

* -----------------------------------------------------------------------------*/

9361

9362

#ifdef __cplusplus

9363

extern "C"

9364

#endif

9365

SWIGEXPORT void SWIG_init(void) {

9366

PyObject *m, *d;

9367

9368

/* Fix SwigMethods to carry the callback ptrs when needed */

9369

SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);

9370

9371

m = Py_InitModule((char *) SWIG_name, SwigMethods);

9372

d = PyModule_GetDict(m);

9373

9374

SWIG_InitializeModule(0);

9375

SWIG_InstallConstants(d,swig_const_table);

9376

9377

9378

SWIG_Python_SetConstant(d, "CC_BUTTON_OUTSIDE_BORDER",SWIG_From_int(static_cast< int >(wxCC_BUTTON_OUTSIDE_BORDER)));

9379

SWIG_Python_SetConstant(d, "CC_POPUP_ON_MOUSE_UP",SWIG_From_int(static_cast< int >(wxCC_POPUP_ON_MOUSE_UP)));

9380

SWIG_Python_SetConstant(d, "CC_NO_TEXT_AUTO_SELECT",SWIG_From_int(static_cast< int >(wxCC_NO_TEXT_AUTO_SELECT)));

9381

SWIG_Python_SetConstant(d, "CC_MF_ON_BUTTON",SWIG_From_int(static_cast< int >(wxCC_MF_ON_BUTTON)));

9382

SWIG_Python_SetConstant(d, "CC_MF_ON_CLICK_AREA",SWIG_From_int(static_cast< int >(wxCC_MF_ON_CLICK_AREA)));

9383

SWIG_Python_SetConstant(d, "ComboCtrlFeatures_MovableButton",SWIG_From_int(static_cast< int >(wxComboCtrlFeatures::MovableButton)));

9384

SWIG_Python_SetConstant(d, "ComboCtrlFeatures_BitmapButton",SWIG_From_int(static_cast< int >(wxComboCtrlFeatures::BitmapButton)));

9385

SWIG_Python_SetConstant(d, "ComboCtrlFeatures_ButtonSpacing",SWIG_From_int(static_cast< int >(wxComboCtrlFeatures::ButtonSpacing)));

9386

SWIG_Python_SetConstant(d, "ComboCtrlFeatures_TextIndent",SWIG_From_int(static_cast< int >(wxComboCtrlFeatures::TextIndent)));

9387

SWIG_Python_SetConstant(d, "ComboCtrlFeatures_PaintControl",SWIG_From_int(static_cast< int >(wxComboCtrlFeatures::PaintControl)));

9388

SWIG_Python_SetConstant(d, "ComboCtrlFeatures_PaintWritable",SWIG_From_int(static_cast< int >(wxComboCtrlFeatures::PaintWritable)));

9389

SWIG_Python_SetConstant(d, "ComboCtrlFeatures_Borderless",SWIG_From_int(static_cast< int >(wxComboCtrlFeatures::Borderless)));

9390

SWIG_Python_SetConstant(d, "ComboCtrlFeatures_All",SWIG_From_int(static_cast< int >(wxComboCtrlFeatures::All)));

9391

SWIG_Python_SetConstant(d, "ComboCtrl_Hidden",SWIG_From_int(static_cast< int >(wxPyComboCtrl::Hidden)));

9392

SWIG_Python_SetConstant(d, "ComboCtrl_Animating",SWIG_From_int(static_cast< int >(wxPyComboCtrl::Animating)));

9393

SWIG_Python_SetConstant(d, "ComboCtrl_Visible",SWIG_From_int(static_cast< int >(wxPyComboCtrl::Visible)));

9394

SWIG_Python_SetConstant(d, "ComboCtrl_ShowBelow",SWIG_From_int(static_cast< int >(wxPyComboCtrl::ShowBelow)));

9395

SWIG_Python_SetConstant(d, "ComboCtrl_ShowAbove",SWIG_From_int(static_cast< int >(wxPyComboCtrl::ShowAbove)));

9396

SWIG_Python_SetConstant(d, "ComboCtrl_CanDeferShow",SWIG_From_int(static_cast< int >(wxPyComboCtrl::CanDeferShow)));

9397

SWIG_Python_SetConstant(d, "ODCB_DCLICK_CYCLES",SWIG_From_int(static_cast< int >(wxODCB_DCLICK_CYCLES)));

9398

SWIG_Python_SetConstant(d, "ODCB_STD_CONTROL_PAINT",SWIG_From_int(static_cast< int >(wxODCB_STD_CONTROL_PAINT)));

9399

SWIG_Python_SetConstant(d, "ODCB_PAINTING_CONTROL",SWIG_From_int(static_cast< int >(wxODCB_PAINTING_CONTROL)));

9400

SWIG_Python_SetConstant(d, "ODCB_PAINTING_SELECTED",SWIG_From_int(static_cast< int >(wxODCB_PAINTING_SELECTED)));

9401

9402

// Map renamed classes back to their common name for OOR

9403

wxPyPtrTypeMap_Add("wxComboCtrl", "wxPyComboCtrl");

9404

wxPyPtrTypeMap_Add("wxComboPopup", "wxPyComboPopup");

9405

wxPyPtrTypeMap_Add("wxOwnerDrawnComboBox", "wxPyOwnerDrawnComboBox");

9406

9407

}

9408