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

1

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

2

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

3

* Version 1.3.29

4

*

5

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

6

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

7

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

8

* interface file instead.

9

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

10

11

#define SWIGPYTHON

12

#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

13

14

#ifdef __cplusplus

15

template<class T> class SwigValueWrapper {

16

T *tt;

17

public:

18

SwigValueWrapper() : tt(0) { }

19

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

20

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

21

~SwigValueWrapper() { delete tt; }

22

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

23

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

24

T *operator&() { return tt; }

25

private:

26

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

27

};

28

#endif

29

30

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

31

* This section contains generic SWIG labels for method/variable

32

* declarations/attributes, and other compiler dependent labels.

33

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

34

35

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

36

#ifndef SWIGTEMPLATEDISAMBIGUATOR

37

# if defined(__SUNPRO_CC)

38

# if (__SUNPRO_CC <= 0x560)

39

# define SWIGTEMPLATEDISAMBIGUATOR template

40

# else

41

# define SWIGTEMPLATEDISAMBIGUATOR

42

# endif

43

# else

44

# define SWIGTEMPLATEDISAMBIGUATOR

45

# endif

46

#endif

47

48

/* inline attribute */

49

#ifndef SWIGINLINE

50

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

51

# define SWIGINLINE inline

52

# else

53

# define SWIGINLINE

54

# endif

55

#endif

56

57

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

58

#ifndef SWIGUNUSED

59

# if defined(__GNUC__)

60

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

61

# define SWIGUNUSED __attribute__ ((__unused__))

62

# else

63

# define SWIGUNUSED

64

# endif

65

# elif defined(__ICC)

66

# define SWIGUNUSED __attribute__ ((__unused__))

67

# else

68

# define SWIGUNUSED

69

# endif

70

#endif

71

72

#ifndef SWIGUNUSEDPARM

73

# ifdef __cplusplus

74

# define SWIGUNUSEDPARM(p)

75

# else

76

# define SWIGUNUSEDPARM(p) p SWIGUNUSED

77

# endif

78

#endif

79

80

/* internal SWIG method */

81

#ifndef SWIGINTERN

82

# define SWIGINTERN static SWIGUNUSED

83

#endif

84

85

/* internal inline SWIG method */

86

#ifndef SWIGINTERNINLINE

87

# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE

88

#endif

89

90

/* exporting methods */

91

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

92

# ifndef GCC_HASCLASSVISIBILITY

93

# define GCC_HASCLASSVISIBILITY

94

# endif

95

#endif

96

97

#ifndef SWIGEXPORT

98

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

99

# if defined(STATIC_LINKED)

100

# define SWIGEXPORT

101

# else

102

# define SWIGEXPORT __declspec(dllexport)

103

# endif

104

# else

105

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

106

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

107

# else

108

# define SWIGEXPORT

109

# endif

110

# endif

111

#endif

112

113

/* calling conventions for Windows */

114

#ifndef SWIGSTDCALL

115

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

116

# define SWIGSTDCALL __stdcall

117

# else

118

# define SWIGSTDCALL

119

# endif

120

#endif

121

122

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

123

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

124

# define _CRT_SECURE_NO_DEPRECATE

125

#endif

126

127

128

/* Python.h has to appear first */

129

#include <Python.h>

130

131

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

132

* swigrun.swg

133

*

134

* This file contains generic CAPI SWIG runtime support for pointer

135

* type checking.

136

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

137

138

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

139

or for whatever reason, the runtime changes incompatibly */

140

#define SWIG_RUNTIME_VERSION "2"

141

142

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */

143

#ifdef SWIG_TYPE_TABLE

144

# define SWIG_QUOTE_STRING(x) #x

145

# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)

146

# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)

147

#else

148

# define SWIG_TYPE_TABLE_NAME

149

#endif

150

151

/*

152

You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for

153

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

154

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

155

156

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

157

with your compiler or so.

158

*/

159

160

#ifndef SWIGRUNTIME

161

# define SWIGRUNTIME SWIGINTERN

162

#endif

163

164

#ifndef SWIGRUNTIMEINLINE

165

# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE

166

#endif

167

168

/* Generic buffer size */

169

#ifndef SWIG_BUFFER_SIZE

170

# define SWIG_BUFFER_SIZE 1024

171

#endif

172

173

/* Flags for pointer conversions */

174

#define SWIG_POINTER_DISOWN 0x1

175

176

/* Flags for new pointer objects */

177

#define SWIG_POINTER_OWN 0x1

178

179

180

/*

181

Flags/methods for returning states.

182

183

The swig conversion methods, as ConvertPtr, return and integer

184

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

185

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

186

187

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

188

states.

189

190

In old swig versions, you usually write code as:

191

192

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

193

// success code

194

} else {

195

//fail code

196

}

197

198

Now you can be more explicit as:

199

200

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

201

if (SWIG_IsOK(res)) {

202

// success code

203

} else {

204

// fail code

205

}

206

207

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

208

209

Type *ptr;

210

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

211

if (SWIG_IsOK(res)) {

212

// success code

213

if (SWIG_IsNewObj(res) {

214

...

215

delete *ptr;

216

} else {

217

...

218

}

219

} else {

220

// fail code

221

}

222

223

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

224

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

225

requires also to SWIG_ConvertPtr to return new result values, as

226

227

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

228

if (<obj is ok>) {

229

if (<need new object>) {

230

*ptr = <ptr to new allocated object>;

231

return SWIG_NEWOBJ;

232

} else {

233

*ptr = <ptr to old object>;

234

return SWIG_OLDOBJ;

235

}

236

} else {

237

return SWIG_BADOBJ;

238

}

239

}

240

241

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

242

more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the

243

swig errors code.

244

245

Finally, if the SWIG_CASTRANK_MODE is enabled, the result code

246

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

247

248

int food(double)

249

int fooi(int);

250

251

and you call

252

253

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

254

fooi(1) // cast rank '0'

255

256

just use the SWIG_AddCast()/SWIG_CheckState()

257

258

259

*/

260

#define SWIG_OK (0)

261

#define SWIG_ERROR (-1)

262

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

263

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

264

265

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

266

#define SWIG_CASTRANKLIMIT (1 << 8)

267

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

268

#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)

269

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

270

#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)

271

/* Simple returning values */

272

#define SWIG_BADOBJ (SWIG_ERROR)

273

#define SWIG_OLDOBJ (SWIG_OK)

274

#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)

275

#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)

276

/* Check, add and del mask methods */

277

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

278

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

279

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

280

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

281

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

282

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

283

284

285

/* Cast-Rank Mode */

286

#if defined(SWIG_CASTRANK_MODE)

287

# ifndef SWIG_TypeRank

288

# define SWIG_TypeRank unsigned long

289

# endif

290

# ifndef SWIG_MAXCASTRANK /* Default cast allowed */

291

# define SWIG_MAXCASTRANK (2)

292

# endif

293

# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)

294

# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)

295

SWIGINTERNINLINE int SWIG_AddCast(int r) {

296

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

297

}

298

SWIGINTERNINLINE int SWIG_CheckState(int r) {

299

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

300

}

301

#else /* no cast-rank mode */

302

# define SWIG_AddCast

303

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

304

#endif

305

306

307

308

309

#include <string.h>

310

311

#ifdef __cplusplus

312

extern "C" {

313

#endif

314

315

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

316

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

317

318

/* Structure to store inforomation on one type */

319

typedef struct swig_type_info {

320

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

321

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

322

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

323

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

324

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

325

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

326

} swig_type_info;

327

328

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

329

typedef struct swig_cast_info {

330

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

331

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

332

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

333

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

334

} swig_cast_info;

335

336

/* Structure used to store module information

337

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

338

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

339

typedef struct swig_module_info {

340

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

341

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

342

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

343

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

344

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

345

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

346

} swig_module_info;

347

348

/*

349

Compare two type names skipping the space characters, therefore

350

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

351

352

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

353

strncmp, but skipping ' '.

354

*/

355

SWIGRUNTIME int

356

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

357

const char *f2, const char *l2) {

358

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

359

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

360

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

361

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

362

}

363

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

364

}

365

366

/*

367

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

368

Return 0 if not equal, 1 if equal

369

*/

370

SWIGRUNTIME int

371

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

372

int equiv = 0;

373

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

374

const char* ne = nb;

375

while (!equiv && *ne) {

376

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

377

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

378

}

379

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

380

if (*ne) ++ne;

381

}

382

return equiv;

383

}

384

385

/*

386

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

387

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

388

*/

389

SWIGRUNTIME int

390

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

391

int equiv = 0;

392

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

393

const char* ne = nb;

394

while (!equiv && *ne) {

395

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

396

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

397

}

398

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

399

if (*ne) ++ne;

400

}

401

return equiv;

402

}

403

404

405

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

406

#define SWIG_TypeCheck_Template(comparison, ty) \

407

if (ty) { \

408

swig_cast_info *iter = ty->cast; \

409

while (iter) { \

410

if (comparison) { \

411

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

412

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

413

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

414

if (iter->next) \

415

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

416

iter->next = ty->cast; \

417

iter->prev = 0; \

418

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

419

ty->cast = iter; \

420

return iter; \

421

} \

422

iter = iter->next; \

423

} \

424

} \

425

return 0

426

427

/*

428

Check the typename

429

*/

430

SWIGRUNTIME swig_cast_info *

431

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

432

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

433

}

434

435

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

436

SWIGRUNTIME swig_cast_info *

437

SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {

438

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

439

}

440

441

/*

442

Cast a pointer up an inheritance hierarchy

443

*/

444

SWIGRUNTIMEINLINE void *

445

SWIG_TypeCast(swig_cast_info *ty, void *ptr) {

446

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

447

}

448

449

/*

450

Dynamic pointer casting. Down an inheritance hierarchy

451

*/

452

SWIGRUNTIME swig_type_info *

453

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

454

swig_type_info *lastty = ty;

455

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

456

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

457

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

458

if (ty) lastty = ty;

459

}

460

return lastty;

461

}

462

463

/*

464

Return the name associated with this type

465

*/

466

SWIGRUNTIMEINLINE const char *

467

SWIG_TypeName(const swig_type_info *ty) {

468

return ty->name;

469

}

470

471

/*

472

Return the pretty name associated with this type,

473

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

474

*/

475

SWIGRUNTIME const char *

476

SWIG_TypePrettyName(const swig_type_info *type) {

477

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

478

type, separated by vertical-bar characters. We choose

479

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

480

specific. */

481

if (!type) return NULL;

482

if (type->str != NULL) {

483

const char *last_name = type->str;

484

const char *s;

485

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

486

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

487

return last_name;

488

}

489

else

490

return type->name;

491

}

492

493

/*

494

Set the clientdata field for a type

495

*/

496

SWIGRUNTIME void

497

SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {

498

swig_cast_info *cast = ti->cast;

499

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

500

ti->clientdata = clientdata;

501

502

while (cast) {

503

if (!cast->converter) {

504

swig_type_info *tc = cast->type;

505

if (!tc->clientdata) {

506

SWIG_TypeClientData(tc, clientdata);

507

}

508

}

509

cast = cast->next;

510

}

511

}

512

SWIGRUNTIME void

513

SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {

514

SWIG_TypeClientData(ti, clientdata);

515

ti->owndata = 1;

516

}

517

518

/*

519

Search for a swig_type_info structure only by mangled name

520

Search is a O(log #types)

521

522

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

523

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

524

the circular list.

525

*/

526

SWIGRUNTIME swig_type_info *

527

SWIG_MangledTypeQueryModule(swig_module_info *start,

528

swig_module_info *end,

529

const char *name) {

530

swig_module_info *iter = start;

531

do {

532

if (iter->size) {

533

register size_t l = 0;

534

register size_t r = iter->size - 1;

535

do {

536

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

537

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

538

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

539

if (iname) {

540

register int compare = strcmp(name, iname);

541

if (compare == 0) {

542

return iter->types[i];

543

} else if (compare < 0) {

544

if (i) {

545

r = i - 1;

546

} else {

547

break;

548

}

549

} else if (compare > 0) {

550

l = i + 1;

551

}

552

} else {

553

break; /* should never happen */

554

}

555

} while (l <= r);

556

}

557

iter = iter->next;

558

} while (iter != end);

559

return 0;

560

}

561

562

/*

563

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

564

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

565

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

566

567

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

568

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

569

the circular list.

570

*/

571

SWIGRUNTIME swig_type_info *

572

SWIG_TypeQueryModule(swig_module_info *start,

573

swig_module_info *end,

574

const char *name) {

575

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

576

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

577

if (ret) {

578

return ret;

579

} else {

580

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

581

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

582

swig_module_info *iter = start;

583

do {

584

register size_t i = 0;

585

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

586

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

587

return iter->types[i];

588

}

589

iter = iter->next;

590

} while (iter != end);

591

}

592

593

/* neither found a match */

594

return 0;

595

}

596

597

/*

598

Pack binary data into a string

599

*/

600

SWIGRUNTIME char *

601

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

602

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

603

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

604

register const unsigned char *eu = u + sz;

605

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

606

register unsigned char uu = *u;

607

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

608

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

609

}

610

return c;

611

}

612

613

/*

614

Unpack binary data from a string

615

*/

616

SWIGRUNTIME const char *

617

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

618

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

619

register const unsigned char *eu = u + sz;

620

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

621

register char d = *(c++);

622

register unsigned char uu;

623

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

624

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

625

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

626

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

627

else

628

return (char *) 0;

629

d = *(c++);

630

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

631

uu |= (d - '0');

632

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

633

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

634

else

635

return (char *) 0;

636

*u = uu;

637

}

638

return c;

639

}

640

641

/*

642

Pack 'void *' into a string buffer.

643

*/

644

SWIGRUNTIME char *

645

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

646

char *r = buff;

647

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

648

*(r++) = '_';

649

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

650

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

651

strcpy(r,name);

652

return buff;

653

}

654

655

SWIGRUNTIME const char *

656

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

657

if (*c != '_') {

658

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

659

*ptr = (void *) 0;

660

return name;

661

} else {

662

return 0;

663

}

664

}

665

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

666

}

667

668

SWIGRUNTIME char *

669

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

670

char *r = buff;

671

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

672

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

673

*(r++) = '_';

674

r = SWIG_PackData(r,ptr,sz);

675

if (lname) {

676

strncpy(r,name,lname+1);

677

} else {

678

*r = 0;

679

}

680

return buff;

681

}

682

683

SWIGRUNTIME const char *

684

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

685

if (*c != '_') {

686

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

687

memset(ptr,0,sz);

688

return name;

689

} else {

690

return 0;

691

}

692

}

693

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

694

}

695

696

#ifdef __cplusplus

697

}

698

#endif

699

700

/* Errors in SWIG */

701

#define SWIG_UnknownError -1

702

#define SWIG_IOError -2

703

#define SWIG_RuntimeError -3

704

#define SWIG_IndexError -4

705

#define SWIG_TypeError -5

706

#define SWIG_DivisionByZero -6

707

#define SWIG_OverflowError -7

708

#define SWIG_SyntaxError -8

709

#define SWIG_ValueError -9

710

#define SWIG_SystemError -10

711

#define SWIG_AttributeError -11

712

#define SWIG_MemoryError -12

713

#define SWIG_NullReferenceError -13

714

715

716

717

/* Python.h has to appear first */

718

#include <Python.h>

719

720

/* Add PyOS_snprintf for old Pythons */

721

#if PY_VERSION_HEX < 0x02020000

722

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

723

# define PyOS_snprintf _snprintf

724

# else

725

# define PyOS_snprintf snprintf

726

# endif

727

#endif

728

729

/* A crude PyString_FromFormat implementation for old Pythons */

730

#if PY_VERSION_HEX < 0x02020000

731

732

#ifndef SWIG_PYBUFFER_SIZE

733

# define SWIG_PYBUFFER_SIZE 1024

734

#endif

735

736

static PyObject *

737

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

738

va_list ap;

739

char buf[SWIG_PYBUFFER_SIZE * 2];

740

int res;

741

va_start(ap, fmt);

742

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

743

va_end(ap);

744

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

745

}

746

#endif

747

748

/* Add PyObject_Del for old Pythons */

749

#if PY_VERSION_HEX < 0x01060000

750

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

751

#endif

752

#ifndef PyObject_DEL

753

# define PyObject_DEL PyObject_Del

754

#endif

755

756

/* A crude PyExc_StopIteration exception for old Pythons */

757

#if PY_VERSION_HEX < 0x02020000

758

# ifndef PyExc_StopIteration

759

# define PyExc_StopIteration PyExc_RuntimeError

760

# endif

761

# ifndef PyObject_GenericGetAttr

762

# define PyObject_GenericGetAttr 0

763

# endif

764

#endif

765

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

766

#if PY_VERSION_HEX < 0x02010000

767

# ifndef Py_NotImplemented

768

# define Py_NotImplemented PyExc_RuntimeError

769

# endif

770

#endif

771

772

773

/* A crude PyString_AsStringAndSize implementation for old Pythons */

774

#if PY_VERSION_HEX < 0x02010000

775

# ifndef PyString_AsStringAndSize

776

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

777

# endif

778

#endif

779

780

/* PySequence_Size for old Pythons */

781

#if PY_VERSION_HEX < 0x02000000

782

# ifndef PySequence_Size

783

# define PySequence_Size PySequence_Length

784

# endif

785

#endif

786

787

788

/* PyBool_FromLong for old Pythons */

789

#if PY_VERSION_HEX < 0x02030000

790

static

791

PyObject *PyBool_FromLong(long ok)

792

{

793

PyObject *result = ok ? Py_True : Py_False;

794

Py_INCREF(result);

795

return result;

796

}

797

#endif

798

799

800

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

801

* error manipulation

802

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

803

804

SWIGRUNTIME PyObject*

805

SWIG_Python_ErrorType(int code) {

806

PyObject* type = 0;

807

switch(code) {

808

case SWIG_MemoryError:

809

type = PyExc_MemoryError;

810

break;

811

case SWIG_IOError:

812

type = PyExc_IOError;

813

break;

814

case SWIG_RuntimeError:

815

type = PyExc_RuntimeError;

816

break;

817

case SWIG_IndexError:

818

type = PyExc_IndexError;

819

break;

820

case SWIG_TypeError:

821

type = PyExc_TypeError;

822

break;

823

case SWIG_DivisionByZero:

824

type = PyExc_ZeroDivisionError;

825

break;

826

case SWIG_OverflowError:

827

type = PyExc_OverflowError;

828

break;

829

case SWIG_SyntaxError:

830

type = PyExc_SyntaxError;

831

break;

832

case SWIG_ValueError:

833

type = PyExc_ValueError;

834

break;

835

case SWIG_SystemError:

836

type = PyExc_SystemError;

837

break;

838

case SWIG_AttributeError:

839

type = PyExc_AttributeError;

840

break;

841

default:

842

type = PyExc_RuntimeError;

843

}

844

return type;

845

}

846

847

848

SWIGRUNTIME void

849

SWIG_Python_AddErrorMsg(const char* mesg)

850

{

851

PyObject *type = 0;

852

PyObject *value = 0;

853

PyObject *traceback = 0;

854

855

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

856

if (value) {

857

PyObject *old_str = PyObject_Str(value);

858

PyErr_Clear();

859

Py_XINCREF(type);

860

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

861

Py_DECREF(old_str);

862

Py_DECREF(value);

863

} else {

864

PyErr_Format(PyExc_RuntimeError, mesg);

865

}

866

}

867

868

869

870

#if defined(SWIG_PYTHON_NO_THREADS)

871

# if defined(SWIG_PYTHON_THREADS)

872

# undef SWIG_PYTHON_THREADS

873

# endif

874

#endif

875

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

876

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

877

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

878

# define SWIG_PYTHON_USE_GIL

879

# endif

880

# endif

881

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

882

# ifndef SWIG_PYTHON_INITIALIZE_THREADS

883

# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()

884

# endif

885

# ifdef __cplusplus /* C++ code */

886

class SWIG_Python_Thread_Block {

887

bool status;

888

PyGILState_STATE state;

889

public:

890

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

891

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

892

~SWIG_Python_Thread_Block() { end(); }

893

};

894

class SWIG_Python_Thread_Allow {

895

bool status;

896

PyThreadState *save;

897

public:

898

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

899

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

900

~SWIG_Python_Thread_Allow() { end(); }

901

};

902

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block

903

# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()

904

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow

905

# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()

906

# else /* C code */

907

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()

908

# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)

909

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()

910

# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)

911

# endif

912

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

913

# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)

914

# define SWIG_PYTHON_INITIALIZE_THREADS

915

# endif

916

# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)

917

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK

918

# endif

919

# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)

920

# define SWIG_PYTHON_THREAD_END_BLOCK

921

# endif

922

# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)

923

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW

924

# endif

925

# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)

926

# define SWIG_PYTHON_THREAD_END_ALLOW

927

# endif

928

# endif

929

#else /* No thread support */

930

# define SWIG_PYTHON_INITIALIZE_THREADS

931

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK

932

# define SWIG_PYTHON_THREAD_END_BLOCK

933

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW

934

# define SWIG_PYTHON_THREAD_END_ALLOW

935

#endif

936

937

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

938

* Python API portion that goes into the runtime

939

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

940

941

#ifdef __cplusplus

942

extern "C" {

943

#if 0

944

} /* cc-mode */

945

#endif

946

#endif

947

948

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

949

* Constant declarations

950

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

951

952

/* Constant Types */

953

#define SWIG_PY_POINTER 4

954

#define SWIG_PY_BINARY 5

955

956

/* Constant information structure */

957

typedef struct swig_const_info {

958

int type;

959

char *name;

960

long lvalue;

961

double dvalue;

962

void *pvalue;

963

swig_type_info **ptype;

964

} swig_const_info;

965

966

#ifdef __cplusplus

967

#if 0

968

{ /* cc-mode */

969

#endif

970

}

971

#endif

972

973

974

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

975

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

976

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

977

*

978

* pyrun.swg

979

*

980

* This file contains the runtime support for Python modules

981

* and includes code for managing global variables and pointer

982

* type checking.

983

*

984

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

985

986

/* Common SWIG API */

987

988

#if PY_VERSION_HEX < 0x02050000

989

typedef int Py_ssize_t;

990

#endif

991

992

/* for raw pointers */

993

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

994

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

995

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

996

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

997

#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)

998

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

999

#define swig_owntype int

1000

1001

/* for raw packed data */

1002

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

1003

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

1004

1005

/* for class or struct pointers */

1006

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

1007

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

1008

1009

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

1010

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

1011

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

1012

1013

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

1014

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

1015

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

1016

1017

1018

/* Runtime API */

1019

1020

#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()

1021

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

1022

#define SWIG_NewClientData(obj) PySwigClientData_New(obj)

1023

1024

#define SWIG_SetErrorObj SWIG_Python_SetErrorObj

1025

#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg

1026

#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)

1027

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

1028

#define SWIG_fail goto fail

1029

1030

1031

/* Runtime API implementation */

1032

1033

/* Error manipulation */

1034

1035

SWIGINTERN void

1036

SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {

1037

SWIG_PYTHON_THREAD_BEGIN_BLOCK;

1038

PyErr_SetObject(errtype, obj);

1039

Py_DECREF(obj);

1040

SWIG_PYTHON_THREAD_END_BLOCK;

1041

}

1042

1043

SWIGINTERN void

1044

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

1045

SWIG_PYTHON_THREAD_BEGIN_BLOCK;

1046

