~ubuntu-branches/ubuntu/utopic/wxwidgets2.8/utopic : 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_wxAnimation swig_types[10]

2477

#define SWIGTYPE_p_wxAnimationBase swig_types[11]

2478

#define SWIGTYPE_p_wxAnimationCtrl swig_types[12]

2479

#define SWIGTYPE_p_wxAnimationCtrlBase swig_types[13]

2480

#define SWIGTYPE_p_wxBMPHandler swig_types[14]

2481

#define SWIGTYPE_p_wxBitmap swig_types[15]

2482

#define SWIGTYPE_p_wxBoxSizer swig_types[16]

2483

#define SWIGTYPE_p_wxCURHandler swig_types[17]

2484

#define SWIGTYPE_p_wxChildFocusEvent swig_types[18]

2485

#define SWIGTYPE_p_wxClipboardTextEvent swig_types[19]

2486

#define SWIGTYPE_p_wxCloseEvent swig_types[20]

2487

#define SWIGTYPE_p_wxColour swig_types[21]

2488

#define SWIGTYPE_p_wxCommandEvent swig_types[22]

2489

#define SWIGTYPE_p_wxContextMenuEvent swig_types[23]

2490

#define SWIGTYPE_p_wxControl swig_types[24]

2491

#define SWIGTYPE_p_wxControlWithItems swig_types[25]

2492

#define SWIGTYPE_p_wxDC swig_types[26]

2493

#define SWIGTYPE_p_wxDateEvent swig_types[27]

2494

#define SWIGTYPE_p_wxDisplayChangedEvent swig_types[28]

2495

#define SWIGTYPE_p_wxDropFilesEvent swig_types[29]

2496

#define SWIGTYPE_p_wxDuplexMode swig_types[30]

2497

#define SWIGTYPE_p_wxEraseEvent swig_types[31]

2498

#define SWIGTYPE_p_wxEvent swig_types[32]

2499

#define SWIGTYPE_p_wxEvtHandler swig_types[33]

2500

#define SWIGTYPE_p_wxFSFile swig_types[34]

2501

#define SWIGTYPE_p_wxFileSystem swig_types[35]

2502

#define SWIGTYPE_p_wxFlexGridSizer swig_types[36]

2503

#define SWIGTYPE_p_wxFocusEvent swig_types[37]

2504

#define SWIGTYPE_p_wxGBSizerItem swig_types[38]

2505

#define SWIGTYPE_p_wxGIFHandler swig_types[39]

2506

#define SWIGTYPE_p_wxGridBagSizer swig_types[40]

2507

#define SWIGTYPE_p_wxGridSizer swig_types[41]

2508

#define SWIGTYPE_p_wxICOHandler swig_types[42]

2509

#define SWIGTYPE_p_wxIconizeEvent swig_types[43]

2510

#define SWIGTYPE_p_wxIdleEvent swig_types[44]

2511

#define SWIGTYPE_p_wxImage swig_types[45]

2512

#define SWIGTYPE_p_wxImageHandler swig_types[46]

2513

#define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[47]

2514

#define SWIGTYPE_p_wxInitDialogEvent swig_types[48]

2515

#define SWIGTYPE_p_wxInputStream swig_types[49]

2516

#define SWIGTYPE_p_wxJPEGHandler swig_types[50]

2517

#define SWIGTYPE_p_wxKeyEvent swig_types[51]

2518

#define SWIGTYPE_p_wxLayoutConstraints swig_types[52]

2519

#define SWIGTYPE_p_wxMaximizeEvent swig_types[53]

2520

#define SWIGTYPE_p_wxMenu swig_types[54]

2521

#define SWIGTYPE_p_wxMenuBar swig_types[55]

2522

#define SWIGTYPE_p_wxMenuEvent swig_types[56]

2523

#define SWIGTYPE_p_wxMenuItem swig_types[57]

2524

#define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[58]

2525

#define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[59]

2526

#define SWIGTYPE_p_wxMouseEvent swig_types[60]

2527

#define SWIGTYPE_p_wxMoveEvent swig_types[61]

2528

#define SWIGTYPE_p_wxNavigationKeyEvent swig_types[62]

2529

#define SWIGTYPE_p_wxNcPaintEvent swig_types[63]

2530

#define SWIGTYPE_p_wxNotifyEvent swig_types[64]

2531

#define SWIGTYPE_p_wxObject swig_types[65]

2532

#define SWIGTYPE_p_wxPCXHandler swig_types[66]

2533

#define SWIGTYPE_p_wxPNGHandler swig_types[67]

2534

#define SWIGTYPE_p_wxPNMHandler swig_types[68]

2535

#define SWIGTYPE_p_wxPaintEvent swig_types[69]

2536

#define SWIGTYPE_p_wxPaletteChangedEvent swig_types[70]

2537

#define SWIGTYPE_p_wxPaperSize swig_types[71]

2538

#define SWIGTYPE_p_wxPoint swig_types[72]

2539

#define SWIGTYPE_p_wxPyApp swig_types[73]

2540

#define SWIGTYPE_p_wxPyCommandEvent swig_types[74]

2541

#define SWIGTYPE_p_wxPyEvent swig_types[75]

2542

#define SWIGTYPE_p_wxPyEvtHandler swig_types[76]

2543

#define SWIGTYPE_p_wxPyImageHandler swig_types[77]

2544

#define SWIGTYPE_p_wxPySizer swig_types[78]

2545

#define SWIGTYPE_p_wxPyValidator swig_types[79]

2546

#define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[80]

2547

#define SWIGTYPE_p_wxScrollEvent swig_types[81]

2548

#define SWIGTYPE_p_wxScrollWinEvent swig_types[82]

2549

#define SWIGTYPE_p_wxSetCursorEvent swig_types[83]

2550

#define SWIGTYPE_p_wxShowEvent swig_types[84]

2551

#define SWIGTYPE_p_wxSize swig_types[85]

2552

#define SWIGTYPE_p_wxSizeEvent swig_types[86]

2553

#define SWIGTYPE_p_wxSizer swig_types[87]

2554

#define SWIGTYPE_p_wxSizerItem swig_types[88]

2555

#define SWIGTYPE_p_wxStaticBoxSizer swig_types[89]

2556

#define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[90]

2557

#define SWIGTYPE_p_wxSysColourChangedEvent swig_types[91]

2558

#define SWIGTYPE_p_wxTGAHandler swig_types[92]

2559

#define SWIGTYPE_p_wxTIFFHandler swig_types[93]

2560

#define SWIGTYPE_p_wxUpdateUIEvent swig_types[94]

2561

#define SWIGTYPE_p_wxValidator swig_types[95]

2562

#define SWIGTYPE_p_wxWindow swig_types[96]

2563

#define SWIGTYPE_p_wxWindowCreateEvent swig_types[97]

2564

#define SWIGTYPE_p_wxWindowDestroyEvent swig_types[98]

2565

#define SWIGTYPE_p_wxXPMHandler swig_types[99]

2566

static swig_type_info *swig_types[101];

2567

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

2568

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

2569

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

2570

2571

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

2572

2573

#if (PY_VERSION_HEX <= 0x02000000)

2574

# if !defined(SWIG_PYTHON_CLASSIC)

2575

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

2576

# endif

2577

#endif

2578

#if (PY_VERSION_HEX <= 0x02020000)

2579

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

2580

#endif

2581

#if (PY_VERSION_HEX <= 0x02020000)

2582

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

2583

#endif

2584

#ifndef METH_O

2585

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

2586

#endif

2587

2588

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

2589

@(target):= _animate.so

2590

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

2591

#define SWIG_init init_animate

2592

2593

#define SWIG_name "_animate"

2594

2595

#define SWIGVERSION 0x010329

2596

2597

2598

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

2599

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

2600

2601

2602

#include <stdexcept>

2603

2604

2605

namespace swig {

2606

class PyObject_ptr {

2607

protected:

2608

PyObject *_obj;

2609

2610

public:

2611

PyObject_ptr() :_obj(0)

2612

{

2613

}

2614

2615

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

2616

{

2617

Py_XINCREF(_obj);

2618

}

2619

2620

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

2621

{

2622

if (initial_ref) Py_XINCREF(_obj);

2623

}

2624

2625

PyObject_ptr & operator=(const PyObject_ptr& item)

2626

{

2627

Py_XINCREF(item._obj);

2628

Py_XDECREF(_obj);

2629

_obj = item._obj;

2630

return *this;

2631

}

2632

2633

~PyObject_ptr()

2634

{

2635

Py_XDECREF(_obj);

2636

}

2637

2638

operator PyObject *() const

2639

{

2640

return _obj;

2641

}

2642

2643

PyObject *operator->() const

2644

{

2645

return _obj;

2646

}

2647

};

2648

}

2649

2650

2651

namespace swig {

2652

struct PyObject_var : PyObject_ptr {

2653

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

2654

2655

PyObject_var & operator = (PyObject* obj)

2656

{

2657

Py_XDECREF(_obj);

2658

_obj = obj;

2659

return *this;

2660

}

2661

};

2662

}

2663

2664

2665

#include "wx/wxPython/wxPython.h"

2666

#include "wx/wxPython/pyclasses.h"

2667

#include "wx/wxPython/pyistream.h"

2668

#include <wx/animate.h>

2669

2670

static const wxString wxPyAnimationCtrlNameStr(wxAnimationCtrlNameStr);

2671

static const wxString wxPyEmptyString(wxEmptyString);

2672

2673

#define SWIG_From_long PyInt_FromLong

2674

2675

2676

SWIGINTERNINLINE PyObject *

2677

SWIG_From_int (int value)

2678

{

2679

return SWIG_From_long (value);

2680

}

2681

2682

2683

#include <limits.h>

2684

#ifndef LLONG_MIN

2685

# define LLONG_MIN LONG_LONG_MIN

2686

#endif

2687

#ifndef LLONG_MAX

2688

# define LLONG_MAX LONG_LONG_MAX

2689

#endif

2690

#ifndef ULLONG_MAX

2691

# define ULLONG_MAX ULONG_LONG_MAX

2692

#endif

2693

2694

2695

SWIGINTERN int

2696

SWIG_AsVal_long (PyObject* obj, long* val)

2697

{

2698

if (PyNumber_Check(obj)) {

2699

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

2700

return SWIG_OK;

2701

}

2702

return SWIG_TypeError;

2703

}

2704

2705

2706

SWIGINTERN int

2707

SWIG_AsVal_int (PyObject * obj, int *val)

2708

{

2709

long v;

2710

int res = SWIG_AsVal_long (obj, &v);

2711

if (SWIG_IsOK(res)) {

2712

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

2713

return SWIG_OverflowError;

2714

} else {

2715

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

2716

}

2717

}

2718

return res;

2719

}

2720

2721

SWIGINTERN wxAnimation *new_wxAnimation__SWIG_1(wxString const &name,wxAnimationType type=wxANIMATION_TYPE_ANY){

2722

wxAnimation* ani = new wxAnimation();

2723

ani->LoadFile(name, type);

2724

return ani;

2725

}

2726

// for backwards compatibility

2727

#ifndef wxAN_FIT_ANIMATION

2728

#define wxAN_FIT_ANIMATION 0x0010

2729

#endif

2730

2731

2732

SWIGINTERN int

2733

SWIG_AsVal_bool (PyObject *obj, bool *val)

2734

{

2735

if (obj == Py_True) {

2736

if (val) *val = true;

2737

return SWIG_OK;

2738

} else if (obj == Py_False) {

2739

if (val) *val = false;

2740

return SWIG_OK;

2741

} else {

2742

long v = 0;

2743

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

2744

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

2745

return res;

2746

}

2747

}

2748

2749

#ifdef __cplusplus

2750

extern "C" {

2751

#endif

2752

SWIGINTERN int AnimationCtrlNameStr_set(PyObject *) {

2753

SWIG_Error(SWIG_AttributeError,"Variable AnimationCtrlNameStr is read-only.");

2754

return 1;

2755

}

2756

2757

2758

SWIGINTERN PyObject *AnimationCtrlNameStr_get(void) {

2759

PyObject *pyobj = 0;

2760

2761

{

2762

#if wxUSE_UNICODE

2763

pyobj = PyUnicode_FromWideChar((&wxPyAnimationCtrlNameStr)->c_str(), (&wxPyAnimationCtrlNameStr)->Len());

2764

#else

2765

pyobj = PyString_FromStringAndSize((&wxPyAnimationCtrlNameStr)->c_str(), (&wxPyAnimationCtrlNameStr)->Len());

2766

#endif

2767

}

2768

return pyobj;

2769

}

2770

2771

2772

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

2773

PyObject *resultobj = 0;

2774

wxAnimationBase *arg1 = (wxAnimationBase *) 0 ;

2775

void *argp1 = 0 ;

2776

int res1 = 0 ;

2777

PyObject *swig_obj[1] ;

2778

2779

if (!args) SWIG_fail;

2780

swig_obj[0] = args;

2781

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

2782

if (!SWIG_IsOK(res1)) {

2783

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

2784

}

2785

arg1 = reinterpret_cast< wxAnimationBase * >(argp1);

2786

{

2787

PyThreadState* __tstate = wxPyBeginAllowThreads();

2788

delete arg1;

2789

2790

wxPyEndAllowThreads(__tstate);

2791

if (PyErr_Occurred()) SWIG_fail;

2792

}

2793

resultobj = SWIG_Py_Void();

2794

return resultobj;

2795

fail:

2796

return NULL;

2797

}

2798

2799

2800

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

2801

PyObject *resultobj = 0;

2802

wxAnimationBase *arg1 = (wxAnimationBase *) 0 ;

2803

bool result;

2804

void *argp1 = 0 ;

2805

int res1 = 0 ;

2806

PyObject *swig_obj[1] ;

2807

2808

if (!args) SWIG_fail;

2809

swig_obj[0] = args;

2810

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

2811

if (!SWIG_IsOK(res1)) {

2812

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

2813

}

2814

arg1 = reinterpret_cast< wxAnimationBase * >(argp1);

2815

{

2816

PyThreadState* __tstate = wxPyBeginAllowThreads();

2817

result = (bool)((wxAnimationBase const *)arg1)->IsOk();

2818

wxPyEndAllowThreads(__tstate);

2819

if (PyErr_Occurred()) SWIG_fail;

2820

}

2821

{

2822

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

2823

}

2824

return resultobj;

2825

fail:

2826

return NULL;

2827

}

2828

2829

2830

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

2831

PyObject *resultobj = 0;

2832

wxAnimationBase *arg1 = (wxAnimationBase *) 0 ;

2833

int arg2 ;

2834

int result;

2835

void *argp1 = 0 ;

2836

int res1 = 0 ;

2837

int val2 ;

2838

int ecode2 = 0 ;

2839

PyObject * obj0 = 0 ;

2840

PyObject * obj1 = 0 ;

2841

char * kwnames[] = {

2842

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

2843

};

2844

2845

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

2846

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

2847

if (!SWIG_IsOK(res1)) {

2848

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

2849

}

2850

arg1 = reinterpret_cast< wxAnimationBase * >(argp1);

2851

ecode2 = SWIG_AsVal_int(obj1, &val2);

2852

if (!SWIG_IsOK(ecode2)) {

2853

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

2854

}

2855

arg2 = static_cast< int >(val2);

2856

{

2857

PyThreadState* __tstate = wxPyBeginAllowThreads();

2858

result = (int)((wxAnimationBase const *)arg1)->GetDelay(arg2);

2859

wxPyEndAllowThreads(__tstate);

2860

if (PyErr_Occurred()) SWIG_fail;

2861

}

2862

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

2863

return resultobj;

2864

fail:

2865

return NULL;

2866

}

2867

2868

2869

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

2870

PyObject *resultobj = 0;

2871

wxAnimationBase *arg1 = (wxAnimationBase *) 0 ;

2872

int result;

2873

void *argp1 = 0 ;

2874

int res1 = 0 ;

2875

PyObject *swig_obj[1] ;

2876

2877

if (!args) SWIG_fail;

2878

swig_obj[0] = args;

2879

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

2880

if (!SWIG_IsOK(res1)) {

2881

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

2882

}

2883

arg1 = reinterpret_cast< wxAnimationBase * >(argp1);

2884

{

2885

PyThreadState* __tstate = wxPyBeginAllowThreads();

2886

result = (int)((wxAnimationBase const *)arg1)->GetFrameCount();

2887

wxPyEndAllowThreads(__tstate);

2888

if (PyErr_Occurred()) SWIG_fail;

2889

}

2890

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

2891

return resultobj;

2892

fail:

2893

return NULL;

2894

}

2895

2896

2897

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

2898

PyObject *resultobj = 0;

2899

wxAnimationBase *arg1 = (wxAnimationBase *) 0 ;

2900

int arg2 ;

2901

SwigValueWrapper<wxImage > result;

2902

void *argp1 = 0 ;

2903

int res1 = 0 ;

2904

int val2 ;

2905

int ecode2 = 0 ;

2906

PyObject * obj0 = 0 ;

2907

PyObject * obj1 = 0 ;

2908

char * kwnames[] = {

2909

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

2910

};

2911

2912

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

2913

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

2914

if (!SWIG_IsOK(res1)) {

2915

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

2916

}

2917

arg1 = reinterpret_cast< wxAnimationBase * >(argp1);

2918

ecode2 = SWIG_AsVal_int(obj1, &val2);

2919

if (!SWIG_IsOK(ecode2)) {

2920

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

2921

}

2922

arg2 = static_cast< int >(val2);

2923

{

2924

PyThreadState* __tstate = wxPyBeginAllowThreads();

2925

result = ((wxAnimationBase const *)arg1)->GetFrame(arg2);

2926

wxPyEndAllowThreads(__tstate);

2927

if (PyErr_Occurred()) SWIG_fail;

2928

}

2929

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

2930

return resultobj;

2931

fail:

2932

return NULL;

2933

}

2934

2935

2936

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

2937

PyObject *resultobj = 0;

2938

wxAnimationBase *arg1 = (wxAnimationBase *) 0 ;

2939

wxSize result;

2940

void *argp1 = 0 ;

2941

int res1 = 0 ;

2942

PyObject *swig_obj[1] ;

2943

2944

if (!args) SWIG_fail;

2945

swig_obj[0] = args;

2946

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

2947

if (!SWIG_IsOK(res1)) {

2948

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

2949

}

2950

arg1 = reinterpret_cast< wxAnimationBase * >(argp1);

2951

{

2952

PyThreadState* __tstate = wxPyBeginAllowThreads();

2953

result = ((wxAnimationBase const *)arg1)->GetSize();

2954

wxPyEndAllowThreads(__tstate);

2955

if (PyErr_Occurred()) SWIG_fail;

2956

}

2957

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

2958

return resultobj;

2959

fail:

2960

return NULL;

2961

}

2962

2963

2964

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

2965

PyObject *resultobj = 0;

2966

wxAnimationBase *arg1 = (wxAnimationBase *) 0 ;

2967

wxString *arg2 = 0 ;

2968

wxAnimationType arg3 = (wxAnimationType) wxANIMATION_TYPE_ANY ;

2969

bool result;

2970

void *argp1 = 0 ;

2971

int res1 = 0 ;

2972

bool temp2 = false ;

2973

int val3 ;

2974

int ecode3 = 0 ;

2975

PyObject * obj0 = 0 ;

2976

PyObject * obj1 = 0 ;

2977

PyObject * obj2 = 0 ;

2978

char * kwnames[] = {

2979

(char *) "self",(char *) "name",(char *) "type", NULL

2980

};

2981

2982

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

2983

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

2984

if (!SWIG_IsOK(res1)) {

2985

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

2986

}

2987

arg1 = reinterpret_cast< wxAnimationBase * >(argp1);

2988

{

2989

arg2 = wxString_in_helper(obj1);

2990

if (arg2 == NULL) SWIG_fail;

2991

temp2 = true;

2992

}

2993

if (obj2) {

2994

ecode3 = SWIG_AsVal_int(obj2, &val3);

2995

if (!SWIG_IsOK(ecode3)) {

2996

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

2997

}

2998

arg3 = static_cast< wxAnimationType >(val3);

2999

}

3000

{

3001

PyThreadState* __tstate = wxPyBeginAllowThreads();

3002

result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);

3003

wxPyEndAllowThreads(__tstate);

3004

if (PyErr_Occurred()) SWIG_fail;

3005

}

3006

{

3007

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

3008

}

3009

{

3010

if (temp2)

3011

delete arg2;

3012

}

3013

return resultobj;

3014

fail:

3015

{

3016

if (temp2)

3017

delete arg2;

3018

}

3019

return NULL;

3020

}

3021

3022

3023

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

3024

PyObject *resultobj = 0;

3025

wxAnimationBase *arg1 = (wxAnimationBase *) 0 ;

3026

wxInputStream *arg2 = 0 ;

3027

wxAnimationType arg3 = (wxAnimationType) wxANIMATION_TYPE_ANY ;

3028

bool result;

3029

void *argp1 = 0 ;

3030

int res1 = 0 ;

3031

wxPyInputStream *temp2 ;

3032

bool created2 ;

3033

int val3 ;

3034

int ecode3 = 0 ;

3035

PyObject * obj0 = 0 ;

3036

PyObject * obj1 = 0 ;

3037

PyObject * obj2 = 0 ;

3038

char * kwnames[] = {

3039

(char *) "self",(char *) "stream",(char *) "type", NULL

3040

};

3041

3042

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

3043

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

3044

if (!SWIG_IsOK(res1)) {

3045

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

3046

}

3047

arg1 = reinterpret_cast< wxAnimationBase * >(argp1);

3048

{

3049

if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {

3050

arg2 = temp2->m_wxis;

3051

created2 = false;

3052

} else {

3053

PyErr_Clear(); // clear the failure of the wxPyConvert above

3054

arg2 = wxPyCBInputStream_create(obj1, false);

3055

if (arg2 == NULL) {

3056

PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");

3057

SWIG_fail;

3058

}

3059

created2 = true;

3060

}

3061

}

3062

if (obj2) {

3063

ecode3 = SWIG_AsVal_int(obj2, &val3);

3064

if (!SWIG_IsOK(ecode3)) {

3065

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

3066

}

3067

arg3 = static_cast< wxAnimationType >(val3);

3068

}

3069

{

3070

PyThreadState* __tstate = wxPyBeginAllowThreads();

3071

result = (bool)(arg1)->Load(*arg2,arg3);

3072

wxPyEndAllowThreads(__tstate);

3073

if (PyErr_Occurred()) SWIG_fail;

3074

}

3075

{

3076

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

3077

}

3078

{

3079

if (created2) delete arg2;

3080

}

3081

return resultobj;

3082

fail:

3083

{

3084

if (created2) delete arg2;

3085

}

3086

return NULL;

3087

}

3088

3089

3090

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

3091

PyObject *obj;

3092

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

3093

SWIG_TypeNewClientData(SWIGTYPE_p_wxAnimationBase, SWIG_NewClientData(obj));

3094

return SWIG_Py_Void();

3095

}

3096

3097

SWIGINTERN PyObject *_wrap_new_Animation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {

3098

PyObject *resultobj = 0;

3099

wxAnimation *result = 0 ;

3100

3101

if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;

3102

{

3103

PyThreadState* __tstate = wxPyBeginAllowThreads();

3104

result = (wxAnimation *)new wxAnimation();

3105

wxPyEndAllowThreads(__tstate);

3106

if (PyErr_Occurred()) SWIG_fail;

3107

}

3108

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

3109

return resultobj;

3110

fail:

3111

return NULL;

3112

}

3113

3114

3115

SWIGINTERN PyObject *_wrap_new_Animation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {

3116

PyObject *resultobj = 0;

3117

wxString *arg1 = 0 ;

3118

wxAnimationType arg2 = (wxAnimationType) wxANIMATION_TYPE_ANY ;

3119

wxAnimation *result = 0 ;

3120

bool temp1 = false ;

3121

int val2 ;

3122

int ecode2 = 0 ;

3123

3124

if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;

3125

{

3126

arg1 = wxString_in_helper(swig_obj[0]);

3127

if (arg1 == NULL) SWIG_fail;

3128

temp1 = true;

3129

}

3130

if (swig_obj[1]) {

3131

ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);

3132

if (!SWIG_IsOK(ecode2)) {

3133

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

3134

}

3135

arg2 = static_cast< wxAnimationType >(val2);

3136

}

3137

{

3138

PyThreadState* __tstate = wxPyBeginAllowThreads();

3139

result = (wxAnimation *)new_wxAnimation__SWIG_1((wxString const &)*arg1,arg2);

3140

wxPyEndAllowThreads(__tstate);

3141

if (PyErr_Occurred()) SWIG_fail;

3142

}

3143

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

3144

{

3145

if (temp1)

3146

delete arg1;

3147

}

3148

return resultobj;

3149

fail:

3150

{

3151

if (temp1)

3152

delete arg1;

3153

}

3154

return NULL;

3155

}

3156

3157

3158

SWIGINTERN PyObject *_wrap_new_Animation(PyObject *self, PyObject *args) {

3159

int argc;

3160

PyObject *argv[3];

3161

3162

if (!(argc = SWIG_Python_UnpackTuple(args,"new_Animation",0,2,argv))) SWIG_fail;

3163

--argc;

3164

if (argc == 0) {

3165

return _wrap_new_Animation__SWIG_0(self, argc, argv);

3166

}

3167

if ((argc >= 1) && (argc <= 2)) {

3168

return _wrap_new_Animation__SWIG_1(self, argc, argv);

3169

}

3170

3171

fail:

3172

SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_Animation'");

3173

return NULL;

3174

}

3175

3176

3177

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

3178

PyObject *resultobj = 0;

3179

wxAnimation *arg1 = (wxAnimation *) 0 ;

3180

void *argp1 = 0 ;

3181

int res1 = 0 ;

3182

PyObject *swig_obj[1] ;

3183

3184

if (!args) SWIG_fail;

3185

swig_obj[0] = args;

3186

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

3187

if (!SWIG_IsOK(res1)) {

3188

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

3189

}

3190

arg1 = reinterpret_cast< wxAnimation * >(argp1);

3191

{

3192

PyThreadState* __tstate = wxPyBeginAllowThreads();

3193

delete arg1;

3194

3195

wxPyEndAllowThreads(__tstate);

3196

if (PyErr_Occurred()) SWIG_fail;

3197

}

3198

resultobj = SWIG_Py_Void();

3199

return resultobj;

3200

fail:

3201

return NULL;

3202

}

3203

3204

3205

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

3206

PyObject *resultobj = 0;

3207

wxAnimation *arg1 = (wxAnimation *) 0 ;

3208

int arg2 ;

3209

wxPoint result;

3210

void *argp1 = 0 ;

3211

int res1 = 0 ;

3212

int val2 ;

3213

int ecode2 = 0 ;

3214

PyObject * obj0 = 0 ;

3215

PyObject * obj1 = 0 ;