PyErr_SetString(errtype, (char *) msg);

1047

SWIG_PYTHON_THREAD_END_BLOCK;

1048

}

1049

1050

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

1051

1052

/* Set a constant value */

1053

1054

SWIGINTERN void

1055

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

1056

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

1057

Py_DECREF(obj);

1058

}

1059

1060

/* Append a value to the result obj */

1061

1062

SWIGINTERN PyObject*

1063

SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {

1064

#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)

1065

if (!result) {

1066

result = obj;

1067

} else if (result == Py_None) {

1068

Py_DECREF(result);

1069

result = obj;

1070

} else {

1071

if (!PyList_Check(result)) {

1072

PyObject *o2 = result;

1073

result = PyList_New(1);

1074

PyList_SetItem(result, 0, o2);

1075

}

1076

PyList_Append(result,obj);

1077

Py_DECREF(obj);

1078

}

1079

return result;

1080

#else

1081

PyObject* o2;

1082

PyObject* o3;

1083

if (!result) {

1084

result = obj;

1085

} else if (result == Py_None) {

1086

Py_DECREF(result);

1087

result = obj;

1088

} else {

1089

if (!PyTuple_Check(result)) {

1090

o2 = result;

1091

result = PyTuple_New(1);

1092

PyTuple_SET_ITEM(result, 0, o2);

1093

}

1094

o3 = PyTuple_New(1);

1095

PyTuple_SET_ITEM(o3, 0, obj);

1096

o2 = result;

1097

result = PySequence_Concat(o2, o3);

1098

Py_DECREF(o2);

1099

Py_DECREF(o3);

1100

}

1101

return result;

1102

#endif

1103

}

1104

1105

/* Unpack the argument tuple */

1106

1107

SWIGINTERN int

1108

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

1109

{

1110

if (!args) {

1111

if (!min && !max) {

1112

return 1;

1113

} else {

1114

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

1115

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

1116

return 0;

1117

}

1118

}

1119

if (!PyTuple_Check(args)) {

1120

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

1121

return 0;

1122

} else {

1123

register int l = PyTuple_GET_SIZE(args);

1124

if (l < min) {

1125

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

1126

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

1127

return 0;

1128

} else if (l > max) {

1129

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

1130

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

1131

return 0;

1132

} else {

1133

register int i;

1134

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

1135

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

1136

}

1137

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

1138

objs[l] = 0;

1139

}

1140

return i + 1;

1141

}

1142

}

1143

}

1144

1145

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

1146

#if PY_VERSION_HEX >= 0x02020000

1147

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

1148

#else

1149

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

1150

#endif

1151

1152

/*

1153

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

1154

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

1155

*/

1156

#ifdef __cplusplus

1157

#define SWIG_STATIC_POINTER(var) var

1158

#else

1159

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

1160

#endif

1161

1162

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

1163

* Pointer declarations

1164

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

1165

1166

/* Flags for new pointer objects */

1167

#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)

1168

#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

1169

1170

#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)

1171

1172

#ifdef __cplusplus

1173

extern "C" {

1174

#if 0

1175

} /* cc-mode */

1176

#endif

1177

#endif

1178

1179

/* How to access Py_None */

1180

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

1181

# ifndef SWIG_PYTHON_NO_BUILD_NONE

1182

# ifndef SWIG_PYTHON_BUILD_NONE

1183

# define SWIG_PYTHON_BUILD_NONE

1184

# endif

1185

# endif

1186

#endif

1187

1188

#ifdef SWIG_PYTHON_BUILD_NONE

1189

# ifdef Py_None

1190

# undef Py_None

1191

# define Py_None SWIG_Py_None()

1192

# endif

1193

SWIGRUNTIMEINLINE PyObject *

1194

_SWIG_Py_None(void)

1195

{

1196

PyObject *none = Py_BuildValue("");

1197

Py_DECREF(none);

1198

return none;

1199

}

1200

SWIGRUNTIME PyObject *

1201

SWIG_Py_None(void)

1202

{

1203

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

1204

return none;

1205

}

1206

#endif

1207

1208

/* The python void return value */

1209

1210

SWIGRUNTIMEINLINE PyObject *

1211

SWIG_Py_Void(void)

1212

{

1213

PyObject *none = Py_None;

1214

Py_INCREF(none);

1215

return none;

1216

}

1217

1218

/* PySwigClientData */

1219

1220

typedef struct {

1221

PyObject *klass;

1222

PyObject *newraw;

1223

PyObject *newargs;

1224

PyObject *destroy;

1225

int delargs;

1226

int implicitconv;

1227

} PySwigClientData;

1228

1229

SWIGRUNTIMEINLINE int

1230

SWIG_Python_CheckImplicit(swig_type_info *ty)

1231

{

1232

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

1233

return data ? data->implicitconv : 0;

1234

}

1235

1236

SWIGRUNTIMEINLINE PyObject *

1237

SWIG_Python_ExceptionType(swig_type_info *desc) {

1238

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

1239

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

1240

return (klass ? klass : PyExc_RuntimeError);

1241

}

1242

1243

1244

SWIGRUNTIME PySwigClientData *

1245

PySwigClientData_New(PyObject* obj)

1246

{

1247

if (!obj) {

1248

return 0;

1249

} else {

1250

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

1251

/* the klass element */

1252

data->klass = obj;

1253

Py_INCREF(data->klass);

1254

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

1255

if (PyClass_Check(obj)) {

1256

data->newraw = 0;

1257

data->newargs = obj;

1258

Py_INCREF(obj);

1259

} else {

1260

#if (PY_VERSION_HEX < 0x02020000)

1261

data->newraw = 0;

1262

#else

1263

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

1264

#endif

1265

if (data->newraw) {

1266

Py_INCREF(data->newraw);

1267

data->newargs = PyTuple_New(1);

1268

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

1269

} else {

1270

data->newargs = obj;

1271

}

1272

Py_INCREF(data->newargs);

1273

}

1274

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

1275

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

1276

if (PyErr_Occurred()) {

1277

PyErr_Clear();

1278

data->destroy = 0;

1279

}

1280

if (data->destroy) {

1281

int flags;

1282

Py_INCREF(data->destroy);

1283

flags = PyCFunction_GET_FLAGS(data->destroy);

1284

#ifdef METH_O

1285

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

1286

#else

1287

data->delargs = 0;

1288

#endif

1289

} else {

1290

data->delargs = 0;

1291

}

1292

data->implicitconv = 0;

1293

return data;

1294

}

1295

}

1296

1297

SWIGRUNTIME void

1298

PySwigClientData_Del(PySwigClientData* data)

1299

{

1300

Py_XDECREF(data->newraw);

1301

Py_XDECREF(data->newargs);

1302

Py_XDECREF(data->destroy);

1303

}

1304

1305

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

1306

1307

typedef struct {

1308

PyObject_HEAD

1309

void *ptr;

1310

swig_type_info *ty;

1311

int own;

1312

PyObject *next;

1313

} PySwigObject;

1314

1315

SWIGRUNTIME PyObject *

1316

PySwigObject_long(PySwigObject *v)

1317

{

1318

return PyLong_FromVoidPtr(v->ptr);

1319

}

1320

1321

SWIGRUNTIME PyObject *

1322

PySwigObject_format(const char* fmt, PySwigObject *v)

1323

{

1324

PyObject *res = NULL;

1325

PyObject *args = PyTuple_New(1);

1326

if (args) {

1327

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

1328

PyObject *ofmt = PyString_FromString(fmt);

1329

if (ofmt) {

1330

res = PyString_Format(ofmt,args);

1331

Py_DECREF(ofmt);

1332

}

1333

Py_DECREF(args);

1334

}

1335

}

1336

return res;

1337

}

1338

1339

SWIGRUNTIME PyObject *

1340

PySwigObject_oct(PySwigObject *v)

1341

{

1342

return PySwigObject_format("%o",v);

1343

}

1344

1345

SWIGRUNTIME PyObject *

1346

PySwigObject_hex(PySwigObject *v)

1347

{

1348

return PySwigObject_format("%x",v);

1349

}

1350

1351

SWIGRUNTIME PyObject *

1352

#ifdef METH_NOARGS

1353

PySwigObject_repr(PySwigObject *v)

1354

#else

1355

PySwigObject_repr(PySwigObject *v, PyObject *args)

1356

#endif

1357

{

1358

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

1359

PyObject *hex = PySwigObject_hex(v);

1360

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

1361

Py_DECREF(hex);

1362

if (v->next) {

1363

#ifdef METH_NOARGS

1364

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

1365

#else

1366

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

1367

#endif

1368

PyString_ConcatAndDel(&repr,nrep);

1369

}

1370

return repr;

1371

}

1372

1373

SWIGRUNTIME int

1374

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

1375

{

1376

#ifdef METH_NOARGS

1377

PyObject *repr = PySwigObject_repr(v);

1378

#else

1379

PyObject *repr = PySwigObject_repr(v, NULL);

1380

#endif

1381

if (repr) {

1382

fputs(PyString_AsString(repr), fp);

1383

Py_DECREF(repr);

1384

return 0;

1385

} else {

1386

return 1;

1387

}

1388

}

1389

1390

SWIGRUNTIME PyObject *

1391

PySwigObject_str(PySwigObject *v)

1392

{

1393

char result[SWIG_BUFFER_SIZE];

1394

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

1395

PyString_FromString(result) : 0;

1396

}

1397

1398

SWIGRUNTIME int

1399

PySwigObject_compare(PySwigObject *v, PySwigObject *w)

1400

{

1401

void *i = v->ptr;

1402

void *j = w->ptr;

1403

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

1404

}

1405

1406

SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);

1407

1408

SWIGRUNTIME PyTypeObject*

1409

PySwigObject_type(void) {

1410

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

1411

return type;

1412

}

1413

1414

SWIGRUNTIMEINLINE int

1415

PySwigObject_Check(PyObject *op) {

1416

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

1417

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

1418

}

1419

1420

SWIGRUNTIME PyObject *

1421

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

1422

1423

SWIGRUNTIME void

1424

PySwigObject_dealloc(PyObject *v)

1425

{

1426

PySwigObject *sobj = (PySwigObject *) v;

1427

PyObject *next = sobj->next;

1428

if (sobj->own) {

1429

swig_type_info *ty = sobj->ty;

1430

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

1431

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

1432

if (destroy) {

1433

/* destroy is always a VARARGS method */

1434

PyObject *res;

1435

if (data->delargs) {

1436

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

1437

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

1438

res = SWIG_Python_CallFunctor(destroy, tmp);

1439

Py_DECREF(tmp);

1440

} else {

1441

PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);

1442

PyObject *mself = PyCFunction_GET_SELF(destroy);

1443

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

1444

}

1445

Py_XDECREF(res);

1446

} else {

1447

const char *name = SWIG_TypePrettyName(ty);

1448

#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)

1449

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

1450

#endif

1451

}

1452

}

1453

Py_XDECREF(next);

1454

PyObject_DEL(v);

1455

}

1456

1457

SWIGRUNTIME PyObject*

1458

PySwigObject_append(PyObject* v, PyObject* next)

1459

{

1460

PySwigObject *sobj = (PySwigObject *) v;

1461

#ifndef METH_O

1462

PyObject *tmp = 0;

1463

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

1464

next = tmp;

1465

#endif

1466

if (!PySwigObject_Check(next)) {

1467

return NULL;

1468

}

1469

sobj->next = next;

1470

Py_INCREF(next);

1471

return SWIG_Py_Void();

1472

}

1473

1474

SWIGRUNTIME PyObject*

1475

#ifdef METH_NOARGS

1476

PySwigObject_next(PyObject* v)

1477

#else

1478

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

1479

#endif

1480

{

1481

PySwigObject *sobj = (PySwigObject *) v;

1482

if (sobj->next) {

1483

Py_INCREF(sobj->next);

1484

return sobj->next;

1485

} else {

1486

return SWIG_Py_Void();

1487

}

1488

}

1489

1490

SWIGINTERN PyObject*

1491

#ifdef METH_NOARGS

1492

PySwigObject_disown(PyObject *v)

1493

#else

1494

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

1495

#endif

1496

{

1497

PySwigObject *sobj = (PySwigObject *)v;

1498

sobj->own = 0;

1499

return SWIG_Py_Void();

1500

}

1501

1502

SWIGINTERN PyObject*

1503

#ifdef METH_NOARGS

1504

PySwigObject_acquire(PyObject *v)

1505

#else

1506

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

1507

#endif

1508

{

1509

PySwigObject *sobj = (PySwigObject *)v;

1510

sobj->own = SWIG_POINTER_OWN;

1511

return SWIG_Py_Void();

1512

}

1513

1514

SWIGINTERN PyObject*

1515

PySwigObject_own(PyObject *v, PyObject *args)

1516

{

1517

PyObject *val = 0;

1518

#if (PY_VERSION_HEX < 0x02020000)

1519

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

1520

#else

1521

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

1522

#endif

1523

{

1524

return NULL;

1525

}

1526

else

1527

{

1528

PySwigObject *sobj = (PySwigObject *)v;

1529

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

1530

if (val) {

1531

#ifdef METH_NOARGS

1532

if (PyObject_IsTrue(val)) {

1533

PySwigObject_acquire(v);

1534

} else {

1535

PySwigObject_disown(v);

1536

}

1537

#else

1538

if (PyObject_IsTrue(val)) {

1539

PySwigObject_acquire(v,args);

1540

} else {

1541

PySwigObject_disown(v,args);

1542

}

1543

#endif

1544

}

1545

return obj;

1546

}

1547

}

1548

1549

#ifdef METH_O

1550

static PyMethodDef

1551

swigobject_methods[] = {

1552

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

1553

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

1554

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

1555

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

1556

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

1557

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

1558

{0, 0, 0, 0}

1559

};

1560

#else

1561

static PyMethodDef

1562

swigobject_methods[] = {

1563

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

1564

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

1565

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

1566

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

1567

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

1568

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

1569

{0, 0, 0, 0}

1570

};

1571

#endif

1572

1573

#if PY_VERSION_HEX < 0x02020000

1574

SWIGINTERN PyObject *

1575

PySwigObject_getattr(PySwigObject *sobj,char *name)

1576

{

1577

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

1578

}

1579

#endif

1580

1581

SWIGRUNTIME PyTypeObject*

1582

_PySwigObject_type(void) {

1583

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

1584

1585

static PyNumberMethods PySwigObject_as_number = {

1586

(binaryfunc)0, /*nb_add*/

1587

(binaryfunc)0, /*nb_subtract*/

1588

(binaryfunc)0, /*nb_multiply*/

1589

(binaryfunc)0, /*nb_divide*/

1590

(binaryfunc)0, /*nb_remainder*/

1591

(binaryfunc)0, /*nb_divmod*/

1592

(ternaryfunc)0,/*nb_power*/

1593

(unaryfunc)0, /*nb_negative*/

1594

(unaryfunc)0, /*nb_positive*/

1595

(unaryfunc)0, /*nb_absolute*/

1596

(inquiry)0, /*nb_nonzero*/

1597

0, /*nb_invert*/

1598

0, /*nb_lshift*/

1599

0, /*nb_rshift*/

1600

0, /*nb_and*/

1601

0, /*nb_xor*/

1602

0, /*nb_or*/

1603

(coercion)0, /*nb_coerce*/

1604

(unaryfunc)PySwigObject_long, /*nb_int*/

1605

(unaryfunc)PySwigObject_long, /*nb_long*/

1606

(unaryfunc)0, /*nb_float*/

1607

(unaryfunc)PySwigObject_oct, /*nb_oct*/

1608

(unaryfunc)PySwigObject_hex, /*nb_hex*/

1609

#if PY_VERSION_HEX >= 0x02020000

1610

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

1611

#elif PY_VERSION_HEX >= 0x02000000

1612

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

1613

#endif

1614

};

1615

1616

static PyTypeObject pyswigobject_type;

1617

static int type_init = 0;

1618

if (!type_init) {

1619

const PyTypeObject tmp

1620

= {

1621

PyObject_HEAD_INIT(NULL)

1622

0, /* ob_size */

1623

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

1624

sizeof(PySwigObject), /* tp_basicsize */

1625

0, /* tp_itemsize */

1626

(destructor)PySwigObject_dealloc, /* tp_dealloc */

1627

(printfunc)PySwigObject_print, /* tp_print */

1628

#if PY_VERSION_HEX < 0x02020000

1629

(getattrfunc)PySwigObject_getattr, /* tp_getattr */

1630

#else

1631

(getattrfunc)0, /* tp_getattr */

1632

#endif

1633

(setattrfunc)0, /* tp_setattr */

1634

(cmpfunc)PySwigObject_compare, /* tp_compare */

1635

(reprfunc)PySwigObject_repr, /* tp_repr */

1636

&PySwigObject_as_number, /* tp_as_number */

1637

0, /* tp_as_sequence */

1638

0, /* tp_as_mapping */

1639

(hashfunc)0, /* tp_hash */

1640

(ternaryfunc)0, /* tp_call */

1641

(reprfunc)PySwigObject_str, /* tp_str */

1642

PyObject_GenericGetAttr, /* tp_getattro */

1643

0, /* tp_setattro */

1644

0, /* tp_as_buffer */

1645

Py_TPFLAGS_DEFAULT, /* tp_flags */

1646

swigobject_doc, /* tp_doc */

1647

0, /* tp_traverse */

1648

0, /* tp_clear */

1649

0, /* tp_richcompare */

1650

0, /* tp_weaklistoffset */

1651

#if PY_VERSION_HEX >= 0x02020000

1652

0, /* tp_iter */

1653

0, /* tp_iternext */

1654

swigobject_methods, /* tp_methods */

1655

0, /* tp_members */

1656

0, /* tp_getset */

1657

0, /* tp_base */

1658

0, /* tp_dict */

1659

0, /* tp_descr_get */

1660

0, /* tp_descr_set */

1661

0, /* tp_dictoffset */

1662

0, /* tp_init */

1663

0, /* tp_alloc */

1664

0, /* tp_new */

1665

0, /* tp_free */

1666

0, /* tp_is_gc */

1667

0, /* tp_bases */

1668

0, /* tp_mro */

1669

0, /* tp_cache */

1670

0, /* tp_subclasses */

1671

0, /* tp_weaklist */

1672

#endif

1673

#if PY_VERSION_HEX >= 0x02030000

1674

0, /* tp_del */

1675

#endif

1676

#ifdef COUNT_ALLOCS

1677

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

1678

#endif

1679

};

1680

pyswigobject_type = tmp;

1681

pyswigobject_type.ob_type = &PyType_Type;

1682

type_init = 1;

1683

}

1684

return &pyswigobject_type;

1685

}

1686

1687

SWIGRUNTIME PyObject *

1688

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

1689

{

1690

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

1691

if (sobj) {

1692

sobj->ptr = ptr;

1693

sobj->ty = ty;

1694

sobj->own = own;

1695

sobj->next = 0;

1696

}

1697

return (PyObject *)sobj;

1698

}

1699

1700

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

1701

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

1702

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

1703

1704

typedef struct {

1705

PyObject_HEAD

1706

void *pack;

1707

swig_type_info *ty;

1708

size_t size;

1709

} PySwigPacked;

1710

1711

SWIGRUNTIME int

1712

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

1713

{

1714

char result[SWIG_BUFFER_SIZE];

1715

fputs("<Swig Packed ", fp);

1716

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

1717

fputs("at ", fp);

1718

fputs(result, fp);

1719

}

1720

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

1721

fputs(">", fp);

1722

return 0;

1723

}

1724

1725

SWIGRUNTIME PyObject *

1726

PySwigPacked_repr(PySwigPacked *v)

1727

{

1728

char result[SWIG_BUFFER_SIZE];

1729

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

1730

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

1731

} else {

1732

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

1733

}

1734

}

1735

1736

SWIGRUNTIME PyObject *

1737

PySwigPacked_str(PySwigPacked *v)

1738

{

1739

char result[SWIG_BUFFER_SIZE];

1740

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

1741

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

1742

} else {

1743

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

1744

}

1745

}

1746

1747

SWIGRUNTIME int

1748

PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)

1749

{

1750

size_t i = v->size;

1751

size_t j = w->size;

1752

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

1753

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

1754

}

1755

1756

SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);

1757

1758

SWIGRUNTIME PyTypeObject*

1759

PySwigPacked_type(void) {

1760

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

1761

return type;

1762

}

1763

1764

SWIGRUNTIMEINLINE int

1765

PySwigPacked_Check(PyObject *op) {

1766

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

1767

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

1768

}

1769

1770

SWIGRUNTIME void

1771

PySwigPacked_dealloc(PyObject *v)

1772

{

1773

if (PySwigPacked_Check(v)) {

1774

PySwigPacked *sobj = (PySwigPacked *) v;

1775

free(sobj->pack);

1776

}

1777

PyObject_DEL(v);

1778

}

1779

1780

SWIGRUNTIME PyTypeObject*

1781

_PySwigPacked_type(void) {

1782

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

1783

static PyTypeObject pyswigpacked_type;

1784

static int type_init = 0;

1785

if (!type_init) {

1786

const PyTypeObject tmp

1787

= {

1788

PyObject_HEAD_INIT(NULL)

1789

0, /* ob_size */

1790

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

1791

sizeof(PySwigPacked), /* tp_basicsize */

1792

0, /* tp_itemsize */

1793

(destructor)PySwigPacked_dealloc, /* tp_dealloc */

1794

(printfunc)PySwigPacked_print, /* tp_print */

1795

(getattrfunc)0, /* tp_getattr */

1796

(setattrfunc)0, /* tp_setattr */

1797

(cmpfunc)PySwigPacked_compare, /* tp_compare */

1798

(reprfunc)PySwigPacked_repr, /* tp_repr */

1799

0, /* tp_as_number */

1800

0, /* tp_as_sequence */

1801

0, /* tp_as_mapping */

1802

(hashfunc)0, /* tp_hash */

1803

(ternaryfunc)0, /* tp_call */

1804

(reprfunc)PySwigPacked_str, /* tp_str */

1805

PyObject_GenericGetAttr, /* tp_getattro */

1806

0, /* tp_setattro */

1807

0, /* tp_as_buffer */

1808

Py_TPFLAGS_DEFAULT, /* tp_flags */

1809

swigpacked_doc, /* tp_doc */

1810

0, /* tp_traverse */

1811

0, /* tp_clear */

1812

0, /* tp_richcompare */

1813

0, /* tp_weaklistoffset */

1814

#if PY_VERSION_HEX >= 0x02020000

1815

0, /* tp_iter */

1816

0, /* tp_iternext */

1817

0, /* tp_methods */

1818

0, /* tp_members */

1819

0, /* tp_getset */

1820

0, /* tp_base */

1821

0, /* tp_dict */

1822

0, /* tp_descr_get */

1823

0, /* tp_descr_set */

1824

0, /* tp_dictoffset */

1825

0, /* tp_init */

1826

0, /* tp_alloc */

1827

0, /* tp_new */

1828

0, /* tp_free */

1829

0, /* tp_is_gc */

1830

0, /* tp_bases */

1831

0, /* tp_mro */

1832

0, /* tp_cache */

1833

0, /* tp_subclasses */

1834

0, /* tp_weaklist */

1835

#endif

1836

#if PY_VERSION_HEX >= 0x02030000

1837

0, /* tp_del */

1838

#endif

1839

#ifdef COUNT_ALLOCS

1840

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

1841

#endif

1842

};

1843

pyswigpacked_type = tmp;

1844

pyswigpacked_type.ob_type = &PyType_Type;

1845

type_init = 1;

1846

}

1847

return &pyswigpacked_type;

1848

}