3216

char * kwnames[] = {

3217

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

3218

};

3219

3220

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

3221

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

3222

if (!SWIG_IsOK(res1)) {

3223

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

3224

}

3225

arg1 = reinterpret_cast< wxAnimation * >(argp1);

3226

ecode2 = SWIG_AsVal_int(obj1, &val2);

3227

if (!SWIG_IsOK(ecode2)) {

3228

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

3229

}

3230

arg2 = static_cast< int >(val2);

3231

{

3232

PyThreadState* __tstate = wxPyBeginAllowThreads();

3233

result = ((wxAnimation const *)arg1)->GetFramePosition(arg2);

3234

wxPyEndAllowThreads(__tstate);

3235

if (PyErr_Occurred()) SWIG_fail;

3236

}

3237

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

3238

return resultobj;

3239

fail:

3240

return NULL;

3241

}

3242

3243

3244

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

3245

PyObject *resultobj = 0;

3246

wxAnimation *arg1 = (wxAnimation *) 0 ;

3247

int arg2 ;

3248

wxSize result;

3249

void *argp1 = 0 ;

3250

int res1 = 0 ;

3251

int val2 ;

3252

int ecode2 = 0 ;

3253

PyObject * obj0 = 0 ;

3254

PyObject * obj1 = 0 ;

3255

char * kwnames[] = {

3256

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

3257

};

3258

3259

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

3260

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

3261

if (!SWIG_IsOK(res1)) {

3262

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

3263

}

3264

arg1 = reinterpret_cast< wxAnimation * >(argp1);

3265

ecode2 = SWIG_AsVal_int(obj1, &val2);

3266

if (!SWIG_IsOK(ecode2)) {

3267

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

3268

}

3269

arg2 = static_cast< int >(val2);

3270

{

3271

PyThreadState* __tstate = wxPyBeginAllowThreads();

3272

result = ((wxAnimation const *)arg1)->GetFrameSize(arg2);

3273

wxPyEndAllowThreads(__tstate);

3274

if (PyErr_Occurred()) SWIG_fail;

3275

}

3276

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

3277

return resultobj;

3278

fail:

3279

return NULL;

3280

}

3281

3282

3283

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

3284

PyObject *resultobj = 0;

3285

wxAnimation *arg1 = (wxAnimation *) 0 ;

3286

int arg2 ;

3287

wxAnimationDisposal result;

3288

void *argp1 = 0 ;

3289

int res1 = 0 ;

3290

int val2 ;

3291

int ecode2 = 0 ;

3292

PyObject * obj0 = 0 ;

3293

PyObject * obj1 = 0 ;

3294

char * kwnames[] = {

3295

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

3296

};

3297

3298

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

3299

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

3300

if (!SWIG_IsOK(res1)) {

3301

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

3302

}

3303

arg1 = reinterpret_cast< wxAnimation * >(argp1);

3304

ecode2 = SWIG_AsVal_int(obj1, &val2);

3305

if (!SWIG_IsOK(ecode2)) {

3306

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

3307

}

3308

arg2 = static_cast< int >(val2);

3309

{

3310

PyThreadState* __tstate = wxPyBeginAllowThreads();

3311

result = (wxAnimationDisposal)((wxAnimation const *)arg1)->GetDisposalMethod(arg2);

3312

wxPyEndAllowThreads(__tstate);

3313

if (PyErr_Occurred()) SWIG_fail;

3314

}

3315

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

3316

return resultobj;

3317

fail:

3318

return NULL;

3319

}

3320

3321

3322

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

3323

PyObject *resultobj = 0;

3324

wxAnimation *arg1 = (wxAnimation *) 0 ;

3325

int arg2 ;

3326

wxColour result;

3327

void *argp1 = 0 ;

3328

int res1 = 0 ;

3329

int val2 ;

3330

int ecode2 = 0 ;

3331

PyObject * obj0 = 0 ;

3332

PyObject * obj1 = 0 ;

3333

char * kwnames[] = {

3334

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

3335

};

3336

3337

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

3338

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

3339

if (!SWIG_IsOK(res1)) {

3340

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

3341

}

3342

arg1 = reinterpret_cast< wxAnimation * >(argp1);

3343

ecode2 = SWIG_AsVal_int(obj1, &val2);

3344

if (!SWIG_IsOK(ecode2)) {

3345

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

3346

}

3347

arg2 = static_cast< int >(val2);

3348

{

3349

PyThreadState* __tstate = wxPyBeginAllowThreads();

3350

result = ((wxAnimation const *)arg1)->GetTransparentColour(arg2);

3351

wxPyEndAllowThreads(__tstate);

3352

if (PyErr_Occurred()) SWIG_fail;

3353

}

3354

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

3355

return resultobj;

3356

fail:

3357

return NULL;

3358

}

3359

3360

3361

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

3362

PyObject *resultobj = 0;

3363

wxAnimation *arg1 = (wxAnimation *) 0 ;

3364

wxColour result;

3365

void *argp1 = 0 ;

3366

int res1 = 0 ;

3367

PyObject *swig_obj[1] ;

3368

3369

if (!args) SWIG_fail;

3370

swig_obj[0] = args;

3371

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

3372

if (!SWIG_IsOK(res1)) {

3373

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

3374

}

3375

arg1 = reinterpret_cast< wxAnimation * >(argp1);

3376

{

3377

PyThreadState* __tstate = wxPyBeginAllowThreads();

3378

result = ((wxAnimation const *)arg1)->GetBackgroundColour();

3379

wxPyEndAllowThreads(__tstate);

3380

if (PyErr_Occurred()) SWIG_fail;

3381

}

3382

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

3383

return resultobj;

3384

fail:

3385

return NULL;

3386

}

3387

3388

3389

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

3390

PyObject *obj;

3391

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

3392

SWIG_TypeNewClientData(SWIGTYPE_p_wxAnimation, SWIG_NewClientData(obj));

3393

return SWIG_Py_Void();

3394

}

3395

3396

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

3397

return SWIG_Python_InitShadowInstance(args);

3398

}

3399

3400

SWIGINTERN int NullAnimation_set(PyObject *) {

3401

SWIG_Error(SWIG_AttributeError,"Variable NullAnimation is read-only.");

3402

return 1;

3403

}

3404

3405

3406

SWIGINTERN PyObject *NullAnimation_get(void) {

3407

PyObject *pyobj = 0;

3408

3409

pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAnimation), SWIGTYPE_p_wxAnimation, 0 );

3410

return pyobj;

3411

}

3412

3413

3414

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

3415

PyObject *resultobj = 0;

3416

wxAnimationCtrlBase *arg1 = (wxAnimationCtrlBase *) 0 ;

3417

wxString *arg2 = 0 ;

3418

wxAnimationType arg3 = (wxAnimationType) wxANIMATION_TYPE_ANY ;

3419

bool result;

3420

void *argp1 = 0 ;

3421

int res1 = 0 ;

3422

bool temp2 = false ;

3423

int val3 ;

3424

int ecode3 = 0 ;

3425

PyObject * obj0 = 0 ;

3426

PyObject * obj1 = 0 ;

3427

PyObject * obj2 = 0 ;

3428

char * kwnames[] = {

3429

(char *) "self",(char *) "filename",(char *) "type", NULL

3430

};

3431

3432

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

3433

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

3434

if (!SWIG_IsOK(res1)) {

3435

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

3436

}

3437

arg1 = reinterpret_cast< wxAnimationCtrlBase * >(argp1);

3438

{

3439

arg2 = wxString_in_helper(obj1);

3440

if (arg2 == NULL) SWIG_fail;

3441

temp2 = true;

3442

}

3443

if (obj2) {

3444

ecode3 = SWIG_AsVal_int(obj2, &val3);

3445

if (!SWIG_IsOK(ecode3)) {

3446

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

3447

}

3448

arg3 = static_cast< wxAnimationType >(val3);

3449

}

3450

{

3451

PyThreadState* __tstate = wxPyBeginAllowThreads();

3452

result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);

3453

wxPyEndAllowThreads(__tstate);

3454

if (PyErr_Occurred()) SWIG_fail;

3455

}

3456

{

3457

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

3458

}

3459

{

3460

if (temp2)

3461

delete arg2;

3462

}

3463

return resultobj;

3464

fail:

3465

{

3466

if (temp2)

3467

delete arg2;

3468

}

3469

return NULL;

3470

}

3471

3472

3473

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

3474

PyObject *resultobj = 0;

3475

wxAnimationCtrlBase *arg1 = (wxAnimationCtrlBase *) 0 ;

3476

wxAnimation *arg2 = 0 ;

3477

void *argp1 = 0 ;

3478

int res1 = 0 ;

3479

void *argp2 = 0 ;

3480

int res2 = 0 ;

3481

PyObject * obj0 = 0 ;

3482

PyObject * obj1 = 0 ;

3483

char * kwnames[] = {

3484

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

3485

};

3486

3487

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

3488

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

3489

if (!SWIG_IsOK(res1)) {

3490

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

3491

}

3492

arg1 = reinterpret_cast< wxAnimationCtrlBase * >(argp1);

3493

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

3494

if (!SWIG_IsOK(res2)) {

3495

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

3496

}

3497

if (!argp2) {

3498

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

3499

}

3500

arg2 = reinterpret_cast< wxAnimation * >(argp2);

3501

{

3502

PyThreadState* __tstate = wxPyBeginAllowThreads();

3503

(arg1)->SetAnimation((wxAnimation const &)*arg2);

3504

wxPyEndAllowThreads(__tstate);

3505

if (PyErr_Occurred()) SWIG_fail;

3506

}

3507

resultobj = SWIG_Py_Void();

3508

return resultobj;

3509

fail:

3510

return NULL;

3511

}

3512

3513

3514

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

3515

PyObject *resultobj = 0;

3516

wxAnimationCtrlBase *arg1 = (wxAnimationCtrlBase *) 0 ;

3517

wxAnimation result;

3518

void *argp1 = 0 ;

3519

int res1 = 0 ;

3520

PyObject *swig_obj[1] ;

3521

3522

if (!args) SWIG_fail;

3523

swig_obj[0] = args;

3524

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

3525

if (!SWIG_IsOK(res1)) {

3526

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

3527

}

3528

arg1 = reinterpret_cast< wxAnimationCtrlBase * >(argp1);

3529

{

3530

PyThreadState* __tstate = wxPyBeginAllowThreads();

3531

result = ((wxAnimationCtrlBase const *)arg1)->GetAnimation();

3532

wxPyEndAllowThreads(__tstate);

3533

if (PyErr_Occurred()) SWIG_fail;

3534

}

3535

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

3536

return resultobj;

3537

fail:

3538

return NULL;

3539

}

3540

3541

3542

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

3543

PyObject *resultobj = 0;

3544

wxAnimationCtrlBase *arg1 = (wxAnimationCtrlBase *) 0 ;

3545

bool result;

3546

void *argp1 = 0 ;

3547

int res1 = 0 ;

3548

PyObject *swig_obj[1] ;

3549

3550

if (!args) SWIG_fail;

3551

swig_obj[0] = args;

3552

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

3553

if (!SWIG_IsOK(res1)) {

3554

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

3555

}

3556

arg1 = reinterpret_cast< wxAnimationCtrlBase * >(argp1);

3557

{

3558

PyThreadState* __tstate = wxPyBeginAllowThreads();

3559

result = (bool)(arg1)->Play();

3560

wxPyEndAllowThreads(__tstate);

3561

if (PyErr_Occurred()) SWIG_fail;

3562

}

3563

{

3564

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

3565

}

3566

return resultobj;

3567

fail:

3568

return NULL;

3569

}

3570

3571

3572

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

3573

PyObject *resultobj = 0;

3574

wxAnimationCtrlBase *arg1 = (wxAnimationCtrlBase *) 0 ;

3575

void *argp1 = 0 ;

3576

int res1 = 0 ;

3577

PyObject *swig_obj[1] ;

3578

3579

if (!args) SWIG_fail;

3580

swig_obj[0] = args;

3581

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

3582

if (!SWIG_IsOK(res1)) {

3583

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

3584

}

3585

arg1 = reinterpret_cast< wxAnimationCtrlBase * >(argp1);

3586

{

3587

PyThreadState* __tstate = wxPyBeginAllowThreads();

3588

(arg1)->Stop();

3589

wxPyEndAllowThreads(__tstate);

3590

if (PyErr_Occurred()) SWIG_fail;

3591

}

3592

resultobj = SWIG_Py_Void();

3593

return resultobj;

3594

fail:

3595

return NULL;

3596

}

3597

3598

3599

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

3600

PyObject *resultobj = 0;

3601

wxAnimationCtrlBase *arg1 = (wxAnimationCtrlBase *) 0 ;

3602

bool result;

3603

void *argp1 = 0 ;

3604

int res1 = 0 ;

3605

PyObject *swig_obj[1] ;

3606

3607

if (!args) SWIG_fail;

3608

swig_obj[0] = args;

3609

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

3610

if (!SWIG_IsOK(res1)) {

3611

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

3612

}

3613

arg1 = reinterpret_cast< wxAnimationCtrlBase * >(argp1);

3614

{

3615

PyThreadState* __tstate = wxPyBeginAllowThreads();

3616

result = (bool)((wxAnimationCtrlBase const *)arg1)->IsPlaying();

3617

wxPyEndAllowThreads(__tstate);

3618

if (PyErr_Occurred()) SWIG_fail;

3619

}

3620

{

3621

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

3622

}

3623

return resultobj;

3624

fail:

3625

return NULL;

3626

}

3627

3628

3629

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

3630

PyObject *resultobj = 0;

3631

wxAnimationCtrlBase *arg1 = (wxAnimationCtrlBase *) 0 ;

3632

wxBitmap *arg2 = 0 ;

3633

void *argp1 = 0 ;

3634

int res1 = 0 ;

3635

void *argp2 = 0 ;

3636

int res2 = 0 ;

3637

PyObject * obj0 = 0 ;

3638

PyObject * obj1 = 0 ;

3639

char * kwnames[] = {

3640

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

3641

};

3642

3643

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

3644

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

3645

if (!SWIG_IsOK(res1)) {

3646

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

3647

}

3648

arg1 = reinterpret_cast< wxAnimationCtrlBase * >(argp1);

3649

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

3650

if (!SWIG_IsOK(res2)) {

3651

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

3652

}

3653

if (!argp2) {

3654

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

3655

}

3656

arg2 = reinterpret_cast< wxBitmap * >(argp2);

3657

{

3658

PyThreadState* __tstate = wxPyBeginAllowThreads();

3659

(arg1)->SetInactiveBitmap((wxBitmap const &)*arg2);

3660

wxPyEndAllowThreads(__tstate);

3661

if (PyErr_Occurred()) SWIG_fail;

3662

}

3663

resultobj = SWIG_Py_Void();

3664

return resultobj;

3665

fail:

3666

return NULL;

3667

}

3668

3669

3670

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

3671

PyObject *resultobj = 0;

3672

wxAnimationCtrlBase *arg1 = (wxAnimationCtrlBase *) 0 ;

3673

wxBitmap result;

3674

void *argp1 = 0 ;

3675

int res1 = 0 ;

3676

PyObject *swig_obj[1] ;

3677

3678

if (!args) SWIG_fail;

3679

swig_obj[0] = args;

3680

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

3681

if (!SWIG_IsOK(res1)) {

3682

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

3683

}

3684

arg1 = reinterpret_cast< wxAnimationCtrlBase * >(argp1);

3685

{

3686

PyThreadState* __tstate = wxPyBeginAllowThreads();

3687

result = ((wxAnimationCtrlBase const *)arg1)->GetInactiveBitmap();

3688

wxPyEndAllowThreads(__tstate);

3689

if (PyErr_Occurred()) SWIG_fail;

3690

}

3691

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

3692

return resultobj;

3693

fail:

3694

return NULL;

3695

}

3696

3697

3698

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

3699

PyObject *obj;

3700

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

3701

SWIG_TypeNewClientData(SWIGTYPE_p_wxAnimationCtrlBase, SWIG_NewClientData(obj));

3702

return SWIG_Py_Void();

3703

}

3704

3705

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

3706

PyObject *resultobj = 0;

3707

wxWindow *arg1 = (wxWindow *) 0 ;

3708

int arg2 = (int) -1 ;

3709

wxAnimation const &arg3_defvalue = wxNullAnimation ;

3710

wxAnimation *arg3 = (wxAnimation *) &arg3_defvalue ;

3711

wxPoint const &arg4_defvalue = wxDefaultPosition ;

3712

wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;

3713

wxSize const &arg5_defvalue = wxDefaultSize ;

3714

wxSize *arg5 = (wxSize *) &arg5_defvalue ;

3715

long arg6 = (long) wxAC_DEFAULT_STYLE ;

3716

wxString const &arg7_defvalue = wxPyAnimationCtrlNameStr ;

3717

wxString *arg7 = (wxString *) &arg7_defvalue ;

3718

wxAnimationCtrl *result = 0 ;

3719

void *argp1 = 0 ;

3720

int res1 = 0 ;

3721

int val2 ;

3722

int ecode2 = 0 ;

3723

void *argp3 = 0 ;

3724

int res3 = 0 ;

3725

wxPoint temp4 ;

3726

wxSize temp5 ;

3727

long val6 ;

3728

int ecode6 = 0 ;

3729

bool temp7 = false ;

3730

PyObject * obj0 = 0 ;

3731

PyObject * obj1 = 0 ;

3732

PyObject * obj2 = 0 ;

3733

PyObject * obj3 = 0 ;

3734

PyObject * obj4 = 0 ;

3735

PyObject * obj5 = 0 ;

3736

PyObject * obj6 = 0 ;

3737

char * kwnames[] = {

3738

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

3739

};

3740

3741

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

3742

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

3743

if (!SWIG_IsOK(res1)) {

3744

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

3745

}

3746

arg1 = reinterpret_cast< wxWindow * >(argp1);

3747

if (obj1) {

3748

ecode2 = SWIG_AsVal_int(obj1, &val2);

3749

if (!SWIG_IsOK(ecode2)) {

3750

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

3751

}

3752

arg2 = static_cast< int >(val2);

3753

}

3754

if (obj2) {

3755

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxAnimation, 0 | 0);

3756

if (!SWIG_IsOK(res3)) {

3757

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AnimationCtrl" "', expected argument " "3"" of type '" "wxAnimation const &""'");

3758

}

3759

if (!argp3) {

3760

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnimationCtrl" "', expected argument " "3"" of type '" "wxAnimation const &""'");

3761

}

3762

arg3 = reinterpret_cast< wxAnimation * >(argp3);

3763

}

3764

if (obj3) {

3765

{

3766

arg4 = &temp4;

3767

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

3768

}

3769

}

3770

if (obj4) {

3771

{

3772

arg5 = &temp5;

3773

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

3774

}

3775

}

3776

if (obj5) {

3777

ecode6 = SWIG_AsVal_long(obj5, &val6);

3778

if (!SWIG_IsOK(ecode6)) {

3779

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

3780

}

3781

arg6 = static_cast< long >(val6);

3782

}

3783

if (obj6) {

3784

{

3785

arg7 = wxString_in_helper(obj6);

3786

if (arg7 == NULL) SWIG_fail;

3787

temp7 = true;

3788

}

3789

}

3790

{

3791

if (!wxPyCheckForApp()) SWIG_fail;

3792

PyThreadState* __tstate = wxPyBeginAllowThreads();

3793

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

3794

wxPyEndAllowThreads(__tstate);

3795

if (PyErr_Occurred()) SWIG_fail;

3796

}

3797

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

3798

{

3799

if (temp7)

3800

delete arg7;

3801

}

3802

return resultobj;

3803

fail:

3804

{

3805

if (temp7)

3806

delete arg7;

3807

}

3808

return NULL;

3809

}

3810

3811

3812

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

3813

PyObject *resultobj = 0;

3814

wxAnimationCtrl *result = 0 ;

3815

3816

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

3817

{

3818

if (!wxPyCheckForApp()) SWIG_fail;

3819

PyThreadState* __tstate = wxPyBeginAllowThreads();

3820

result = (wxAnimationCtrl *)new wxAnimationCtrl();

3821

wxPyEndAllowThreads(__tstate);

3822

if (PyErr_Occurred()) SWIG_fail;

3823

}

3824

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

3825

return resultobj;

3826

fail:

3827

return NULL;

3828

}

3829

3830

3831

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

3832

PyObject *resultobj = 0;

3833

wxAnimationCtrl *arg1 = (wxAnimationCtrl *) 0 ;

3834

wxWindow *arg2 = (wxWindow *) 0 ;

3835

int arg3 ;

3836

wxAnimation const &arg4_defvalue = wxNullAnimation ;

3837

wxAnimation *arg4 = (wxAnimation *) &arg4_defvalue ;

3838

wxPoint const &arg5_defvalue = wxDefaultPosition ;

3839

wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;

3840

wxSize const &arg6_defvalue = wxDefaultSize ;

3841

wxSize *arg6 = (wxSize *) &arg6_defvalue ;

3842

long arg7 = (long) wxAC_DEFAULT_STYLE ;

3843

wxString const &arg8_defvalue = wxPyAnimationCtrlNameStr ;

3844

wxString *arg8 = (wxString *) &arg8_defvalue ;

3845

bool result;

3846

void *argp1 = 0 ;

3847

int res1 = 0 ;

3848

void *argp2 = 0 ;

3849

int res2 = 0 ;

3850

int val3 ;

3851

int ecode3 = 0 ;

3852

void *argp4 = 0 ;

3853

int res4 = 0 ;

3854

wxPoint temp5 ;

3855

wxSize temp6 ;

3856

long val7 ;

3857

int ecode7 = 0 ;

3858

bool temp8 = false ;

3859

PyObject * obj0 = 0 ;

3860

PyObject * obj1 = 0 ;

3861

PyObject * obj2 = 0 ;

3862

PyObject * obj3 = 0 ;

3863

PyObject * obj4 = 0 ;

3864

PyObject * obj5 = 0 ;

3865

PyObject * obj6 = 0 ;

3866

PyObject * obj7 = 0 ;

3867

char * kwnames[] = {

3868

(char *) "self",(char *) "parent",(char *) "id",(char *) "anim",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL

3869

};

3870

3871

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

3872

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

3873

if (!SWIG_IsOK(res1)) {

3874

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

3875

}

3876

arg1 = reinterpret_cast< wxAnimationCtrl * >(argp1);

3877

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

3878

if (!SWIG_IsOK(res2)) {

3879

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

3880

}

3881

arg2 = reinterpret_cast< wxWindow * >(argp2);

3882

ecode3 = SWIG_AsVal_int(obj2, &val3);

3883

if (!SWIG_IsOK(ecode3)) {

3884

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

3885

}

3886

arg3 = static_cast< int >(val3);

3887

if (obj3) {

3888

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

3889

if (!SWIG_IsOK(res4)) {

3890

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

3891

}

3892

if (!argp4) {

3893

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

3894

}

3895

arg4 = reinterpret_cast< wxAnimation * >(argp4);

3896

}

3897

if (obj4) {

3898

{

3899

arg5 = &temp5;

3900

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

3901

}

3902

}

3903

if (obj5) {

3904

{

3905

arg6 = &temp6;

3906

if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;

3907

}

3908

}

3909

if (obj6) {

3910

ecode7 = SWIG_AsVal_long(obj6, &val7);

3911

if (!SWIG_IsOK(ecode7)) {

3912

SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "AnimationCtrl_Create" "', expected argument " "7"" of type '" "long""'");

3913

}

3914

arg7 = static_cast< long >(val7);

3915

}

3916

if (obj7) {

3917

{

3918

arg8 = wxString_in_helper(obj7);

3919

if (arg8 == NULL) SWIG_fail;

3920

temp8 = true;

3921

}

3922

}

3923

{

3924

PyThreadState* __tstate = wxPyBeginAllowThreads();

3925

result = (bool)(arg1)->Create(arg2,arg3,(wxAnimation const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxString const &)*arg8);

3926

wxPyEndAllowThreads(__tstate);

3927

if (PyErr_Occurred()) SWIG_fail;

3928

}

3929

{

3930

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

3931

}

3932

{

3933

if (temp8)

3934

delete arg8;

3935

}

3936

return resultobj;

3937

fail:

3938

{

3939

if (temp8)

3940

delete arg8;

3941

}

3942

return NULL;

3943

}

3944

3945

3946

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

3947

PyObject *resultobj = 0;

3948

wxAnimationCtrl *arg1 = (wxAnimationCtrl *) 0 ;

3949

bool arg2 = (bool) true ;

3950

void *argp1 = 0 ;

3951

int res1 = 0 ;

3952

bool val2 ;

3953

int ecode2 = 0 ;

3954

PyObject * obj0 = 0 ;

3955

PyObject * obj1 = 0 ;

3956

char * kwnames[] = {

3957

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

3958

};

3959

3960

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

3961

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

3962

if (!SWIG_IsOK(res1)) {

3963

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

3964

}

3965

arg1 = reinterpret_cast< wxAnimationCtrl * >(argp1);

3966

if (obj1) {

3967

ecode2 = SWIG_AsVal_bool(obj1, &val2);

3968

if (!SWIG_IsOK(ecode2)) {

3969

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

3970

}

3971

arg2 = static_cast< bool >(val2);

3972

}

3973

{

3974

PyThreadState* __tstate = wxPyBeginAllowThreads();

3975

(arg1)->SetUseWindowBackgroundColour(arg2);

3976

wxPyEndAllowThreads(__tstate);

3977

if (PyErr_Occurred()) SWIG_fail;

3978

}

3979

resultobj = SWIG_Py_Void();

3980

return resultobj;

3981

fail:

3982

return NULL;

3983

}

3984

3985

3986

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

3987

PyObject *resultobj = 0;

3988

wxAnimationCtrl *arg1 = (wxAnimationCtrl *) 0 ;

3989

bool result;

3990

void *argp1 = 0 ;

3991

int res1 = 0 ;

3992

PyObject *swig_obj[1] ;

3993

3994

if (!args) SWIG_fail;

3995

swig_obj[0] = args;

3996

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

3997

if (!SWIG_IsOK(res1)) {

3998

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

3999

}

4000

arg1 = reinterpret_cast< wxAnimationCtrl * >(argp1);

4001

{

4002

PyThreadState* __tstate = wxPyBeginAllowThreads();

4003

result = (bool)((wxAnimationCtrl const *)arg1)->IsUsingWindowBackgroundColour();

4004

wxPyEndAllowThreads(__tstate);

4005

if (PyErr_Occurred()) SWIG_fail;

4006

}

4007

{

4008

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

4009

}

4010

return resultobj;

4011

fail:

4012

return NULL;

4013

}

4014

4015

4016

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

4017

PyObject *resultobj = 0;

4018

wxAnimationCtrl *arg1 = (wxAnimationCtrl *) 0 ;

4019

wxDC *arg2 = 0 ;