1849

1850

SWIGRUNTIME PyObject *

1851

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

1852

{

1853

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

1854

if (sobj) {

1855

void *pack = malloc(size);

1856

if (pack) {

1857

memcpy(pack, ptr, size);

1858

sobj->pack = pack;

1859

sobj->ty = ty;

1860

sobj->size = size;

1861

} else {

1862

PyObject_DEL((PyObject *) sobj);

1863

sobj = 0;

1864

}

1865

}

1866

return (PyObject *) sobj;

1867

}

1868

1869

SWIGRUNTIME swig_type_info *

1870

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

1871

{

1872

if (PySwigPacked_Check(obj)) {

1873

PySwigPacked *sobj = (PySwigPacked *)obj;

1874

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

1875

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

1876

return sobj->ty;

1877

} else {

1878

return 0;

1879

}

1880

}

1881

1882

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

1883

* pointers/data manipulation

1884

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

1885

1886

SWIGRUNTIMEINLINE PyObject *

1887

_SWIG_This(void)

1888

{

1889

return PyString_FromString("this");

1890

}

1891

1892

SWIGRUNTIME PyObject *

1893

SWIG_This(void)

1894

{

1895

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

1896

return swig_this;

1897

}

1898

1899

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

1900

1901

SWIGRUNTIME PySwigObject *

1902

SWIG_Python_GetSwigThis(PyObject *pyobj)

1903

{

1904

if (PySwigObject_Check(pyobj)) {

1905

return (PySwigObject *) pyobj;

1906

} else {

1907

PyObject *obj = 0;

1908

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

1909

if (PyInstance_Check(pyobj)) {

1910

obj = _PyInstance_Lookup(pyobj, SWIG_This());

1911

} else {

1912

PyObject **dictptr = _PyObject_GetDictPtr(pyobj);

1913

if (dictptr != NULL) {

1914

PyObject *dict = *dictptr;

1915

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

1916

} else {

1917

#ifdef PyWeakref_CheckProxy

1918

if (PyWeakref_CheckProxy(pyobj)) {

1919

PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);

1920

return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;

1921

}

1922

#endif

1923

obj = PyObject_GetAttr(pyobj,SWIG_This());

1924

if (obj) {

1925

Py_DECREF(obj);

1926

} else {

1927

if (PyErr_Occurred()) PyErr_Clear();

1928

return 0;

1929

}

1930

}

1931

}

1932

#else

1933

obj = PyObject_GetAttr(pyobj,SWIG_This());

1934

if (obj) {

1935

Py_DECREF(obj);

1936

} else {

1937

if (PyErr_Occurred()) PyErr_Clear();

1938

return 0;

1939

}

1940

#endif

1941

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

1942

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

1943

PySwigObject from it */

1944

return SWIG_Python_GetSwigThis(obj);

1945

}

1946

return (PySwigObject *)obj;

1947

}

1948

}

1949

1950

/* Acquire a pointer value */

1951

1952

SWIGRUNTIME int

1953

SWIG_Python_AcquirePtr(PyObject *obj, int own) {

1954

if (own) {

1955

PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);

1956

if (sobj) {

1957

int oldown = sobj->own;

1958

sobj->own = own;

1959

return oldown;

1960

}

1961

}

1962

return 0;

1963

}

1964

1965

/* Convert a pointer value */

1966

1967

SWIGRUNTIME int

1968

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

1969

if (!obj) return SWIG_ERROR;

1970

if (obj == Py_None) {

1971

if (ptr) *ptr = 0;

1972

return SWIG_OK;

1973

} else {

1974

PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);

1975

while (sobj) {

1976

void *vptr = sobj->ptr;

1977

if (ty) {

1978

swig_type_info *to = sobj->ty;

1979

if (to == ty) {

1980

/* no type cast needed */

1981

if (ptr) *ptr = vptr;

1982

break;

1983

} else {

1984

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

1985

if (!tc) {

1986

sobj = (PySwigObject *)sobj->next;

1987

} else {

1988

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

1989

break;

1990

}

1991

}

1992

} else {

1993

if (ptr) *ptr = vptr;

1994

break;

1995

}

1996

}

1997

if (sobj) {

1998

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

1999

if (flags & SWIG_POINTER_DISOWN) {

2000

sobj->own = 0;

2001

}

2002

return SWIG_OK;

2003

} else {

2004

int res = SWIG_ERROR;

2005

if (flags & SWIG_POINTER_IMPLICIT_CONV) {

2006

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

2007

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

2008

PyObject *klass = data->klass;

2009

if (klass) {

2010

PyObject *impconv;

2011

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

2012

impconv = SWIG_Python_CallFunctor(klass, obj);

2013

data->implicitconv = 0;

2014

if (PyErr_Occurred()) {

2015

PyErr_Clear();

2016

impconv = 0;

2017

}

2018

if (impconv) {

2019

PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);

2020

if (iobj) {

2021

void *vptr;

2022

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

2023

if (SWIG_IsOK(res)) {

2024

if (ptr) {

2025

*ptr = vptr;

2026

/* transfer the ownership to 'ptr' */

2027

iobj->own = 0;

2028

res = SWIG_AddCast(res);

2029

res = SWIG_AddNewMask(res);

2030

} else {

2031

res = SWIG_AddCast(res);

2032

}

2033

}

2034

}

2035

Py_DECREF(impconv);

2036

}

2037

}

2038

}

2039

}

2040

return res;

2041

}

2042

}

2043

}

2044

2045

/* Convert a function ptr value */

2046

2047

SWIGRUNTIME int

2048

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

2049

if (!PyCFunction_Check(obj)) {

2050

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

2051

} else {

2052

void *vptr = 0;

2053

2054

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

2055

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

2056

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

2057

if (desc) {

2058

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

2059

if (!desc) return SWIG_ERROR;

2060

}

2061

if (ty) {

2062

swig_cast_info *tc = SWIG_TypeCheck(desc,ty);

2063

if (!tc) return SWIG_ERROR;

2064

*ptr = SWIG_TypeCast(tc,vptr);

2065

} else {

2066

*ptr = vptr;

2067

}

2068

return SWIG_OK;

2069

}

2070

}

2071

2072

/* Convert a packed value value */

2073

2074

SWIGRUNTIME int

2075

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

2076

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

2077

if (!to) return SWIG_ERROR;

2078

if (ty) {

2079

if (to != ty) {

2080

/* check type cast? */

2081

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

2082

if (!tc) return SWIG_ERROR;

2083

}

2084

}

2085

return SWIG_OK;

2086

}

2087

2088

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

2089

* Create a new pointer object

2090

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

2091

2092

/*

2093

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

2094

'this' attribute.

2095

*/

2096

2097

SWIGRUNTIME PyObject*

2098

SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)

2099

{

2100

#if (PY_VERSION_HEX >= 0x02020000)

2101

PyObject *inst = 0;

2102

PyObject *newraw = data->newraw;

2103

if (newraw) {

2104

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

2105

if (inst) {

2106

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)

2107

PyObject **dictptr = _PyObject_GetDictPtr(inst);

2108

if (dictptr != NULL) {

2109

PyObject *dict = *dictptr;

2110

if (dict == NULL) {

2111

dict = PyDict_New();

2112

*dictptr = dict;

2113

PyDict_SetItem(dict, SWIG_This(), swig_this);

2114

}

2115

}

2116

#else

2117

PyObject *key = SWIG_This();

2118

PyObject_SetAttr(inst, key, swig_this);

2119

#endif

2120

}

2121

} else {

2122

PyObject *dict = PyDict_New();

2123

PyDict_SetItem(dict, SWIG_This(), swig_this);

2124

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

2125

Py_DECREF(dict);

2126

}

2127

return inst;

2128

#else

2129

#if (PY_VERSION_HEX >= 0x02010000)

2130

PyObject *inst;

2131

PyObject *dict = PyDict_New();

2132

PyDict_SetItem(dict, SWIG_This(), swig_this);

2133

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

2134

Py_DECREF(dict);

2135

return (PyObject *) inst;

2136

#else

2137

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

2138

if (inst == NULL) {

2139

return NULL;

2140

}

2141

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

2142

Py_INCREF(inst->in_class);

2143

inst->in_dict = PyDict_New();

2144

if (inst->in_dict == NULL) {

2145

Py_DECREF(inst);

2146

return NULL;

2147

}

2148

#ifdef Py_TPFLAGS_HAVE_WEAKREFS

2149

inst->in_weakreflist = NULL;

2150

#endif

2151

#ifdef Py_TPFLAGS_GC

2152

PyObject_GC_Init(inst);

2153

#endif

2154

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

2155

return (PyObject *) inst;

2156

#endif

2157

#endif

2158

}

2159

2160

SWIGRUNTIME void

2161

SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)

2162

{

2163

PyObject *dict;

2164

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

2165

PyObject **dictptr = _PyObject_GetDictPtr(inst);

2166

if (dictptr != NULL) {

2167

dict = *dictptr;

2168

if (dict == NULL) {

2169

dict = PyDict_New();

2170

*dictptr = dict;

2171

}

2172

PyDict_SetItem(dict, SWIG_This(), swig_this);

2173

return;

2174

}

2175

#endif

2176

dict = PyObject_GetAttrString(inst, "__dict__");

2177

PyDict_SetItem(dict, SWIG_This(), swig_this);

2178

Py_DECREF(dict);

2179

}

2180

2181

2182

SWIGINTERN PyObject *

2183

SWIG_Python_InitShadowInstance(PyObject *args) {

2184

PyObject *obj[2];

2185

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

2186

return NULL;

2187

} else {

2188

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

2189

if (sthis) {

2190

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

2191

} else {

2192

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

2193

}

2194

return SWIG_Py_Void();

2195

}

2196

}

2197

2198

/* Create a new pointer object */

2199

2200

SWIGRUNTIME PyObject *

2201

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

2202

if (!ptr) {

2203

return SWIG_Py_Void();

2204

} else {

2205

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

2206

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

2207

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

2208

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

2209

PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);

2210

if (inst) {

2211

Py_DECREF(robj);

2212

robj = inst;

2213

}

2214

}

2215

return robj;

2216

}

2217

}

2218

2219

/* Create a new packed object */

2220

2221

SWIGRUNTIMEINLINE PyObject *

2222

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

2223

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

2224

}

2225

2226

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

2227

* Get type list

2228

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

2229

2230

#ifdef SWIG_LINK_RUNTIME

2231

void *SWIG_ReturnGlobalTypeList(void *);

2232

#endif

2233

2234

SWIGRUNTIME swig_module_info *

2235

SWIG_Python_GetModule(void) {

2236

static void *type_pointer = (void *)0;

2237

/* first check if module already created */

2238

if (!type_pointer) {

2239

#ifdef SWIG_LINK_RUNTIME

2240

type_pointer = SWIG_ReturnGlobalTypeList((void *)0);

2241

#else

2242

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

2243

(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);

2244

if (PyErr_Occurred()) {

2245

PyErr_Clear();

2246

type_pointer = (void *)0;

2247

}

2248

#endif

2249

}

2250

return (swig_module_info *) type_pointer;

2251

}

2252

2253

#if PY_MAJOR_VERSION < 2

2254

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

2255

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

2256

SWIGINTERN int

2257

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

2258

{

2259

PyObject *dict;

2260

if (!PyModule_Check(m)) {

2261

PyErr_SetString(PyExc_TypeError,

2262

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

2263

return SWIG_ERROR;

2264

}

2265

if (!o) {

2266

PyErr_SetString(PyExc_TypeError,

2267

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

2268

return SWIG_ERROR;

2269

}

2270

2271

dict = PyModule_GetDict(m);

2272

if (dict == NULL) {

2273

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

2274

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

2275

PyModule_GetName(m));

2276

return SWIG_ERROR;

2277

}

2278

if (PyDict_SetItemString(dict, name, o))

2279

return SWIG_ERROR;

2280

Py_DECREF(o);

2281

return SWIG_OK;

2282

}

2283

#endif

2284

2285

SWIGRUNTIME void

2286

SWIG_Python_DestroyModule(void *vptr)

2287

{

2288

swig_module_info *swig_module = (swig_module_info *) vptr;

2289

swig_type_info **types = swig_module->types;

2290

size_t i;

2291

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

2292

swig_type_info *ty = types[i];

2293

if (ty->owndata) {

2294

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

2295

if (data) PySwigClientData_Del(data);

2296

}

2297

}

2298

Py_DECREF(SWIG_This());

2299

}

2300

2301

SWIGRUNTIME void

2302

SWIG_Python_SetModule(swig_module_info *swig_module) {

2303

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

2304

2305

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

2306

swig_empty_runtime_method_table);

2307

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

2308

if (pointer && module) {

2309

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

2310

} else {

2311

Py_XDECREF(pointer);

2312

}

2313

}

2314

2315

/* The python cached type query */

2316

SWIGRUNTIME PyObject *

2317

SWIG_Python_TypeCache() {

2318

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

2319

return cache;

2320

}

2321

2322

SWIGRUNTIME swig_type_info *

2323

SWIG_Python_TypeQuery(const char *type)

2324

{

2325

PyObject *cache = SWIG_Python_TypeCache();

2326

PyObject *key = PyString_FromString(type);

2327

PyObject *obj = PyDict_GetItem(cache, key);

2328

swig_type_info *descriptor;

2329

if (obj) {

2330

descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);

2331

} else {

2332

swig_module_info *swig_module = SWIG_Python_GetModule();

2333

descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);

2334

if (descriptor) {

2335

obj = PyCObject_FromVoidPtr(descriptor, NULL);

2336

PyDict_SetItem(cache, key, obj);

2337

Py_DECREF(obj);

2338

}

2339

}

2340

Py_DECREF(key);

2341

return descriptor;

2342

}

2343

2344

/*

2345

For backward compatibility only

2346

*/

2347

#define SWIG_POINTER_EXCEPTION 0

2348

#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)

2349

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

2350

2351

SWIGRUNTIME int

2352

SWIG_Python_AddErrMesg(const char* mesg, int infront)

2353

{

2354

if (PyErr_Occurred()) {

2355

PyObject *type = 0;

2356

PyObject *value = 0;

2357

PyObject *traceback = 0;

2358

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

2359

if (value) {

2360

PyObject *old_str = PyObject_Str(value);

2361

Py_XINCREF(type);

2362

PyErr_Clear();

2363

if (infront) {

2364

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

2365

} else {

2366

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

2367

}

2368

Py_DECREF(old_str);

2369

}

2370

return 1;

2371

} else {

2372

return 0;

2373

}

2374

}

2375

2376

SWIGRUNTIME int

2377

SWIG_Python_ArgFail(int argnum)

2378

{

2379

if (PyErr_Occurred()) {

2380

/* add information about failing argument */

2381

char mesg[256];

2382

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

2383

return SWIG_Python_AddErrMesg(mesg, 1);

2384

} else {

2385

return 0;

2386

}

2387

}

2388

2389

SWIGRUNTIMEINLINE const char *

2390

PySwigObject_GetDesc(PyObject *self)

2391

{

2392

PySwigObject *v = (PySwigObject *)self;

2393

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

2394

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

2395

}

2396

2397

SWIGRUNTIME void

2398

SWIG_Python_TypeError(const char *type, PyObject *obj)

2399

{

2400

if (type) {

2401

#if defined(SWIG_COBJECT_TYPES)

2402

if (obj && PySwigObject_Check(obj)) {

2403

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

2404

if (otype) {

2405

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

2406

type, otype);

2407

return;

2408

}

2409

} else

2410

#endif

2411

{

2412

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

2413

if (otype) {

2414

PyObject *str = PyObject_Str(obj);

2415

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

2416

if (cstr) {

2417

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

2418

type, otype, cstr);

2419

} else {

2420

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

2421

type, otype);

2422

}

2423

Py_XDECREF(str);

2424

return;

2425

}

2426

}

2427

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

2428

} else {

2429

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

2430

}

2431

}

2432

2433

2434

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

2435

SWIGRUNTIME void *

2436

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

2437

void *result;

2438

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

2439

PyErr_Clear();

2440

if (flags & SWIG_POINTER_EXCEPTION) {

2441

SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);

2442

SWIG_Python_ArgFail(argnum);

2443

}

2444

}

2445

return result;

2446

}

2447

2448

2449

#ifdef __cplusplus

2450

#if 0

2451

{ /* cc-mode */

2452

#endif

2453

}

2454

#endif

2455

2456

2457

2458

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

2459

2460

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

2461

2462

2463

2464

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

2465

2466

#define SWIGTYPE_p_char swig_types[0]

2467

#define SWIGTYPE_p_double swig_types[1]

2468

#define SWIGTYPE_p_form_ops_t swig_types[2]

2469

#define SWIGTYPE_p_int swig_types[3]

2470

#define SWIGTYPE_p_unsigned_char swig_types[4]

2471

#define SWIGTYPE_p_unsigned_int swig_types[5]

2472

#define SWIGTYPE_p_unsigned_long swig_types[6]

2473

#define SWIGTYPE_p_wxANIHandler swig_types[7]

2474

#define SWIGTYPE_p_wxAcceleratorTable swig_types[8]

2475

#define SWIGTYPE_p_wxActivateEvent swig_types[9]

2476

#define SWIGTYPE_p_wxBMPHandler swig_types[10]

2477

#define SWIGTYPE_p_wxBoxSizer swig_types[11]

2478

#define SWIGTYPE_p_wxCURHandler swig_types[12]

2479

#define SWIGTYPE_p_wxChildFocusEvent swig_types[13]

2480

#define SWIGTYPE_p_wxClipboardTextEvent swig_types[14]

2481

#define SWIGTYPE_p_wxCloseEvent swig_types[15]

2482

#define SWIGTYPE_p_wxCommandEvent swig_types[16]

2483

#define SWIGTYPE_p_wxContextMenuEvent swig_types[17]

2484

#define SWIGTYPE_p_wxControl swig_types[18]

2485

#define SWIGTYPE_p_wxControlWithItems swig_types[19]

2486

#define SWIGTYPE_p_wxDateEvent swig_types[20]

2487

#define SWIGTYPE_p_wxDisplayChangedEvent swig_types[21]

2488

#define SWIGTYPE_p_wxDropFilesEvent swig_types[22]

2489

#define SWIGTYPE_p_wxDuplexMode swig_types[23]

2490

#define SWIGTYPE_p_wxEraseEvent swig_types[24]

2491

#define SWIGTYPE_p_wxEvent swig_types[25]

2492

#define SWIGTYPE_p_wxEvtHandler swig_types[26]

2493

#define SWIGTYPE_p_wxFSFile swig_types[27]

2494

#define SWIGTYPE_p_wxFileSystem swig_types[28]

2495

#define SWIGTYPE_p_wxFlexGridSizer swig_types[29]

2496

#define SWIGTYPE_p_wxFocusEvent swig_types[30]

2497

#define SWIGTYPE_p_wxGBSizerItem swig_types[31]

2498

#define SWIGTYPE_p_wxGIFHandler swig_types[32]

2499

#define SWIGTYPE_p_wxGridBagSizer swig_types[33]

2500

#define SWIGTYPE_p_wxGridSizer swig_types[34]

2501

#define SWIGTYPE_p_wxICOHandler swig_types[35]

2502

#define SWIGTYPE_p_wxIconizeEvent swig_types[36]

2503

#define SWIGTYPE_p_wxIdleEvent swig_types[37]

2504

#define SWIGTYPE_p_wxImage swig_types[38]

2505

#define SWIGTYPE_p_wxImageHandler swig_types[39]

2506

#define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[40]

2507

#define SWIGTYPE_p_wxInitDialogEvent swig_types[41]

2508

#define SWIGTYPE_p_wxJPEGHandler swig_types[42]

2509

#define SWIGTYPE_p_wxKeyEvent swig_types[43]

2510

#define SWIGTYPE_p_wxLayoutConstraints swig_types[44]

2511

#define SWIGTYPE_p_wxMaximizeEvent swig_types[45]

2512

#define SWIGTYPE_p_wxMenu swig_types[46]

2513

#define SWIGTYPE_p_wxMenuBar swig_types[47]

2514

#define SWIGTYPE_p_wxMenuEvent swig_types[48]

2515

#define SWIGTYPE_p_wxMenuItem swig_types[49]

2516

#define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[50]

2517

#define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[51]

2518

#define SWIGTYPE_p_wxMouseEvent swig_types[52]

2519

#define SWIGTYPE_p_wxMoveEvent swig_types[53]

2520

#define SWIGTYPE_p_wxNavigationKeyEvent swig_types[54]

2521

#define SWIGTYPE_p_wxNcPaintEvent swig_types[55]

2522

#define SWIGTYPE_p_wxNotifyEvent swig_types[56]

2523

#define SWIGTYPE_p_wxObject swig_types[57]

2524

#define SWIGTYPE_p_wxPCXHandler swig_types[58]

2525

#define SWIGTYPE_p_wxPNGHandler swig_types[59]

2526

#define SWIGTYPE_p_wxPNMHandler swig_types[60]

2527

#define SWIGTYPE_p_wxPaintEvent swig_types[61]

2528

#define SWIGTYPE_p_wxPaletteChangedEvent swig_types[62]

2529

#define SWIGTYPE_p_wxPaperSize swig_types[63]

2530

#define SWIGTYPE_p_wxPyApp swig_types[64]

2531

#define SWIGTYPE_p_wxPyCommandEvent swig_types[65]

2532

#define SWIGTYPE_p_wxPyEvent swig_types[66]

2533

#define SWIGTYPE_p_wxPyEvtHandler swig_types[67]

2534

#define SWIGTYPE_p_wxPyImageHandler swig_types[68]

2535

#define SWIGTYPE_p_wxPySizer swig_types[69]

2536

#define SWIGTYPE_p_wxPyValidator swig_types[70]

2537

#define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[71]

2538

#define SWIGTYPE_p_wxScrollEvent swig_types[72]

2539

#define SWIGTYPE_p_wxScrollWinEvent swig_types[73]

2540

#define SWIGTYPE_p_wxSetCursorEvent swig_types[74]

2541

#define SWIGTYPE_p_wxShowEvent swig_types[75]

2542

#define SWIGTYPE_p_wxSizeEvent swig_types[76]

2543

#define SWIGTYPE_p_wxSizer swig_types[77]

2544

#define SWIGTYPE_p_wxSizerItem swig_types[78]

2545

#define SWIGTYPE_p_wxStaticBoxSizer swig_types[79]

2546

#define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[80]

2547

#define SWIGTYPE_p_wxSysColourChangedEvent swig_types[81]

2548

#define SWIGTYPE_p_wxTGAHandler swig_types[82]

2549

#define SWIGTYPE_p_wxTIFFHandler swig_types[83]

2550

#define SWIGTYPE_p_wxUpdateUIEvent swig_types[84]

2551

#define SWIGTYPE_p_wxValidator swig_types[85]

2552

#define SWIGTYPE_p_wxWebKitBeforeLoadEvent swig_types[86]

2553

#define SWIGTYPE_p_wxWebKitCtrl swig_types[87]

2554

#define SWIGTYPE_p_wxWebKitNewWindowEvent swig_types[88]

2555

#define SWIGTYPE_p_wxWebKitStateChangedEvent swig_types[89]

2556

#define SWIGTYPE_p_wxWindow swig_types[90]

2557

#define SWIGTYPE_p_wxWindowCreateEvent swig_types[91]

2558

#define SWIGTYPE_p_wxWindowDestroyEvent swig_types[92]

2559

#define SWIGTYPE_p_wxXPMHandler swig_types[93]

2560

static swig_type_info *swig_types[95];

2561

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

2562

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

2563

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

2564

2565

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

2566

2567

#if (PY_VERSION_HEX <= 0x02000000)

2568

# if !defined(SWIG_PYTHON_CLASSIC)

2569

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

2570

# endif

2571

#endif

2572

#if (PY_VERSION_HEX <= 0x02020000)

2573

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

2574

#endif

2575

#if (PY_VERSION_HEX <= 0x02020000)

2576

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

2577

#endif

2578

#ifndef METH_O

2579

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

2580

#endif

2581

2582

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

2583

@(target):= _webkit.so

2584

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

2585

#define SWIG_init init_webkit

2586

2587

#define SWIG_name "_webkit"

2588

2589

#define SWIGVERSION 0x010329

2590

2591

2592

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

2593

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

2594

2595

2596

#include <stdexcept>

2597

2598

2599

namespace swig {

2600

class PyObject_ptr {

2601

protected:

2602

PyObject *_obj;

2603

2604

public:

2605

PyObject_ptr() :_obj(0)

2606

{

2607

}

2608

2609

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

2610

{

2611

Py_XINCREF(_obj);

2612

}

2613

2614

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

2615

{

2616

if (initial_ref) Py_XINCREF(_obj);

2617

}

2618

2619

PyObject_ptr & operator=(const PyObject_ptr& item)

2620

{

2621

Py_XINCREF(item._obj);

2622

Py_XDECREF(_obj);

2623

_obj = item._obj;

2624

return *this;

2625

}

2626

2627

~PyObject_ptr()

2628

{

2629

Py_XDECREF(_obj);

2630

}

2631

2632

operator PyObject *() const

2633

{

2634

return _obj;

2635

}

2636

2637

PyObject *operator->() const

2638

{

2639

return _obj;

2640

}

2641

};

2642

}

2643

2644

2645

namespace swig {

2646

struct PyObject_var : PyObject_ptr {

2647

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

2648

2649

PyObject_var & operator = (PyObject* obj)

2650

{

2651

Py_XDECREF(_obj);

2652

_obj = obj;

2653

return *this;

2654

}

2655

};

2656

}

2657

2658

2659

2660

#include "wx/wxPython/wxPython.h"

2661

#include "wx/wxPython/pyclasses.h"

2662

#include "wx/wxPython/pyistream.h"

2663

2664

#ifdef __WXMAC__ // avoid a bug in Carbon headers

2665

#define scalb scalbn

2666

#endif

2667

2668

#if wxUSE_WEBKIT

2669

#include "wx/html/webkit.h"

2670

#endif

2671

2672

static const wxString wxPyEmptyString(wxEmptyString);

2673

static const wxString wxPyWebKitNameStr(wxT("webkitctrl"));

2674

2675

#if !wxUSE_WEBKIT

2676

// a dummy class for ports that don't have wxWebKitCtrl

2677

class wxWebKitCtrl : public wxControl

2678

{

2679

public:

2680

wxWebKitCtrl(wxWindow *parent,

2681

wxWindowID winID,

2682

const wxString& strURL,

2683

const wxPoint& pos = wxDefaultPosition,

2684

const wxSize& size = wxDefaultSize, long style = 0,

2685

const wxValidator& validator = wxDefaultValidator,

2686

const wxString& name = wxPyWebKitNameStr)

2687

{ wxPyRaiseNotImplemented(); }

2688

2689

wxWebKitCtrl() { wxPyRaiseNotImplemented(); }

2690

2691

bool Create(wxWindow *parent,

2692

wxWindowID winID,

2693

const wxString& strURL,

2694

const wxPoint& pos = wxDefaultPosition,

2695

const wxSize& size = wxDefaultSize, long style = 0,

2696

const wxValidator& validator = wxDefaultValidator,

2697

const wxString& name = wxPyWebKitNameStr)

2698

{ return false; }

2699

2700

void LoadURL(const wxString &url) {}

2701

2702

bool CanGoBack() { return false; }

2703

bool CanGoForward() { return false; }

2704

bool GoBack() { return false; }

2705

bool GoForward() { return false; }

2706

void Reload() {}

2707

void Stop() {}

2708

bool CanGetPageSource() { return false; }

2709

wxString GetPageSource() { return wxEmptyString; }

2710

void SetPageSource(wxString& source, const wxString& baseUrl = wxEmptyString) {}

2711

wxString GetPageURL() { return wxEmptyString; }

2712

wxString GetPageTitle() { return wxEmptyString; }

2713

2714

wxString GetSelection() { return wxEmptyString; }

2715

2716

bool CanIncreaseTextSize() { return false; }

2717

void IncreaseTextSize() { }

2718

bool CanDecreaseTextSize() { return false; }

2719

void DecreaseTextSize() { }

2720

2721

void Print(bool showPrompt=false) { }

2722

2723

void MakeEditable(bool enable=true) { }

2724

bool IsEditable() { return false; }

2725

2726

wxString RunScript(const wxString& javascript) { return wxEmptyString; }

2727

2728

void SetScrollPos(int pos) { }

2729

int GetScrollPos() { return 0; }

2730

2731

};

2732

2733

2734

enum {

2735

wxWEBKIT_STATE_START = 0,

2736

wxWEBKIT_STATE_NEGOTIATING = 0,

2737

wxWEBKIT_STATE_REDIRECTING = 0,

2738

wxWEBKIT_STATE_TRANSFERRING = 0,

2739

wxWEBKIT_STATE_STOP = 0,

2740

wxWEBKIT_STATE_FAILED = 0,

2741

2742

wxEVT_WEBKIT_STATE_CHANGED = 0,

2743

wxEVT_WEBKIT_BEFORE_LOAD = 0,

2744

wxEVT_WEBKIT_NEW_WINDOW = 0

2745

};

2746

2747

enum {

2748

wxWEBKIT_NAV_LINK_CLICKED = 0,

2749

wxWEBKIT_NAV_BACK_NEXT = 0,

2750

wxWEBKIT_NAV_FORM_SUBMITTED = 0,

2751

wxWEBKIT_NAV_RELOAD = 0,

2752

wxWEBKIT_NAV_FORM_RESUBMITTED = 0,

2753

wxWEBKIT_NAV_OTHER = 0

2754

2755

};

2756

2757

class wxWebKitStateChangedEvent : public wxCommandEvent

2758

{

2759

public:

2760

wxWebKitStateChangedEvent( wxWindow* win = NULL )

2761

{ wxPyRaiseNotImplemented(); }

2762

2763

int GetState() { return 0; }

2764

void SetState(const int state) {}

2765

wxString GetURL() { return wxEmptyString; }

2766

void SetURL(const wxString& url) {}

2767

};

2768

2769

class wxWebKitBeforeLoadEvent : public wxCommandEvent

2770

{

2771

public:

2772

bool IsCancelled() { return false; }

2773

void Cancel(bool cancel = true) { }

2774

wxString GetURL() { return wxEmptyString; }

2775

void SetURL(const wxString& url) { }

2776

void SetNavigationType(int navType) { }

2777

int GetNavigationType() { return 0; }

2778

2779

wxWebKitBeforeLoadEvent( wxWindow* win = (wxWindow*) NULL ) { wxPyRaiseNotImplemented(); }

2780

};

2781

2782

2783

class wxWebKitNewWindowEvent : public wxCommandEvent

2784

{

2785

public:

2786

wxString GetURL() const { return wxEmptyString; }

2787

void SetURL(const wxString& ) { }

2788

wxString GetTargetName() const { return wxEmptyString; }

2789

void SetTargetName(const wxString&) { }

2790

2791

wxWebKitNewWindowEvent( wxWindow* win = (wxWindow*)(NULL)) { wxPyRaiseNotImplemented(); }

2792

};

2793

2794

2795

#endif

2796

2797

2798

#include <limits.h>

2799

#ifndef LLONG_MIN

2800

# define LLONG_MIN LONG_LONG_MIN

2801

#endif

2802

#ifndef LLONG_MAX

2803

# define LLONG_MAX LONG_LONG_MAX

2804

#endif

2805

#ifndef ULLONG_MAX

2806

# define ULLONG_MAX ULONG_LONG_MAX

2807

#endif

2808

2809

2810

SWIGINTERN int

2811

SWIG_AsVal_long (PyObject* obj, long* val)

2812

{

2813

if (PyNumber_Check(obj)) {

2814

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

2815

return SWIG_OK;

2816

}

2817

return SWIG_TypeError;

2818

}

2819

2820

2821

SWIGINTERN int

2822

SWIG_AsVal_int (PyObject * obj, int *val)

2823

{

2824

long v;

2825

int res = SWIG_AsVal_long (obj, &v);

2826

if (SWIG_IsOK(res)) {

2827

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

2828

return SWIG_OverflowError;

2829

} else {

2830

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

2831

}

2832

}

2833

return res;

2834

}

2835

2836

2837

SWIGINTERN int

2838

SWIG_AsVal_bool (PyObject *obj, bool *val)

2839

{

2840

if (obj == Py_True) {

2841

if (val) *val = true;

2842

return SWIG_OK;

2843

} else if (obj == Py_False) {

2844

if (val) *val = false;

2845

return SWIG_OK;

2846

} else {

2847

long v = 0;

2848

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

2849

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

2850

return res;

2851

}

2852

}

2853

2854

2855

#define SWIG_From_long PyInt_FromLong

2856

2857

2858

SWIGINTERNINLINE PyObject *

2859

SWIG_From_int (int value)

2860

{

2861

return SWIG_From_long (value);

2862

}

2863

2864

#ifdef __cplusplus

2865

extern "C" {

2866

#endif

2867

SWIGINTERN int WebKitNameStr_set(PyObject *) {

2868

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

2869

return 1;

2870

}

2871

2872

2873

SWIGINTERN PyObject *WebKitNameStr_get(void) {

2874

PyObject *pyobj = 0;

2875

2876

{

2877

#if wxUSE_UNICODE

2878

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

2879

#else

2880

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

2881

#endif

2882

}

2883

return pyobj;

2884

}

2885

2886

2887

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

2888

PyObject *resultobj = 0;

2889

wxWindow *arg1 = (wxWindow *) 0 ;

2890

int arg2 = (int) -1 ;

2891

wxString const &arg3_defvalue = wxPyEmptyString ;

2892

wxString *arg3 = (wxString *) &arg3_defvalue ;

2893

wxPoint const &arg4_defvalue = wxDefaultPosition ;

2894

wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;

2895

wxSize const &arg5_defvalue = wxDefaultSize ;

2896

wxSize *arg5 = (wxSize *) &arg5_defvalue ;

2897

long arg6 = (long) 0 ;

2898

wxValidator const &arg7_defvalue = wxDefaultValidator ;

2899

wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;

2900

wxString const &arg8_defvalue = wxPyWebKitNameStr ;

2901

wxString *arg8 = (wxString *) &arg8_defvalue ;

2902

wxWebKitCtrl *result = 0 ;

2903

void *argp1 = 0 ;

2904

int res1 = 0 ;

2905

int val2 ;

2906

int ecode2 = 0 ;

2907

bool temp3 = false ;

2908

wxPoint temp4 ;

2909

wxSize temp5 ;

2910

long val6 ;

2911

int ecode6 = 0 ;

2912

void *argp7 = 0 ;

2913

int res7 = 0 ;

2914

bool temp8 = false ;

2915

PyObject * obj0 = 0 ;

2916

PyObject * obj1 = 0 ;

2917

PyObject * obj2 = 0 ;

2918

PyObject * obj3 = 0 ;

2919

PyObject * obj4 = 0 ;

2920

PyObject * obj5 = 0 ;

2921

PyObject * obj6 = 0 ;

2922

PyObject * obj7 = 0 ;

2923

char * kwnames[] = {

2924

(char *) "parent",(char *) "winID",(char *) "strURL",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL

2925

};

2926

2927

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

2928

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

2929

if (!SWIG_IsOK(res1)) {

2930

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

2931

}

2932

arg1 = reinterpret_cast< wxWindow * >(argp1);

2933

if (obj1) {

2934

ecode2 = SWIG_AsVal_int(obj1, &val2);

2935

if (!SWIG_IsOK(ecode2)) {

2936

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

2937

}

2938

arg2 = static_cast< int >(val2);

2939

}

2940

if (obj2) {

2941

{

2942

arg3 = wxString_in_helper(obj2);

2943

if (arg3 == NULL) SWIG_fail;

2944

temp3 = true;

2945

}

2946

}

2947

if (obj3) {

2948

{

2949

arg4 = &temp4;

2950

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

2951

}

2952

}

2953

if (obj4) {

2954

{

2955

arg5 = &temp5;

2956

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

2957

}

2958

}

2959

if (obj5) {

2960

ecode6 = SWIG_AsVal_long(obj5, &val6);

2961

if (!SWIG_IsOK(ecode6)) {

2962

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

2963

}

2964

arg6 = static_cast< long >(val6);

2965

}

2966

if (obj6) {

2967

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

2968

if (!SWIG_IsOK(res7)) {

2969

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

2970

}

2971

if (!argp7) {

2972

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

2973

}

2974

arg7 = reinterpret_cast< wxValidator * >(argp7);

2975

}

2976

if (obj7) {

2977

{

2978

arg8 = wxString_in_helper(obj7);

2979

if (arg8 == NULL) SWIG_fail;

2980

temp8 = true;

2981

}

2982

}

2983

{

2984

if (!wxPyCheckForApp()) SWIG_fail;

2985

PyThreadState* __tstate = wxPyBeginAllowThreads();

2986

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

2987

wxPyEndAllowThreads(__tstate);

2988

if (PyErr_Occurred()) SWIG_fail;

2989

}

2990

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

2991

{

2992

if (temp3)

2993

delete arg3;

2994

}

2995

{

2996

if (temp8)

2997

delete arg8;

2998

}

2999

return resultobj;

3000

fail:

3001

{

3002

if (temp3)

3003

delete arg3;

3004

}

3005

{

3006

if (temp8)

3007

delete arg8;

3008

}

3009

return NULL;

3010

}

3011

3012

3013

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

3014

PyObject *resultobj = 0;

3015

wxWebKitCtrl *result = 0 ;

3016

3017

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

3018

{

3019

if (!wxPyCheckForApp()) SWIG_fail;

3020

PyThreadState* __tstate = wxPyBeginAllowThreads();

3021

result = (wxWebKitCtrl *)new wxWebKitCtrl();

3022

wxPyEndAllowThreads(__tstate);

3023

if (PyErr_Occurred()) SWIG_fail;

3024

}

3025

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

3026

return resultobj;

3027

fail:

3028

return NULL;

3029

}

3030

3031

3032

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

3033

PyObject *resultobj = 0;

3034

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3035

wxWindow *arg2 = (wxWindow *) 0 ;

3036

int arg3 = (int) -1 ;

3037

wxString const &arg4_defvalue = wxPyEmptyString ;

3038

wxString *arg4 = (wxString *) &arg4_defvalue ;

3039

wxPoint const &arg5_defvalue = wxDefaultPosition ;

3040

wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;

3041

wxSize const &arg6_defvalue = wxDefaultSize ;

3042

wxSize *arg6 = (wxSize *) &arg6_defvalue ;

3043

long arg7 = (long) 0 ;

3044

wxValidator const &arg8_defvalue = wxDefaultValidator ;

3045

wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;

3046

wxString const &arg9_defvalue = wxPyWebKitNameStr ;

3047

wxString *arg9 = (wxString *) &arg9_defvalue ;

3048

bool result;

3049

void *argp1 = 0 ;

3050

int res1 = 0 ;

3051

void *argp2 = 0 ;

3052

int res2 = 0 ;

3053

int val3 ;

3054

int ecode3 = 0 ;

3055

bool temp4 = false ;

3056

wxPoint temp5 ;

3057

wxSize temp6 ;

3058

long val7 ;

3059

int ecode7 = 0 ;

3060

void *argp8 = 0 ;

3061

int res8 = 0 ;

3062

bool temp9 = false ;

3063

PyObject * obj0 = 0 ;

3064

PyObject * obj1 = 0 ;

3065

PyObject * obj2 = 0 ;

3066

PyObject * obj3 = 0 ;

3067

PyObject * obj4 = 0 ;

3068

PyObject * obj5 = 0 ;

3069

PyObject * obj6 = 0 ;

3070

PyObject * obj7 = 0 ;

3071

PyObject * obj8 = 0 ;

3072

char * kwnames[] = {

3073

(char *) "self",(char *) "parent",(char *) "winID",(char *) "strURL",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL

3074

};

3075

3076

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

3077

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

3078

if (!SWIG_IsOK(res1)) {

3079

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

3080

}

3081

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3082

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

3083

if (!SWIG_IsOK(res2)) {

3084

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

3085

}

3086

arg2 = reinterpret_cast< wxWindow * >(argp2);

3087

if (obj2) {

3088

ecode3 = SWIG_AsVal_int(obj2, &val3);

3089

if (!SWIG_IsOK(ecode3)) {

3090

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

3091

}

3092

arg3 = static_cast< int >(val3);

3093

}

3094

if (obj3) {

3095

{

3096

arg4 = wxString_in_helper(obj3);

3097

if (arg4 == NULL) SWIG_fail;

3098

temp4 = true;

3099

}

3100

}

3101

if (obj4) {

3102

{

3103

arg5 = &temp5;

3104

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

3105

}

3106

}

3107

if (obj5) {

3108

{

3109

arg6 = &temp6;

3110

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

3111

}

3112

}

3113

if (obj6) {

3114

ecode7 = SWIG_AsVal_long(obj6, &val7);

3115

if (!SWIG_IsOK(ecode7)) {

3116

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

3117

}

3118

arg7 = static_cast< long >(val7);

3119

}

3120

if (obj7) {

3121

res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator, 0 | 0);

3122

if (!SWIG_IsOK(res8)) {

3123

SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "WebKitCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'");

3124

}

3125

if (!argp8) {

3126

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

3127

}

3128

arg8 = reinterpret_cast< wxValidator * >(argp8);

3129

}

3130

if (obj8) {

3131

{

3132

arg9 = wxString_in_helper(obj8);

3133

if (arg9 == NULL) SWIG_fail;

3134

temp9 = true;

3135

}

3136

}

3137

{

3138

PyThreadState* __tstate = wxPyBeginAllowThreads();

3139

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

3140

wxPyEndAllowThreads(__tstate);

3141

if (PyErr_Occurred()) SWIG_fail;

3142

}

3143

{

3144

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

3145

}

3146

{

3147

if (temp4)

3148

delete arg4;

3149

}

3150

{

3151

if (temp9)

3152

delete arg9;

3153

}

3154

return resultobj;

3155

fail:

3156

{

3157

if (temp4)

3158

delete arg4;

3159

}

3160

{

3161

if (temp9)

3162

delete arg9;

3163

}

3164

return NULL;

3165

}

3166

3167

3168

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

3169

PyObject *resultobj = 0;

3170

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3171

wxString *arg2 = 0 ;

3172

void *argp1 = 0 ;

3173

int res1 = 0 ;

3174

bool temp2 = false ;

3175

PyObject * obj0 = 0 ;

3176

PyObject * obj1 = 0 ;

3177

char * kwnames[] = {

3178

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

3179

};

3180

3181

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

3182

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

3183

if (!SWIG_IsOK(res1)) {

3184

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

3185

}

3186

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3187

{

3188

arg2 = wxString_in_helper(obj1);

3189

if (arg2 == NULL) SWIG_fail;

3190

temp2 = true;

3191

}

3192

{

3193

PyThreadState* __tstate = wxPyBeginAllowThreads();

3194

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

3195

wxPyEndAllowThreads(__tstate);

3196

if (PyErr_Occurred()) SWIG_fail;

3197

}

3198

resultobj = SWIG_Py_Void();

3199

{

3200

if (temp2)

3201

delete arg2;

3202

}

3203

return resultobj;

3204

fail:

3205

{

3206

if (temp2)

3207

delete arg2;

3208

}

3209

return NULL;

3210

}

3211

3212

3213

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

3214

PyObject *resultobj = 0;

3215

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3216

bool result;

3217

void *argp1 = 0 ;

3218

int res1 = 0 ;

3219

PyObject *swig_obj[1] ;

3220

3221

if (!args) SWIG_fail;

3222

swig_obj[0] = args;

3223

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

3224

if (!SWIG_IsOK(res1)) {

3225

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

3226

}

3227

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3228

{

3229

PyThreadState* __tstate = wxPyBeginAllowThreads();

3230

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

3231

wxPyEndAllowThreads(__tstate);

3232

if (PyErr_Occurred()) SWIG_fail;

3233

}

3234

{

3235

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

3236

}

3237

return resultobj;

3238

fail:

3239

return NULL;

3240

}

3241

3242

3243

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

3244

PyObject *resultobj = 0;

3245

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3246

bool result;

3247

void *argp1 = 0 ;

3248

int res1 = 0 ;

3249

PyObject *swig_obj[1] ;

3250

3251

if (!args) SWIG_fail;

3252

swig_obj[0] = args;

3253

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

3254

if (!SWIG_IsOK(res1)) {

3255

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

3256

}

3257

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3258

{

3259

PyThreadState* __tstate = wxPyBeginAllowThreads();

3260

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

3261

wxPyEndAllowThreads(__tstate);

3262

if (PyErr_Occurred()) SWIG_fail;

3263

}

3264

{

3265

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

3266

}

3267

return resultobj;

3268

fail:

3269

return NULL;

3270

}

3271

3272

3273

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

3274

PyObject *resultobj = 0;

3275

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3276

bool result;

3277

void *argp1 = 0 ;

3278

int res1 = 0 ;

3279

PyObject *swig_obj[1] ;

3280

3281

if (!args) SWIG_fail;

3282

swig_obj[0] = args;

3283

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

3284

if (!SWIG_IsOK(res1)) {

3285

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

3286

}

3287

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3288

{

3289

PyThreadState* __tstate = wxPyBeginAllowThreads();

3290

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

3291

wxPyEndAllowThreads(__tstate);

3292

if (PyErr_Occurred()) SWIG_fail;

3293

}

3294

{

3295

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

3296

}

3297

return resultobj;

3298

fail:

3299

return NULL;

3300

}

3301

3302

3303

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

3304

PyObject *resultobj = 0;

3305

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3306

bool result;

3307

void *argp1 = 0 ;

3308

int res1 = 0 ;

3309

PyObject *swig_obj[1] ;

3310

3311

if (!args) SWIG_fail;

3312

swig_obj[0] = args;

3313

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

3314

if (!SWIG_IsOK(res1)) {

3315

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

3316

}

3317

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3318

{

3319

PyThreadState* __tstate = wxPyBeginAllowThreads();

3320

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

3321

wxPyEndAllowThreads(__tstate);

3322

if (PyErr_Occurred()) SWIG_fail;

3323

}

3324

{

3325

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

3326

}

3327

return resultobj;

3328

fail:

3329

return NULL;

3330

}

3331

3332

3333

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

3334

PyObject *resultobj = 0;

3335

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3336

void *argp1 = 0 ;

3337

int res1 = 0 ;

3338

PyObject *swig_obj[1] ;

3339

3340

if (!args) SWIG_fail;

3341

swig_obj[0] = args;

3342

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

3343

if (!SWIG_IsOK(res1)) {

3344

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

3345

}