4020

void *argp1 = 0 ;

4021

int res1 = 0 ;

4022

void *argp2 = 0 ;

4023

int res2 = 0 ;

4024

PyObject * obj0 = 0 ;

4025

PyObject * obj1 = 0 ;

4026

char * kwnames[] = {

4027

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

4028

};

4029

4030

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

4031

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

4032

if (!SWIG_IsOK(res1)) {

4033

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

4034

}

4035

arg1 = reinterpret_cast< wxAnimationCtrl * >(argp1);

4036

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

4037

if (!SWIG_IsOK(res2)) {

4038

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

4039

}

4040

if (!argp2) {

4041

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

4042

}

4043

arg2 = reinterpret_cast< wxDC * >(argp2);

4044

{

4045

PyThreadState* __tstate = wxPyBeginAllowThreads();

4046

(arg1)->DrawCurrentFrame(*arg2);

4047

wxPyEndAllowThreads(__tstate);

4048

if (PyErr_Occurred()) SWIG_fail;

4049

}

4050

resultobj = SWIG_Py_Void();

4051

return resultobj;

4052

fail:

4053

return NULL;

4054

}

4055

4056

4057

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

4058

PyObject *resultobj = 0;

4059

wxAnimationCtrl *arg1 = (wxAnimationCtrl *) 0 ;

4060

wxBitmap *result = 0 ;

4061

void *argp1 = 0 ;

4062

int res1 = 0 ;

4063

PyObject *swig_obj[1] ;

4064

4065

if (!args) SWIG_fail;

4066

swig_obj[0] = args;

4067

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

4068

if (!SWIG_IsOK(res1)) {

4069

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

4070

}

4071

arg1 = reinterpret_cast< wxAnimationCtrl * >(argp1);

4072

{

4073

PyThreadState* __tstate = wxPyBeginAllowThreads();

4074

{

4075

wxBitmap &_result_ref = (arg1)->GetBackingStore();

4076

result = (wxBitmap *) &_result_ref;

4077

}

4078

wxPyEndAllowThreads(__tstate);

4079

if (PyErr_Occurred()) SWIG_fail;

4080

}

4081

{

4082

wxBitmap* resultptr = new wxBitmap(*result);

4083

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

4084

}

4085

return resultobj;

4086

fail:

4087

return NULL;

4088

}

4089

4090

4091

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

4092

PyObject *obj;

4093

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

4094

SWIG_TypeNewClientData(SWIGTYPE_p_wxAnimationCtrl, SWIG_NewClientData(obj));

4095

return SWIG_Py_Void();

4096

}

4097

4098

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

4099

return SWIG_Python_InitShadowInstance(args);

4100

}

4101

4102

static PyMethodDef SwigMethods[] = {

4103

{ (char *)"delete_AnimationBase", (PyCFunction)_wrap_delete_AnimationBase, METH_O, NULL},

4104

{ (char *)"AnimationBase_IsOk", (PyCFunction)_wrap_AnimationBase_IsOk, METH_O, NULL},

4105

{ (char *)"AnimationBase_GetDelay", (PyCFunction) _wrap_AnimationBase_GetDelay, METH_VARARGS | METH_KEYWORDS, NULL},

4106

{ (char *)"AnimationBase_GetFrameCount", (PyCFunction)_wrap_AnimationBase_GetFrameCount, METH_O, NULL},

4107

{ (char *)"AnimationBase_GetFrame", (PyCFunction) _wrap_AnimationBase_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},

4108

{ (char *)"AnimationBase_GetSize", (PyCFunction)_wrap_AnimationBase_GetSize, METH_O, NULL},

4109

{ (char *)"AnimationBase_LoadFile", (PyCFunction) _wrap_AnimationBase_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},

4110

{ (char *)"AnimationBase_Load", (PyCFunction) _wrap_AnimationBase_Load, METH_VARARGS | METH_KEYWORDS, NULL},

4111

{ (char *)"AnimationBase_swigregister", AnimationBase_swigregister, METH_VARARGS, NULL},

4112

{ (char *)"new_Animation", _wrap_new_Animation, METH_VARARGS, NULL},

4113

{ (char *)"delete_Animation", (PyCFunction)_wrap_delete_Animation, METH_O, NULL},

4114

{ (char *)"Animation_GetFramePosition", (PyCFunction) _wrap_Animation_GetFramePosition, METH_VARARGS | METH_KEYWORDS, NULL},

4115

{ (char *)"Animation_GetFrameSize", (PyCFunction) _wrap_Animation_GetFrameSize, METH_VARARGS | METH_KEYWORDS, NULL},

4116

{ (char *)"Animation_GetDisposalMethod", (PyCFunction) _wrap_Animation_GetDisposalMethod, METH_VARARGS | METH_KEYWORDS, NULL},

4117

{ (char *)"Animation_GetTransparentColour", (PyCFunction) _wrap_Animation_GetTransparentColour, METH_VARARGS | METH_KEYWORDS, NULL},

4118

{ (char *)"Animation_GetBackgroundColour", (PyCFunction)_wrap_Animation_GetBackgroundColour, METH_O, NULL},

4119

{ (char *)"Animation_swigregister", Animation_swigregister, METH_VARARGS, NULL},

4120

{ (char *)"Animation_swiginit", Animation_swiginit, METH_VARARGS, NULL},

4121

{ (char *)"AnimationCtrlBase_LoadFile", (PyCFunction) _wrap_AnimationCtrlBase_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},

4122

{ (char *)"AnimationCtrlBase_SetAnimation", (PyCFunction) _wrap_AnimationCtrlBase_SetAnimation, METH_VARARGS | METH_KEYWORDS, NULL},

4123

{ (char *)"AnimationCtrlBase_GetAnimation", (PyCFunction)_wrap_AnimationCtrlBase_GetAnimation, METH_O, NULL},

4124

{ (char *)"AnimationCtrlBase_Play", (PyCFunction)_wrap_AnimationCtrlBase_Play, METH_O, NULL},

4125

{ (char *)"AnimationCtrlBase_Stop", (PyCFunction)_wrap_AnimationCtrlBase_Stop, METH_O, NULL},

4126

{ (char *)"AnimationCtrlBase_IsPlaying", (PyCFunction)_wrap_AnimationCtrlBase_IsPlaying, METH_O, NULL},

4127

{ (char *)"AnimationCtrlBase_SetInactiveBitmap", (PyCFunction) _wrap_AnimationCtrlBase_SetInactiveBitmap, METH_VARARGS | METH_KEYWORDS, NULL},

4128

{ (char *)"AnimationCtrlBase_GetInactiveBitmap", (PyCFunction)_wrap_AnimationCtrlBase_GetInactiveBitmap, METH_O, NULL},

4129

{ (char *)"AnimationCtrlBase_swigregister", AnimationCtrlBase_swigregister, METH_VARARGS, NULL},

4130

{ (char *)"new_AnimationCtrl", (PyCFunction) _wrap_new_AnimationCtrl, METH_VARARGS | METH_KEYWORDS, NULL},

4131

{ (char *)"new_PreAnimationCtrl", (PyCFunction)_wrap_new_PreAnimationCtrl, METH_NOARGS, NULL},

4132

{ (char *)"AnimationCtrl_Create", (PyCFunction) _wrap_AnimationCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},

4133

{ (char *)"AnimationCtrl_SetUseWindowBackgroundColour", (PyCFunction) _wrap_AnimationCtrl_SetUseWindowBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},

4134

{ (char *)"AnimationCtrl_IsUsingWindowBackgroundColour", (PyCFunction)_wrap_AnimationCtrl_IsUsingWindowBackgroundColour, METH_O, NULL},

4135

{ (char *)"AnimationCtrl_DrawCurrentFrame", (PyCFunction) _wrap_AnimationCtrl_DrawCurrentFrame, METH_VARARGS | METH_KEYWORDS, NULL},

4136

{ (char *)"AnimationCtrl_GetBackingStore", (PyCFunction)_wrap_AnimationCtrl_GetBackingStore, METH_O, NULL},

4137

{ (char *)"AnimationCtrl_swigregister", AnimationCtrl_swigregister, METH_VARARGS, NULL},

4138

{ (char *)"AnimationCtrl_swiginit", AnimationCtrl_swiginit, METH_VARARGS, NULL},

4139

{ NULL, NULL, 0, NULL }

4140

};

4141

4142

4143

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

4144

4145

static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {

4146

return (void *)((wxObject *) ((wxLayoutConstraints *) x));

4147

}

4148

static void *_p_wxSizerItemTo_p_wxObject(void *x) {

4149

return (void *)((wxObject *) ((wxSizerItem *) x));

4150

}

4151

static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {

4152

return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));

4153

}

4154

static void *_p_wxScrollEventTo_p_wxObject(void *x) {

4155

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));

4156

}

4157

static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {

4158

return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));

4159

}

4160

static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {

4161

return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));

4162

}

4163

static void *_p_wxBoxSizerTo_p_wxObject(void *x) {

4164

return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));

4165

}

4166

static void *_p_wxSizerTo_p_wxObject(void *x) {

4167

return (void *)((wxObject *) ((wxSizer *) x));

4168

}

4169

static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {

4170

return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));

4171

}

4172

static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {

4173

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));

4174

}

4175

static void *_p_wxEventTo_p_wxObject(void *x) {

4176

return (void *)((wxObject *) ((wxEvent *) x));

4177

}

4178

static void *_p_wxGridSizerTo_p_wxObject(void *x) {

4179

return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));

4180

}

4181

static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {

4182

return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));

4183

}

4184

static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {

4185

return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));

4186

}

4187

static void *_p_wxAnimationBaseTo_p_wxObject(void *x) {

4188

return (void *)((wxObject *) ((wxAnimationBase *) x));

4189

}

4190

static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {

4191

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));

4192

}

4193

static void *_p_wxPaintEventTo_p_wxObject(void *x) {

4194

return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));

4195

}

4196

static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {

4197

return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));

4198

}

4199

static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {

4200

return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));

4201

}

4202

static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {

4203

return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));

4204

}

4205

static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {

4206

return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));

4207

}

4208

static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {

4209

return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));

4210

}

4211

static void *_p_wxControlTo_p_wxObject(void *x) {

4212

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));

4213

}

4214

static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {

4215

return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));

4216

}

4217

static void *_p_wxFSFileTo_p_wxObject(void *x) {

4218

return (void *)((wxObject *) ((wxFSFile *) x));

4219

}

4220

static void *_p_wxPySizerTo_p_wxObject(void *x) {

4221

return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));

4222

}

4223

static void *_p_wxPyEventTo_p_wxObject(void *x) {

4224

return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));

4225

}

4226

static void *_p_wxNotifyEventTo_p_wxObject(void *x) {

4227

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));

4228

}

4229

static void *_p_wxShowEventTo_p_wxObject(void *x) {

4230

return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));

4231

}

4232

static void *_p_wxMenuItemTo_p_wxObject(void *x) {

4233

return (void *)((wxObject *) ((wxMenuItem *) x));

4234

}

4235

static void *_p_wxDateEventTo_p_wxObject(void *x) {

4236

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));

4237

}

4238

static void *_p_wxIdleEventTo_p_wxObject(void *x) {

4239

return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));

4240

}

4241

static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {

4242

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));

4243

}

4244

static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {

4245

return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));

4246

}

4247

static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {

4248

return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));

4249

}

4250

static void *_p_wxIconizeEventTo_p_wxObject(void *x) {

4251

return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));

4252

}

4253

static void *_p_wxActivateEventTo_p_wxObject(void *x) {

4254

return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));

4255

}

4256

static void *_p_wxSizeEventTo_p_wxObject(void *x) {

4257

return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));

4258

}

4259

static void *_p_wxMoveEventTo_p_wxObject(void *x) {

4260

return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));

4261

}

4262

static void *_p_wxAnimationCtrlBaseTo_p_wxObject(void *x) {

4263

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxAnimationCtrlBase *) x));

4264

}

4265

static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {

4266

return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));

4267

}

4268

static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {

4269

return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));

4270

}

4271

static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {

4272

return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));

4273

}

4274

static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {

4275

return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));

4276

}

4277

static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {

4278

return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));

4279

}

4280

static void *_p_wxANIHandlerTo_p_wxObject(void *x) {

4281

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));

4282

}

4283

static void *_p_wxCURHandlerTo_p_wxObject(void *x) {

4284

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));

4285

}

4286

static void *_p_wxICOHandlerTo_p_wxObject(void *x) {

4287

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));

4288

}

4289

static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {

4290

return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));

4291

}

4292

static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {

4293

return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));

4294

}

4295

static void *_p_wxImageHandlerTo_p_wxObject(void *x) {

4296

return (void *)((wxObject *) ((wxImageHandler *) x));

4297

}

4298

static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {

4299

return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));

4300

}

4301

static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {

4302

return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));

4303

}

4304

static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {

4305

return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));

4306

}

4307

static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {

4308

return (void *)((wxObject *) ((wxEvtHandler *) x));

4309

}

4310

static void *_p_wxPyEvtHandlerTo_p_wxObject(void *x) {

4311

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyEvtHandler *) x));

4312

}

4313

static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {

4314

return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));

4315

}

4316

static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {

4317

return (void *)((wxObject *) ((wxAcceleratorTable *) x));

4318

}

4319

static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {

4320

return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));

4321

}

4322

static void *_p_wxImageTo_p_wxObject(void *x) {

4323

return (void *)((wxObject *) ((wxImage *) x));

4324

}

4325

static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {

4326

return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));

4327

}

4328

static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {

4329

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));

4330

}

4331

static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {

4332

return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));

4333

}

4334

static void *_p_wxKeyEventTo_p_wxObject(void *x) {

4335

return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));

4336

}

4337

static void *_p_wxWindowTo_p_wxObject(void *x) {

4338

return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));

4339

}

4340

static void *_p_wxMenuTo_p_wxObject(void *x) {

4341

return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));

4342

}

4343

static void *_p_wxMenuBarTo_p_wxObject(void *x) {

4344

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));

4345

}

4346

static void *_p_wxFileSystemTo_p_wxObject(void *x) {

4347

return (void *)((wxObject *) ((wxFileSystem *) x));

4348

}

4349

static void *_p_wxAnimationTo_p_wxObject(void *x) {

4350

return (void *)((wxObject *) (wxAnimationBase *) ((wxAnimation *) x));

4351

}

4352

static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {

4353

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));

4354

}

4355

static void *_p_wxMenuEventTo_p_wxObject(void *x) {

4356

return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));

4357

}

4358

static void *_p_wxPyAppTo_p_wxObject(void *x) {

4359

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));

4360

}

4361

static void *_p_wxCloseEventTo_p_wxObject(void *x) {

4362

return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));

4363

}

4364

static void *_p_wxMouseEventTo_p_wxObject(void *x) {

4365

return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));

4366

}

4367

static void *_p_wxEraseEventTo_p_wxObject(void *x) {

4368

return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));

4369

}

4370

static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {

4371

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));

4372

}

4373

static void *_p_wxCommandEventTo_p_wxObject(void *x) {

4374

return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));

4375

}

4376

static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {

4377

return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));

4378

}

4379

static void *_p_wxFocusEventTo_p_wxObject(void *x) {

4380

return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));

4381

}

4382

static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {

4383

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));

4384

}

4385

static void *_p_wxAnimationCtrlTo_p_wxObject(void *x) {

4386

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *)(wxAnimationCtrlBase *) ((wxAnimationCtrl *) x));

4387

}

4388

static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {

4389

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));

4390

}

4391

static void *_p_wxPyValidatorTo_p_wxObject(void *x) {

4392

return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));

4393

}

4394

static void *_p_wxValidatorTo_p_wxObject(void *x) {

4395

return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));

4396

}

4397

static void *_p_wxControlTo_p_wxWindow(void *x) {

4398

return (void *)((wxWindow *) ((wxControl *) x));

4399

}

4400

static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {

4401

return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));

4402

}

4403

static void *_p_wxAnimationCtrlBaseTo_p_wxWindow(void *x) {

4404

return (void *)((wxWindow *) (wxControl *) ((wxAnimationCtrlBase *) x));

4405

}

4406

static void *_p_wxAnimationCtrlTo_p_wxWindow(void *x) {

4407

return (void *)((wxWindow *) (wxControl *)(wxAnimationCtrlBase *) ((wxAnimationCtrl *) x));

4408

}

4409

static void *_p_wxMenuBarTo_p_wxWindow(void *x) {

4410

return (void *)((wxWindow *) ((wxMenuBar *) x));

4411

}

4412

static void *_p_wxAnimationTo_p_wxAnimationBase(void *x) {

4413

return (void *)((wxAnimationBase *) ((wxAnimation *) x));

4414

}

4415

static void *_p_wxControlTo_p_wxEvtHandler(void *x) {

4416

return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));

4417

}

4418

static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {

4419

return (void *)((wxEvtHandler *) ((wxWindow *) x));

4420

}

4421

static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {

4422

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));

4423

}

4424

static void *_p_wxAnimationCtrlBaseTo_p_wxEvtHandler(void *x) {

4425

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxAnimationCtrlBase *) x));

4426

}

4427

static void *_p_wxPyEvtHandlerTo_p_wxEvtHandler(void *x) {

4428

return (void *)((wxEvtHandler *) ((wxPyEvtHandler *) x));

4429

}

4430

static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {

4431

return (void *)((wxEvtHandler *) ((wxPyApp *) x));

4432

}

4433

static void *_p_wxAnimationCtrlTo_p_wxEvtHandler(void *x) {

4434

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *)(wxAnimationCtrlBase *) ((wxAnimationCtrl *) x));

4435

}

4436

static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {

4437

return (void *)((wxEvtHandler *) ((wxValidator *) x));

4438

}

4439

static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {

4440

return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));

4441

}

4442

static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {

4443

return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));

4444

}

4445

static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {

4446

return (void *)((wxEvtHandler *) ((wxMenu *) x));

4447

}

4448

static void *_p_wxAnimationCtrlTo_p_wxAnimationCtrlBase(void *x) {

4449

return (void *)((wxAnimationCtrlBase *) ((wxAnimationCtrl *) x));

4450

}

4451

static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {

4452

return (void *)((wxControl *) ((wxControlWithItems *) x));

4453

}

4454

static void *_p_wxAnimationCtrlBaseTo_p_wxControl(void *x) {

4455

return (void *)((wxControl *) ((wxAnimationCtrlBase *) x));

4456

}

4457

static void *_p_wxAnimationCtrlTo_p_wxControl(void *x) {

4458

return (void *)((wxControl *) (wxAnimationCtrlBase *) ((wxAnimationCtrl *) x));

4459

}

4460

static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};

4461

static swig_type_info _swigt__p_double = {"_p_double", "double *|wxDouble *", 0, 0, (void*)0, 0};

4462

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};

4463

static swig_type_info _swigt__p_int = {"_p_int", "int *|wxEventType *", 0, 0, (void*)0, 0};

4464

static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};

4465

static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};

4466

static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};

4467

static swig_type_info _swigt__p_wxAnimation = {"_p_wxAnimation", "wxAnimation *", 0, 0, (void*)0, 0};

4468

static swig_type_info _swigt__p_wxAnimationBase = {"_p_wxAnimationBase", "wxAnimationBase *", 0, 0, (void*)0, 0};

4469

static swig_type_info _swigt__p_wxAnimationCtrl = {"_p_wxAnimationCtrl", "wxAnimationCtrl *", 0, 0, (void*)0, 0};

4470

static swig_type_info _swigt__p_wxAnimationCtrlBase = {"_p_wxAnimationCtrlBase", "wxAnimationCtrlBase *", 0, 0, (void*)0, 0};

4471

static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};

4472

static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};

4473

static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};

4474

static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};

4475

static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};

4476

static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};

4477

static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};

4478

static swig_type_info _swigt__p_wxPyEvtHandler = {"_p_wxPyEvtHandler", 0, 0, 0, 0, 0};

4479

static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};

4480

static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};

4481

static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};

4482

static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};

4483

static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};

4484

static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};

4485

static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};

4486

static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};

4487

static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};

4488

static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};

4489

static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};

4490

static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};

4491

static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};

4492

static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};

4493

static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};

4494

static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};

4495

static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};

4496

static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};

4497

static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", 0, 0, 0, 0, 0};

4498

static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};

4499

static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};

4500

static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};

4501

static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};

4502

static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};

4503

static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};

4504

static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};

4505

static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};

4506

static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};

4507

static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};

4508

static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};

4509

static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};

4510

static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};

4511

static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};

4512

static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};

4513

static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};

4514

static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};

4515

static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};

4516

static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};

4517

static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};

4518

static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};

4519

static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};

4520

static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};

4521

static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};

4522

static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};

4523

static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};

4524

static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};

4525

static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};

4526

static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};

4527

static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};

4528

static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};

4529

static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};

4530

static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};

4531

static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};

4532

static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};

4533

static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};

4534

static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};

4535

static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};

4536

static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};

4537

static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};

4538

static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};

4539

static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};

4540

static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};

4541

static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};

4542

static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};

4543

static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};

4544

static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};

4545

static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};

4546

static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};

4547

static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};

4548

static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};

4549

static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};

4550

static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};

4551

static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};

4552

static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};

4553

static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};

4554

static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};

4555

static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};

4556

static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};

4557

static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};

4558

static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};

4559

static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};

4560

4561

static swig_type_info *swig_type_initial[] = {

4562

&_swigt__p_char,

4563

&_swigt__p_double,

4564

&_swigt__p_form_ops_t,

4565

&_swigt__p_int,

4566

&_swigt__p_unsigned_char,

4567

&_swigt__p_unsigned_int,

4568

&_swigt__p_unsigned_long,

4569

&_swigt__p_wxANIHandler,

4570

&_swigt__p_wxAcceleratorTable,

4571

&_swigt__p_wxActivateEvent,

4572

&_swigt__p_wxAnimation,

4573

&_swigt__p_wxAnimationBase,

4574

&_swigt__p_wxAnimationCtrl,

4575

&_swigt__p_wxAnimationCtrlBase,

4576

&_swigt__p_wxBMPHandler,

4577

&_swigt__p_wxBitmap,

4578

&_swigt__p_wxBoxSizer,

4579

&_swigt__p_wxCURHandler,

4580

&_swigt__p_wxChildFocusEvent,

4581

&_swigt__p_wxClipboardTextEvent,

4582

&_swigt__p_wxCloseEvent,

4583

&_swigt__p_wxColour,

4584

&_swigt__p_wxCommandEvent,

4585

&_swigt__p_wxContextMenuEvent,

4586

&_swigt__p_wxControl,

4587

&_swigt__p_wxControlWithItems,

4588

&_swigt__p_wxDC,

4589

&_swigt__p_wxDateEvent,

4590

&_swigt__p_wxDisplayChangedEvent,

4591

&_swigt__p_wxDropFilesEvent,

4592

&_swigt__p_wxDuplexMode,

4593

&_swigt__p_wxEraseEvent,

4594

&_swigt__p_wxEvent,

4595

&_swigt__p_wxEvtHandler,

4596

&_swigt__p_wxFSFile,

4597

&_swigt__p_wxFileSystem,

4598

&_swigt__p_wxFlexGridSizer,

4599

&_swigt__p_wxFocusEvent,

4600

&_swigt__p_wxGBSizerItem,

4601

&_swigt__p_wxGIFHandler,

4602

&_swigt__p_wxGridBagSizer,

4603

&_swigt__p_wxGridSizer,

4604

&_swigt__p_wxICOHandler,

4605

&_swigt__p_wxIconizeEvent,

4606

&_swigt__p_wxIdleEvent,

4607

&_swigt__p_wxImage,

4608

&_swigt__p_wxImageHandler,

4609

&_swigt__p_wxIndividualLayoutConstraint,

4610

&_swigt__p_wxInitDialogEvent,

4611

&_swigt__p_wxInputStream,

4612

&_swigt__p_wxJPEGHandler,

4613

&_swigt__p_wxKeyEvent,

4614

&_swigt__p_wxLayoutConstraints,

4615

&_swigt__p_wxMaximizeEvent,

4616

&_swigt__p_wxMenu,

4617

&_swigt__p_wxMenuBar,

4618

&_swigt__p_wxMenuEvent,

4619

&_swigt__p_wxMenuItem,

4620

&_swigt__p_wxMouseCaptureChangedEvent,

4621

&_swigt__p_wxMouseCaptureLostEvent,

4622

&_swigt__p_wxMouseEvent,

4623

&_swigt__p_wxMoveEvent,

4624

&_swigt__p_wxNavigationKeyEvent,

4625

&_swigt__p_wxNcPaintEvent,

4626

&_swigt__p_wxNotifyEvent,

4627

&_swigt__p_wxObject,

4628

&_swigt__p_wxPCXHandler,

4629

&_swigt__p_wxPNGHandler,

4630

&_swigt__p_wxPNMHandler,

4631

&_swigt__p_wxPaintEvent,

4632

&_swigt__p_wxPaletteChangedEvent,

4633

&_swigt__p_wxPaperSize,

4634

&_swigt__p_wxPoint,

4635

&_swigt__p_wxPyApp,

4636

&_swigt__p_wxPyCommandEvent,

4637

&_swigt__p_wxPyEvent,

4638

&_swigt__p_wxPyEvtHandler,

4639

&_swigt__p_wxPyImageHandler,

4640

&_swigt__p_wxPySizer,

4641

&_swigt__p_wxPyValidator,

4642

&_swigt__p_wxQueryNewPaletteEvent,

4643

&_swigt__p_wxScrollEvent,

4644

&_swigt__p_wxScrollWinEvent,

4645

&_swigt__p_wxSetCursorEvent,

4646

&_swigt__p_wxShowEvent,

4647

&_swigt__p_wxSize,

4648

&_swigt__p_wxSizeEvent,

4649

&_swigt__p_wxSizer,

4650

&_swigt__p_wxSizerItem,

4651

&_swigt__p_wxStaticBoxSizer,

4652

&_swigt__p_wxStdDialogButtonSizer,

4653

&_swigt__p_wxSysColourChangedEvent,

4654

&_swigt__p_wxTGAHandler,

4655

&_swigt__p_wxTIFFHandler,

4656

&_swigt__p_wxUpdateUIEvent,

4657

&_swigt__p_wxValidator,

4658

&_swigt__p_wxWindow,

4659

&_swigt__p_wxWindowCreateEvent,

4660

&_swigt__p_wxWindowDestroyEvent,

4661

&_swigt__p_wxXPMHandler,

4662

};

4663

4664

static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};

4665

static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};

4666

static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};

4667

static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};

4668

static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};

4669

static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};

4670

static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};

4671

static swig_cast_info _swigc__p_wxAnimation[] = { {&_swigt__p_wxAnimation, 0, 0, 0},{0, 0, 0, 0}};

4672