3346

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3347

{

3348

PyThreadState* __tstate = wxPyBeginAllowThreads();

3349

(arg1)->Reload();

3350

wxPyEndAllowThreads(__tstate);

3351

if (PyErr_Occurred()) SWIG_fail;

3352

}

3353

resultobj = SWIG_Py_Void();

3354

return resultobj;

3355

fail:

3356

return NULL;

3357

}

3358

3359

3360

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

3361

PyObject *resultobj = 0;

3362

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3363

void *argp1 = 0 ;

3364

int res1 = 0 ;

3365

PyObject *swig_obj[1] ;

3366

3367

if (!args) SWIG_fail;

3368

swig_obj[0] = args;

3369

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

3370

if (!SWIG_IsOK(res1)) {

3371

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

3372

}

3373

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3374

{

3375

PyThreadState* __tstate = wxPyBeginAllowThreads();

3376

(arg1)->Stop();

3377

wxPyEndAllowThreads(__tstate);

3378

if (PyErr_Occurred()) SWIG_fail;

3379

}

3380

resultobj = SWIG_Py_Void();

3381

return resultobj;

3382

fail:

3383

return NULL;

3384

}

3385

3386

3387

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

3388

PyObject *resultobj = 0;

3389

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3390

bool result;

3391

void *argp1 = 0 ;

3392

int res1 = 0 ;

3393

PyObject *swig_obj[1] ;

3394

3395

if (!args) SWIG_fail;

3396

swig_obj[0] = args;

3397

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

3398

if (!SWIG_IsOK(res1)) {

3399

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

3400

}

3401

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3402

{

3403

PyThreadState* __tstate = wxPyBeginAllowThreads();

3404

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

3405

wxPyEndAllowThreads(__tstate);

3406

if (PyErr_Occurred()) SWIG_fail;

3407

}

3408

{

3409

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

3410

}

3411

return resultobj;

3412

fail:

3413

return NULL;

3414

}

3415

3416

3417

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

3418

PyObject *resultobj = 0;

3419

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3420

wxString result;

3421

void *argp1 = 0 ;

3422

int res1 = 0 ;

3423

PyObject *swig_obj[1] ;

3424

3425

if (!args) SWIG_fail;

3426

swig_obj[0] = args;

3427

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

3428

if (!SWIG_IsOK(res1)) {

3429

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

3430

}

3431

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3432

{

3433

PyThreadState* __tstate = wxPyBeginAllowThreads();

3434

result = (arg1)->GetPageSource();

3435

wxPyEndAllowThreads(__tstate);

3436

if (PyErr_Occurred()) SWIG_fail;

3437

}

3438

{

3439

#if wxUSE_UNICODE

3440

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

3441

#else

3442

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

3443

#endif

3444

}

3445

return resultobj;

3446

fail:

3447

return NULL;

3448

}

3449

3450

3451

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

3452

PyObject *resultobj = 0;

3453

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3454

wxString *arg2 = 0 ;

3455

wxString const &arg3_defvalue = wxPyEmptyString ;

3456

wxString *arg3 = (wxString *) &arg3_defvalue ;

3457

void *argp1 = 0 ;

3458

int res1 = 0 ;

3459

bool temp2 = false ;

3460

bool temp3 = false ;

3461

PyObject * obj0 = 0 ;

3462

PyObject * obj1 = 0 ;

3463

PyObject * obj2 = 0 ;

3464

char * kwnames[] = {

3465

(char *) "self",(char *) "source",(char *) "baseUrl", NULL

3466

};

3467

3468

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

3469

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

3470

if (!SWIG_IsOK(res1)) {

3471

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

3472

}

3473

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3474

{

3475

arg2 = wxString_in_helper(obj1);

3476

if (arg2 == NULL) SWIG_fail;

3477

temp2 = true;

3478

}

3479

if (obj2) {

3480

{

3481

arg3 = wxString_in_helper(obj2);

3482

if (arg3 == NULL) SWIG_fail;

3483

temp3 = true;

3484

}

3485

}

3486

{

3487

PyThreadState* __tstate = wxPyBeginAllowThreads();

3488

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

3489

wxPyEndAllowThreads(__tstate);

3490

if (PyErr_Occurred()) SWIG_fail;

3491

}

3492

resultobj = SWIG_Py_Void();

3493

{

3494

if (temp2)

3495

delete arg2;

3496

}

3497

{

3498

if (temp3)

3499

delete arg3;

3500

}

3501

return resultobj;

3502

fail:

3503

{

3504

if (temp2)

3505

delete arg2;

3506

}

3507

{

3508

if (temp3)

3509

delete arg3;

3510

}

3511

return NULL;

3512

}

3513

3514

3515

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

3516

PyObject *resultobj = 0;

3517

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3518

wxString result;

3519

void *argp1 = 0 ;

3520

int res1 = 0 ;

3521

PyObject *swig_obj[1] ;

3522

3523

if (!args) SWIG_fail;

3524

swig_obj[0] = args;

3525

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

3526

if (!SWIG_IsOK(res1)) {

3527

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

3528

}

3529

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3530

{

3531

PyThreadState* __tstate = wxPyBeginAllowThreads();

3532

result = (arg1)->GetPageURL();

3533

wxPyEndAllowThreads(__tstate);

3534

if (PyErr_Occurred()) SWIG_fail;

3535

}

3536

{

3537

#if wxUSE_UNICODE

3538

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

3539

#else

3540

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

3541

#endif

3542

}

3543

return resultobj;

3544

fail:

3545

return NULL;

3546

}

3547

3548

3549

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

3550

PyObject *resultobj = 0;

3551

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3552

wxString result;

3553

void *argp1 = 0 ;

3554

int res1 = 0 ;

3555

PyObject *swig_obj[1] ;

3556

3557

if (!args) SWIG_fail;

3558

swig_obj[0] = args;

3559

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

3560

if (!SWIG_IsOK(res1)) {

3561

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

3562

}

3563

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3564

{

3565

PyThreadState* __tstate = wxPyBeginAllowThreads();

3566

result = (arg1)->GetPageTitle();

3567

wxPyEndAllowThreads(__tstate);

3568

if (PyErr_Occurred()) SWIG_fail;

3569

}

3570

{

3571

#if wxUSE_UNICODE

3572

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

3573

#else

3574

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

3575

#endif

3576

}

3577

return resultobj;

3578

fail:

3579

return NULL;

3580

}

3581

3582

3583

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

3584

PyObject *resultobj = 0;

3585

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3586

wxString result;

3587

void *argp1 = 0 ;

3588

int res1 = 0 ;

3589

PyObject *swig_obj[1] ;

3590

3591

if (!args) SWIG_fail;

3592

swig_obj[0] = args;

3593

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

3594

if (!SWIG_IsOK(res1)) {

3595

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

3596

}

3597

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3598

{

3599

PyThreadState* __tstate = wxPyBeginAllowThreads();

3600

result = (arg1)->GetSelection();

3601

wxPyEndAllowThreads(__tstate);

3602

if (PyErr_Occurred()) SWIG_fail;

3603

}

3604

{

3605

#if wxUSE_UNICODE

3606

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

3607

#else

3608

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

3609

#endif

3610

}

3611

return resultobj;

3612

fail:

3613

return NULL;

3614

}

3615

3616

3617

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

3618

PyObject *resultobj = 0;

3619

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3620

bool result;

3621

void *argp1 = 0 ;

3622

int res1 = 0 ;

3623

PyObject *swig_obj[1] ;

3624

3625

if (!args) SWIG_fail;

3626

swig_obj[0] = args;

3627

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

3628

if (!SWIG_IsOK(res1)) {

3629

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

3630

}

3631

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3632

{

3633

PyThreadState* __tstate = wxPyBeginAllowThreads();

3634

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

3635

wxPyEndAllowThreads(__tstate);

3636

if (PyErr_Occurred()) SWIG_fail;

3637

}

3638

{

3639

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

3640

}

3641

return resultobj;

3642

fail:

3643

return NULL;

3644

}

3645

3646

3647

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

3648

PyObject *resultobj = 0;

3649

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3650

void *argp1 = 0 ;

3651

int res1 = 0 ;

3652

PyObject *swig_obj[1] ;

3653

3654

if (!args) SWIG_fail;

3655

swig_obj[0] = args;

3656

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

3657

if (!SWIG_IsOK(res1)) {

3658

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

3659

}

3660

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3661

{

3662

PyThreadState* __tstate = wxPyBeginAllowThreads();

3663

(arg1)->IncreaseTextSize();

3664

wxPyEndAllowThreads(__tstate);

3665

if (PyErr_Occurred()) SWIG_fail;

3666

}

3667

resultobj = SWIG_Py_Void();

3668

return resultobj;

3669

fail:

3670

return NULL;

3671

}

3672

3673

3674

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

3675

PyObject *resultobj = 0;

3676

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3677

bool result;

3678

void *argp1 = 0 ;

3679

int res1 = 0 ;

3680

PyObject *swig_obj[1] ;

3681

3682

if (!args) SWIG_fail;

3683

swig_obj[0] = args;

3684

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

3685

if (!SWIG_IsOK(res1)) {

3686

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

3687

}

3688

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3689

{

3690

PyThreadState* __tstate = wxPyBeginAllowThreads();

3691

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

3692

wxPyEndAllowThreads(__tstate);

3693

if (PyErr_Occurred()) SWIG_fail;

3694

}

3695

{

3696

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

3697

}

3698

return resultobj;

3699

fail:

3700

return NULL;

3701

}

3702

3703

3704

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

3705

PyObject *resultobj = 0;

3706

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3707

void *argp1 = 0 ;

3708

int res1 = 0 ;

3709

PyObject *swig_obj[1] ;

3710

3711

if (!args) SWIG_fail;

3712

swig_obj[0] = args;

3713

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

3714

if (!SWIG_IsOK(res1)) {

3715

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

3716

}

3717

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3718

{

3719

PyThreadState* __tstate = wxPyBeginAllowThreads();

3720

(arg1)->DecreaseTextSize();

3721

wxPyEndAllowThreads(__tstate);

3722

if (PyErr_Occurred()) SWIG_fail;

3723

}

3724

resultobj = SWIG_Py_Void();

3725

return resultobj;

3726

fail:

3727

return NULL;

3728

}

3729

3730

3731

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

3732

PyObject *resultobj = 0;

3733

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3734

bool arg2 = (bool) false ;

3735

void *argp1 = 0 ;

3736

int res1 = 0 ;

3737

bool val2 ;

3738

int ecode2 = 0 ;

3739

PyObject * obj0 = 0 ;

3740

PyObject * obj1 = 0 ;

3741

char * kwnames[] = {

3742

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

3743

};

3744

3745

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

3746

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

3747

if (!SWIG_IsOK(res1)) {

3748

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

3749

}

3750

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3751

if (obj1) {

3752

ecode2 = SWIG_AsVal_bool(obj1, &val2);

3753

if (!SWIG_IsOK(ecode2)) {

3754

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

3755

}

3756

arg2 = static_cast< bool >(val2);

3757

}

3758

{

3759

PyThreadState* __tstate = wxPyBeginAllowThreads();

3760

(arg1)->Print(arg2);

3761

wxPyEndAllowThreads(__tstate);

3762

if (PyErr_Occurred()) SWIG_fail;

3763

}

3764

resultobj = SWIG_Py_Void();

3765

return resultobj;

3766

fail:

3767

return NULL;

3768

}

3769

3770

3771

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

3772

PyObject *resultobj = 0;

3773

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3774

bool arg2 = (bool) true ;

3775

void *argp1 = 0 ;

3776

int res1 = 0 ;

3777

bool val2 ;

3778

int ecode2 = 0 ;

3779

PyObject * obj0 = 0 ;

3780

PyObject * obj1 = 0 ;

3781

char * kwnames[] = {

3782

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

3783

};

3784

3785

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

3786

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

3787

if (!SWIG_IsOK(res1)) {

3788

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

3789

}

3790

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3791

if (obj1) {

3792

ecode2 = SWIG_AsVal_bool(obj1, &val2);

3793

if (!SWIG_IsOK(ecode2)) {

3794

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

3795

}

3796

arg2 = static_cast< bool >(val2);

3797

}

3798

{

3799

PyThreadState* __tstate = wxPyBeginAllowThreads();

3800

(arg1)->MakeEditable(arg2);

3801

wxPyEndAllowThreads(__tstate);

3802

if (PyErr_Occurred()) SWIG_fail;

3803

}

3804

resultobj = SWIG_Py_Void();

3805

return resultobj;

3806

fail:

3807

return NULL;

3808

}

3809

3810

3811

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

3812

PyObject *resultobj = 0;

3813

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3814

bool result;

3815

void *argp1 = 0 ;

3816

int res1 = 0 ;

3817

PyObject *swig_obj[1] ;

3818

3819

if (!args) SWIG_fail;

3820

swig_obj[0] = args;

3821

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

3822

if (!SWIG_IsOK(res1)) {

3823

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

3824

}

3825

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3826

{

3827

PyThreadState* __tstate = wxPyBeginAllowThreads();

3828

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

3829

wxPyEndAllowThreads(__tstate);

3830

if (PyErr_Occurred()) SWIG_fail;

3831

}

3832

{

3833

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

3834

}

3835

return resultobj;

3836

fail:

3837

return NULL;

3838

}

3839

3840

3841

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

3842

PyObject *resultobj = 0;

3843

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3844

wxString *arg2 = 0 ;

3845

wxString result;

3846

void *argp1 = 0 ;

3847

int res1 = 0 ;

3848

bool temp2 = false ;

3849

PyObject * obj0 = 0 ;

3850

PyObject * obj1 = 0 ;

3851

char * kwnames[] = {

3852

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

3853

};

3854

3855

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

3856

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

3857

if (!SWIG_IsOK(res1)) {

3858

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

3859

}

3860

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3861

{

3862

arg2 = wxString_in_helper(obj1);

3863

if (arg2 == NULL) SWIG_fail;

3864

temp2 = true;

3865

}

3866

{

3867

PyThreadState* __tstate = wxPyBeginAllowThreads();

3868

result = (arg1)->RunScript((wxString const &)*arg2);

3869

wxPyEndAllowThreads(__tstate);

3870

if (PyErr_Occurred()) SWIG_fail;

3871

}

3872

{

3873

#if wxUSE_UNICODE

3874

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

3875

#else

3876

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

3877

#endif

3878

}

3879

{

3880

if (temp2)

3881

delete arg2;

3882

}

3883

return resultobj;

3884

fail:

3885

{

3886

if (temp2)

3887

delete arg2;

3888

}

3889

return NULL;

3890

}

3891

3892

3893

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

3894

PyObject *resultobj = 0;

3895

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3896

int arg2 ;

3897

void *argp1 = 0 ;

3898

int res1 = 0 ;

3899

int val2 ;

3900

int ecode2 = 0 ;

3901

PyObject * obj0 = 0 ;

3902

PyObject * obj1 = 0 ;

3903

char * kwnames[] = {

3904

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

3905

};

3906

3907

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

3908

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

3909

if (!SWIG_IsOK(res1)) {

3910

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

3911

}

3912

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3913

ecode2 = SWIG_AsVal_int(obj1, &val2);

3914

if (!SWIG_IsOK(ecode2)) {

3915

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

3916

}

3917

arg2 = static_cast< int >(val2);

3918

{

3919

PyThreadState* __tstate = wxPyBeginAllowThreads();

3920

(arg1)->SetScrollPos(arg2);

3921

wxPyEndAllowThreads(__tstate);

3922

if (PyErr_Occurred()) SWIG_fail;

3923

}

3924

resultobj = SWIG_Py_Void();

3925

return resultobj;

3926

fail:

3927

return NULL;

3928

}

3929

3930

3931

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

3932

PyObject *resultobj = 0;

3933

wxWebKitCtrl *arg1 = (wxWebKitCtrl *) 0 ;

3934

int result;

3935

void *argp1 = 0 ;

3936

int res1 = 0 ;

3937

PyObject *swig_obj[1] ;

3938

3939

if (!args) SWIG_fail;

3940

swig_obj[0] = args;

3941

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

3942

if (!SWIG_IsOK(res1)) {

3943

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

3944

}

3945

arg1 = reinterpret_cast< wxWebKitCtrl * >(argp1);

3946

{

3947

PyThreadState* __tstate = wxPyBeginAllowThreads();

3948

result = (int)(arg1)->GetScrollPos();

3949

wxPyEndAllowThreads(__tstate);

3950

if (PyErr_Occurred()) SWIG_fail;

3951

}

3952

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

3953

return resultobj;

3954

fail:

3955

return NULL;

3956

}

3957

3958

3959

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

3960

PyObject *obj;

3961

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

3962

SWIG_TypeNewClientData(SWIGTYPE_p_wxWebKitCtrl, SWIG_NewClientData(obj));

3963

return SWIG_Py_Void();

3964

}

3965

3966

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

3967

return SWIG_Python_InitShadowInstance(args);

3968

}

3969

3970

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

3971

PyObject *resultobj = 0;

3972

wxWebKitBeforeLoadEvent *arg1 = (wxWebKitBeforeLoadEvent *) 0 ;

3973

bool result;

3974

void *argp1 = 0 ;

3975

int res1 = 0 ;

3976

PyObject *swig_obj[1] ;

3977

3978

if (!args) SWIG_fail;

3979

swig_obj[0] = args;

3980

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

3981

if (!SWIG_IsOK(res1)) {

3982

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

3983

}

3984

arg1 = reinterpret_cast< wxWebKitBeforeLoadEvent * >(argp1);

3985

{

3986

PyThreadState* __tstate = wxPyBeginAllowThreads();

3987

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

3988

wxPyEndAllowThreads(__tstate);

3989

if (PyErr_Occurred()) SWIG_fail;

3990

}

3991

{

3992

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

3993

}

3994

return resultobj;

3995

fail:

3996

return NULL;

3997

}

3998

3999

4000

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

4001

PyObject *resultobj = 0;

4002

wxWebKitBeforeLoadEvent *arg1 = (wxWebKitBeforeLoadEvent *) 0 ;

4003

bool arg2 = (bool) true ;

4004

void *argp1 = 0 ;

4005

int res1 = 0 ;

4006

bool val2 ;

4007

int ecode2 = 0 ;

4008

PyObject * obj0 = 0 ;

4009

PyObject * obj1 = 0 ;

4010

char * kwnames[] = {

4011

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

4012

};

4013

4014

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

4015

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

4016

if (!SWIG_IsOK(res1)) {

4017

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

4018

}

4019

arg1 = reinterpret_cast< wxWebKitBeforeLoadEvent * >(argp1);

4020

if (obj1) {

4021

ecode2 = SWIG_AsVal_bool(obj1, &val2);

4022

if (!SWIG_IsOK(ecode2)) {

4023

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

4024

}

4025

arg2 = static_cast< bool >(val2);

4026

}

4027

{

4028

PyThreadState* __tstate = wxPyBeginAllowThreads();

4029

(arg1)->Cancel(arg2);

4030

wxPyEndAllowThreads(__tstate);

4031

if (PyErr_Occurred()) SWIG_fail;

4032

}

4033

resultobj = SWIG_Py_Void();

4034

return resultobj;

4035

fail:

4036

return NULL;

4037

}

4038

4039

4040

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

4041

PyObject *resultobj = 0;

4042

wxWebKitBeforeLoadEvent *arg1 = (wxWebKitBeforeLoadEvent *) 0 ;

4043

wxString result;

4044

void *argp1 = 0 ;

4045

int res1 = 0 ;

4046

PyObject *swig_obj[1] ;

4047

4048

if (!args) SWIG_fail;

4049

swig_obj[0] = args;

4050

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

4051

if (!SWIG_IsOK(res1)) {

4052

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

4053

}

4054

arg1 = reinterpret_cast< wxWebKitBeforeLoadEvent * >(argp1);

4055

{

4056

PyThreadState* __tstate = wxPyBeginAllowThreads();

4057

result = (arg1)->GetURL();

4058

wxPyEndAllowThreads(__tstate);

4059

if (PyErr_Occurred()) SWIG_fail;

4060

}

4061

{

4062

#if wxUSE_UNICODE

4063

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

4064

#else

4065

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

4066

#endif

4067

}

4068

return resultobj;

4069

fail:

4070

return NULL;

4071

}

4072

4073

4074

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

4075

PyObject *resultobj = 0;

4076

wxWebKitBeforeLoadEvent *arg1 = (wxWebKitBeforeLoadEvent *) 0 ;

4077

wxString *arg2 = 0 ;

4078

void *argp1 = 0 ;

4079

int res1 = 0 ;

4080

bool temp2 = false ;

4081

PyObject * obj0 = 0 ;

4082

PyObject * obj1 = 0 ;

4083

char * kwnames[] = {

4084

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

4085

};

4086

4087

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

4088

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

4089

if (!SWIG_IsOK(res1)) {

4090

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

4091

}

4092

arg1 = reinterpret_cast< wxWebKitBeforeLoadEvent * >(argp1);

4093

{

4094

arg2 = wxString_in_helper(obj1);

4095

if (arg2 == NULL) SWIG_fail;

4096

temp2 = true;

4097

}

4098

{

4099

PyThreadState* __tstate = wxPyBeginAllowThreads();

4100

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

4101

wxPyEndAllowThreads(__tstate);

4102

if (PyErr_Occurred()) SWIG_fail;

4103

}

4104

resultobj = SWIG_Py_Void();

4105

{

4106

if (temp2)

4107

delete arg2;

4108

}

4109

return resultobj;

4110

fail:

4111

{

4112

if (temp2)

4113

delete arg2;

4114

}

4115

return NULL;

4116

}

4117

4118

4119

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

4120

PyObject *resultobj = 0;

4121

wxWebKitBeforeLoadEvent *arg1 = (wxWebKitBeforeLoadEvent *) 0 ;

4122

int arg2 ;

4123

void *argp1 = 0 ;

4124

int res1 = 0 ;

4125

int val2 ;

4126

int ecode2 = 0 ;

4127

PyObject * obj0 = 0 ;

4128

PyObject * obj1 = 0 ;

4129

char * kwnames[] = {

4130

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

4131

};

4132

4133

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

4134

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

4135

if (!SWIG_IsOK(res1)) {

4136

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

4137

}

4138

arg1 = reinterpret_cast< wxWebKitBeforeLoadEvent * >(argp1);

4139

ecode2 = SWIG_AsVal_int(obj1, &val2);

4140

if (!SWIG_IsOK(ecode2)) {

4141

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

4142

}

4143

arg2 = static_cast< int >(val2);

4144

{

4145

PyThreadState* __tstate = wxPyBeginAllowThreads();

4146

(arg1)->SetNavigationType(arg2);

4147

wxPyEndAllowThreads(__tstate);

4148

if (PyErr_Occurred()) SWIG_fail;

4149

}

4150

resultobj = SWIG_Py_Void();

4151

return resultobj;

4152

fail:

4153

return NULL;

4154

}

4155

4156

4157

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

4158

PyObject *resultobj = 0;

4159

wxWebKitBeforeLoadEvent *arg1 = (wxWebKitBeforeLoadEvent *) 0 ;

4160

int result;

4161

void *argp1 = 0 ;

4162

int res1 = 0 ;

4163

PyObject *swig_obj[1] ;

4164

4165

if (!args) SWIG_fail;

4166

swig_obj[0] = args;

4167

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

4168

if (!SWIG_IsOK(res1)) {

4169

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

4170

}

4171

arg1 = reinterpret_cast< wxWebKitBeforeLoadEvent * >(argp1);

4172

{

4173

PyThreadState* __tstate = wxPyBeginAllowThreads();

4174

result = (int)(arg1)->GetNavigationType();

4175

wxPyEndAllowThreads(__tstate);

4176

if (PyErr_Occurred()) SWIG_fail;

4177

}

4178

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

4179

return resultobj;

4180

fail:

4181

return NULL;

4182

}

4183

4184

4185

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

4186

PyObject *resultobj = 0;

4187

wxWindow *arg1 = (wxWindow *) (wxWindow *) NULL ;

4188

wxWebKitBeforeLoadEvent *result = 0 ;

4189

void *argp1 = 0 ;

4190

int res1 = 0 ;

4191

PyObject * obj0 = 0 ;

4192

char * kwnames[] = {

4193

(char *) "win", NULL

4194

};

4195

4196

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

4197

if (obj0) {

4198

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

4199

if (!SWIG_IsOK(res1)) {

4200

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

4201

}

4202

arg1 = reinterpret_cast< wxWindow * >(argp1);

4203

}

4204

{

4205

PyThreadState* __tstate = wxPyBeginAllowThreads();

4206

result = (wxWebKitBeforeLoadEvent *)new wxWebKitBeforeLoadEvent(arg1);

4207

wxPyEndAllowThreads(__tstate);

4208

if (PyErr_Occurred()) SWIG_fail;

4209

}

4210

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

4211

return resultobj;

4212

fail:

4213

return NULL;

4214

}

4215

4216

4217

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

4218

PyObject *obj;

4219

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

4220

SWIG_TypeNewClientData(SWIGTYPE_p_wxWebKitBeforeLoadEvent, SWIG_NewClientData(obj));

4221

return SWIG_Py_Void();

4222

}

4223

4224

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

4225

return SWIG_Python_InitShadowInstance(args);

4226

}

4227

4228

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

4229

PyObject *resultobj = 0;

4230

wxWindow *arg1 = (wxWindow *) NULL ;

4231

wxWebKitStateChangedEvent *result = 0 ;

4232

void *argp1 = 0 ;

4233

int res1 = 0 ;

4234

PyObject * obj0 = 0 ;

4235

char * kwnames[] = {

4236

(char *) "win", NULL

4237

};

4238

4239

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

4240

if (obj0) {

4241

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

4242

if (!SWIG_IsOK(res1)) {

4243

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

4244

}

4245

arg1 = reinterpret_cast< wxWindow * >(argp1);

4246

}

4247

{

4248

PyThreadState* __tstate = wxPyBeginAllowThreads();

4249

result = (wxWebKitStateChangedEvent *)new wxWebKitStateChangedEvent(arg1);

4250

wxPyEndAllowThreads(__tstate);

4251

if (PyErr_Occurred()) SWIG_fail;

4252

}

4253

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

4254

return resultobj;

4255

fail:

4256

return NULL;

4257

}

4258

4259

4260

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

4261

PyObject *resultobj = 0;

4262

wxWebKitStateChangedEvent *arg1 = (wxWebKitStateChangedEvent *) 0 ;

4263

int result;

4264

void *argp1 = 0 ;

4265

int res1 = 0 ;

4266

PyObject *swig_obj[1] ;

4267

4268

if (!args) SWIG_fail;

4269

swig_obj[0] = args;

4270

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

4271

if (!SWIG_IsOK(res1)) {

4272

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

4273

}

4274

arg1 = reinterpret_cast< wxWebKitStateChangedEvent * >(argp1);

4275

{

4276

PyThreadState* __tstate = wxPyBeginAllowThreads();

4277

result = (int)(arg1)->GetState();

4278

wxPyEndAllowThreads(__tstate);

4279

if (PyErr_Occurred()) SWIG_fail;

4280

}

4281

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

4282

return resultobj;

4283

fail:

4284

return NULL;

4285

}

4286

4287

4288

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

4289

PyObject *resultobj = 0;

4290

wxWebKitStateChangedEvent *arg1 = (wxWebKitStateChangedEvent *) 0 ;

4291

int arg2 ;

4292

void *argp1 = 0 ;

4293

int res1 = 0 ;

4294

int val2 ;

4295

int ecode2 = 0 ;

4296

PyObject * obj0 = 0 ;

4297

PyObject * obj1 = 0 ;

4298

char * kwnames[] = {

4299

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

4300

};

4301

4302

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

4303

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

4304

if (!SWIG_IsOK(res1)) {

4305

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

4306

}

4307

arg1 = reinterpret_cast< wxWebKitStateChangedEvent * >(argp1);

4308

ecode2 = SWIG_AsVal_int(obj1, &val2);

4309

if (!SWIG_IsOK(ecode2)) {

4310

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

4311

}

4312

arg2 = static_cast< int >(val2);

4313

{

4314

PyThreadState* __tstate = wxPyBeginAllowThreads();

4315

(arg1)->SetState(arg2);

4316

wxPyEndAllowThreads(__tstate);

4317

if (PyErr_Occurred()) SWIG_fail;

4318

}

4319

resultobj = SWIG_Py_Void();

4320

return resultobj;

4321

fail:

4322

return NULL;

4323

}

4324

4325

4326

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

4327

PyObject *resultobj = 0;

4328

wxWebKitStateChangedEvent *arg1 = (wxWebKitStateChangedEvent *) 0 ;

4329

wxString result;

4330

void *argp1 = 0 ;

4331

int res1 = 0 ;

4332

PyObject *swig_obj[1] ;

4333

4334

if (!args) SWIG_fail;

4335

swig_obj[0] = args;

4336

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

4337

if (!SWIG_IsOK(res1)) {

4338

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

4339

}

4340

arg1 = reinterpret_cast< wxWebKitStateChangedEvent * >(argp1);

4341

{

4342

PyThreadState* __tstate = wxPyBeginAllowThreads();

4343

result = (arg1)->GetURL();

4344

wxPyEndAllowThreads(__tstate);

4345

if (PyErr_Occurred()) SWIG_fail;

4346

}

4347

{

4348

#if wxUSE_UNICODE

4349

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

4350

#else

4351

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

4352

#endif

4353

}

4354

return resultobj;

4355

fail:

4356

return NULL;

4357

}

4358

4359

4360

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

4361

PyObject *resultobj = 0;

4362

wxWebKitStateChangedEvent *arg1 = (wxWebKitStateChangedEvent *) 0 ;

4363

wxString *arg2 = 0 ;

4364

void *argp1 = 0 ;

4365

int res1 = 0 ;

4366

bool temp2 = false ;

4367

PyObject * obj0 = 0 ;

4368

PyObject * obj1 = 0 ;

4369

char * kwnames[] = {

4370

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

4371

};

4372

4373

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

4374

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

4375

if (!SWIG_IsOK(res1)) {

4376

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

4377

}

4378

arg1 = reinterpret_cast< wxWebKitStateChangedEvent * >(argp1);

4379

{

4380

arg2 = wxString_in_helper(obj1);

4381

if (arg2 == NULL) SWIG_fail;

4382

temp2 = true;

4383

}

4384

{

4385

PyThreadState* __tstate = wxPyBeginAllowThreads();

4386

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

4387

wxPyEndAllowThreads(__tstate);

4388

if (PyErr_Occurred()) SWIG_fail;

4389

}

4390

resultobj = SWIG_Py_Void();

4391

{

4392

if (temp2)

4393

delete arg2;

4394

}

4395

return resultobj;

4396

fail:

4397

{

4398

if (temp2)

4399

delete arg2;

4400

}

4401

return NULL;

4402

}

4403

4404

4405

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

4406

PyObject *obj;

4407

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

4408

SWIG_TypeNewClientData(SWIGTYPE_p_wxWebKitStateChangedEvent, SWIG_NewClientData(obj));

4409

return SWIG_Py_Void();

4410

}

4411

4412

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

4413

return SWIG_Python_InitShadowInstance(args);

4414

}

4415

4416

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

4417

PyObject *resultobj = 0;

4418

wxWebKitNewWindowEvent *arg1 = (wxWebKitNewWindowEvent *) 0 ;

4419

wxString result;

4420

void *argp1 = 0 ;

4421

int res1 = 0 ;

4422

PyObject *swig_obj[1] ;

4423

4424

if (!args) SWIG_fail;

4425

swig_obj[0] = args;

4426

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

4427

if (!SWIG_IsOK(res1)) {

4428

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

4429

}

4430

arg1 = reinterpret_cast< wxWebKitNewWindowEvent * >(argp1);

4431

{

4432

PyThreadState* __tstate = wxPyBeginAllowThreads();

4433

result = ((wxWebKitNewWindowEvent const *)arg1)->GetURL();

4434

wxPyEndAllowThreads(__tstate);

4435

if (PyErr_Occurred()) SWIG_fail;

4436

}

4437

{

4438

#if wxUSE_UNICODE

4439

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

4440

#else

4441

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

4442

#endif

4443

}

4444

return resultobj;

4445

fail:

4446

return NULL;

4447

}

4448

4449

4450

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

4451

PyObject *resultobj = 0;

4452

wxWebKitNewWindowEvent *arg1 = (wxWebKitNewWindowEvent *) 0 ;

4453

wxString *arg2 = 0 ;

4454

void *argp1 = 0 ;

4455

int res1 = 0 ;

4456

bool temp2 = false ;

4457

PyObject * obj0 = 0 ;

4458

PyObject * obj1 = 0 ;

4459

char * kwnames[] = {

4460

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

4461

};

4462

4463

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

4464

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

4465

if (!SWIG_IsOK(res1)) {

4466

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

4467

}

4468

arg1 = reinterpret_cast< wxWebKitNewWindowEvent * >(argp1);

4469

{

4470

arg2 = wxString_in_helper(obj1);

4471

if (arg2 == NULL) SWIG_fail;

4472

temp2 = true;

4473

}

4474

{

4475

PyThreadState* __tstate = wxPyBeginAllowThreads();

4476

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

4477

wxPyEndAllowThreads(__tstate);

4478

if (PyErr_Occurred()) SWIG_fail;

4479

}

4480

resultobj = SWIG_Py_Void();

4481

{

4482

if (temp2)

4483

delete arg2;

4484

}

4485

return resultobj;

4486

fail:

4487

{

4488

if (temp2)

4489

delete arg2;

4490

}

4491

return NULL;

4492

}

4493

4494

4495

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

4496

PyObject *resultobj = 0;

4497

wxWebKitNewWindowEvent *arg1 = (wxWebKitNewWindowEvent *) 0 ;

4498

wxString result;

4499

void *argp1 = 0 ;

4500

int res1 = 0 ;

4501

PyObject *swig_obj[1] ;

4502

4503

if (!args) SWIG_fail;

4504

swig_obj[0] = args;

4505

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

4506

if (!SWIG_IsOK(res1)) {

4507

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

4508

}

4509

arg1 = reinterpret_cast< wxWebKitNewWindowEvent * >(argp1);

4510

{

4511

PyThreadState* __tstate = wxPyBeginAllowThreads();

4512

result = ((wxWebKitNewWindowEvent const *)arg1)->GetTargetName();

4513

wxPyEndAllowThreads(__tstate);

4514

if (PyErr_Occurred()) SWIG_fail;

4515

}

4516

{

4517

#if wxUSE_UNICODE

4518

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

4519

#else

4520

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

4521

#endif

4522

}

4523

return resultobj;

4524

fail:

4525

return NULL;

4526

}

4527

4528

4529

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

4530

PyObject *resultobj = 0;

4531

wxWebKitNewWindowEvent *arg1 = (wxWebKitNewWindowEvent *) 0 ;

4532

wxString *arg2 = 0 ;

4533

void *argp1 = 0 ;

4534

int res1 = 0 ;

4535

bool temp2 = false ;

4536

PyObject * obj0 = 0 ;

4537

PyObject * obj1 = 0 ;

4538

char * kwnames[] = {

4539

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

4540

};

4541

4542

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

4543

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

4544

if (!SWIG_IsOK(res1)) {

4545

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

4546

}

4547

arg1 = reinterpret_cast< wxWebKitNewWindowEvent * >(argp1);

4548

{

4549

arg2 = wxString_in_helper(obj1);

4550

if (arg2 == NULL) SWIG_fail;

4551

temp2 = true;

4552

}

4553

{

4554

PyThreadState* __tstate = wxPyBeginAllowThreads();

4555

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

4556

wxPyEndAllowThreads(__tstate);

4557

if (PyErr_Occurred()) SWIG_fail;

4558

}

4559

resultobj = SWIG_Py_Void();

4560

{

4561

if (temp2)

4562

delete arg2;

4563

}

4564

return resultobj;

4565

fail:

4566

{

4567

if (temp2)

4568

delete arg2;

4569

}

4570

return NULL;

4571

}

4572

4573

4574

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

4575

PyObject *resultobj = 0;

4576

wxWindow *arg1 = (wxWindow *) NULL ;

4577

wxWebKitNewWindowEvent *result = 0 ;

4578

void *argp1 = 0 ;

4579

int res1 = 0 ;

4580

PyObject * obj0 = 0 ;

4581

char * kwnames[] = {

4582

(char *) "win", NULL

4583

};

4584

4585

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

4586

if (obj0) {

4587

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

4588

if (!SWIG_IsOK(res1)) {

4589

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

4590

}

4591

arg1 = reinterpret_cast< wxWindow * >(argp1);

4592

}

4593

{

4594

PyThreadState* __tstate = wxPyBeginAllowThreads();

4595

result = (wxWebKitNewWindowEvent *)new wxWebKitNewWindowEvent(arg1);

4596

wxPyEndAllowThreads(__tstate);

4597

if (PyErr_Occurred()) SWIG_fail;

4598

}

4599

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

4600

return resultobj;

4601

fail:

4602

return NULL;

4603

}

4604

4605

4606

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

4607

PyObject *obj;

4608

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

4609

SWIG_TypeNewClientData(SWIGTYPE_p_wxWebKitNewWindowEvent, SWIG_NewClientData(obj));

4610

return SWIG_Py_Void();

4611

}

4612

4613

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

4614

return SWIG_Python_InitShadowInstance(args);

4615

}

4616

4617

static PyMethodDef SwigMethods[] = {

4618

{ (char *)"new_WebKitCtrl", (PyCFunction) _wrap_new_WebKitCtrl, METH_VARARGS | METH_KEYWORDS, NULL},

4619

{ (char *)"new_PreWebKitCtrl", (PyCFunction)_wrap_new_PreWebKitCtrl, METH_NOARGS, NULL},

4620

{ (char *)"WebKitCtrl_Create", (PyCFunction) _wrap_WebKitCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},

4621

{ (char *)"WebKitCtrl_LoadURL", (PyCFunction) _wrap_WebKitCtrl_LoadURL, METH_VARARGS | METH_KEYWORDS, NULL},

4622

{ (char *)"WebKitCtrl_CanGoBack", (PyCFunction)_wrap_WebKitCtrl_CanGoBack, METH_O, NULL},

4623

{ (char *)"WebKitCtrl_CanGoForward", (PyCFunction)_wrap_WebKitCtrl_CanGoForward, METH_O, NULL},

4624

{ (char *)"WebKitCtrl_GoBack", (PyCFunction)_wrap_WebKitCtrl_GoBack, METH_O, NULL},

4625

{ (char *)"WebKitCtrl_GoForward", (PyCFunction)_wrap_WebKitCtrl_GoForward, METH_O, NULL},

4626

{ (char *)"WebKitCtrl_Reload", (PyCFunction)_wrap_WebKitCtrl_Reload, METH_O, NULL},

4627

{ (char *)"WebKitCtrl_Stop", (PyCFunction)_wrap_WebKitCtrl_Stop, METH_O, NULL},

4628

{ (char *)"WebKitCtrl_CanGetPageSource", (PyCFunction)_wrap_WebKitCtrl_CanGetPageSource, METH_O, NULL},

4629

{ (char *)"WebKitCtrl_GetPageSource", (PyCFunction)_wrap_WebKitCtrl_GetPageSource, METH_O, NULL},

4630

{ (char *)"WebKitCtrl_SetPageSource", (PyCFunction) _wrap_WebKitCtrl_SetPageSource, METH_VARARGS | METH_KEYWORDS, NULL},

4631

{ (char *)"WebKitCtrl_GetPageURL", (PyCFunction)_wrap_WebKitCtrl_GetPageURL, METH_O, NULL},

4632

{ (char *)"WebKitCtrl_GetPageTitle", (PyCFunction)_wrap_WebKitCtrl_GetPageTitle, METH_O, NULL},

4633

{ (char *)"WebKitCtrl_GetSelection", (PyCFunction)_wrap_WebKitCtrl_GetSelection, METH_O, NULL},

4634

{ (char *)"WebKitCtrl_CanIncreaseTextSize", (PyCFunction)_wrap_WebKitCtrl_CanIncreaseTextSize, METH_O, NULL},

4635

{ (char *)"WebKitCtrl_IncreaseTextSize", (PyCFunction)_wrap_WebKitCtrl_IncreaseTextSize, METH_O, NULL},

4636

{ (char *)"WebKitCtrl_CanDecreaseTextSize", (PyCFunction)_wrap_WebKitCtrl_CanDecreaseTextSize, METH_O, NULL},

4637

{ (char *)"WebKitCtrl_DecreaseTextSize", (PyCFunction)_wrap_WebKitCtrl_DecreaseTextSize, METH_O, NULL},

4638

{ (char *)"WebKitCtrl_Print", (PyCFunction) _wrap_WebKitCtrl_Print, METH_VARARGS | METH_KEYWORDS, NULL},

4639

{ (char *)"WebKitCtrl_MakeEditable", (PyCFunction) _wrap_WebKitCtrl_MakeEditable, METH_VARARGS | METH_KEYWORDS, NULL},

4640

{ (char *)"WebKitCtrl_IsEditable", (PyCFunction)_wrap_WebKitCtrl_IsEditable, METH_O, NULL},

4641

{ (char *)"WebKitCtrl_RunScript", (PyCFunction) _wrap_WebKitCtrl_RunScript, METH_VARARGS | METH_KEYWORDS, NULL},

4642

{ (char *)"WebKitCtrl_SetScrollPos", (PyCFunction) _wrap_WebKitCtrl_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},

4643

{ (char *)"WebKitCtrl_GetScrollPos", (PyCFunction)_wrap_WebKitCtrl_GetScrollPos, METH_O, NULL},

4644

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

4645

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

4646

{ (char *)"WebKitBeforeLoadEvent_IsCancelled", (PyCFunction)_wrap_WebKitBeforeLoadEvent_IsCancelled, METH_O, NULL},

4647

{ (char *)"WebKitBeforeLoadEvent_Cancel", (PyCFunction) _wrap_WebKitBeforeLoadEvent_Cancel, METH_VARARGS | METH_KEYWORDS, NULL},

4648

{ (char *)"WebKitBeforeLoadEvent_GetURL", (PyCFunction)_wrap_WebKitBeforeLoadEvent_GetURL, METH_O, NULL},

4649

{ (char *)"WebKitBeforeLoadEvent_SetURL", (PyCFunction) _wrap_WebKitBeforeLoadEvent_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},

4650

{ (char *)"WebKitBeforeLoadEvent_SetNavigationType", (PyCFunction) _wrap_WebKitBeforeLoadEvent_SetNavigationType, METH_VARARGS | METH_KEYWORDS, NULL},

4651

{ (char *)"WebKitBeforeLoadEvent_GetNavigationType", (PyCFunction)_wrap_WebKitBeforeLoadEvent_GetNavigationType, METH_O, NULL},

4652

{ (char *)"new_WebKitBeforeLoadEvent", (PyCFunction) _wrap_new_WebKitBeforeLoadEvent, METH_VARARGS | METH_KEYWORDS, NULL},

4653

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

4654

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

4655

{ (char *)"new_WebKitStateChangedEvent", (PyCFunction) _wrap_new_WebKitStateChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},

4656

{ (char *)"WebKitStateChangedEvent_GetState", (PyCFunction)_wrap_WebKitStateChangedEvent_GetState, METH_O, NULL},

4657

{ (char *)"WebKitStateChangedEvent_SetState", (PyCFunction) _wrap_WebKitStateChangedEvent_SetState, METH_VARARGS | METH_KEYWORDS, NULL},

4658

{ (char *)"WebKitStateChangedEvent_GetURL", (PyCFunction)_wrap_WebKitStateChangedEvent_GetURL, METH_O, NULL},

4659

{ (char *)"WebKitStateChangedEvent_SetURL", (PyCFunction) _wrap_WebKitStateChangedEvent_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},

4660

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

4661

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

4662

{ (char *)"WebKitNewWindowEvent_GetURL", (PyCFunction)_wrap_WebKitNewWindowEvent_GetURL, METH_O, NULL},

4663

{ (char *)"WebKitNewWindowEvent_SetURL", (PyCFunction) _wrap_WebKitNewWindowEvent_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},

4664

{ (char *)"WebKitNewWindowEvent_GetTargetName", (PyCFunction)_wrap_WebKitNewWindowEvent_GetTargetName, METH_O, NULL},

4665

{ (char *)"WebKitNewWindowEvent_SetTargetName", (PyCFunction) _wrap_WebKitNewWindowEvent_SetTargetName, METH_VARARGS | METH_KEYWORDS, NULL},

4666

{ (char *)"new_WebKitNewWindowEvent", (PyCFunction) _wrap_new_WebKitNewWindowEvent, METH_VARARGS | METH_KEYWORDS, NULL},

4667

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

4668

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

4669

{ NULL, NULL, 0, NULL }

4670

};

4671

4672

4673

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

4674

4675

static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {

4676

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

4677

}

4678

static void *_p_wxSizerItemTo_p_wxObject(void *x) {

4679

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

4680

}

4681

static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {

4682

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

4683

}

4684

static void *_p_wxScrollEventTo_p_wxObject(void *x) {

4685

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

4686

}

4687

static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {

4688

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

4689

}

4690

static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {

4691

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

4692

}

4693

static void *_p_wxBoxSizerTo_p_wxObject(void *x) {

4694

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

4695

}

4696

static void *_p_wxSizerTo_p_wxObject(void *x) {

4697

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

4698

}

4699

static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {

4700

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

4701

}

4702

static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {

4703

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

4704

}

4705

static void *_p_wxEventTo_p_wxObject(void *x) {

4706

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

4707

}

4708

static void *_p_wxGridSizerTo_p_wxObject(void *x) {

4709

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

4710

}

4711

static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {

4712

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

4713

}

4714

static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {

4715

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

4716

}

4717

static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {

4718

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

4719

}

4720

static void *_p_wxPaintEventTo_p_wxObject(void *x) {

4721

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

4722

}

4723

static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {

4724

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

4725

}

4726

static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {

4727

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

4728

}

4729

static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {

4730

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

4731

}

4732

static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {

4733

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

4734

}

4735

static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {

4736

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

4737

}

4738

static void *_p_wxWebKitBeforeLoadEventTo_p_wxObject(void *x) {

4739

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

4740

}

4741

static void *_p_wxWebKitStateChangedEventTo_p_wxObject(void *x) {

4742

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

4743

}

4744

static void *_p_wxControlTo_p_wxObject(void *x) {

4745

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

4746

}

4747

static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {

4748

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

4749

}

4750

static void *_p_wxFSFileTo_p_wxObject(void *x) {

4751

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

4752

}

4753

static void *_p_wxPySizerTo_p_wxObject(void *x) {

4754

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

4755

}