static swig_cast_info _swigc__p_wxAnimationBase[] = { {&_swigt__p_wxAnimationBase, 0, 0, 0}, {&_swigt__p_wxAnimation, _p_wxAnimationTo_p_wxAnimationBase, 0, 0},{0, 0, 0, 0}};

4673

static swig_cast_info _swigc__p_wxAnimationCtrl[] = { {&_swigt__p_wxAnimationCtrl, 0, 0, 0},{0, 0, 0, 0}};

4674

static swig_cast_info _swigc__p_wxAnimationCtrlBase[] = { {&_swigt__p_wxAnimationCtrlBase, 0, 0, 0}, {&_swigt__p_wxAnimationCtrl, _p_wxAnimationCtrlTo_p_wxAnimationCtrlBase, 0, 0},{0, 0, 0, 0}};

4675

static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};

4676

static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};

4677

static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};

4678

static swig_cast_info _swigc__p_wxControl[] = { {&_swigt__p_wxControl, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxControl, 0, 0}, {&_swigt__p_wxAnimationCtrlBase, _p_wxAnimationCtrlBaseTo_p_wxControl, 0, 0}, {&_swigt__p_wxAnimationCtrl, _p_wxAnimationCtrlTo_p_wxControl, 0, 0},{0, 0, 0, 0}};

4679

static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};

4680

static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};

4681

static swig_cast_info _swigc__p_wxPyEvtHandler[] = {{&_swigt__p_wxPyEvtHandler, 0, 0, 0},{0, 0, 0, 0}};

4682

static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};

4683

static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};

4684

static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};

4685

static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};

4686

static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};

4687

static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxAnimationCtrlBase, _p_wxAnimationCtrlBaseTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxAnimationCtrl, _p_wxAnimationCtrlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyEvtHandler, _p_wxPyEvtHandlerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_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_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};

4688

static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};

4689

static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};

4690

static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};

4691

static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};

4692

static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};

4693

static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};

4694

static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};

4695

static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};

4696

static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};

4697

static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};

4698

static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};

4699

static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};

4700

static swig_cast_info _swigc__p_wxEvent[] = {{&_swigt__p_wxEvent, 0, 0, 0},{0, 0, 0, 0}};

4701

static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};

4702

static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};

4703

static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};

4704

static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};

4705

static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};

4706

static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};

4707

static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

4708

static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

4709

static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

4710

static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

4711

static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};

4712

static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};

4713

static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};

4714

static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};

4715

static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};

4716

static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};

4717

static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};

4718

static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};

4719

static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};

4720

static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};

4721

static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};

4722

static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};

4723

static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};

4724

static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};

4725

static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};

4726

static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};

4727

static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};

4728

static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};

4729

static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};

4730

static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};

4731

static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};

4732

static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};

4733

static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};

4734

static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};

4735

static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};

4736

static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};

4737

static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};

4738

static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};

4739

static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};

4740

static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};

4741

static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};

4742

static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};

4743

static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};

4744

static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};

4745

static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};

4746

static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};

4747

static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};

4748

static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};

4749

static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};

4750

static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};

4751

static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};

4752

static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};

4753

static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};

4754

static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};

4755

static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};

4756

static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};

4757

static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};

4758

static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};

4759

static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_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_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxAnimationBase, _p_wxAnimationBaseTo_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_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_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_wxAnimationCtrlBase, _p_wxAnimationCtrlBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_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_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_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_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_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxAnimation, _p_wxAnimationTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_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_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_wxAnimationCtrl, _p_wxAnimationCtrlTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};

4760

static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};

4761

static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};

4762

static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};

4763

static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxAnimationCtrlBase, _p_wxAnimationCtrlBaseTo_p_wxWindow, 0, 0}, {&_swigt__p_wxAnimationCtrl, _p_wxAnimationCtrlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};

4764

4765

static swig_cast_info *swig_cast_initial[] = {

4766

_swigc__p_char,

4767

_swigc__p_double,

4768

_swigc__p_form_ops_t,

4769

_swigc__p_int,

4770

_swigc__p_unsigned_char,

4771

_swigc__p_unsigned_int,

4772

_swigc__p_unsigned_long,

4773

_swigc__p_wxANIHandler,

4774

_swigc__p_wxAcceleratorTable,

4775

_swigc__p_wxActivateEvent,

4776

_swigc__p_wxAnimation,

4777

_swigc__p_wxAnimationBase,

4778

_swigc__p_wxAnimationCtrl,

4779

_swigc__p_wxAnimationCtrlBase,

4780

_swigc__p_wxBMPHandler,

4781

_swigc__p_wxBitmap,

4782

_swigc__p_wxBoxSizer,

4783

_swigc__p_wxCURHandler,

4784

_swigc__p_wxChildFocusEvent,

4785

_swigc__p_wxClipboardTextEvent,

4786

_swigc__p_wxCloseEvent,

4787

_swigc__p_wxColour,

4788

_swigc__p_wxCommandEvent,

4789

_swigc__p_wxContextMenuEvent,

4790

_swigc__p_wxControl,

4791

_swigc__p_wxControlWithItems,

4792

_swigc__p_wxDC,

4793

_swigc__p_wxDateEvent,

4794

_swigc__p_wxDisplayChangedEvent,

4795

_swigc__p_wxDropFilesEvent,

4796

_swigc__p_wxDuplexMode,

4797

_swigc__p_wxEraseEvent,

4798

_swigc__p_wxEvent,

4799

_swigc__p_wxEvtHandler,

4800

_swigc__p_wxFSFile,

4801

_swigc__p_wxFileSystem,

4802

_swigc__p_wxFlexGridSizer,

4803

_swigc__p_wxFocusEvent,

4804

_swigc__p_wxGBSizerItem,

4805

_swigc__p_wxGIFHandler,

4806

_swigc__p_wxGridBagSizer,

4807

_swigc__p_wxGridSizer,

4808

_swigc__p_wxICOHandler,

4809

_swigc__p_wxIconizeEvent,

4810

_swigc__p_wxIdleEvent,

4811

_swigc__p_wxImage,

4812

_swigc__p_wxImageHandler,

4813

_swigc__p_wxIndividualLayoutConstraint,

4814

_swigc__p_wxInitDialogEvent,

4815

_swigc__p_wxInputStream,

4816

_swigc__p_wxJPEGHandler,

4817

_swigc__p_wxKeyEvent,

4818

_swigc__p_wxLayoutConstraints,

4819

_swigc__p_wxMaximizeEvent,

4820

_swigc__p_wxMenu,

4821

_swigc__p_wxMenuBar,

4822

_swigc__p_wxMenuEvent,

4823

_swigc__p_wxMenuItem,

4824

_swigc__p_wxMouseCaptureChangedEvent,

4825

_swigc__p_wxMouseCaptureLostEvent,

4826

_swigc__p_wxMouseEvent,

4827

_swigc__p_wxMoveEvent,

4828

_swigc__p_wxNavigationKeyEvent,

4829

_swigc__p_wxNcPaintEvent,

4830

_swigc__p_wxNotifyEvent,

4831

_swigc__p_wxObject,

4832

_swigc__p_wxPCXHandler,

4833

_swigc__p_wxPNGHandler,

4834

_swigc__p_wxPNMHandler,

4835

_swigc__p_wxPaintEvent,

4836

_swigc__p_wxPaletteChangedEvent,

4837

_swigc__p_wxPaperSize,

4838

_swigc__p_wxPoint,

4839

_swigc__p_wxPyApp,

4840

_swigc__p_wxPyCommandEvent,

4841

_swigc__p_wxPyEvent,

4842

_swigc__p_wxPyEvtHandler,

4843

_swigc__p_wxPyImageHandler,

4844

_swigc__p_wxPySizer,

4845

_swigc__p_wxPyValidator,

4846

_swigc__p_wxQueryNewPaletteEvent,

4847

_swigc__p_wxScrollEvent,

4848

_swigc__p_wxScrollWinEvent,

4849

_swigc__p_wxSetCursorEvent,

4850

_swigc__p_wxShowEvent,

4851

_swigc__p_wxSize,

4852

_swigc__p_wxSizeEvent,

4853

_swigc__p_wxSizer,

4854

_swigc__p_wxSizerItem,

4855

_swigc__p_wxStaticBoxSizer,

4856

_swigc__p_wxStdDialogButtonSizer,

4857

_swigc__p_wxSysColourChangedEvent,

4858

_swigc__p_wxTGAHandler,

4859

_swigc__p_wxTIFFHandler,

4860

_swigc__p_wxUpdateUIEvent,

4861

_swigc__p_wxValidator,

4862

_swigc__p_wxWindow,

4863

_swigc__p_wxWindowCreateEvent,

4864

_swigc__p_wxWindowDestroyEvent,

4865

_swigc__p_wxXPMHandler,

4866

};

4867

4868

4869

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

4870

4871

static swig_const_info swig_const_table[] = {

4872

{0, 0, 0, 0.0, 0, 0}};

4873

4874

#ifdef __cplusplus

4875

}

4876

#endif

4877

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

4878

* Type initialization:

4879

* This problem is tough by the requirement that no dynamic

4880

* memory is used. Also, since swig_type_info structures store pointers to

4881

* swig_cast_info structures and swig_cast_info structures store pointers back

4882

* to swig_type_info structures, we need some lookup code at initialization.

4883

* The idea is that swig generates all the structures that are needed.

4884

* The runtime then collects these partially filled structures.

4885

* The SWIG_InitializeModule function takes these initial arrays out of

4886

* swig_module, and does all the lookup, filling in the swig_module.types

4887

* array with the correct data and linking the correct swig_cast_info

4888

* structures together.

4889

*

4890

* The generated swig_type_info structures are assigned staticly to an initial

4891

* array. We just loop though that array, and handle each type individually.

4892

* First we lookup if this type has been already loaded, and if so, use the

4893

* loaded structure instead of the generated one. Then we have to fill in the

4894

* cast linked list. The cast data is initially stored in something like a

4895

* two-dimensional array. Each row corresponds to a type (there are the same

4896

* number of rows as there are in the swig_type_initial array). Each entry in

4897

* a column is one of the swig_cast_info structures for that type.

4898

* The cast_initial array is actually an array of arrays, because each row has

4899

* a variable number of columns. So to actually build the cast linked list,

4900

* we find the array of casts associated with the type, and loop through it

4901

* adding the casts to the list. The one last trick we need to do is making

4902

* sure the type pointer in the swig_cast_info struct is correct.

4903

*

4904

* First off, we lookup the cast->type name to see if it is already loaded.

4905

* There are three cases to handle:

4906

* 1) If the cast->type has already been loaded AND the type we are adding

4907

* casting info to has not been loaded (it is in this module), THEN we

4908

* replace the cast->type pointer with the type pointer that has already

4909

* been loaded.

4910

* 2) If BOTH types (the one we are adding casting info to, and the

4911

* cast->type) are loaded, THEN the cast info has already been loaded by

4912

* the previous module so we just ignore it.

4913

* 3) Finally, if cast->type has not already been loaded, then we add that

4914

* swig_cast_info to the linked list (because the cast->type) pointer will

4915

* be correct.

4916

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

4917

4918

#ifdef __cplusplus

4919

extern "C" {

4920

#if 0

4921

} /* c-mode */

4922

#endif

4923

#endif

4924

4925

#if 0

4926

#define SWIGRUNTIME_DEBUG

4927

#endif

4928

4929

SWIGRUNTIME void

4930

SWIG_InitializeModule(void *clientdata) {

4931

size_t i;

4932

swig_module_info *module_head;

4933

static int init_run = 0;

4934

4935

clientdata = clientdata;

4936

4937

if (init_run) return;

4938

init_run = 1;

4939

4940

/* Initialize the swig_module */

4941

swig_module.type_initial = swig_type_initial;

4942

swig_module.cast_initial = swig_cast_initial;

4943

4944

/* Try and load any already created modules */

4945

module_head = SWIG_GetModule(clientdata);

4946

if (module_head) {

4947

swig_module.next = module_head->next;

4948

module_head->next = &swig_module;

4949

} else {

4950

/* This is the first module loaded */

4951

swig_module.next = &swig_module;

4952

SWIG_SetModule(clientdata, &swig_module);

4953

}

4954

4955

/* Now work on filling in swig_module.types */

4956

#ifdef SWIGRUNTIME_DEBUG

4957

printf("SWIG_InitializeModule: size %d\n", swig_module.size);

4958

#endif

4959

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

4960

swig_type_info *type = 0;

4961

swig_type_info *ret;

4962

swig_cast_info *cast;

4963

4964

#ifdef SWIGRUNTIME_DEBUG

4965

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

4966

#endif

4967

4968

/* if there is another module already loaded */

4969

if (swig_module.next != &swig_module) {

4970

type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);

4971

}

4972

if (type) {

4973

/* Overwrite clientdata field */

4974

#ifdef SWIGRUNTIME_DEBUG

4975

printf("SWIG_InitializeModule: found type %s\n", type->name);

4976

#endif

4977

if (swig_module.type_initial[i]->clientdata) {

4978

type->clientdata = swig_module.type_initial[i]->clientdata;

4979

#ifdef SWIGRUNTIME_DEBUG

4980

printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);

4981

#endif

4982

}

4983

} else {

4984

type = swig_module.type_initial[i];

4985

}

4986

4987

/* Insert casting types */

4988

cast = swig_module.cast_initial[i];

4989

while (cast->type) {

4990

/* Don't need to add information already in the list */

4991

ret = 0;

4992

#ifdef SWIGRUNTIME_DEBUG

4993

printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);

4994

#endif

4995

if (swig_module.next != &swig_module) {

4996

ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);

4997