4756

static void *_p_wxPyEventTo_p_wxObject(void *x) {

4757

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

4758

}

4759

static void *_p_wxNotifyEventTo_p_wxObject(void *x) {

4760

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

4761

}

4762

static void *_p_wxShowEventTo_p_wxObject(void *x) {

4763

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

4764

}

4765

static void *_p_wxWebKitNewWindowEventTo_p_wxObject(void *x) {

4766

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

4767

}

4768

static void *_p_wxMenuItemTo_p_wxObject(void *x) {

4769

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

4770

}

4771

static void *_p_wxDateEventTo_p_wxObject(void *x) {

4772

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

4773

}

4774

static void *_p_wxIdleEventTo_p_wxObject(void *x) {

4775

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

4776

}

4777

static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {

4778

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

4779

}

4780

static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {

4781

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

4782

}

4783

static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {

4784

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

4785

}

4786

static void *_p_wxIconizeEventTo_p_wxObject(void *x) {

4787

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

4788

}

4789

static void *_p_wxActivateEventTo_p_wxObject(void *x) {

4790

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

4791

}

4792

static void *_p_wxSizeEventTo_p_wxObject(void *x) {

4793

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

4794

}

4795

static void *_p_wxMoveEventTo_p_wxObject(void *x) {

4796

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

4797

}

4798

static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {

4799

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

4800

}

4801

static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {

4802

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

4803

}

4804

static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {

4805

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

4806

}

4807

static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {

4808

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

4809

}

4810

static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {

4811

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

4812

}

4813

static void *_p_wxANIHandlerTo_p_wxObject(void *x) {

4814

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

4815

}

4816

static void *_p_wxCURHandlerTo_p_wxObject(void *x) {

4817

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

4818

}

4819

static void *_p_wxICOHandlerTo_p_wxObject(void *x) {

4820

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

4821

}

4822

static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {

4823

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

4824

}

4825

static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {

4826

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

4827

}

4828

static void *_p_wxImageHandlerTo_p_wxObject(void *x) {

4829

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

4830

}

4831

static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {

4832

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

4833

}

4834

static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {

4835

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

4836

}

4837

static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {

4838

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

4839

}

4840

static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {

4841

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

4842

}

4843

static void *_p_wxPyEvtHandlerTo_p_wxObject(void *x) {

4844

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

4845

}

4846

static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {

4847

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

4848

}

4849

static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {

4850

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

4851

}

4852

static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {

4853

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

4854

}

4855

static void *_p_wxImageTo_p_wxObject(void *x) {

4856

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

4857

}

4858

static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {

4859

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

4860

}

4861

static void *_p_wxWebKitCtrlTo_p_wxObject(void *x) {

4862

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

4863

}

4864

static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {

4865

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

4866

}

4867

static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {

4868

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

4869

}

4870

static void *_p_wxKeyEventTo_p_wxObject(void *x) {

4871

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

4872

}

4873

static void *_p_wxWindowTo_p_wxObject(void *x) {

4874

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

4875

}

4876

static void *_p_wxMenuTo_p_wxObject(void *x) {

4877

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

4878

}

4879

static void *_p_wxMenuBarTo_p_wxObject(void *x) {

4880

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

4881

}

4882

static void *_p_wxFileSystemTo_p_wxObject(void *x) {

4883

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

4884

}

4885

static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {

4886

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

4887

}

4888

static void *_p_wxMenuEventTo_p_wxObject(void *x) {

4889

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

4890

}

4891

static void *_p_wxPyAppTo_p_wxObject(void *x) {

4892

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

4893

}

4894

static void *_p_wxCloseEventTo_p_wxObject(void *x) {

4895

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

4896

}

4897

static void *_p_wxMouseEventTo_p_wxObject(void *x) {

4898

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

4899

}

4900

static void *_p_wxEraseEventTo_p_wxObject(void *x) {

4901

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

4902

}

4903

static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {

4904

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

4905

}

4906

static void *_p_wxCommandEventTo_p_wxObject(void *x) {

4907

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

4908

}

4909

static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {

4910

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

4911

}

4912

static void *_p_wxFocusEventTo_p_wxObject(void *x) {

4913

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

4914

}

4915

static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {

4916

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

4917

}

4918

static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {

4919

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

4920

}

4921

static void *_p_wxPyValidatorTo_p_wxObject(void *x) {

4922

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

4923

}

4924

static void *_p_wxValidatorTo_p_wxObject(void *x) {

4925

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

4926

}

4927

static void *_p_wxControlTo_p_wxWindow(void *x) {

4928

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

4929

}

4930

static void *_p_wxWebKitCtrlTo_p_wxWindow(void *x) {

4931

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

4932

}

4933

static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {

4934

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

4935

}

4936

static void *_p_wxMenuBarTo_p_wxWindow(void *x) {

4937

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

4938

}

4939

static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {

4940

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

4941

}

4942

static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {

4943

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

4944

}

4945

static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {

4946

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

4947

}

4948

static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {

4949

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

4950

}

4951

static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {

4952

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

4953

}

4954

static void *_p_wxWebKitNewWindowEventTo_p_wxCommandEvent(void *x) {

4955

return (void *)((wxCommandEvent *) ((wxWebKitNewWindowEvent *) x));

4956

}

4957

static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {

4958

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

4959

}

4960

static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {

4961

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

4962

}

4963

static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {

4964

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

4965

}

4966

static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {

4967

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

4968

}

4969

static void *_p_wxWebKitBeforeLoadEventTo_p_wxCommandEvent(void *x) {

4970

return (void *)((wxCommandEvent *) ((wxWebKitBeforeLoadEvent *) x));

4971

}

4972

static void *_p_wxWebKitStateChangedEventTo_p_wxCommandEvent(void *x) {

4973

return (void *)((wxCommandEvent *) ((wxWebKitStateChangedEvent *) x));

4974

}

4975

static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {

4976

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

4977

}

4978

static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {

4979

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

4980

}

4981

static void *_p_wxControlTo_p_wxEvtHandler(void *x) {

4982

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

4983

}

4984

static void *_p_wxWebKitCtrlTo_p_wxEvtHandler(void *x) {

4985

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

4986

}

4987

static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {

4988

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

4989

}

4990

static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {

4991

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

4992

}

4993

static void *_p_wxPyEvtHandlerTo_p_wxEvtHandler(void *x) {

4994

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

4995

}

4996

static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {

4997

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

4998

}

4999

static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {

5000

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

5001

}

5002

static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {

5003

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

5004

}

5005

static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {

5006

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

5007

}

5008

static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {

5009

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

5010

}

5011

static void *_p_wxWebKitCtrlTo_p_wxControl(void *x) {

5012

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

5013

}

5014

static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {

5015

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

5016

}

5017

static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {

5018

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

5019

}

5020

static void *_p_wxMenuEventTo_p_wxEvent(void *x) {

5021

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

5022

}

5023

static void *_p_wxCloseEventTo_p_wxEvent(void *x) {

5024

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

5025

}

5026

static void *_p_wxMouseEventTo_p_wxEvent(void *x) {

5027

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

5028

}

5029

static void *_p_wxEraseEventTo_p_wxEvent(void *x) {

5030

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

5031

}

5032

static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {

5033

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

5034

}

5035

static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {

5036

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

5037

}

5038

static void *_p_wxScrollEventTo_p_wxEvent(void *x) {

5039

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

5040

}

5041

static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {

5042

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

5043

}

5044

static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {

5045

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

5046

}

5047

static void *_p_wxPyEventTo_p_wxEvent(void *x) {

5048

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

5049

}

5050

static void *_p_wxIdleEventTo_p_wxEvent(void *x) {

5051

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

5052

}

5053

static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {

5054

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

5055

}

5056

static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {

5057

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

5058

}

5059

static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {

5060

return (void *)((wxEvent *) ((wxMaximizeEvent *) x));

5061

}

5062

static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {

5063

return (void *)((wxEvent *) ((wxIconizeEvent *) x));

5064

}

5065

static void *_p_wxActivateEventTo_p_wxEvent(void *x) {

5066

return (void *)((wxEvent *) ((wxActivateEvent *) x));

5067

}

5068

static void *_p_wxSizeEventTo_p_wxEvent(void *x) {

5069

return (void *)((wxEvent *) ((wxSizeEvent *) x));

5070

}

5071

static void *_p_wxMoveEventTo_p_wxEvent(void *x) {

5072

return (void *)((wxEvent *) ((wxMoveEvent *) x));

5073

}

5074

static void *_p_wxDateEventTo_p_wxEvent(void *x) {

5075

return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));

5076

}

5077

static void *_p_wxPaintEventTo_p_wxEvent(void *x) {

5078

return (void *)((wxEvent *) ((wxPaintEvent *) x));

5079

}

5080

static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {

5081

return (void *)((wxEvent *) ((wxNcPaintEvent *) x));

5082

}

5083

static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {

5084

return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));

5085

}

5086

static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {

5087

return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));

5088

}

5089

static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {

5090

return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));

5091

}

5092

static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {

5093

return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));

5094

}

5095

static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {

5096

return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));

5097

}

5098

static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {

5099

return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));

5100

}

5101

static void *_p_wxWebKitBeforeLoadEventTo_p_wxEvent(void *x) {

5102

return (void *)((wxEvent *) (wxCommandEvent *) ((wxWebKitBeforeLoadEvent *) x));

5103

}

5104

static void *_p_wxWebKitStateChangedEventTo_p_wxEvent(void *x) {

5105

return (void *)((wxEvent *) (wxCommandEvent *) ((wxWebKitStateChangedEvent *) x));

5106

}

5107

static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {

5108

return (void *)((wxEvent *) ((wxDropFilesEvent *) x));

5109

}

5110

static void *_p_wxFocusEventTo_p_wxEvent(void *x) {

5111

return (void *)((wxEvent *) ((wxFocusEvent *) x));

5112

}

5113

static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {

5114

return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));

5115

}

5116

static void *_p_wxShowEventTo_p_wxEvent(void *x) {

5117

return (void *)((wxEvent *) ((wxShowEvent *) x));

5118

}

5119

static void *_p_wxWebKitNewWindowEventTo_p_wxEvent(void *x) {

5120

return (void *)((wxEvent *) (wxCommandEvent *) ((wxWebKitNewWindowEvent *) x));

5121

}

5122

static void *_p_wxCommandEventTo_p_wxEvent(void *x) {

5123

return (void *)((wxEvent *) ((wxCommandEvent *) x));

5124

}

5125

static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {

5126

return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));

5127

}

5128

static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {

5129

return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));

5130

}

5131

static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {

5132

return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));

5133

}

5134

static void *_p_wxKeyEventTo_p_wxEvent(void *x) {

5135

return (void *)((wxEvent *) ((wxKeyEvent *) x));

5136

}

5137

static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {

5138

return (void *)((wxEvent *) ((wxScrollWinEvent *) x));

5139

}

5140

static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};

5141

static swig_type_info _swigt__p_double = {"_p_double", "double *|wxDouble *", 0, 0, (void*)0, 0};

5142

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};

5143

static swig_type_info _swigt__p_int = {"_p_int", "int *|wxEventType *", 0, 0, (void*)0, 0};

5144

static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};

5145

static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};

5146

static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};

5147

static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};

5148

static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};

5149

static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};

5150

static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};

5151

static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};

5152

static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};

5153

static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};

5154

static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};

5155

static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};

5156

static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};

5157

static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};

5158

static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};

5159

static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};

5160

static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};

5161

static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};

5162

static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};

5163

static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};

5164

static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};

5165

static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};

5166

static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};

5167

static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};

5168

static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};

5169

static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};

5170

static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};

5171

static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};

5172

static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};

5173

static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};

5174

static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};

5175

static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};

5176

static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};

5177

static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};

5178

static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};

5179

static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};

5180

static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};

5181

static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};

5182

static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};

5183

static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};

5184

static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};

5185

static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};

5186

static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};

5187

static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};

5188

static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};

5189

static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};

5190

static swig_type_info _swigt__p_wxPyEvtHandler = {"_p_wxPyEvtHandler", 0, 0, 0, 0, 0};

5191

static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};

5192

static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};

5193

static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};

5194

static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};

5195

static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};

5196

static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};

5197

static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};

5198

static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};

5199

static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};

5200

static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};

5201

static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};

5202

static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};

5203

static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};

5204

static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};

5205

static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};

5206

static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};

5207

static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};

5208

static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};

5209

static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};

5210

static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};

5211

static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};

5212

static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};

5213

static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};

5214

static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};

5215

static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};

5216

static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};

5217

static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};

5218

static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};

5219

static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};

5220

static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};

5221

static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};

5222

static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};

5223

static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};

5224

static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};

5225

static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};

5226

static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};

5227

static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};

5228

static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};

5229

static swig_type_info _swigt__p_wxWebKitBeforeLoadEvent = {"_p_wxWebKitBeforeLoadEvent", "wxWebKitBeforeLoadEvent *", 0, 0, (void*)0, 0};

5230

static swig_type_info _swigt__p_wxWebKitCtrl = {"_p_wxWebKitCtrl", "wxWebKitCtrl *", 0, 0, (void*)0, 0};

5231

static swig_type_info _swigt__p_wxWebKitNewWindowEvent = {"_p_wxWebKitNewWindowEvent", "wxWebKitNewWindowEvent *", 0, 0, (void*)0, 0};

5232

static swig_type_info _swigt__p_wxWebKitStateChangedEvent = {"_p_wxWebKitStateChangedEvent", "wxWebKitStateChangedEvent *", 0, 0, (void*)0, 0};

5233

static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};

5234

5235

static swig_type_info *swig_type_initial[] = {

5236

&_swigt__p_char,

5237

&_swigt__p_double,

5238

&_swigt__p_form_ops_t,

5239

&_swigt__p_int,

5240

&_swigt__p_unsigned_char,

5241

&_swigt__p_unsigned_int,

5242

&_swigt__p_unsigned_long,

5243

&_swigt__p_wxANIHandler,

5244

&_swigt__p_wxAcceleratorTable,

5245

&_swigt__p_wxActivateEvent,

5246

&_swigt__p_wxBMPHandler,

5247

&_swigt__p_wxBoxSizer,

5248

&_swigt__p_wxCURHandler,

5249

&_swigt__p_wxChildFocusEvent,

5250

&_swigt__p_wxClipboardTextEvent,

5251

&_swigt__p_wxCloseEvent,

5252

&_swigt__p_wxCommandEvent,

5253

&_swigt__p_wxContextMenuEvent,

5254

&_swigt__p_wxControl,

5255

&_swigt__p_wxControlWithItems,

5256

&_swigt__p_wxDateEvent,

5257

&_swigt__p_wxDisplayChangedEvent,

5258

&_swigt__p_wxDropFilesEvent,

5259

&_swigt__p_wxDuplexMode,

5260

&_swigt__p_wxEraseEvent,

5261

&_swigt__p_wxEvent,

5262

&_swigt__p_wxEvtHandler,

5263

&_swigt__p_wxFSFile,

5264

&_swigt__p_wxFileSystem,

5265

&_swigt__p_wxFlexGridSizer,

5266

&_swigt__p_wxFocusEvent,

5267

&_swigt__p_wxGBSizerItem,

5268

&_swigt__p_wxGIFHandler,

5269

&_swigt__p_wxGridBagSizer,

5270

&_swigt__p_wxGridSizer,

5271

&_swigt__p_wxICOHandler,

5272

&_swigt__p_wxIconizeEvent,

5273

&_swigt__p_wxIdleEvent,

5274

&_swigt__p_wxImage,

5275

&_swigt__p_wxImageHandler,

5276

&_swigt__p_wxIndividualLayoutConstraint,

5277

&_swigt__p_wxInitDialogEvent,

5278

&_swigt__p_wxJPEGHandler,

5279

&_swigt__p_wxKeyEvent,

5280

&_swigt__p_wxLayoutConstraints,

5281

&_swigt__p_wxMaximizeEvent,

5282

&_swigt__p_wxMenu,

5283

&_swigt__p_wxMenuBar,

5284

&_swigt__p_wxMenuEvent,

5285

&_swigt__p_wxMenuItem,

5286

&_swigt__p_wxMouseCaptureChangedEvent,

5287

&_swigt__p_wxMouseCaptureLostEvent,

5288

&_swigt__p_wxMouseEvent,

5289

&_swigt__p_wxMoveEvent,

5290

&_swigt__p_wxNavigationKeyEvent,

5291

&_swigt__p_wxNcPaintEvent,

5292

&_swigt__p_wxNotifyEvent,

5293

&_swigt__p_wxObject,

5294

&_swigt__p_wxPCXHandler,

5295

&_swigt__p_wxPNGHandler,

5296

&_swigt__p_wxPNMHandler,

5297

&_swigt__p_wxPaintEvent,

5298

&_swigt__p_wxPaletteChangedEvent,

5299

&_swigt__p_wxPaperSize,

5300

&_swigt__p_wxPyApp,

5301

&_swigt__p_wxPyCommandEvent,

5302

&_swigt__p_wxPyEvent,

5303

&_swigt__p_wxPyEvtHandler,

5304

&_swigt__p_wxPyImageHandler,

5305

&_swigt__p_wxPySizer,

5306

&_swigt__p_wxPyValidator,

5307

&_swigt__p_wxQueryNewPaletteEvent,

5308

&_swigt__p_wxScrollEvent,

5309

&_swigt__p_wxScrollWinEvent,

5310

&_swigt__p_wxSetCursorEvent,

5311

&_swigt__p_wxShowEvent,

5312

&_swigt__p_wxSizeEvent,

5313

&_swigt__p_wxSizer,

5314

&_swigt__p_wxSizerItem,

5315

&_swigt__p_wxStaticBoxSizer,

5316

&_swigt__p_wxStdDialogButtonSizer,

5317

&_swigt__p_wxSysColourChangedEvent,

5318

&_swigt__p_wxTGAHandler,

5319

&_swigt__p_wxTIFFHandler,

5320

&_swigt__p_wxUpdateUIEvent,

5321

&_swigt__p_wxValidator,

5322

&_swigt__p_wxWebKitBeforeLoadEvent,

5323

&_swigt__p_wxWebKitCtrl,

5324

&_swigt__p_wxWebKitNewWindowEvent,

5325

&_swigt__p_wxWebKitStateChangedEvent,

5326

&_swigt__p_wxWindow,

5327

&_swigt__p_wxWindowCreateEvent,

5328

&_swigt__p_wxWindowDestroyEvent,

5329

&_swigt__p_wxXPMHandler,

5330

};

5331

5332

static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};

5333

static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};

5334

static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};

5335

static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};

5336

static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};

5337

static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};

5338

static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};

5339

static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};

5340

static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};

5341

static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};

5342

static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};

5343

static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};

5344

static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};

5345

static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};

5346

static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};

5347

static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};

5348

static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};

5349

static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWebKitBeforeLoadEvent, _p_wxWebKitBeforeLoadEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWebKitStateChangedEvent, _p_wxWebKitStateChangedEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWebKitNewWindowEvent, _p_wxWebKitNewWindowEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};

5350

static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};

5351

static swig_cast_info _swigc__p_wxControl[] = { {&_swigt__p_wxControl, 0, 0, 0}, {&_swigt__p_wxWebKitCtrl, _p_wxWebKitCtrlTo_p_wxControl, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxControl, 0, 0},{0, 0, 0, 0}};

5352

static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};

5353

static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};

5354

static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};

5355

static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};

5356

static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};

5357

static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};

5358

static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};

5359

static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};

5360

static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};

5361

static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};

5362

static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};

5363

static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};

5364

static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};

5365

static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};

5366

static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};

5367

static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};

5368

static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};

5369

static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};

5370

static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

5371

static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

5372

static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

5373

static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

5374

static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};

5375

static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};

5376

static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};

5377

static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};

5378

static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};

5379

static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};

5380

static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWebKitBeforeLoadEvent, _p_wxWebKitBeforeLoadEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWebKitStateChangedEvent, _p_wxWebKitStateChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWebKitNewWindowEvent, _p_wxWebKitNewWindowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};

5381

static swig_cast_info _swigc__p_wxPyEvtHandler[] = {{&_swigt__p_wxPyEvtHandler, 0, 0, 0},{0, 0, 0, 0}};

5382

static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};

5383

static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};

5384

static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};

5385

static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};

5386

static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWebKitCtrl, _p_wxWebKitCtrlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 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}};

5387

static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};

5388

static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};

5389

static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};

5390

static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};

5391

static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};

5392

static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};

5393

static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};

5394

static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};

5395

static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};

5396

static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};

5397

static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};

5398

static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};

5399

static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};

5400

static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};

5401

static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};

5402

static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};

5403

static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};

5404

static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};

5405

static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};

5406

static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};

5407

static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};

5408

static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};

5409

static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};

5410

static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};

5411

static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};

5412

static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};

5413

static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};

5414

static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};

5415

static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};

5416

static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};

5417

static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};

5418

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_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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_wxWebKitBeforeLoadEvent, _p_wxWebKitBeforeLoadEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWebKitStateChangedEvent, _p_wxWebKitStateChangedEventTo_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_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWebKitNewWindowEvent, _p_wxWebKitNewWindowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_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_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxWebKitCtrl, _p_wxWebKitCtrlTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};

5419

static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};

5420

static swig_cast_info _swigc__p_wxValidator[] = { {&_swigt__p_wxValidator, 0, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxValidator, 0, 0},{0, 0, 0, 0}};

5421

static swig_cast_info _swigc__p_wxWebKitBeforeLoadEvent[] = { {&_swigt__p_wxWebKitBeforeLoadEvent, 0, 0, 0},{0, 0, 0, 0}};

5422

static swig_cast_info _swigc__p_wxWebKitCtrl[] = { {&_swigt__p_wxWebKitCtrl, 0, 0, 0},{0, 0, 0, 0}};

5423

static swig_cast_info _swigc__p_wxWebKitNewWindowEvent[] = { {&_swigt__p_wxWebKitNewWindowEvent, 0, 0, 0},{0, 0, 0, 0}};

5424