#ifdef SWIGRUNTIME_DEBUG

4998

if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);

4999

#endif

5000

}

5001

if (ret) {

5002

if (type == swig_module.type_initial[i]) {

5003

#ifdef SWIGRUNTIME_DEBUG

5004

printf("SWIG_InitializeModule: skip old type %s\n", ret->name);

5005

#endif

5006

cast->type = ret;

5007

ret = 0;

5008

} else {

5009

/* Check for casting already in the list */

5010

swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);

5011

#ifdef SWIGRUNTIME_DEBUG

5012

if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);

5013

#endif

5014

if (!ocast) ret = 0;

5015

}

5016

}

5017

5018

if (!ret) {

5019

#ifdef SWIGRUNTIME_DEBUG

5020

printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);

5021

#endif

5022

if (type->cast) {

5023

type->cast->prev = cast;

5024

cast->next = type->cast;

5025

}

5026

type->cast = cast;

5027

}

5028

cast++;

5029

}

5030

/* Set entry in modules->types array equal to the type */

5031

swig_module.types[i] = type;

5032

}

5033

swig_module.types[i] = 0;

5034

5035

#ifdef SWIGRUNTIME_DEBUG

5036

printf("**** SWIG_InitializeModule: Cast List ******\n");

5037

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

5038

int j = 0;

5039

swig_cast_info *cast = swig_module.cast_initial[i];

5040

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

5041

while (cast->type) {

5042

printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);

5043

cast++;

5044

++j;

5045

}

5046

printf("---- Total casts: %d\n",j);

5047

}

5048

printf("**** SWIG_InitializeModule: Cast List ******\n");

5049

#endif

5050

}

5051

5052

/* This function will propagate the clientdata field of type to

5053

* any new swig_type_info structures that have been added into the list

5054

* of equivalent types. It is like calling

5055

* SWIG_TypeClientData(type, clientdata) a second time.

5056

*/

5057

SWIGRUNTIME void

5058

SWIG_PropagateClientData(void) {

5059

size_t i;

5060

swig_cast_info *equiv;

5061

static int init_run = 0;

5062

5063

if (init_run) return;

5064

init_run = 1;

5065

5066

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

5067

if (swig_module.types[i]->clientdata) {

5068

equiv = swig_module.types[i]->cast;

5069

while (equiv) {

5070

if (!equiv->converter) {

5071

if (equiv->type && !equiv->type->clientdata)

5072

SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);

5073

}

5074

equiv = equiv->next;

5075

}

5076

}

5077

}

5078

}

5079

5080

#ifdef __cplusplus

5081

#if 0

5082

{

5083

/* c-mode */

5084

#endif

5085

}

5086

#endif

5087

5088

5089

5090

#ifdef __cplusplus

5091

extern "C" {

5092

#endif

5093

5094

/* Python-specific SWIG API */

5095

#define SWIG_newvarlink() SWIG_Python_newvarlink()

5096

#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)

5097

#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)

5098

5099

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

5100

* global variable support code.

5101

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

5102

5103

typedef struct swig_globalvar {

5104

char *name; /* Name of global variable */

5105

PyObject *(*get_attr)(void); /* Return the current value */

5106

int (*set_attr)(PyObject *); /* Set the value */

5107

struct swig_globalvar *next;

5108

} swig_globalvar;

5109

5110

typedef struct swig_varlinkobject {

5111

PyObject_HEAD

5112

swig_globalvar *vars;

5113

} swig_varlinkobject;

5114

5115

SWIGINTERN PyObject *

5116

swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {

5117

return PyString_FromString("<Swig global variables>");

5118

}

5119

5120

SWIGINTERN PyObject *

5121

swig_varlink_str(swig_varlinkobject *v) {

5122

PyObject *str = PyString_FromString("(");

5123

swig_globalvar *var;

5124

for (var = v->vars; var; var=var->next) {

5125

PyString_ConcatAndDel(&str,PyString_FromString(var->name));

5126

if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));

5127

}

5128

PyString_ConcatAndDel(&str,PyString_FromString(")"));

5129

return str;

5130

}

5131

5132

SWIGINTERN int

5133

swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {

5134

PyObject *str = swig_varlink_str(v);

5135

fprintf(fp,"Swig global variables ");

5136

fprintf(fp,"%s\n", PyString_AsString(str));

5137

Py_DECREF(str);

5138

return 0;

5139

}

5140

5141

SWIGINTERN void

5142

swig_varlink_dealloc(swig_varlinkobject *v) {

5143

swig_globalvar *var = v->vars;

5144

while (var) {

5145

swig_globalvar *n = var->next;

5146

free(var->name);

5147

free(var);

5148

var = n;

5149

}

5150

}

5151

5152

SWIGINTERN PyObject *

5153

swig_varlink_getattr(swig_varlinkobject *v, char *n) {

5154

PyObject *res = NULL;

5155

swig_globalvar *var = v->vars;

5156

while (var) {

5157

if (strcmp(var->name,n) == 0) {

5158

res = (*var->get_attr)();

5159

break;

5160

}

5161

var = var->next;

5162

}

5163

if (res == NULL && !PyErr_Occurred()) {

5164

PyErr_SetString(PyExc_NameError,"Unknown C global variable");

5165

}

5166

return res;

5167

}

5168

5169

SWIGINTERN int

5170

swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {

5171

int res = 1;

5172

swig_globalvar *var = v->vars;

5173

while (var) {

5174

if (strcmp(var->name,n) == 0) {

5175

res = (*var->set_attr)(p);

5176

break;

5177

}

5178

var = var->next;

5179

}

5180

if (res == 1 && !PyErr_Occurred()) {

5181

PyErr_SetString(PyExc_NameError,"Unknown C global variable");

5182

}

5183

return res;

5184

}

5185

5186

SWIGINTERN PyTypeObject*

5187

swig_varlink_type(void) {

5188

static char varlink__doc__[] = "Swig var link object";

5189

static PyTypeObject varlink_type;

5190

static int type_init = 0;

5191

if (!type_init) {

5192

const PyTypeObject tmp

5193

= {

5194

PyObject_HEAD_INIT(NULL)

5195

0, /* Number of items in variable part (ob_size) */

5196

(char *)"swigvarlink", /* Type name (tp_name) */

5197

sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */

5198

0, /* Itemsize (tp_itemsize) */

5199

(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */

5200

(printfunc) swig_varlink_print, /* Print (tp_print) */

5201

(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */

5202

(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */

5203

0, /* tp_compare */

5204

(reprfunc) swig_varlink_repr, /* tp_repr */

5205

0, /* tp_as_number */

5206

0, /* tp_as_sequence */

5207

0, /* tp_as_mapping */

5208

0, /* tp_hash */

5209

0, /* tp_call */

5210

(reprfunc)swig_varlink_str, /* tp_str */

5211

0, /* tp_getattro */

5212

0, /* tp_setattro */

5213

0, /* tp_as_buffer */

5214

0, /* tp_flags */

5215

varlink__doc__, /* tp_doc */

5216

0, /* tp_traverse */

5217

0, /* tp_clear */

5218

0, /* tp_richcompare */

5219

0, /* tp_weaklistoffset */

5220

#if PY_VERSION_HEX >= 0x02020000

5221

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */

5222

#endif

5223

#if PY_VERSION_HEX >= 0x02030000

5224

0, /* tp_del */

5225

#endif

5226

#ifdef COUNT_ALLOCS

5227

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

5228

#endif

5229

};

5230

varlink_type = tmp;

5231

varlink_type.ob_type = &PyType_Type;

5232

type_init = 1;

5233

}

5234

return &varlink_type;

5235

}

5236

5237

/* Create a variable linking object for use later */

5238

SWIGINTERN PyObject *

5239

SWIG_Python_newvarlink(void) {

5240

swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());

5241

if (result) {

5242

result->vars = 0;

5243

}

5244

return ((PyObject*) result);

5245

}

5246

5247

SWIGINTERN void

5248

SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {

5249

swig_varlinkobject *v = (swig_varlinkobject *) p;

5250

swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));

5251

if (gv) {

5252

size_t size = strlen(name)+1;

5253

gv->name = (char *)malloc(size);

5254

if (gv->name) {

5255

strncpy(gv->name,name,size);

5256

gv->get_attr = get_attr;

5257

gv->set_attr = set_attr;

5258

gv->next = v->vars;

5259

}

5260

}

5261

v->vars = gv;

5262

}

5263

5264

SWIGINTERN PyObject *

5265

SWIG_globals() {

5266

static PyObject *_SWIG_globals = 0;

5267

if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();

5268

return _SWIG_globals;

5269

}

5270

5271

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

5272

* constants/methods manipulation

5273

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

5274

5275

/* Install Constants */

5276

SWIGINTERN void

5277

SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {

5278

PyObject *obj = 0;

5279

size_t i;

5280

for (i = 0; constants[i].type; ++i) {

5281

switch(constants[i].type) {

5282

case SWIG_PY_POINTER:

5283

obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);

5284

break;

5285

case SWIG_PY_BINARY:

5286

obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));

5287

break;

5288

default:

5289

obj = 0;

5290

break;

5291

}

5292

if (obj) {

5293

PyDict_SetItemString(d, constants[i].name, obj);

5294

Py_DECREF(obj);

5295

}

5296

}

5297

}

5298

5299

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

5300

/* Fix SwigMethods to carry the callback ptrs when needed */

5301

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

5302

5303

SWIGINTERN void

5304

SWIG_Python_FixMethods(PyMethodDef *methods,

5305

swig_const_info *const_table,

5306

swig_type_info **types,

5307

swig_type_info **types_initial) {

5308

size_t i;

5309

for (i = 0; methods[i].ml_name; ++i) {

5310

const char *c = methods[i].ml_doc;

5311

if (c && (c = strstr(c, "swig_ptr: "))) {

5312

int j;

5313

swig_const_info *ci = 0;

5314

const char *name = c + 10;

5315

for (j = 0; const_table[j].type; ++j) {

5316

if (strncmp(const_table[j].name, name,

5317

strlen(const_table[j].name)) == 0) {

5318

ci = &(const_table[j]);

5319

break;

5320

}

5321

}

5322

if (ci) {

5323

size_t shift = (ci->ptype) - types;

5324

swig_type_info *ty = types_initial[shift];

5325

size_t ldoc = (c - methods[i].ml_doc);

5326

size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;

5327

char *ndoc = (char*)malloc(ldoc + lptr + 10);

5328

if (ndoc) {

5329

char *buff = ndoc;

5330

void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;

5331

if (ptr) {

5332

strncpy(buff, methods[i].ml_doc, ldoc);

5333

buff += ldoc;

5334

strncpy(buff, "swig_ptr: ", 10);

5335

buff += 10;

5336

SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);

5337

methods[i].ml_doc = ndoc;

5338

}

5339

}

5340

}

5341

}

5342

}

5343

}

5344

5345

#ifdef __cplusplus

5346

}

5347

#endif

5348

5349

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

5350

* Partial Init method

5351

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

5352

5353

#ifdef __cplusplus

5354

extern "C"

5355

#endif

5356

SWIGEXPORT void SWIG_init(void) {

5357

PyObject *m, *d;

5358

5359

/* Fix SwigMethods to carry the callback ptrs when needed */

5360

SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);

5361

5362

m = Py_InitModule((char *) SWIG_name, SwigMethods);

5363

d = PyModule_GetDict(m);

5364

5365

SWIG_InitializeModule(0);

5366

SWIG_InstallConstants(d,swig_const_table);

5367

5368

5369

PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());

5370

SWIG_addvarlink(SWIG_globals(),(char*)"AnimationCtrlNameStr",AnimationCtrlNameStr_get, AnimationCtrlNameStr_set);

5371

SWIG_Python_SetConstant(d, "ANIM_UNSPECIFIED",SWIG_From_int(static_cast< int >(wxANIM_UNSPECIFIED)));

5372

SWIG_Python_SetConstant(d, "ANIM_DONOTREMOVE",SWIG_From_int(static_cast< int >(wxANIM_DONOTREMOVE)));

5373

SWIG_Python_SetConstant(d, "ANIM_TOBACKGROUND",SWIG_From_int(static_cast< int >(wxANIM_TOBACKGROUND)));

5374

SWIG_Python_SetConstant(d, "ANIM_TOPREVIOUS",SWIG_From_int(static_cast< int >(wxANIM_TOPREVIOUS)));

5375

SWIG_Python_SetConstant(d, "ANIMATION_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxANIMATION_TYPE_INVALID)));

5376

SWIG_Python_SetConstant(d, "ANIMATION_TYPE_GIF",SWIG_From_int(static_cast< int >(wxANIMATION_TYPE_GIF)));

5377

SWIG_Python_SetConstant(d, "ANIMATION_TYPE_ANI",SWIG_From_int(static_cast< int >(wxANIMATION_TYPE_ANI)));

5378

SWIG_Python_SetConstant(d, "ANIMATION_TYPE_ANY",SWIG_From_int(static_cast< int >(wxANIMATION_TYPE_ANY)));

5379

SWIG_addvarlink(SWIG_globals(),(char*)"NullAnimation",NullAnimation_get, NullAnimation_set);

5380

SWIG_Python_SetConstant(d, "AC_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxAC_NO_AUTORESIZE)));

5381

SWIG_Python_SetConstant(d, "AC_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxAC_DEFAULT_STYLE)));

5382

SWIG_Python_SetConstant(d, "AN_FIT_ANIMATION",SWIG_From_int(static_cast< int >(wxAN_FIT_ANIMATION)));

5383

}

5384