static swig_cast_info _swigc__p_wxWebKitStateChangedEvent[] = { {&_swigt__p_wxWebKitStateChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

5425

static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWebKitCtrl, _p_wxWebKitCtrlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};

5426

5427

static swig_cast_info *swig_cast_initial[] = {

5428

_swigc__p_char,

5429

_swigc__p_double,

5430

_swigc__p_form_ops_t,

5431

_swigc__p_int,

5432

_swigc__p_unsigned_char,

5433

_swigc__p_unsigned_int,

5434

_swigc__p_unsigned_long,

5435

_swigc__p_wxANIHandler,

5436

_swigc__p_wxAcceleratorTable,

5437

_swigc__p_wxActivateEvent,

5438

_swigc__p_wxBMPHandler,

5439

_swigc__p_wxBoxSizer,

5440

_swigc__p_wxCURHandler,

5441

_swigc__p_wxChildFocusEvent,

5442

_swigc__p_wxClipboardTextEvent,

5443

_swigc__p_wxCloseEvent,

5444

_swigc__p_wxCommandEvent,

5445

_swigc__p_wxContextMenuEvent,

5446

_swigc__p_wxControl,

5447

_swigc__p_wxControlWithItems,

5448

_swigc__p_wxDateEvent,

5449

_swigc__p_wxDisplayChangedEvent,

5450

_swigc__p_wxDropFilesEvent,

5451

_swigc__p_wxDuplexMode,

5452

_swigc__p_wxEraseEvent,

5453

_swigc__p_wxEvent,

5454

_swigc__p_wxEvtHandler,

5455

_swigc__p_wxFSFile,

5456

_swigc__p_wxFileSystem,

5457

_swigc__p_wxFlexGridSizer,

5458

_swigc__p_wxFocusEvent,

5459

_swigc__p_wxGBSizerItem,

5460

_swigc__p_wxGIFHandler,

5461

_swigc__p_wxGridBagSizer,

5462

_swigc__p_wxGridSizer,

5463

_swigc__p_wxICOHandler,

5464

_swigc__p_wxIconizeEvent,

5465

_swigc__p_wxIdleEvent,

5466

_swigc__p_wxImage,

5467

_swigc__p_wxImageHandler,

5468

_swigc__p_wxIndividualLayoutConstraint,

5469

_swigc__p_wxInitDialogEvent,

5470

_swigc__p_wxJPEGHandler,

5471

_swigc__p_wxKeyEvent,

5472

_swigc__p_wxLayoutConstraints,

5473

_swigc__p_wxMaximizeEvent,

5474

_swigc__p_wxMenu,

5475

_swigc__p_wxMenuBar,

5476

_swigc__p_wxMenuEvent,

5477

_swigc__p_wxMenuItem,

5478

_swigc__p_wxMouseCaptureChangedEvent,

5479

_swigc__p_wxMouseCaptureLostEvent,

5480

_swigc__p_wxMouseEvent,

5481

_swigc__p_wxMoveEvent,

5482

_swigc__p_wxNavigationKeyEvent,

5483

_swigc__p_wxNcPaintEvent,

5484

_swigc__p_wxNotifyEvent,

5485

_swigc__p_wxObject,

5486

_swigc__p_wxPCXHandler,

5487

_swigc__p_wxPNGHandler,

5488

_swigc__p_wxPNMHandler,

5489

_swigc__p_wxPaintEvent,

5490

_swigc__p_wxPaletteChangedEvent,

5491

_swigc__p_wxPaperSize,

5492

_swigc__p_wxPyApp,

5493

_swigc__p_wxPyCommandEvent,

5494

_swigc__p_wxPyEvent,

5495

_swigc__p_wxPyEvtHandler,

5496

_swigc__p_wxPyImageHandler,

5497

_swigc__p_wxPySizer,

5498

_swigc__p_wxPyValidator,

5499

_swigc__p_wxQueryNewPaletteEvent,

5500

_swigc__p_wxScrollEvent,

5501

_swigc__p_wxScrollWinEvent,

5502

_swigc__p_wxSetCursorEvent,

5503

_swigc__p_wxShowEvent,

5504

_swigc__p_wxSizeEvent,

5505

_swigc__p_wxSizer,

5506

_swigc__p_wxSizerItem,

5507

_swigc__p_wxStaticBoxSizer,

5508

_swigc__p_wxStdDialogButtonSizer,

5509

_swigc__p_wxSysColourChangedEvent,

5510

_swigc__p_wxTGAHandler,

5511

_swigc__p_wxTIFFHandler,

5512

_swigc__p_wxUpdateUIEvent,

5513

_swigc__p_wxValidator,

5514

_swigc__p_wxWebKitBeforeLoadEvent,

5515

_swigc__p_wxWebKitCtrl,

5516

_swigc__p_wxWebKitNewWindowEvent,

5517

_swigc__p_wxWebKitStateChangedEvent,

5518

_swigc__p_wxWindow,

5519

_swigc__p_wxWindowCreateEvent,

5520

_swigc__p_wxWindowDestroyEvent,

5521

_swigc__p_wxXPMHandler,

5522

};

5523

5524

5525

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

5526

5527

static swig_const_info swig_const_table[] = {

5528

{0, 0, 0, 0.0, 0, 0}};

5529

5530

#ifdef __cplusplus

5531

}

5532

#endif

5533

/* -----------------------------------------------------------------------------

5534

* Type initialization:

5535

* This problem is tough by the requirement that no dynamic

5536

* memory is used. Also, since swig_type_info structures store pointers to

5537

* swig_cast_info structures and swig_cast_info structures store pointers back

5538

* to swig_type_info structures, we need some lookup code at initialization.

5539

* The idea is that swig generates all the structures that are needed.

5540

* The runtime then collects these partially filled structures.

5541

* The SWIG_InitializeModule function takes these initial arrays out of

5542

* swig_module, and does all the lookup, filling in the swig_module.types

5543

* array with the correct data and linking the correct swig_cast_info

5544

* structures together.

5545

*

5546

* The generated swig_type_info structures are assigned staticly to an initial

5547

* array. We just loop though that array, and handle each type individually.

5548

* First we lookup if this type has been already loaded, and if so, use the

5549

* loaded structure instead of the generated one. Then we have to fill in the

5550

* cast linked list. The cast data is initially stored in something like a

5551

* two-dimensional array. Each row corresponds to a type (there are the same

5552

* number of rows as there are in the swig_type_initial array). Each entry in

5553

* a column is one of the swig_cast_info structures for that type.

5554

* The cast_initial array is actually an array of arrays, because each row has

5555

* a variable number of columns. So to actually build the cast linked list,

5556

* we find the array of casts associated with the type, and loop through it

5557

* adding the casts to the list. The one last trick we need to do is making

5558

* sure the type pointer in the swig_cast_info struct is correct.

5559

*

5560

* First off, we lookup the cast->type name to see if it is already loaded.

5561

* There are three cases to handle:

5562

* 1) If the cast->type has already been loaded AND the type we are adding

5563

* casting info to has not been loaded (it is in this module), THEN we

5564

* replace the cast->type pointer with the type pointer that has already

5565

* been loaded.

5566

* 2) If BOTH types (the one we are adding casting info to, and the

5567

* cast->type) are loaded, THEN the cast info has already been loaded by

5568

* the previous module so we just ignore it.

5569

* 3) Finally, if cast->type has not already been loaded, then we add that

5570

* swig_cast_info to the linked list (because the cast->type) pointer will

5571

* be correct.

5572

* ----------------------------------------------------------------------------- */

5573

5574

#ifdef __cplusplus

5575

extern "C" {

5576

#if 0

5577

} /* c-mode */

5578

#endif

5579

#endif

5580

5581

#if 0

5582

#define SWIGRUNTIME_DEBUG

5583

#endif

5584

5585

SWIGRUNTIME void

5586

SWIG_InitializeModule(void *clientdata) {

5587

size_t i;

5588

swig_module_info *module_head;

5589

static int init_run = 0;

5590

5591

clientdata = clientdata;

5592

5593

if (init_run) return;

5594

init_run = 1;

5595

5596

/* Initialize the swig_module */

5597

swig_module.type_initial = swig_type_initial;

5598

swig_module.cast_initial = swig_cast_initial;

5599

5600

/* Try and load any already created modules */

5601

module_head = SWIG_GetModule(clientdata);

5602

if (module_head) {

5603

swig_module.next = module_head->next;

5604

module_head->next = &swig_module;

5605

} else {

5606

/* This is the first module loaded */

5607

swig_module.next = &swig_module;

5608

SWIG_SetModule(clientdata, &swig_module);

5609

}

5610

5611

/* Now work on filling in swig_module.types */

5612

#ifdef SWIGRUNTIME_DEBUG

5613

printf("SWIG_InitializeModule: size %d\n", swig_module.size);

5614

#endif

5615

for (i = 0; i < swig_module.size; ++i) {

5616

swig_type_info *type = 0;

5617

swig_type_info *ret;

5618

swig_cast_info *cast;

5619

5620

#ifdef SWIGRUNTIME_DEBUG

5621

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

5622

#endif

5623

5624

/* if there is another module already loaded */

5625

if (swig_module.next != &swig_module) {

5626

type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);

5627

}

5628

if (type) {

5629

/* Overwrite clientdata field */

5630

#ifdef SWIGRUNTIME_DEBUG

5631

printf("SWIG_InitializeModule: found type %s\n", type->name);

5632

#endif

5633

if (swig_module.type_initial[i]->clientdata) {

5634

type->clientdata = swig_module.type_initial[i]->clientdata;

5635

#ifdef SWIGRUNTIME_DEBUG

5636

printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);

5637

#endif

5638

}

5639

} else {

5640

type = swig_module.type_initial[i];

5641

}

5642

5643

/* Insert casting types */

5644

cast = swig_module.cast_initial[i];

5645

while (cast->type) {

5646

/* Don't need to add information already in the list */

5647

ret = 0;

5648

#ifdef SWIGRUNTIME_DEBUG

5649

printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);

5650

#endif

5651

if (swig_module.next != &swig_module) {

5652

ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);

5653

#ifdef SWIGRUNTIME_DEBUG

5654

if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);

5655

#endif

5656

}

5657

if (ret) {

5658

if (type == swig_module.type_initial[i]) {

5659

#ifdef SWIGRUNTIME_DEBUG

5660

printf("SWIG_InitializeModule: skip old type %s\n", ret->name);

5661

#endif

5662

cast->type = ret;

5663

ret = 0;

5664

} else {

5665

/* Check for casting already in the list */

5666

swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);

5667

#ifdef SWIGRUNTIME_DEBUG

5668

if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);

5669

#endif

5670

if (!ocast) ret = 0;

5671

}

5672

}

5673

5674

if (!ret) {

5675

#ifdef SWIGRUNTIME_DEBUG

5676

printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);

5677

#endif

5678

if (type->cast) {

5679

type->cast->prev = cast;

5680

cast->next = type->cast;

5681

}

5682

type->cast = cast;

5683

}

5684

cast++;

5685

}

5686

/* Set entry in modules->types array equal to the type */

5687

swig_module.types[i] = type;

5688

}

5689

swig_module.types[i] = 0;

5690

5691

#ifdef SWIGRUNTIME_DEBUG

5692

printf("**** SWIG_InitializeModule: Cast List ******\n");

5693

for (i = 0; i < swig_module.size; ++i) {

5694

int j = 0;

5695

swig_cast_info *cast = swig_module.cast_initial[i];

5696

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

5697

while (cast->type) {

5698

printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);

5699

cast++;

5700

++j;

5701

}

5702

printf("---- Total casts: %d\n",j);

5703

}

5704

printf("**** SWIG_InitializeModule: Cast List ******\n");

5705

#endif

5706

}

5707

5708

/* This function will propagate the clientdata field of type to

5709

* any new swig_type_info structures that have been added into the list

5710

* of equivalent types. It is like calling

5711

* SWIG_TypeClientData(type, clientdata) a second time.

5712

*/

5713

SWIGRUNTIME void

5714

SWIG_PropagateClientData(void) {

5715

size_t i;

5716

swig_cast_info *equiv;

5717

static int init_run = 0;

5718

5719

if (init_run) return;

5720

init_run = 1;

5721

5722

for (i = 0; i < swig_module.size; i++) {

5723

if (swig_module.types[i]->clientdata) {

5724

equiv = swig_module.types[i]->cast;

5725

while (equiv) {

5726

if (!equiv->converter) {

5727

if (equiv->type && !equiv->type->clientdata)

5728

SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);

5729

}

5730

equiv = equiv->next;

5731

}

5732

}

5733

}

5734

}

5735

5736

#ifdef __cplusplus

5737

#if 0

5738

{

5739

/* c-mode */

5740

#endif

5741

}

5742

#endif

5743

5744

5745

5746

#ifdef __cplusplus

5747

extern "C" {

5748

#endif

5749

5750

/* Python-specific SWIG API */

5751

#define SWIG_newvarlink() SWIG_Python_newvarlink()

5752

#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)

5753

#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)

5754

5755

/* -----------------------------------------------------------------------------

5756

* global variable support code.

5757

* ----------------------------------------------------------------------------- */

5758

5759

typedef struct swig_globalvar {

5760

char *name; /* Name of global variable */

5761

PyObject *(*get_attr)(void); /* Return the current value */

5762

int (*set_attr)(PyObject *); /* Set the value */

5763

struct swig_globalvar *next;

5764

} swig_globalvar;

5765

5766

typedef struct swig_varlinkobject {

5767

PyObject_HEAD

5768

swig_globalvar *vars;

5769

} swig_varlinkobject;

5770

5771

SWIGINTERN PyObject *

5772

swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {

5773

return PyString_FromString("<Swig global variables>");

5774

}

5775

5776

SWIGINTERN PyObject *

5777

swig_varlink_str(swig_varlinkobject *v) {

5778

PyObject *str = PyString_FromString("(");

5779

swig_globalvar *var;

5780

for (var = v->vars; var; var=var->next) {

5781

PyString_ConcatAndDel(&str,PyString_FromString(var->name));

5782

if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));

5783

}

5784

PyString_ConcatAndDel(&str,PyString_FromString(")"));

5785

return str;

5786

}

5787

5788

SWIGINTERN int

5789

swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {

5790

PyObject *str = swig_varlink_str(v);

5791

fprintf(fp,"Swig global variables ");

5792

fprintf(fp,"%s\n", PyString_AsString(str));

5793

Py_DECREF(str);

5794

return 0;

5795

}

5796

5797

SWIGINTERN void

5798

swig_varlink_dealloc(swig_varlinkobject *v) {

5799

swig_globalvar *var = v->vars;

5800

while (var) {

5801

swig_globalvar *n = var->next;

5802

free(var->name);

5803

free(var);

5804

var = n;

5805

}

5806

}

5807

5808

SWIGINTERN PyObject *

5809

swig_varlink_getattr(swig_varlinkobject *v, char *n) {

5810

PyObject *res = NULL;

5811

swig_globalvar *var = v->vars;

5812

while (var) {

5813

if (strcmp(var->name,n) == 0) {

5814

res = (*var->get_attr)();

5815

break;

5816

}

5817

var = var->next;

5818

}

5819

if (res == NULL && !PyErr_Occurred()) {

5820

PyErr_SetString(PyExc_NameError,"Unknown C global variable");

5821

}

5822

return res;

5823

}

5824

5825

SWIGINTERN int

5826

swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {

5827

int res = 1;

5828

swig_globalvar *var = v->vars;

5829

while (var) {

5830

if (strcmp(var->name,n) == 0) {

5831

res = (*var->set_attr)(p);

5832

break;

5833

}

5834

var = var->next;

5835

}

5836

if (res == 1 && !PyErr_Occurred()) {

5837

PyErr_SetString(PyExc_NameError,"Unknown C global variable");

5838

}

5839

return res;

5840

}

5841

5842

SWIGINTERN PyTypeObject*

5843

swig_varlink_type(void) {

5844

static char varlink__doc__[] = "Swig var link object";

5845

static PyTypeObject varlink_type;

5846

static int type_init = 0;

5847

if (!type_init) {

5848

const PyTypeObject tmp

5849

= {

5850

PyObject_HEAD_INIT(NULL)

5851

0, /* Number of items in variable part (ob_size) */

5852

(char *)"swigvarlink", /* Type name (tp_name) */

5853

sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */

5854

0, /* Itemsize (tp_itemsize) */

5855

(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */

5856

(printfunc) swig_varlink_print, /* Print (tp_print) */

5857

(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */

5858

(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */

5859

0, /* tp_compare */

5860

(reprfunc) swig_varlink_repr, /* tp_repr */

5861

0, /* tp_as_number */

5862

0, /* tp_as_sequence */

5863

0, /* tp_as_mapping */

5864

0, /* tp_hash */

5865

0, /* tp_call */

5866

(reprfunc)swig_varlink_str, /* tp_str */

5867

0, /* tp_getattro */

5868

0, /* tp_setattro */

5869

0, /* tp_as_buffer */

5870

0, /* tp_flags */

5871

varlink__doc__, /* tp_doc */

5872

0, /* tp_traverse */

5873

0, /* tp_clear */

5874

0, /* tp_richcompare */

5875

0, /* tp_weaklistoffset */

5876

#if PY_VERSION_HEX >= 0x02020000

5877

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */

5878

#endif

5879

#if PY_VERSION_HEX >= 0x02030000

5880

0, /* tp_del */

5881

#endif

5882

#ifdef COUNT_ALLOCS

5883

0,0,0,0 /* tp_alloc -> tp_next */

5884

#endif

5885

};

5886

varlink_type = tmp;

5887

varlink_type.ob_type = &PyType_Type;

5888

type_init = 1;

5889

}

5890

return &varlink_type;

5891

}

5892

5893

/* Create a variable linking object for use later */

5894

SWIGINTERN PyObject *

5895

SWIG_Python_newvarlink(void) {

5896

swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());

5897

if (result) {

5898

result->vars = 0;

5899

}

5900

return ((PyObject*) result);

5901

}

5902

5903

SWIGINTERN void

5904

SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {

5905

swig_varlinkobject *v = (swig_varlinkobject *) p;

5906

swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));

5907

if (gv) {

5908

size_t size = strlen(name)+1;

5909

gv->name = (char *)malloc(size);

5910

if (gv->name) {

5911

strncpy(gv->name,name,size);

5912

gv->get_attr = get_attr;

5913

gv->set_attr = set_attr;

5914

gv->next = v->vars;

5915

}

5916

}

5917

v->vars = gv;

5918

}

5919

5920

SWIGINTERN PyObject *

5921

SWIG_globals() {

5922

static PyObject *_SWIG_globals = 0;

5923

if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();

5924

return _SWIG_globals;

5925

}

5926

5927

/* -----------------------------------------------------------------------------

5928

* constants/methods manipulation

5929

* ----------------------------------------------------------------------------- */

5930

5931

/* Install Constants */

5932

SWIGINTERN void

5933

SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {

5934

PyObject *obj = 0;

5935

size_t i;

5936

for (i = 0; constants[i].type; ++i) {

5937

switch(constants[i].type) {

5938

case SWIG_PY_POINTER:

5939

obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);

5940

break;

5941

case SWIG_PY_BINARY:

5942

obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));

5943

break;

5944

default:

5945

obj = 0;

5946

break;

5947

}

5948

if (obj) {

5949

PyDict_SetItemString(d, constants[i].name, obj);

5950

Py_DECREF(obj);

5951

}

5952

}

5953

}

5954

5955

/* -----------------------------------------------------------------------------*/

5956

/* Fix SwigMethods to carry the callback ptrs when needed */

5957

/* -----------------------------------------------------------------------------*/

5958

5959

SWIGINTERN void

5960

SWIG_Python_FixMethods(PyMethodDef *methods,

5961

swig_const_info *const_table,

5962

swig_type_info **types,

5963

swig_type_info **types_initial) {

5964

size_t i;

5965

for (i = 0; methods[i].ml_name; ++i) {

5966

const char *c = methods[i].ml_doc;

5967

if (c && (c = strstr(c, "swig_ptr: "))) {

5968

int j;

5969

swig_const_info *ci = 0;

5970

const char *name = c + 10;

5971

for (j = 0; const_table[j].type; ++j) {

5972

if (strncmp(const_table[j].name, name,

5973

strlen(const_table[j].name)) == 0) {

5974

ci = &(const_table[j]);

5975

break;

5976

}

5977

}

5978

if (ci) {

5979

size_t shift = (ci->ptype) - types;

5980

swig_type_info *ty = types_initial[shift];

5981

size_t ldoc = (c - methods[i].ml_doc);

5982

size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;

5983

char *ndoc = (char*)malloc(ldoc + lptr + 10);

5984

if (ndoc) {

5985

char *buff = ndoc;

5986

void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;

5987

if (ptr) {

5988

strncpy(buff, methods[i].ml_doc, ldoc);

5989

buff += ldoc;

5990

strncpy(buff, "swig_ptr: ", 10);

5991

buff += 10;

5992

SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);

5993

methods[i].ml_doc = ndoc;

5994

}

5995

}

5996

}

5997

}

5998

}

5999

}

6000

6001

#ifdef __cplusplus

6002

}

6003

#endif

6004

6005

/* -----------------------------------------------------------------------------*

6006

* Partial Init method

6007

* -----------------------------------------------------------------------------*/

6008

6009

#ifdef __cplusplus

6010

extern "C"

6011

#endif

6012

SWIGEXPORT void SWIG_init(void) {

6013

PyObject *m, *d;

6014

6015

/* Fix SwigMethods to carry the callback ptrs when needed */

6016

SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);

6017

6018

m = Py_InitModule((char *) SWIG_name, SwigMethods);

6019

d = PyModule_GetDict(m);

6020

6021

SWIG_InitializeModule(0);

6022

SWIG_InstallConstants(d,swig_const_table);

6023

6024

6025

PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());

6026

SWIG_addvarlink(SWIG_globals(),(char*)"WebKitNameStr",WebKitNameStr_get, WebKitNameStr_set);

6027

SWIG_Python_SetConstant(d, "WEBKIT_STATE_START",SWIG_From_int(static_cast< int >(wxWEBKIT_STATE_START)));

6028

SWIG_Python_SetConstant(d, "WEBKIT_STATE_NEGOTIATING",SWIG_From_int(static_cast< int >(wxWEBKIT_STATE_NEGOTIATING)));

6029

SWIG_Python_SetConstant(d, "WEBKIT_STATE_REDIRECTING",SWIG_From_int(static_cast< int >(wxWEBKIT_STATE_REDIRECTING)));

6030

SWIG_Python_SetConstant(d, "WEBKIT_STATE_TRANSFERRING",SWIG_From_int(static_cast< int >(wxWEBKIT_STATE_TRANSFERRING)));

6031

SWIG_Python_SetConstant(d, "WEBKIT_STATE_STOP",SWIG_From_int(static_cast< int >(wxWEBKIT_STATE_STOP)));

6032

SWIG_Python_SetConstant(d, "WEBKIT_STATE_FAILED",SWIG_From_int(static_cast< int >(wxWEBKIT_STATE_FAILED)));

6033

SWIG_Python_SetConstant(d, "WEBKIT_NAV_LINK_CLICKED",SWIG_From_int(static_cast< int >(wxWEBKIT_NAV_LINK_CLICKED)));

6034

SWIG_Python_SetConstant(d, "WEBKIT_NAV_BACK_NEXT",SWIG_From_int(static_cast< int >(wxWEBKIT_NAV_BACK_NEXT)));

6035

SWIG_Python_SetConstant(d, "WEBKIT_NAV_FORM_SUBMITTED",SWIG_From_int(static_cast< int >(wxWEBKIT_NAV_FORM_SUBMITTED)));

6036

SWIG_Python_SetConstant(d, "WEBKIT_NAV_RELOAD",SWIG_From_int(static_cast< int >(wxWEBKIT_NAV_RELOAD)));

6037

SWIG_Python_SetConstant(d, "WEBKIT_NAV_FORM_RESUBMITTED",SWIG_From_int(static_cast< int >(wxWEBKIT_NAV_FORM_RESUBMITTED)));

6038

SWIG_Python_SetConstant(d, "WEBKIT_NAV_OTHER",SWIG_From_int(static_cast< int >(wxWEBKIT_NAV_OTHER)));

6039

PyDict_SetItemString(d, "wxEVT_WEBKIT_STATE_CHANGED", PyInt_FromLong(wxEVT_WEBKIT_STATE_CHANGED));

6040

PyDict_SetItemString(d, "wxEVT_WEBKIT_BEFORE_LOAD", PyInt_FromLong(wxEVT_WEBKIT_BEFORE_LOAD));

6041

PyDict_SetItemString(d, "wxEVT_WEBKIT_NEW_WINDOW", PyInt_FromLong(wxEVT_WEBKIT_NEW_WINDOW));

6042

6043

6044

6045

}

6046