~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_void swig_types[7]

2474

#define SWIGTYPE_p_wxANIHandler swig_types[8]

2475

#define SWIGTYPE_p_wxAcceleratorTable swig_types[9]

2476

#define SWIGTYPE_p_wxActivateEvent swig_types[10]

2477

#define SWIGTYPE_p_wxBMPHandler swig_types[11]

2478

#define SWIGTYPE_p_wxBitmap swig_types[12]

2479

#define SWIGTYPE_p_wxBoxSizer swig_types[13]

2480

#define SWIGTYPE_p_wxBusyInfo swig_types[14]

2481

#define SWIGTYPE_p_wxCURHandler swig_types[15]

2482

#define SWIGTYPE_p_wxChildFocusEvent swig_types[16]

2483

#define SWIGTYPE_p_wxClipboard swig_types[17]

2484

#define SWIGTYPE_p_wxClipboardTextEvent swig_types[18]

2485

#define SWIGTYPE_p_wxCloseEvent swig_types[19]

2486

#define SWIGTYPE_p_wxColour swig_types[20]

2487

#define SWIGTYPE_p_wxCommandEvent swig_types[21]

2488

#define SWIGTYPE_p_wxContextMenuEvent swig_types[22]

2489

#define SWIGTYPE_p_wxControl swig_types[23]

2490

#define SWIGTYPE_p_wxControlWithItems swig_types[24]

2491

#define SWIGTYPE_p_wxDC swig_types[25]

2492

#define SWIGTYPE_p_wxDateEvent swig_types[26]

2493

#define SWIGTYPE_p_wxDisplayChangedEvent swig_types[27]

2494

#define SWIGTYPE_p_wxDropFilesEvent swig_types[28]

2495

#define SWIGTYPE_p_wxDuplexMode swig_types[29]

2496

#define SWIGTYPE_p_wxEraseEvent swig_types[30]

2497

#define SWIGTYPE_p_wxEvent swig_types[31]

2498

#define SWIGTYPE_p_wxEvtHandler swig_types[32]

2499

#define SWIGTYPE_p_wxFSFile swig_types[33]

2500

#define SWIGTYPE_p_wxFileHistory swig_types[34]

2501

#define SWIGTYPE_p_wxFileSystem swig_types[35]

2502

#define SWIGTYPE_p_wxFlexGridSizer swig_types[36]

2503

#define SWIGTYPE_p_wxFocusEvent swig_types[37]

2504

#define SWIGTYPE_p_wxFont swig_types[38]

2505

#define SWIGTYPE_p_wxGBSizerItem swig_types[39]

2506

#define SWIGTYPE_p_wxGIFHandler swig_types[40]

2507

#define SWIGTYPE_p_wxGridBagSizer swig_types[41]

2508

#define SWIGTYPE_p_wxGridSizer swig_types[42]

2509

#define SWIGTYPE_p_wxICOHandler swig_types[43]

2510

#define SWIGTYPE_p_wxIconizeEvent swig_types[44]

2511

#define SWIGTYPE_p_wxIdleEvent swig_types[45]

2512

#define SWIGTYPE_p_wxImage swig_types[46]

2513

#define SWIGTYPE_p_wxImageHandler swig_types[47]

2514

#define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[48]

2515

#define SWIGTYPE_p_wxInitDialogEvent swig_types[49]

2516

#define SWIGTYPE_p_wxIntPtr swig_types[50]

2517

#define SWIGTYPE_p_wxJPEGHandler swig_types[51]

2518

#define SWIGTYPE_p_wxJoystickEvent swig_types[52]

2519

#define SWIGTYPE_p_wxKeyEvent swig_types[53]

2520

#define SWIGTYPE_p_wxLayoutConstraints swig_types[54]

2521

#define SWIGTYPE_p_wxMaximizeEvent swig_types[55]

2522

#define SWIGTYPE_p_wxMemoryBuffer swig_types[56]

2523

#define SWIGTYPE_p_wxMenu swig_types[57]

2524

#define SWIGTYPE_p_wxMenuBar swig_types[58]

2525

#define SWIGTYPE_p_wxMenuEvent swig_types[59]

2526

#define SWIGTYPE_p_wxMenuItem swig_types[60]

2527

#define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[61]

2528

#define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[62]

2529

#define SWIGTYPE_p_wxMouseEvent swig_types[63]

2530

#define SWIGTYPE_p_wxMoveEvent swig_types[64]

2531

#define SWIGTYPE_p_wxNavigationKeyEvent swig_types[65]

2532

#define SWIGTYPE_p_wxNcPaintEvent swig_types[66]

2533

#define SWIGTYPE_p_wxNotifyEvent swig_types[67]

2534

#define SWIGTYPE_p_wxObject swig_types[68]

2535

#define SWIGTYPE_p_wxPCXHandler swig_types[69]

2536

#define SWIGTYPE_p_wxPNGHandler swig_types[70]

2537

#define SWIGTYPE_p_wxPNMHandler swig_types[71]

2538

#define SWIGTYPE_p_wxPaintEvent swig_types[72]

2539

#define SWIGTYPE_p_wxPaletteChangedEvent swig_types[73]

2540

#define SWIGTYPE_p_wxPaperSize swig_types[74]

2541

#define SWIGTYPE_p_wxPoint swig_types[75]

2542

#define SWIGTYPE_p_wxPowerEvent swig_types[76]

2543

#define SWIGTYPE_p_wxProcessEvent swig_types[77]

2544

#define SWIGTYPE_p_wxPyApp swig_types[78]

2545

#define SWIGTYPE_p_wxPyCommandEvent swig_types[79]

2546

#define SWIGTYPE_p_wxPyEvent swig_types[80]

2547

#define SWIGTYPE_p_wxPyEvtHandler swig_types[81]

2548

#define SWIGTYPE_p_wxPyImageHandler swig_types[82]

2549

#define SWIGTYPE_p_wxPyProcess swig_types[83]

2550

#define SWIGTYPE_p_wxPySizer swig_types[84]

2551

#define SWIGTYPE_p_wxPyTimer swig_types[85]

2552

#define SWIGTYPE_p_wxPyValidator swig_types[86]

2553

#define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[87]

2554

#define SWIGTYPE_p_wxRect swig_types[88]

2555

#define SWIGTYPE_p_wxScrollBar swig_types[89]

2556

#define SWIGTYPE_p_wxScrollEvent swig_types[90]

2557

#define SWIGTYPE_p_wxScrollWinEvent swig_types[91]

2558

#define SWIGTYPE_p_wxSetCursorEvent swig_types[92]

2559

#define SWIGTYPE_p_wxShowEvent swig_types[93]

2560

#define SWIGTYPE_p_wxSizeEvent swig_types[94]

2561

#define SWIGTYPE_p_wxSizer swig_types[95]

2562

#define SWIGTYPE_p_wxSizerItem swig_types[96]

2563

#define SWIGTYPE_p_wxStaticBoxSizer swig_types[97]

2564

#define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[98]

2565

#define SWIGTYPE_p_wxStyledTextCtrl swig_types[99]

2566

#define SWIGTYPE_p_wxStyledTextEvent swig_types[100]

2567

#define SWIGTYPE_p_wxSysColourChangedEvent swig_types[101]

2568

#define SWIGTYPE_p_wxSystemOptions swig_types[102]

2569

#define SWIGTYPE_p_wxTGAHandler swig_types[103]

2570

#define SWIGTYPE_p_wxTIFFHandler swig_types[104]

2571

#define SWIGTYPE_p_wxTimerEvent swig_types[105]

2572

#define SWIGTYPE_p_wxToolTip swig_types[106]

2573

#define SWIGTYPE_p_wxUpdateUIEvent swig_types[107]

2574

#define SWIGTYPE_p_wxValidator swig_types[108]

2575

#define SWIGTYPE_p_wxWindow swig_types[109]

2576

#define SWIGTYPE_p_wxWindowCreateEvent swig_types[110]

2577

#define SWIGTYPE_p_wxWindowDestroyEvent swig_types[111]

2578

#define SWIGTYPE_p_wxXPMHandler swig_types[112]

2579

static swig_type_info *swig_types[114];

2580

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

2581

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

2582

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

2583

2584

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

2585

2586

#if (PY_VERSION_HEX <= 0x02000000)

2587

# if !defined(SWIG_PYTHON_CLASSIC)

2588

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

2589

# endif

2590

#endif

2591

#if (PY_VERSION_HEX <= 0x02020000)

2592

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

2593

#endif

2594

#if (PY_VERSION_HEX <= 0x02020000)

2595

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

2596

#endif

2597

#ifndef METH_O

2598

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

2599

#endif

2600

2601

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

2602

@(target):= _stc.so

2603

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

2604

#define SWIG_init init_stc

2605

2606

#define SWIG_name "_stc"

2607

2608

#define SWIGVERSION 0x010329

2609

2610

2611

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

2612

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

2613

2614

2615

#include <stdexcept>

2616

2617

2618

namespace swig {

2619

class PyObject_ptr {

2620

protected:

2621

PyObject *_obj;

2622

2623

public:

2624

PyObject_ptr() :_obj(0)

2625

{

2626

}

2627

2628

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

2629

{

2630

Py_XINCREF(_obj);

2631

}

2632

2633

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

2634

{

2635

if (initial_ref) Py_XINCREF(_obj);

2636

}

2637

2638

PyObject_ptr & operator=(const PyObject_ptr& item)

2639

{

2640

Py_XINCREF(item._obj);

2641

Py_XDECREF(_obj);

2642

_obj = item._obj;

2643

return *this;

2644

}

2645

2646

~PyObject_ptr()

2647

{

2648

Py_XDECREF(_obj);

2649

}

2650

2651

operator PyObject *() const

2652

{

2653

return _obj;

2654

}

2655

2656

PyObject *operator->() const

2657

{

2658

return _obj;

2659

}

2660

};

2661

}

2662

2663

2664

namespace swig {

2665

struct PyObject_var : PyObject_ptr {

2666

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

2667

2668

PyObject_var & operator = (PyObject* obj)

2669

{

2670

Py_XDECREF(_obj);

2671

_obj = obj;

2672

return *this;

2673

}

2674

};

2675

}

2676

2677

2678

#include "wx/wxPython/wxPython.h"

2679

#include "wx/wxPython/pyclasses.h"

2680

#include <wx/stc/stc.h>

2681

2682

2683

static const wxString wxPySTCNameStr(wxSTCNameStr);

2684

2685

#define SWIG_From_long PyInt_FromLong

2686

2687

2688

SWIGINTERNINLINE PyObject *

2689

SWIG_From_int (int value)

2690

{

2691

return SWIG_From_long (value);

2692

}

2693

2694

2695

#include <limits.h>

2696

#ifndef LLONG_MIN

2697

# define LLONG_MIN LONG_LONG_MIN

2698

#endif

2699

#ifndef LLONG_MAX

2700

# define LLONG_MAX LONG_LONG_MAX

2701

#endif

2702

#ifndef ULLONG_MAX

2703

# define ULLONG_MAX ULONG_LONG_MAX

2704

#endif

2705

2706

2707

SWIGINTERN int

2708

SWIG_AsVal_long (PyObject* obj, long* val)

2709

{

2710

if (PyNumber_Check(obj)) {

2711

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

2712

return SWIG_OK;

2713

}

2714

return SWIG_TypeError;

2715

}

2716

2717

2718

SWIGINTERN int

2719

SWIG_AsVal_int (PyObject * obj, int *val)

2720

{

2721

long v;

2722

int res = SWIG_AsVal_long (obj, &v);

2723

if (SWIG_IsOK(res)) {

2724

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

2725

return SWIG_OverflowError;

2726

} else {

2727

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

2728

}

2729

}

2730

return res;

2731

}

2732

2733

2734

SWIGINTERN int

2735

SWIG_AsVal_bool (PyObject *obj, bool *val)

2736

{

2737

if (obj == Py_True) {

2738

if (val) *val = true;

2739

return SWIG_OK;

2740

} else if (obj == Py_False) {

2741

if (val) *val = false;

2742

return SWIG_OK;

2743

} else {

2744

long v = 0;

2745

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

2746

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

2747

return res;

2748

}

2749

}

2750

2751

2752

SWIGINTERN swig_type_info*

2753

SWIG_pchar_descriptor()

2754

{

2755

static int init = 0;

2756

static swig_type_info* info = 0;

2757

if (!init) {

2758

info = SWIG_TypeQuery("_p_char");

2759

init = 1;

2760

}

2761

return info;

2762

}

2763

2764

2765

SWIGINTERN int

2766

SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)

2767

{

2768

if (PyString_Check(obj)) {

2769

char *cstr; Py_ssize_t len;

2770

PyString_AsStringAndSize(obj, &cstr, &len);

2771

if (cptr) {

2772

if (alloc) {

2773

/*

2774

In python the user should not be able to modify the inner

2775

string representation. To warranty that, if you define

2776

SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string

2777

buffer is always returned.

2778

2779

The default behavior is just to return the pointer value,

2780

so, be careful.

2781

*/

2782

#if defined(SWIG_PYTHON_SAFE_CSTRINGS)

2783

if (*alloc != SWIG_OLDOBJ)

2784

#else

2785

if (*alloc == SWIG_NEWOBJ)

2786

#endif

2787

{

2788

*cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));

2789

*alloc = SWIG_NEWOBJ;

2790

}

2791

else {

2792

*cptr = cstr;

2793

*alloc = SWIG_OLDOBJ;

2794

}

2795

} else {

2796

*cptr = PyString_AsString(obj);

2797

}

2798

}

2799

if (psize) *psize = len + 1;

2800

return SWIG_OK;

2801

} else {

2802

swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();

2803

if (pchar_descriptor) {

2804

void* vptr = 0;

2805

if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {

2806

if (cptr) *cptr = (char *) vptr;

2807

if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;

2808

if (alloc) *alloc = SWIG_OLDOBJ;

2809

return SWIG_OK;

2810

}

2811

}

2812

}

2813

return SWIG_TypeError;

2814

}

2815

2816

2817

2818

2819

2820

SWIGINTERN int

2821

SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)

2822

{

2823

long v = 0;

2824

int res = SWIG_AsVal_long(obj, &v);

2825

if (SWIG_IsOK(res)) {

2826

if ( v < 0) {

2827

return SWIG_ValueError;

2828

}

2829

else if (val)

2830

*val = (unsigned long)v;

2831

}

2832

return res;

2833

}

2834

2835

#ifdef __cplusplus

2836

extern "C" {

2837

#endif

2838

SWIGINTERN int STCNameStr_set(PyObject *) {

2839

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

2840

return 1;

2841

}

2842

2843

2844

SWIGINTERN PyObject *STCNameStr_get(void) {

2845

PyObject *pyobj = 0;

2846

2847

{

2848

#if wxUSE_UNICODE

2849

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

2850

#else

2851

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

2852

#endif

2853

}

2854

return pyobj;

2855

}

2856

2857

2858

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

2859

PyObject *resultobj = 0;

2860

wxWindow *arg1 = (wxWindow *) 0 ;

2861

int arg2 = (int) wxID_ANY ;

2862

wxPoint const &arg3_defvalue = wxDefaultPosition ;

2863

wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;

2864

wxSize const &arg4_defvalue = wxDefaultSize ;

2865

wxSize *arg4 = (wxSize *) &arg4_defvalue ;

2866

long arg5 = (long) 0 ;

2867

wxString const &arg6_defvalue = wxPySTCNameStr ;

2868

wxString *arg6 = (wxString *) &arg6_defvalue ;

2869

wxStyledTextCtrl *result = 0 ;

2870

void *argp1 = 0 ;

2871

int res1 = 0 ;

2872

int val2 ;

2873

int ecode2 = 0 ;

2874

wxPoint temp3 ;

2875

wxSize temp4 ;

2876

long val5 ;

2877

int ecode5 = 0 ;

2878

bool temp6 = false ;

2879

PyObject * obj0 = 0 ;

2880

PyObject * obj1 = 0 ;

2881

PyObject * obj2 = 0 ;

2882

PyObject * obj3 = 0 ;

2883

PyObject * obj4 = 0 ;

2884

PyObject * obj5 = 0 ;

2885

char * kwnames[] = {

2886

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

2887

};

2888

2889

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

2890

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

2891

if (!SWIG_IsOK(res1)) {

2892

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

2893

}

2894

arg1 = reinterpret_cast< wxWindow * >(argp1);

2895

if (obj1) {

2896

ecode2 = SWIG_AsVal_int(obj1, &val2);

2897

if (!SWIG_IsOK(ecode2)) {

2898

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

2899

}

2900

arg2 = static_cast< int >(val2);

2901

}

2902

if (obj2) {

2903

{

2904

arg3 = &temp3;

2905

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

2906

}

2907

}

2908

if (obj3) {

2909

{

2910

arg4 = &temp4;

2911

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

2912

}

2913

}

2914

if (obj4) {

2915

ecode5 = SWIG_AsVal_long(obj4, &val5);

2916

if (!SWIG_IsOK(ecode5)) {

2917

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

2918

}

2919

arg5 = static_cast< long >(val5);

2920

}

2921

if (obj5) {

2922

{

2923

arg6 = wxString_in_helper(obj5);

2924

if (arg6 == NULL) SWIG_fail;

2925

temp6 = true;

2926

}

2927

}

2928

{

2929

if (!wxPyCheckForApp()) SWIG_fail;

2930

PyThreadState* __tstate = wxPyBeginAllowThreads();

2931

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

2932

wxPyEndAllowThreads(__tstate);

2933

if (PyErr_Occurred()) SWIG_fail;

2934

}

2935

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

2936

{

2937

if (temp6)

2938

delete arg6;

2939

}

2940

return resultobj;

2941

fail:

2942

{

2943

if (temp6)

2944

delete arg6;

2945

}

2946

return NULL;

2947

}

2948

2949

2950

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

2951

PyObject *resultobj = 0;

2952

wxStyledTextCtrl *result = 0 ;

2953

2954

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

2955

{

2956

if (!wxPyCheckForApp()) SWIG_fail;

2957

PyThreadState* __tstate = wxPyBeginAllowThreads();

2958

result = (wxStyledTextCtrl *)new wxStyledTextCtrl();

2959

wxPyEndAllowThreads(__tstate);

2960

if (PyErr_Occurred()) SWIG_fail;

2961

}

2962

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

2963

return resultobj;

2964

fail:

2965

return NULL;

2966

}

2967

2968

2969

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

2970

PyObject *resultobj = 0;

2971

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

2972

wxWindow *arg2 = (wxWindow *) 0 ;

2973

int arg3 = (int) wxID_ANY ;

2974

wxPoint const &arg4_defvalue = wxDefaultPosition ;

2975

wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;

2976

wxSize const &arg5_defvalue = wxDefaultSize ;

2977

wxSize *arg5 = (wxSize *) &arg5_defvalue ;

2978

long arg6 = (long) 0 ;

2979

wxString const &arg7_defvalue = wxSTCNameStr ;

2980

wxString *arg7 = (wxString *) &arg7_defvalue ;

2981

bool result;

2982

void *argp1 = 0 ;

2983

int res1 = 0 ;

2984

void *argp2 = 0 ;

2985

int res2 = 0 ;

2986

int val3 ;

2987

int ecode3 = 0 ;

2988

wxPoint temp4 ;

2989

wxSize temp5 ;

2990

long val6 ;

2991

int ecode6 = 0 ;

2992

bool temp7 = false ;

2993

PyObject * obj0 = 0 ;

2994

PyObject * obj1 = 0 ;

2995

PyObject * obj2 = 0 ;

2996

PyObject * obj3 = 0 ;

2997

PyObject * obj4 = 0 ;

2998

PyObject * obj5 = 0 ;

2999

PyObject * obj6 = 0 ;

3000

char * kwnames[] = {

3001

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

3002

};

3003

3004

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

3005

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

3006

if (!SWIG_IsOK(res1)) {

3007

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

3008

}

3009

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3010

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

3011

if (!SWIG_IsOK(res2)) {

3012

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

3013

}

3014

arg2 = reinterpret_cast< wxWindow * >(argp2);

3015

if (obj2) {

3016

ecode3 = SWIG_AsVal_int(obj2, &val3);

3017

if (!SWIG_IsOK(ecode3)) {

3018

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

3019

}

3020

arg3 = static_cast< int >(val3);

3021

}

3022

if (obj3) {

3023

{

3024

arg4 = &temp4;

3025

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

3026

}

3027

}

3028

if (obj4) {

3029

{

3030

arg5 = &temp5;

3031

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

3032

}

3033

}

3034

if (obj5) {

3035

ecode6 = SWIG_AsVal_long(obj5, &val6);

3036

if (!SWIG_IsOK(ecode6)) {

3037

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

3038

}

3039

arg6 = static_cast< long >(val6);

3040

}

3041

if (obj6) {

3042

{

3043

arg7 = wxString_in_helper(obj6);

3044

if (arg7 == NULL) SWIG_fail;

3045

temp7 = true;

3046

}

3047

}

3048

{

3049

PyThreadState* __tstate = wxPyBeginAllowThreads();

3050

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

3051

wxPyEndAllowThreads(__tstate);

3052

if (PyErr_Occurred()) SWIG_fail;

3053

}

3054

{

3055

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

3056

}

3057

{

3058

if (temp7)

3059

delete arg7;

3060

}

3061

return resultobj;

3062

fail:

3063

{

3064

if (temp7)

3065

delete arg7;

3066

}

3067

return NULL;

3068

}

3069

3070

3071

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

3072

PyObject *resultobj = 0;

3073

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3074

wxString *arg2 = 0 ;

3075

void *argp1 = 0 ;

3076

int res1 = 0 ;

3077

bool temp2 = false ;

3078

PyObject * obj0 = 0 ;

3079

PyObject * obj1 = 0 ;

3080

char * kwnames[] = {

3081

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

3082

};

3083

3084

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

3085

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

3086

if (!SWIG_IsOK(res1)) {

3087

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

3088

}

3089

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3090

{

3091

arg2 = wxString_in_helper(obj1);

3092

if (arg2 == NULL) SWIG_fail;

3093

temp2 = true;

3094

}

3095

{

3096

PyThreadState* __tstate = wxPyBeginAllowThreads();

3097

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

3098

wxPyEndAllowThreads(__tstate);

3099

if (PyErr_Occurred()) SWIG_fail;

3100

}

3101

resultobj = SWIG_Py_Void();

3102

{

3103

if (temp2)

3104

delete arg2;

3105

}

3106

return resultobj;

3107

fail:

3108

{

3109

if (temp2)

3110

delete arg2;

3111

}

3112

return NULL;

3113

}

3114

3115

3116

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

3117

PyObject *resultobj = 0;

3118

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3119

wxMemoryBuffer *arg2 = 0 ;

3120

void *argp1 = 0 ;

3121

int res1 = 0 ;

3122

bool temp2 = false ;

3123

PyObject * obj0 = 0 ;

3124

PyObject * obj1 = 0 ;

3125

char * kwnames[] = {

3126

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

3127

};

3128

3129

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

3130

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

3131

if (!SWIG_IsOK(res1)) {

3132

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

3133

}

3134

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3135

{

3136

if (!PyString_Check(obj1)) {

3137

PyErr_SetString(PyExc_TypeError, "String buffer expected");

3138

SWIG_fail;

3139

}

3140

char* str = PyString_AS_STRING(obj1);

3141

int len = PyString_GET_SIZE(obj1);

3142

arg2 = new wxMemoryBuffer(len);

3143

temp2 = true;

3144

memcpy(arg2->GetData(), str, len);

3145

arg2->SetDataLen(len);

3146

}

3147

{

3148

PyThreadState* __tstate = wxPyBeginAllowThreads();

3149

(arg1)->AddStyledText((wxMemoryBuffer const &)*arg2);

3150

wxPyEndAllowThreads(__tstate);

3151

if (PyErr_Occurred()) SWIG_fail;

3152

}

3153

resultobj = SWIG_Py_Void();

3154

{

3155

if (temp2) delete arg2;

3156

}

3157

return resultobj;

3158

fail:

3159

{

3160

if (temp2) delete arg2;

3161

}

3162

return NULL;

3163

}

3164

3165

3166

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

3167

PyObject *resultobj = 0;

3168

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3169

int arg2 ;

3170

wxString *arg3 = 0 ;

3171

void *argp1 = 0 ;

3172

int res1 = 0 ;

3173

int val2 ;

3174

int ecode2 = 0 ;

3175

bool temp3 = false ;

3176

PyObject * obj0 = 0 ;

3177

PyObject * obj1 = 0 ;

3178

PyObject * obj2 = 0 ;

3179

char * kwnames[] = {

3180

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

3181

};

3182

3183

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

3184

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

3185

if (!SWIG_IsOK(res1)) {

3186

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

3187

}

3188

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3189

ecode2 = SWIG_AsVal_int(obj1, &val2);

3190

if (!SWIG_IsOK(ecode2)) {

3191

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

3192

}

3193

arg2 = static_cast< int >(val2);

3194

{

3195

arg3 = wxString_in_helper(obj2);

3196

if (arg3 == NULL) SWIG_fail;

3197

temp3 = true;

3198

}

3199

{

3200

PyThreadState* __tstate = wxPyBeginAllowThreads();

3201

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

3202

wxPyEndAllowThreads(__tstate);

3203

if (PyErr_Occurred()) SWIG_fail;

3204

}

3205

resultobj = SWIG_Py_Void();

3206

{

3207

if (temp3)

3208

delete arg3;

3209

}

3210

return resultobj;

3211

fail:

3212

{

3213

if (temp3)

3214

delete arg3;

3215

}

3216

return NULL;

3217

}

3218

3219

3220

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

3221

PyObject *resultobj = 0;

3222

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3223

void *argp1 = 0 ;

3224

int res1 = 0 ;

3225

PyObject *swig_obj[1] ;

3226

3227

if (!args) SWIG_fail;

3228

swig_obj[0] = args;

3229

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

3230

if (!SWIG_IsOK(res1)) {

3231

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

3232

}

3233

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3234

{

3235

PyThreadState* __tstate = wxPyBeginAllowThreads();

3236

(arg1)->ClearAll();

3237

wxPyEndAllowThreads(__tstate);

3238

if (PyErr_Occurred()) SWIG_fail;

3239

}

3240

resultobj = SWIG_Py_Void();

3241

return resultobj;

3242

fail:

3243

return NULL;

3244

}

3245

3246

3247

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

3248

PyObject *resultobj = 0;

3249

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3250

void *argp1 = 0 ;

3251

int res1 = 0 ;

3252

PyObject *swig_obj[1] ;

3253

3254

if (!args) SWIG_fail;

3255

swig_obj[0] = args;

3256

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

3257

if (!SWIG_IsOK(res1)) {

3258

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

3259

}

3260

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3261

{

3262

PyThreadState* __tstate = wxPyBeginAllowThreads();

3263

(arg1)->ClearDocumentStyle();

3264

wxPyEndAllowThreads(__tstate);

3265

if (PyErr_Occurred()) SWIG_fail;

3266

}

3267

resultobj = SWIG_Py_Void();

3268

return resultobj;

3269

fail:

3270

return NULL;

3271

}

3272

3273

3274

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

3275

PyObject *resultobj = 0;

3276

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3277

int result;

3278

void *argp1 = 0 ;

3279

int res1 = 0 ;

3280

PyObject *swig_obj[1] ;

3281

3282

if (!args) SWIG_fail;

3283

swig_obj[0] = args;

3284

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

3285

if (!SWIG_IsOK(res1)) {

3286

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

3287

}

3288

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3289

{

3290

PyThreadState* __tstate = wxPyBeginAllowThreads();

3291

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

3292

wxPyEndAllowThreads(__tstate);

3293

if (PyErr_Occurred()) SWIG_fail;

3294

}

3295

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

3296

return resultobj;

3297

fail:

3298

return NULL;

3299

}

3300

3301

3302

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

3303

PyObject *resultobj = 0;

3304

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3305

int arg2 ;

3306

int result;

3307

void *argp1 = 0 ;

3308

int res1 = 0 ;

3309

int val2 ;

3310

int ecode2 = 0 ;

3311

PyObject * obj0 = 0 ;

3312

PyObject * obj1 = 0 ;

3313

char * kwnames[] = {

3314

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

3315

};

3316

3317

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

3318

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

3319

if (!SWIG_IsOK(res1)) {

3320

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

3321

}

3322

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3323

ecode2 = SWIG_AsVal_int(obj1, &val2);

3324

if (!SWIG_IsOK(ecode2)) {

3325

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

3326

}

3327

arg2 = static_cast< int >(val2);

3328

{

3329

PyThreadState* __tstate = wxPyBeginAllowThreads();

3330

result = (int)(arg1)->GetCharAt(arg2);

3331

wxPyEndAllowThreads(__tstate);

3332

if (PyErr_Occurred()) SWIG_fail;

3333

}

3334

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

3335

return resultobj;

3336

fail:

3337

return NULL;

3338

}

3339

3340

3341

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

3342

PyObject *resultobj = 0;

3343

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3344

int result;

3345

void *argp1 = 0 ;

3346

int res1 = 0 ;

3347

PyObject *swig_obj[1] ;

3348

3349

if (!args) SWIG_fail;

3350

swig_obj[0] = args;

3351

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

3352

if (!SWIG_IsOK(res1)) {

3353

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

3354

}

3355

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3356

{

3357

PyThreadState* __tstate = wxPyBeginAllowThreads();

3358

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

3359

wxPyEndAllowThreads(__tstate);

3360

if (PyErr_Occurred()) SWIG_fail;

3361

}

3362

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

3363

return resultobj;

3364

fail:

3365

return NULL;

3366

}

3367

3368

3369

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

3370

PyObject *resultobj = 0;

3371

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3372

int result;

3373

void *argp1 = 0 ;

3374

int res1 = 0 ;

3375

PyObject *swig_obj[1] ;

3376

3377

if (!args) SWIG_fail;

3378

swig_obj[0] = args;

3379

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

3380

if (!SWIG_IsOK(res1)) {

3381

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

3382

}

3383

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3384

{

3385

PyThreadState* __tstate = wxPyBeginAllowThreads();

3386

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

3387

wxPyEndAllowThreads(__tstate);

3388

if (PyErr_Occurred()) SWIG_fail;

3389

}

3390

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

3391

return resultobj;

3392

fail:

3393

return NULL;

3394

}

3395

3396

3397

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

3398

PyObject *resultobj = 0;

3399

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3400

int arg2 ;

3401

int result;

3402

void *argp1 = 0 ;

3403

int res1 = 0 ;

3404

int val2 ;

3405

int ecode2 = 0 ;

3406

PyObject * obj0 = 0 ;

3407

PyObject * obj1 = 0 ;

3408

char * kwnames[] = {

3409

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

3410

};

3411

3412

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

3413

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

3414

if (!SWIG_IsOK(res1)) {

3415

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

3416

}

3417

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3418

ecode2 = SWIG_AsVal_int(obj1, &val2);

3419

if (!SWIG_IsOK(ecode2)) {

3420

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

3421

}

3422

arg2 = static_cast< int >(val2);

3423

{

3424

PyThreadState* __tstate = wxPyBeginAllowThreads();

3425

result = (int)(arg1)->GetStyleAt(arg2);

3426

wxPyEndAllowThreads(__tstate);

3427

if (PyErr_Occurred()) SWIG_fail;

3428

}

3429

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

3430

return resultobj;

3431

fail:

3432

return NULL;

3433

}

3434

3435

3436

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

3437

PyObject *resultobj = 0;

3438

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3439

void *argp1 = 0 ;

3440

int res1 = 0 ;

3441

PyObject *swig_obj[1] ;

3442

3443

if (!args) SWIG_fail;

3444

swig_obj[0] = args;

3445

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

3446

if (!SWIG_IsOK(res1)) {

3447

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

3448

}

3449

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3450

{

3451

PyThreadState* __tstate = wxPyBeginAllowThreads();

3452

(arg1)->Redo();

3453

wxPyEndAllowThreads(__tstate);

3454

if (PyErr_Occurred()) SWIG_fail;

3455

}

3456

resultobj = SWIG_Py_Void();

3457

return resultobj;

3458

fail:

3459

return NULL;

3460

}

3461

3462

3463

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

3464

PyObject *resultobj = 0;

3465

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3466

bool arg2 ;

3467

void *argp1 = 0 ;

3468

int res1 = 0 ;

3469

bool val2 ;

3470

int ecode2 = 0 ;

3471

PyObject * obj0 = 0 ;

3472

PyObject * obj1 = 0 ;

3473

char * kwnames[] = {

3474

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

3475

};

3476

3477

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

3478

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

3479

if (!SWIG_IsOK(res1)) {

3480

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

3481

}

3482

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3483

ecode2 = SWIG_AsVal_bool(obj1, &val2);

3484

if (!SWIG_IsOK(ecode2)) {

3485

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

3486

}

3487

arg2 = static_cast< bool >(val2);

3488

{

3489

PyThreadState* __tstate = wxPyBeginAllowThreads();

3490

(arg1)->SetUndoCollection(arg2);

3491

wxPyEndAllowThreads(__tstate);

3492

if (PyErr_Occurred()) SWIG_fail;

3493

}

3494

resultobj = SWIG_Py_Void();

3495

return resultobj;

3496

fail:

3497

return NULL;

3498

}

3499

3500

3501

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

3502

PyObject *resultobj = 0;

3503

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3504

void *argp1 = 0 ;

3505

int res1 = 0 ;

3506

PyObject *swig_obj[1] ;

3507

3508

if (!args) SWIG_fail;

3509

swig_obj[0] = args;

3510

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

3511

if (!SWIG_IsOK(res1)) {

3512

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

3513

}

3514

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3515

{

3516

PyThreadState* __tstate = wxPyBeginAllowThreads();

3517

(arg1)->SelectAll();

3518

wxPyEndAllowThreads(__tstate);

3519

if (PyErr_Occurred()) SWIG_fail;

3520

}

3521

resultobj = SWIG_Py_Void();

3522

return resultobj;

3523

fail:

3524

return NULL;

3525

}

3526

3527

3528

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

3529

PyObject *resultobj = 0;

3530

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3531

void *argp1 = 0 ;

3532

int res1 = 0 ;

3533

PyObject *swig_obj[1] ;

3534

3535

if (!args) SWIG_fail;

3536

swig_obj[0] = args;

3537

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

3538

if (!SWIG_IsOK(res1)) {

3539

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

3540

}

3541

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3542

{

3543

PyThreadState* __tstate = wxPyBeginAllowThreads();

3544

(arg1)->SetSavePoint();

3545

wxPyEndAllowThreads(__tstate);

3546

if (PyErr_Occurred()) SWIG_fail;

3547

}

3548

resultobj = SWIG_Py_Void();

3549

return resultobj;

3550

fail:

3551

return NULL;

3552

}

3553

3554

3555

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

3556

PyObject *resultobj = 0;

3557

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3558

int arg2 ;

3559

int arg3 ;

3560

wxMemoryBuffer result;

3561

void *argp1 = 0 ;

3562

int res1 = 0 ;

3563

int val2 ;

3564

int ecode2 = 0 ;

3565

int val3 ;

3566

int ecode3 = 0 ;

3567

PyObject * obj0 = 0 ;

3568

PyObject * obj1 = 0 ;

3569

PyObject * obj2 = 0 ;

3570

char * kwnames[] = {

3571

(char *) "self",(char *) "startPos",(char *) "endPos", NULL

3572

};

3573

3574

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

3575

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

3576

if (!SWIG_IsOK(res1)) {

3577

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

3578

}

3579

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3580

ecode2 = SWIG_AsVal_int(obj1, &val2);

3581

if (!SWIG_IsOK(ecode2)) {

3582

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

3583

}

3584

arg2 = static_cast< int >(val2);

3585

ecode3 = SWIG_AsVal_int(obj2, &val3);

3586

if (!SWIG_IsOK(ecode3)) {

3587

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

3588

}

3589

arg3 = static_cast< int >(val3);

3590

{

3591

PyThreadState* __tstate = wxPyBeginAllowThreads();

3592

result = (arg1)->GetStyledText(arg2,arg3);

3593

wxPyEndAllowThreads(__tstate);

3594

if (PyErr_Occurred()) SWIG_fail;

3595

}

3596

{

3597

resultobj = PyString_FromStringAndSize((char*)(&result)->GetData(), (&result)->GetDataLen());

3598

}

3599

return resultobj;

3600

fail:

3601

return NULL;

3602

}

3603

3604

3605

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

3606

PyObject *resultobj = 0;

3607

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3608

bool result;

3609

void *argp1 = 0 ;

3610

int res1 = 0 ;

3611

PyObject *swig_obj[1] ;

3612

3613

if (!args) SWIG_fail;

3614

swig_obj[0] = args;

3615

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

3616

if (!SWIG_IsOK(res1)) {

3617

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

3618

}

3619

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3620

{

3621

PyThreadState* __tstate = wxPyBeginAllowThreads();

3622

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

3623

wxPyEndAllowThreads(__tstate);

3624

if (PyErr_Occurred()) SWIG_fail;

3625

}

3626

{

3627

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

3628

}

3629

return resultobj;

3630

fail:

3631

return NULL;

3632

}

3633

3634

3635

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

3636

PyObject *resultobj = 0;

3637

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3638

int arg2 ;

3639

int result;

3640

void *argp1 = 0 ;

3641

int res1 = 0 ;

3642

int val2 ;

3643

int ecode2 = 0 ;

3644

PyObject * obj0 = 0 ;

3645

PyObject * obj1 = 0 ;

3646

char * kwnames[] = {

3647

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

3648

};

3649

3650

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

3651

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

3652

if (!SWIG_IsOK(res1)) {

3653

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

3654

}

3655

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3656

ecode2 = SWIG_AsVal_int(obj1, &val2);

3657

if (!SWIG_IsOK(ecode2)) {

3658

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

3659

}

3660

arg2 = static_cast< int >(val2);

3661

{

3662

PyThreadState* __tstate = wxPyBeginAllowThreads();

3663

result = (int)(arg1)->MarkerLineFromHandle(arg2);

3664

wxPyEndAllowThreads(__tstate);

3665

if (PyErr_Occurred()) SWIG_fail;

3666

}

3667

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

3668

return resultobj;

3669

fail:

3670

return NULL;

3671

}

3672

3673

3674

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

3675

PyObject *resultobj = 0;

3676

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3677

int arg2 ;

3678

void *argp1 = 0 ;

3679

int res1 = 0 ;

3680

int val2 ;

3681

int ecode2 = 0 ;

3682

PyObject * obj0 = 0 ;

3683

PyObject * obj1 = 0 ;

3684

char * kwnames[] = {

3685

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

3686

};

3687

3688

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

3689

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

3690

if (!SWIG_IsOK(res1)) {

3691

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

3692

}

3693

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3694

ecode2 = SWIG_AsVal_int(obj1, &val2);

3695

if (!SWIG_IsOK(ecode2)) {

3696

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

3697

}

3698

arg2 = static_cast< int >(val2);

3699

{

3700

PyThreadState* __tstate = wxPyBeginAllowThreads();

3701

(arg1)->MarkerDeleteHandle(arg2);

3702

wxPyEndAllowThreads(__tstate);

3703

if (PyErr_Occurred()) SWIG_fail;

3704

}

3705

resultobj = SWIG_Py_Void();

3706

return resultobj;

3707

fail:

3708

return NULL;

3709

}

3710

3711

3712

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

3713

PyObject *resultobj = 0;

3714

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3715

bool result;

3716

void *argp1 = 0 ;

3717

int res1 = 0 ;

3718

PyObject *swig_obj[1] ;

3719

3720

if (!args) SWIG_fail;

3721

swig_obj[0] = args;

3722

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

3723

if (!SWIG_IsOK(res1)) {

3724

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

3725

}

3726

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3727

{

3728

PyThreadState* __tstate = wxPyBeginAllowThreads();

3729

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

3730

wxPyEndAllowThreads(__tstate);

3731

if (PyErr_Occurred()) SWIG_fail;

3732

}

3733

{

3734

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

3735

}

3736

return resultobj;

3737

fail:

3738

return NULL;

3739

}

3740

3741

3742

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

3743

PyObject *resultobj = 0;

3744

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3745

int result;

3746

void *argp1 = 0 ;

3747

int res1 = 0 ;

3748

PyObject *swig_obj[1] ;

3749

3750

if (!args) SWIG_fail;

3751

swig_obj[0] = args;

3752

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

3753

if (!SWIG_IsOK(res1)) {

3754

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

3755

}

3756

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3757

{

3758

PyThreadState* __tstate = wxPyBeginAllowThreads();

3759

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

3760

wxPyEndAllowThreads(__tstate);

3761

if (PyErr_Occurred()) SWIG_fail;

3762

}

3763

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

3764

return resultobj;

3765

fail:

3766

return NULL;

3767

}

3768

3769

3770

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

3771

PyObject *resultobj = 0;

3772

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3773

int arg2 ;

3774

void *argp1 = 0 ;

3775

int res1 = 0 ;

3776

int val2 ;

3777

int ecode2 = 0 ;

3778

PyObject * obj0 = 0 ;

3779

PyObject * obj1 = 0 ;

3780

char * kwnames[] = {

3781

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

3782

};

3783

3784

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

3785

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

3786

if (!SWIG_IsOK(res1)) {

3787

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

3788

}

3789

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3790

ecode2 = SWIG_AsVal_int(obj1, &val2);

3791

if (!SWIG_IsOK(ecode2)) {

3792

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

3793

}

3794

arg2 = static_cast< int >(val2);

3795

{

3796

PyThreadState* __tstate = wxPyBeginAllowThreads();

3797

(arg1)->SetViewWhiteSpace(arg2);

3798

wxPyEndAllowThreads(__tstate);

3799

if (PyErr_Occurred()) SWIG_fail;

3800

}

3801

resultobj = SWIG_Py_Void();

3802

return resultobj;

3803

fail:

3804

return NULL;

3805

}

3806

3807

3808

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

3809

PyObject *resultobj = 0;

3810

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3811

wxPoint arg2 ;

3812

int result;

3813

void *argp1 = 0 ;

3814

int res1 = 0 ;

3815

void *argp2 ;

3816

int res2 = 0 ;

3817

PyObject * obj0 = 0 ;

3818

PyObject * obj1 = 0 ;

3819

char * kwnames[] = {

3820

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

3821

};

3822

3823

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

3824

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

3825

if (!SWIG_IsOK(res1)) {

3826

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

3827

}

3828

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3829

{

3830

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

3831

if (!SWIG_IsOK(res2)) {

3832

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyledTextCtrl_PositionFromPoint" "', expected argument " "2"" of type '" "wxPoint""'");

3833

}

3834

if (!argp2) {

3835

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StyledTextCtrl_PositionFromPoint" "', expected argument " "2"" of type '" "wxPoint""'");

3836

} else {

3837

wxPoint * temp = reinterpret_cast< wxPoint * >(argp2);

3838

arg2 = *temp;

3839

if (SWIG_IsNewObj(res2)) delete temp;

3840

}

3841

}

3842

{

3843

PyThreadState* __tstate = wxPyBeginAllowThreads();

3844

result = (int)(arg1)->PositionFromPoint(arg2);

3845

wxPyEndAllowThreads(__tstate);

3846

if (PyErr_Occurred()) SWIG_fail;

3847

}

3848

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

3849

return resultobj;

3850

fail:

3851

return NULL;

3852

}

3853

3854

3855

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

3856

PyObject *resultobj = 0;

3857

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3858

int arg2 ;

3859

int arg3 ;

3860

int result;

3861

void *argp1 = 0 ;

3862

int res1 = 0 ;

3863

int val2 ;

3864

int ecode2 = 0 ;

3865

int val3 ;

3866

int ecode3 = 0 ;

3867

PyObject * obj0 = 0 ;

3868

PyObject * obj1 = 0 ;

3869

PyObject * obj2 = 0 ;

3870

char * kwnames[] = {

3871

(char *) "self",(char *) "x",(char *) "y", NULL

3872

};

3873

3874

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

3875

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

3876

if (!SWIG_IsOK(res1)) {

3877

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

3878

}

3879

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3880

ecode2 = SWIG_AsVal_int(obj1, &val2);

3881

if (!SWIG_IsOK(ecode2)) {

3882

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

3883

}

3884

arg2 = static_cast< int >(val2);

3885

ecode3 = SWIG_AsVal_int(obj2, &val3);

3886

if (!SWIG_IsOK(ecode3)) {

3887

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

3888

}

3889

arg3 = static_cast< int >(val3);

3890

{

3891

PyThreadState* __tstate = wxPyBeginAllowThreads();

3892

result = (int)(arg1)->PositionFromPointClose(arg2,arg3);

3893

wxPyEndAllowThreads(__tstate);

3894

if (PyErr_Occurred()) SWIG_fail;

3895

}

3896

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

3897

return resultobj;

3898

fail:

3899

return NULL;

3900

}

3901

3902

3903

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

3904

PyObject *resultobj = 0;

3905

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3906

int arg2 ;

3907

void *argp1 = 0 ;

3908

int res1 = 0 ;

3909

int val2 ;

3910

int ecode2 = 0 ;

3911

PyObject * obj0 = 0 ;

3912

PyObject * obj1 = 0 ;

3913

char * kwnames[] = {

3914

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

3915

};

3916

3917

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

3918

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

3919

if (!SWIG_IsOK(res1)) {

3920

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

3921

}

3922

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3923

ecode2 = SWIG_AsVal_int(obj1, &val2);

3924

if (!SWIG_IsOK(ecode2)) {

3925

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

3926

}

3927

arg2 = static_cast< int >(val2);

3928

{

3929

PyThreadState* __tstate = wxPyBeginAllowThreads();

3930

(arg1)->GotoLine(arg2);

3931

wxPyEndAllowThreads(__tstate);

3932

if (PyErr_Occurred()) SWIG_fail;

3933

}

3934

resultobj = SWIG_Py_Void();

3935

return resultobj;

3936

fail:

3937

return NULL;

3938

}

3939

3940

3941

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

3942

PyObject *resultobj = 0;

3943

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3944

int arg2 ;

3945

void *argp1 = 0 ;

3946

int res1 = 0 ;

3947

int val2 ;

3948

int ecode2 = 0 ;

3949

PyObject * obj0 = 0 ;

3950

PyObject * obj1 = 0 ;

3951

char * kwnames[] = {

3952

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

3953

};

3954

3955

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

3956

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

3957

if (!SWIG_IsOK(res1)) {

3958

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

3959

}

3960

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3961

ecode2 = SWIG_AsVal_int(obj1, &val2);

3962

if (!SWIG_IsOK(ecode2)) {

3963

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

3964

}

3965

arg2 = static_cast< int >(val2);

3966

{

3967

PyThreadState* __tstate = wxPyBeginAllowThreads();

3968

(arg1)->GotoPos(arg2);

3969

wxPyEndAllowThreads(__tstate);

3970

if (PyErr_Occurred()) SWIG_fail;

3971

}

3972

resultobj = SWIG_Py_Void();

3973

return resultobj;

3974

fail:

3975

return NULL;

3976

}

3977

3978

3979

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

3980

PyObject *resultobj = 0;

3981

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

3982

int arg2 ;

3983

void *argp1 = 0 ;

3984

int res1 = 0 ;

3985

int val2 ;

3986

int ecode2 = 0 ;

3987

PyObject * obj0 = 0 ;

3988

PyObject * obj1 = 0 ;

3989

char * kwnames[] = {

3990

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

3991

};

3992

3993

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

3994

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

3995

if (!SWIG_IsOK(res1)) {

3996

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

3997

}

3998

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

3999

ecode2 = SWIG_AsVal_int(obj1, &val2);

4000

if (!SWIG_IsOK(ecode2)) {

4001

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

4002

}

4003

arg2 = static_cast< int >(val2);

4004

{

4005

PyThreadState* __tstate = wxPyBeginAllowThreads();

4006

(arg1)->SetAnchor(arg2);

4007

wxPyEndAllowThreads(__tstate);

4008

if (PyErr_Occurred()) SWIG_fail;

4009

}

4010

resultobj = SWIG_Py_Void();

4011

return resultobj;

4012

fail:

4013

return NULL;

4014

}

4015

4016

4017

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

4018

PyObject *resultobj = 0;

4019

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4020

int *arg2 = (int *) 0 ;

4021

wxString result;

4022

void *argp1 = 0 ;

4023

int res1 = 0 ;

4024

int temp2 ;

4025

int res2 = SWIG_TMPOBJ ;

4026

PyObject *swig_obj[1] ;

4027

4028

arg2 = &temp2;

4029

if (!args) SWIG_fail;

4030

swig_obj[0] = args;

4031

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

4032

if (!SWIG_IsOK(res1)) {

4033

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

4034

}

4035

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4036

{

4037

PyThreadState* __tstate = wxPyBeginAllowThreads();

4038

result = (arg1)->GetCurLine(arg2);

4039

wxPyEndAllowThreads(__tstate);

4040

if (PyErr_Occurred()) SWIG_fail;

4041

}

4042

{

4043

#if wxUSE_UNICODE

4044

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

4045

#else

4046

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

4047

#endif

4048

}

4049

if (SWIG_IsTmpObj(res2)) {

4050

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));

4051

} else {

4052

int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

4053

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));

4054

}

4055

return resultobj;

4056

fail:

4057

return NULL;

4058

}

4059

4060

4061

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

4062

PyObject *resultobj = 0;

4063

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4064

int result;

4065

void *argp1 = 0 ;

4066

int res1 = 0 ;

4067

PyObject *swig_obj[1] ;

4068

4069

if (!args) SWIG_fail;

4070

swig_obj[0] = args;

4071

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

4072

if (!SWIG_IsOK(res1)) {

4073

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

4074

}

4075

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4076

{

4077

PyThreadState* __tstate = wxPyBeginAllowThreads();

4078

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

4079

wxPyEndAllowThreads(__tstate);

4080

if (PyErr_Occurred()) SWIG_fail;

4081

}

4082

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

4083

return resultobj;

4084

fail:

4085

return NULL;

4086

}

4087

4088

4089

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

4090

PyObject *resultobj = 0;

4091

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4092

int arg2 ;

4093

void *argp1 = 0 ;

4094

int res1 = 0 ;

4095

int val2 ;

4096

int ecode2 = 0 ;

4097

PyObject * obj0 = 0 ;

4098

PyObject * obj1 = 0 ;

4099

char * kwnames[] = {

4100

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

4101

};

4102

4103

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

4104

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

4105

if (!SWIG_IsOK(res1)) {

4106

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

4107

}

4108

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4109

ecode2 = SWIG_AsVal_int(obj1, &val2);

4110

if (!SWIG_IsOK(ecode2)) {

4111

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

4112

}

4113

arg2 = static_cast< int >(val2);

4114

{

4115

PyThreadState* __tstate = wxPyBeginAllowThreads();

4116

(arg1)->ConvertEOLs(arg2);

4117

wxPyEndAllowThreads(__tstate);

4118

if (PyErr_Occurred()) SWIG_fail;

4119

}

4120

resultobj = SWIG_Py_Void();

4121

return resultobj;

4122

fail:

4123

return NULL;

4124

}

4125

4126

4127

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

4128

PyObject *resultobj = 0;

4129

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4130

int result;

4131

void *argp1 = 0 ;

4132

int res1 = 0 ;

4133

PyObject *swig_obj[1] ;

4134

4135

if (!args) SWIG_fail;

4136

swig_obj[0] = args;

4137

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

4138

if (!SWIG_IsOK(res1)) {

4139

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

4140

}

4141

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4142

{

4143

PyThreadState* __tstate = wxPyBeginAllowThreads();

4144

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

4145

wxPyEndAllowThreads(__tstate);

4146

if (PyErr_Occurred()) SWIG_fail;

4147

}

4148

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

4149

return resultobj;

4150

fail:

4151

return NULL;

4152

}

4153

4154

4155

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

4156

PyObject *resultobj = 0;

4157

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4158

int arg2 ;

4159

void *argp1 = 0 ;

4160

int res1 = 0 ;

4161

int val2 ;

4162

int ecode2 = 0 ;

4163

PyObject * obj0 = 0 ;

4164

PyObject * obj1 = 0 ;

4165

char * kwnames[] = {

4166

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

4167

};

4168

4169

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

4170

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

4171

if (!SWIG_IsOK(res1)) {

4172

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

4173

}

4174

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4175

ecode2 = SWIG_AsVal_int(obj1, &val2);

4176

if (!SWIG_IsOK(ecode2)) {

4177

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

4178

}

4179

arg2 = static_cast< int >(val2);

4180

{

4181

PyThreadState* __tstate = wxPyBeginAllowThreads();

4182

(arg1)->SetEOLMode(arg2);

4183

wxPyEndAllowThreads(__tstate);

4184

if (PyErr_Occurred()) SWIG_fail;

4185

}

4186

resultobj = SWIG_Py_Void();

4187

return resultobj;

4188

fail:

4189

return NULL;

4190

}

4191

4192

4193

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

4194

PyObject *resultobj = 0;

4195

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4196

int arg2 ;

4197

int arg3 ;

4198

void *argp1 = 0 ;

4199

int res1 = 0 ;

4200

int val2 ;

4201

int ecode2 = 0 ;

4202

int val3 ;

4203

int ecode3 = 0 ;

4204

PyObject * obj0 = 0 ;

4205

PyObject * obj1 = 0 ;

4206

PyObject * obj2 = 0 ;

4207

char * kwnames[] = {

4208

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

4209

};

4210

4211

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

4212

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

4213

if (!SWIG_IsOK(res1)) {

4214

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

4215

}

4216

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4217

ecode2 = SWIG_AsVal_int(obj1, &val2);

4218

if (!SWIG_IsOK(ecode2)) {

4219

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

4220

}

4221

arg2 = static_cast< int >(val2);

4222

ecode3 = SWIG_AsVal_int(obj2, &val3);

4223

if (!SWIG_IsOK(ecode3)) {

4224

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

4225

}

4226

arg3 = static_cast< int >(val3);

4227

{

4228

PyThreadState* __tstate = wxPyBeginAllowThreads();

4229

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

4230

wxPyEndAllowThreads(__tstate);

4231

if (PyErr_Occurred()) SWIG_fail;

4232

}

4233

resultobj = SWIG_Py_Void();

4234

return resultobj;

4235

fail:

4236

return NULL;

4237

}

4238

4239

4240

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

4241

PyObject *resultobj = 0;

4242

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4243

int arg2 ;

4244

int arg3 ;

4245

void *argp1 = 0 ;

4246

int res1 = 0 ;

4247

int val2 ;

4248

int ecode2 = 0 ;

4249

int val3 ;

4250

int ecode3 = 0 ;

4251

PyObject * obj0 = 0 ;

4252

PyObject * obj1 = 0 ;

4253

PyObject * obj2 = 0 ;

4254

char * kwnames[] = {

4255

(char *) "self",(char *) "length",(char *) "style", NULL

4256

};

4257

4258

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

4259

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

4260

if (!SWIG_IsOK(res1)) {

4261

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

4262

}

4263

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4264

ecode2 = SWIG_AsVal_int(obj1, &val2);

4265

if (!SWIG_IsOK(ecode2)) {

4266

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

4267

}

4268

arg2 = static_cast< int >(val2);

4269

ecode3 = SWIG_AsVal_int(obj2, &val3);

4270

if (!SWIG_IsOK(ecode3)) {

4271

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

4272

}

4273

arg3 = static_cast< int >(val3);

4274

{

4275

PyThreadState* __tstate = wxPyBeginAllowThreads();

4276

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

4277

wxPyEndAllowThreads(__tstate);

4278

if (PyErr_Occurred()) SWIG_fail;

4279

}

4280

resultobj = SWIG_Py_Void();

4281

return resultobj;

4282

fail:

4283

return NULL;

4284

}

4285

4286

4287

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

4288

PyObject *resultobj = 0;

4289

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4290

bool result;

4291

void *argp1 = 0 ;

4292

int res1 = 0 ;

4293

PyObject *swig_obj[1] ;

4294

4295

if (!args) SWIG_fail;

4296

swig_obj[0] = args;

4297

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

4298

if (!SWIG_IsOK(res1)) {

4299

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

4300

}

4301

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4302

{

4303

PyThreadState* __tstate = wxPyBeginAllowThreads();

4304

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

4305

wxPyEndAllowThreads(__tstate);

4306

if (PyErr_Occurred()) SWIG_fail;

4307

}

4308

{

4309

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

4310

}

4311

return resultobj;

4312

fail:

4313

return NULL;

4314

}

4315

4316

4317

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

4318

PyObject *resultobj = 0;

4319

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4320

bool arg2 ;

4321

void *argp1 = 0 ;

4322

int res1 = 0 ;

4323

bool val2 ;

4324

int ecode2 = 0 ;

4325

PyObject * obj0 = 0 ;

4326

PyObject * obj1 = 0 ;

4327

char * kwnames[] = {

4328

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

4329

};

4330

4331

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

4332

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

4333

if (!SWIG_IsOK(res1)) {

4334

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

4335

}

4336

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4337

ecode2 = SWIG_AsVal_bool(obj1, &val2);

4338

if (!SWIG_IsOK(ecode2)) {

4339

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

4340

}

4341

arg2 = static_cast< bool >(val2);

4342

{

4343

PyThreadState* __tstate = wxPyBeginAllowThreads();

4344

(arg1)->SetBufferedDraw(arg2);

4345

wxPyEndAllowThreads(__tstate);

4346

if (PyErr_Occurred()) SWIG_fail;

4347

}

4348

resultobj = SWIG_Py_Void();

4349

return resultobj;

4350

fail:

4351

return NULL;

4352

}

4353

4354

4355

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

4356

PyObject *resultobj = 0;

4357

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4358

int arg2 ;

4359

void *argp1 = 0 ;

4360

int res1 = 0 ;

4361

int val2 ;

4362

int ecode2 = 0 ;

4363

PyObject * obj0 = 0 ;

4364

PyObject * obj1 = 0 ;

4365

char * kwnames[] = {

4366

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

4367

};

4368

4369

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

4370

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

4371

if (!SWIG_IsOK(res1)) {

4372

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

4373

}

4374

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4375

ecode2 = SWIG_AsVal_int(obj1, &val2);

4376

if (!SWIG_IsOK(ecode2)) {

4377

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

4378

}

4379

arg2 = static_cast< int >(val2);

4380

{

4381

PyThreadState* __tstate = wxPyBeginAllowThreads();

4382

(arg1)->SetTabWidth(arg2);

4383

wxPyEndAllowThreads(__tstate);

4384

if (PyErr_Occurred()) SWIG_fail;

4385

}

4386

resultobj = SWIG_Py_Void();

4387

return resultobj;

4388

fail:

4389

return NULL;

4390

}

4391

4392

4393

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

4394

PyObject *resultobj = 0;

4395

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4396

int result;

4397

void *argp1 = 0 ;

4398

int res1 = 0 ;

4399

PyObject *swig_obj[1] ;

4400

4401

if (!args) SWIG_fail;

4402

swig_obj[0] = args;

4403

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

4404

if (!SWIG_IsOK(res1)) {

4405

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

4406

}

4407

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4408

{

4409

PyThreadState* __tstate = wxPyBeginAllowThreads();

4410

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

4411

wxPyEndAllowThreads(__tstate);

4412

if (PyErr_Occurred()) SWIG_fail;

4413

}

4414

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

4415

return resultobj;

4416

fail:

4417

return NULL;

4418

}

4419

4420

4421

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

4422

PyObject *resultobj = 0;

4423

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4424

int arg2 ;

4425

void *argp1 = 0 ;

4426

int res1 = 0 ;

4427

int val2 ;

4428

int ecode2 = 0 ;

4429

PyObject * obj0 = 0 ;

4430

PyObject * obj1 = 0 ;

4431

char * kwnames[] = {

4432

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

4433

};

4434

4435

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

4436

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

4437

if (!SWIG_IsOK(res1)) {

4438

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

4439

}

4440

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4441

ecode2 = SWIG_AsVal_int(obj1, &val2);

4442

if (!SWIG_IsOK(ecode2)) {

4443

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

4444

}

4445

arg2 = static_cast< int >(val2);

4446

{

4447

PyThreadState* __tstate = wxPyBeginAllowThreads();

4448

(arg1)->SetCodePage(arg2);

4449

wxPyEndAllowThreads(__tstate);

4450

if (PyErr_Occurred()) SWIG_fail;

4451

}

4452

resultobj = SWIG_Py_Void();

4453

return resultobj;

4454

fail:

4455

return NULL;

4456

}

4457

4458

4459

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

4460

PyObject *resultobj = 0;

4461

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4462

int arg2 ;

4463

int arg3 ;

4464

wxColour const &arg4_defvalue = wxNullColour ;

4465

wxColour *arg4 = (wxColour *) &arg4_defvalue ;

4466

wxColour const &arg5_defvalue = wxNullColour ;

4467

wxColour *arg5 = (wxColour *) &arg5_defvalue ;

4468

void *argp1 = 0 ;

4469

int res1 = 0 ;

4470

int val2 ;

4471

int ecode2 = 0 ;

4472

int val3 ;

4473

int ecode3 = 0 ;

4474

wxColour temp4 ;

4475

wxColour temp5 ;

4476

PyObject * obj0 = 0 ;

4477

PyObject * obj1 = 0 ;

4478

PyObject * obj2 = 0 ;

4479

PyObject * obj3 = 0 ;

4480

PyObject * obj4 = 0 ;

4481

char * kwnames[] = {

4482

(char *) "self",(char *) "markerNumber",(char *) "markerSymbol",(char *) "foreground",(char *) "background", NULL

4483

};

4484

4485

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

4486

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

4487

if (!SWIG_IsOK(res1)) {

4488

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

4489

}

4490

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4491

ecode2 = SWIG_AsVal_int(obj1, &val2);

4492

if (!SWIG_IsOK(ecode2)) {

4493

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

4494

}

4495

arg2 = static_cast< int >(val2);

4496

ecode3 = SWIG_AsVal_int(obj2, &val3);

4497

if (!SWIG_IsOK(ecode3)) {

4498

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

4499

}

4500

arg3 = static_cast< int >(val3);

4501

if (obj3) {

4502

{

4503

arg4 = &temp4;

4504

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

4505

}

4506

}

4507

if (obj4) {

4508

{

4509

arg5 = &temp5;

4510

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

4511

}

4512

}

4513

{

4514

PyThreadState* __tstate = wxPyBeginAllowThreads();

4515

(arg1)->MarkerDefine(arg2,arg3,(wxColour const &)*arg4,(wxColour const &)*arg5);

4516

wxPyEndAllowThreads(__tstate);

4517

if (PyErr_Occurred()) SWIG_fail;

4518

}

4519

resultobj = SWIG_Py_Void();

4520

return resultobj;

4521

fail:

4522

return NULL;

4523

}

4524

4525

4526

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

4527

PyObject *resultobj = 0;

4528

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4529

int arg2 ;

4530

wxColour *arg3 = 0 ;

4531

void *argp1 = 0 ;

4532

int res1 = 0 ;

4533

int val2 ;

4534

int ecode2 = 0 ;

4535

wxColour temp3 ;

4536

PyObject * obj0 = 0 ;

4537

PyObject * obj1 = 0 ;

4538

PyObject * obj2 = 0 ;

4539

char * kwnames[] = {

4540

(char *) "self",(char *) "markerNumber",(char *) "fore", NULL

4541

};

4542

4543

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

4544

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

4545

if (!SWIG_IsOK(res1)) {

4546

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

4547

}

4548

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4549

ecode2 = SWIG_AsVal_int(obj1, &val2);

4550

if (!SWIG_IsOK(ecode2)) {

4551

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

4552

}

4553

arg2 = static_cast< int >(val2);

4554

{

4555

arg3 = &temp3;

4556

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

4557

}

4558

{

4559

PyThreadState* __tstate = wxPyBeginAllowThreads();

4560

(arg1)->MarkerSetForeground(arg2,(wxColour const &)*arg3);

4561

wxPyEndAllowThreads(__tstate);

4562

if (PyErr_Occurred()) SWIG_fail;

4563

}

4564

resultobj = SWIG_Py_Void();

4565

return resultobj;

4566

fail:

4567

return NULL;

4568

}

4569

4570

4571

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

4572

PyObject *resultobj = 0;

4573

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4574

int arg2 ;

4575

wxColour *arg3 = 0 ;

4576

void *argp1 = 0 ;

4577

int res1 = 0 ;

4578

int val2 ;

4579

int ecode2 = 0 ;

4580

wxColour temp3 ;

4581

PyObject * obj0 = 0 ;

4582

PyObject * obj1 = 0 ;

4583

PyObject * obj2 = 0 ;

4584

char * kwnames[] = {

4585

(char *) "self",(char *) "markerNumber",(char *) "back", NULL

4586

};

4587

4588

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

4589

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

4590

if (!SWIG_IsOK(res1)) {

4591

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

4592

}

4593

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4594

ecode2 = SWIG_AsVal_int(obj1, &val2);

4595

if (!SWIG_IsOK(ecode2)) {

4596

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

4597

}

4598

arg2 = static_cast< int >(val2);

4599

{

4600

arg3 = &temp3;

4601

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

4602

}

4603

{

4604

PyThreadState* __tstate = wxPyBeginAllowThreads();

4605

(arg1)->MarkerSetBackground(arg2,(wxColour const &)*arg3);

4606

wxPyEndAllowThreads(__tstate);

4607

if (PyErr_Occurred()) SWIG_fail;

4608

}

4609

resultobj = SWIG_Py_Void();

4610

return resultobj;

4611

fail:

4612

return NULL;

4613

}

4614

4615

4616

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

4617

PyObject *resultobj = 0;

4618

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4619

int arg2 ;

4620

int arg3 ;

4621

int result;

4622

void *argp1 = 0 ;

4623

int res1 = 0 ;

4624

int val2 ;

4625

int ecode2 = 0 ;

4626

int val3 ;

4627

int ecode3 = 0 ;

4628

PyObject * obj0 = 0 ;

4629

PyObject * obj1 = 0 ;

4630

PyObject * obj2 = 0 ;

4631

char * kwnames[] = {

4632

(char *) "self",(char *) "line",(char *) "markerNumber", NULL

4633

};

4634

4635

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

4636

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

4637

if (!SWIG_IsOK(res1)) {

4638

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

4639

}

4640

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4641

ecode2 = SWIG_AsVal_int(obj1, &val2);

4642

if (!SWIG_IsOK(ecode2)) {

4643

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

4644

}

4645

arg2 = static_cast< int >(val2);

4646

ecode3 = SWIG_AsVal_int(obj2, &val3);

4647

if (!SWIG_IsOK(ecode3)) {

4648

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

4649

}

4650

arg3 = static_cast< int >(val3);

4651

{

4652

PyThreadState* __tstate = wxPyBeginAllowThreads();

4653

result = (int)(arg1)->MarkerAdd(arg2,arg3);

4654

wxPyEndAllowThreads(__tstate);

4655

if (PyErr_Occurred()) SWIG_fail;

4656

}

4657

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

4658

return resultobj;

4659

fail:

4660

return NULL;

4661

}

4662

4663

4664

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

4665

PyObject *resultobj = 0;

4666

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4667

int arg2 ;

4668

int arg3 ;

4669

void *argp1 = 0 ;

4670

int res1 = 0 ;

4671

int val2 ;

4672

int ecode2 = 0 ;

4673

int val3 ;

4674

int ecode3 = 0 ;

4675

PyObject * obj0 = 0 ;

4676

PyObject * obj1 = 0 ;

4677

PyObject * obj2 = 0 ;

4678

char * kwnames[] = {

4679

(char *) "self",(char *) "line",(char *) "markerNumber", NULL

4680

};

4681

4682

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

4683

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

4684

if (!SWIG_IsOK(res1)) {

4685

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

4686

}

4687

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4688

ecode2 = SWIG_AsVal_int(obj1, &val2);

4689

if (!SWIG_IsOK(ecode2)) {

4690

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

4691

}

4692

arg2 = static_cast< int >(val2);

4693

ecode3 = SWIG_AsVal_int(obj2, &val3);

4694

if (!SWIG_IsOK(ecode3)) {

4695

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

4696

}

4697

arg3 = static_cast< int >(val3);

4698

{

4699

PyThreadState* __tstate = wxPyBeginAllowThreads();

4700

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

4701

wxPyEndAllowThreads(__tstate);

4702

if (PyErr_Occurred()) SWIG_fail;

4703

}

4704

resultobj = SWIG_Py_Void();

4705

return resultobj;

4706

fail:

4707

return NULL;

4708

}

4709

4710

4711

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

4712

PyObject *resultobj = 0;

4713

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4714

int arg2 ;

4715

void *argp1 = 0 ;

4716

int res1 = 0 ;

4717

int val2 ;

4718

int ecode2 = 0 ;

4719

PyObject * obj0 = 0 ;

4720

PyObject * obj1 = 0 ;

4721

char * kwnames[] = {

4722

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

4723

};

4724

4725

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

4726

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

4727

if (!SWIG_IsOK(res1)) {

4728

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

4729

}

4730

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4731

ecode2 = SWIG_AsVal_int(obj1, &val2);

4732

if (!SWIG_IsOK(ecode2)) {

4733

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

4734

}

4735

arg2 = static_cast< int >(val2);

4736

{

4737

PyThreadState* __tstate = wxPyBeginAllowThreads();

4738

(arg1)->MarkerDeleteAll(arg2);

4739

wxPyEndAllowThreads(__tstate);

4740

if (PyErr_Occurred()) SWIG_fail;

4741

}

4742

resultobj = SWIG_Py_Void();

4743

return resultobj;

4744

fail:

4745

return NULL;

4746

}

4747

4748

4749

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

4750

PyObject *resultobj = 0;

4751

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4752

int arg2 ;

4753

int result;

4754

void *argp1 = 0 ;

4755

int res1 = 0 ;

4756

int val2 ;

4757

int ecode2 = 0 ;

4758

PyObject * obj0 = 0 ;

4759

PyObject * obj1 = 0 ;

4760

char * kwnames[] = {

4761

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

4762

};

4763

4764

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

4765

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

4766

if (!SWIG_IsOK(res1)) {

4767

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

4768

}

4769

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4770

ecode2 = SWIG_AsVal_int(obj1, &val2);

4771

if (!SWIG_IsOK(ecode2)) {

4772

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

4773

}

4774

arg2 = static_cast< int >(val2);

4775

{

4776

PyThreadState* __tstate = wxPyBeginAllowThreads();

4777

result = (int)(arg1)->MarkerGet(arg2);

4778

wxPyEndAllowThreads(__tstate);

4779

if (PyErr_Occurred()) SWIG_fail;

4780

}

4781

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

4782

return resultobj;

4783

fail:

4784

return NULL;

4785

}

4786

4787

4788

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

4789

PyObject *resultobj = 0;

4790

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4791

int arg2 ;

4792

int arg3 ;

4793

int result;

4794

void *argp1 = 0 ;

4795

int res1 = 0 ;

4796

int val2 ;

4797

int ecode2 = 0 ;

4798

int val3 ;

4799

int ecode3 = 0 ;

4800

PyObject * obj0 = 0 ;

4801

PyObject * obj1 = 0 ;

4802

PyObject * obj2 = 0 ;

4803

char * kwnames[] = {

4804

(char *) "self",(char *) "lineStart",(char *) "markerMask", NULL

4805

};

4806

4807

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

4808

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

4809

if (!SWIG_IsOK(res1)) {

4810

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

4811

}

4812

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4813

ecode2 = SWIG_AsVal_int(obj1, &val2);

4814

if (!SWIG_IsOK(ecode2)) {

4815

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

4816

}

4817

arg2 = static_cast< int >(val2);

4818

ecode3 = SWIG_AsVal_int(obj2, &val3);

4819

if (!SWIG_IsOK(ecode3)) {

4820

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

4821

}

4822

arg3 = static_cast< int >(val3);

4823

{

4824

PyThreadState* __tstate = wxPyBeginAllowThreads();

4825

result = (int)(arg1)->MarkerNext(arg2,arg3);

4826

wxPyEndAllowThreads(__tstate);

4827

if (PyErr_Occurred()) SWIG_fail;

4828

}

4829

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

4830

return resultobj;

4831

fail:

4832

return NULL;

4833

}

4834

4835

4836

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

4837

PyObject *resultobj = 0;

4838

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4839

int arg2 ;

4840

int arg3 ;

4841

int result;

4842

void *argp1 = 0 ;

4843

int res1 = 0 ;

4844

int val2 ;

4845

int ecode2 = 0 ;

4846

int val3 ;

4847

int ecode3 = 0 ;

4848

PyObject * obj0 = 0 ;

4849

PyObject * obj1 = 0 ;

4850

PyObject * obj2 = 0 ;

4851

char * kwnames[] = {

4852

(char *) "self",(char *) "lineStart",(char *) "markerMask", NULL

4853

};

4854

4855

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

4856

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

4857

if (!SWIG_IsOK(res1)) {

4858

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

4859

}

4860

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4861

ecode2 = SWIG_AsVal_int(obj1, &val2);

4862

if (!SWIG_IsOK(ecode2)) {

4863

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

4864

}

4865

arg2 = static_cast< int >(val2);

4866

ecode3 = SWIG_AsVal_int(obj2, &val3);

4867

if (!SWIG_IsOK(ecode3)) {

4868

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

4869

}

4870

arg3 = static_cast< int >(val3);

4871

{

4872

PyThreadState* __tstate = wxPyBeginAllowThreads();

4873

result = (int)(arg1)->MarkerPrevious(arg2,arg3);

4874

wxPyEndAllowThreads(__tstate);

4875

if (PyErr_Occurred()) SWIG_fail;

4876

}

4877

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

4878

return resultobj;

4879

fail:

4880

return NULL;

4881

}

4882

4883

4884

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

4885

PyObject *resultobj = 0;

4886

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4887

int arg2 ;

4888

wxBitmap *arg3 = 0 ;

4889

void *argp1 = 0 ;

4890

int res1 = 0 ;

4891

int val2 ;

4892

int ecode2 = 0 ;

4893

void *argp3 = 0 ;

4894

int res3 = 0 ;

4895

PyObject * obj0 = 0 ;

4896

PyObject * obj1 = 0 ;

4897

PyObject * obj2 = 0 ;

4898

char * kwnames[] = {

4899

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

4900

};

4901

4902

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

4903

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

4904

if (!SWIG_IsOK(res1)) {

4905

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

4906

}

4907

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4908

ecode2 = SWIG_AsVal_int(obj1, &val2);

4909

if (!SWIG_IsOK(ecode2)) {

4910

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

4911

}

4912

arg2 = static_cast< int >(val2);

4913

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

4914

if (!SWIG_IsOK(res3)) {

4915

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

4916

}

4917

if (!argp3) {

4918

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

4919

}

4920

arg3 = reinterpret_cast< wxBitmap * >(argp3);

4921

{

4922

PyThreadState* __tstate = wxPyBeginAllowThreads();

4923

(arg1)->MarkerDefineBitmap(arg2,(wxBitmap const &)*arg3);

4924

wxPyEndAllowThreads(__tstate);

4925

if (PyErr_Occurred()) SWIG_fail;

4926

}

4927

resultobj = SWIG_Py_Void();

4928

return resultobj;

4929

fail:

4930

return NULL;

4931

}

4932

4933

4934

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

4935

PyObject *resultobj = 0;

4936

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4937

int arg2 ;

4938

int arg3 ;

4939

void *argp1 = 0 ;

4940

int res1 = 0 ;

4941

int val2 ;

4942

int ecode2 = 0 ;

4943

int val3 ;

4944

int ecode3 = 0 ;

4945

PyObject * obj0 = 0 ;

4946

PyObject * obj1 = 0 ;

4947

PyObject * obj2 = 0 ;

4948

char * kwnames[] = {

4949

(char *) "self",(char *) "line",(char *) "set", NULL

4950

};

4951

4952

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

4953

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

4954

if (!SWIG_IsOK(res1)) {

4955

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

4956

}

4957

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

4958

ecode2 = SWIG_AsVal_int(obj1, &val2);

4959

if (!SWIG_IsOK(ecode2)) {

4960

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

4961

}

4962

arg2 = static_cast< int >(val2);

4963

ecode3 = SWIG_AsVal_int(obj2, &val3);

4964

if (!SWIG_IsOK(ecode3)) {

4965

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

4966

}

4967

arg3 = static_cast< int >(val3);

4968

{

4969

PyThreadState* __tstate = wxPyBeginAllowThreads();

4970

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

4971

wxPyEndAllowThreads(__tstate);

4972

if (PyErr_Occurred()) SWIG_fail;

4973

}

4974

resultobj = SWIG_Py_Void();

4975

return resultobj;

4976

fail:

4977

return NULL;

4978

}

4979

4980

4981

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

4982

PyObject *resultobj = 0;

4983

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

4984

int arg2 ;

4985

int arg3 ;

4986

void *argp1 = 0 ;

4987

int res1 = 0 ;

4988

int val2 ;

4989

int ecode2 = 0 ;

4990

int val3 ;

4991

int ecode3 = 0 ;

4992

PyObject * obj0 = 0 ;

4993

PyObject * obj1 = 0 ;

4994

PyObject * obj2 = 0 ;

4995

char * kwnames[] = {

4996

(char *) "self",(char *) "markerNumber",(char *) "alpha", NULL

4997

};

4998

4999

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

5000

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

5001

if (!SWIG_IsOK(res1)) {

5002

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

5003

}

5004

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5005

ecode2 = SWIG_AsVal_int(obj1, &val2);

5006

if (!SWIG_IsOK(ecode2)) {

5007

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

5008

}

5009

arg2 = static_cast< int >(val2);

5010

ecode3 = SWIG_AsVal_int(obj2, &val3);

5011

if (!SWIG_IsOK(ecode3)) {

5012

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

5013

}

5014

arg3 = static_cast< int >(val3);

5015

{

5016

PyThreadState* __tstate = wxPyBeginAllowThreads();

5017

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

5018

wxPyEndAllowThreads(__tstate);

5019

if (PyErr_Occurred()) SWIG_fail;

5020

}

5021

resultobj = SWIG_Py_Void();

5022

return resultobj;

5023

fail:

5024

return NULL;

5025

}

5026

5027

5028

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

5029

PyObject *resultobj = 0;

5030

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5031

int arg2 ;

5032

int arg3 ;

5033

void *argp1 = 0 ;

5034

int res1 = 0 ;

5035

int val2 ;

5036

int ecode2 = 0 ;

5037

int val3 ;

5038

int ecode3 = 0 ;

5039

PyObject * obj0 = 0 ;

5040

PyObject * obj1 = 0 ;

5041

PyObject * obj2 = 0 ;

5042

char * kwnames[] = {

5043

(char *) "self",(char *) "margin",(char *) "marginType", NULL

5044

};

5045

5046

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

5047

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

5048

if (!SWIG_IsOK(res1)) {

5049

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

5050

}

5051

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5052

ecode2 = SWIG_AsVal_int(obj1, &val2);

5053

if (!SWIG_IsOK(ecode2)) {

5054

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

5055

}

5056

arg2 = static_cast< int >(val2);

5057

ecode3 = SWIG_AsVal_int(obj2, &val3);

5058

if (!SWIG_IsOK(ecode3)) {

5059

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

5060

}

5061

arg3 = static_cast< int >(val3);

5062

{

5063

PyThreadState* __tstate = wxPyBeginAllowThreads();

5064

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

5065

wxPyEndAllowThreads(__tstate);

5066

if (PyErr_Occurred()) SWIG_fail;

5067

}

5068

resultobj = SWIG_Py_Void();

5069

return resultobj;

5070

fail:

5071

return NULL;

5072

}

5073

5074

5075

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

5076

PyObject *resultobj = 0;

5077

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5078

int arg2 ;

5079

int result;

5080

void *argp1 = 0 ;

5081

int res1 = 0 ;

5082

int val2 ;

5083

int ecode2 = 0 ;

5084

PyObject * obj0 = 0 ;

5085

PyObject * obj1 = 0 ;

5086

char * kwnames[] = {

5087

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

5088

};

5089

5090

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

5091

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

5092

if (!SWIG_IsOK(res1)) {

5093

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

5094

}

5095

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5096

ecode2 = SWIG_AsVal_int(obj1, &val2);

5097

if (!SWIG_IsOK(ecode2)) {

5098

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

5099

}

5100

arg2 = static_cast< int >(val2);

5101

{

5102

PyThreadState* __tstate = wxPyBeginAllowThreads();

5103

result = (int)(arg1)->GetMarginType(arg2);

5104

wxPyEndAllowThreads(__tstate);

5105

if (PyErr_Occurred()) SWIG_fail;

5106

}

5107

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

5108

return resultobj;

5109

fail:

5110

return NULL;

5111

}

5112

5113

5114

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

5115

PyObject *resultobj = 0;

5116

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5117

int arg2 ;

5118

int arg3 ;

5119

void *argp1 = 0 ;

5120

int res1 = 0 ;

5121

int val2 ;

5122

int ecode2 = 0 ;

5123

int val3 ;

5124

int ecode3 = 0 ;

5125

PyObject * obj0 = 0 ;

5126

PyObject * obj1 = 0 ;

5127

PyObject * obj2 = 0 ;

5128

char * kwnames[] = {

5129

(char *) "self",(char *) "margin",(char *) "pixelWidth", NULL

5130

};

5131

5132

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

5133

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

5134

if (!SWIG_IsOK(res1)) {

5135

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

5136

}

5137

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5138

ecode2 = SWIG_AsVal_int(obj1, &val2);

5139

if (!SWIG_IsOK(ecode2)) {

5140

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

5141

}

5142

arg2 = static_cast< int >(val2);

5143

ecode3 = SWIG_AsVal_int(obj2, &val3);

5144

if (!SWIG_IsOK(ecode3)) {

5145

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

5146

}

5147

arg3 = static_cast< int >(val3);

5148

{

5149

PyThreadState* __tstate = wxPyBeginAllowThreads();

5150

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

5151

wxPyEndAllowThreads(__tstate);

5152

if (PyErr_Occurred()) SWIG_fail;

5153

}

5154

resultobj = SWIG_Py_Void();

5155

return resultobj;

5156

fail:

5157

return NULL;

5158

}

5159

5160

5161

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

5162

PyObject *resultobj = 0;

5163

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5164

int arg2 ;

5165

int result;

5166

void *argp1 = 0 ;

5167

int res1 = 0 ;

5168

int val2 ;

5169

int ecode2 = 0 ;

5170

PyObject * obj0 = 0 ;

5171

PyObject * obj1 = 0 ;

5172

char * kwnames[] = {

5173

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

5174

};

5175

5176

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

5177

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

5178

if (!SWIG_IsOK(res1)) {

5179

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

5180

}

5181

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5182

ecode2 = SWIG_AsVal_int(obj1, &val2);

5183

if (!SWIG_IsOK(ecode2)) {

5184

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

5185

}

5186

arg2 = static_cast< int >(val2);

5187

{

5188

PyThreadState* __tstate = wxPyBeginAllowThreads();

5189

result = (int)(arg1)->GetMarginWidth(arg2);

5190

wxPyEndAllowThreads(__tstate);

5191

if (PyErr_Occurred()) SWIG_fail;

5192

}

5193

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

5194

return resultobj;

5195

fail:

5196

return NULL;

5197

}

5198

5199

5200

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

5201

PyObject *resultobj = 0;

5202

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5203

int arg2 ;

5204

int arg3 ;

5205

void *argp1 = 0 ;

5206

int res1 = 0 ;

5207

int val2 ;

5208

int ecode2 = 0 ;

5209

int val3 ;

5210

int ecode3 = 0 ;

5211

PyObject * obj0 = 0 ;

5212

PyObject * obj1 = 0 ;

5213

PyObject * obj2 = 0 ;

5214

char * kwnames[] = {

5215

(char *) "self",(char *) "margin",(char *) "mask", NULL

5216

};

5217

5218

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

5219

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

5220

if (!SWIG_IsOK(res1)) {

5221

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

5222

}

5223

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5224

ecode2 = SWIG_AsVal_int(obj1, &val2);

5225

if (!SWIG_IsOK(ecode2)) {

5226

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

5227

}

5228

arg2 = static_cast< int >(val2);

5229

ecode3 = SWIG_AsVal_int(obj2, &val3);

5230

if (!SWIG_IsOK(ecode3)) {

5231

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

5232

}

5233

arg3 = static_cast< int >(val3);

5234

{

5235

PyThreadState* __tstate = wxPyBeginAllowThreads();

5236

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

5237

wxPyEndAllowThreads(__tstate);

5238

if (PyErr_Occurred()) SWIG_fail;

5239

}

5240

resultobj = SWIG_Py_Void();

5241

return resultobj;

5242

fail:

5243

return NULL;

5244

}

5245

5246

5247

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

5248

PyObject *resultobj = 0;

5249

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5250

int arg2 ;

5251

int result;

5252

void *argp1 = 0 ;

5253

int res1 = 0 ;

5254

int val2 ;

5255

int ecode2 = 0 ;

5256

PyObject * obj0 = 0 ;

5257

PyObject * obj1 = 0 ;

5258

char * kwnames[] = {

5259

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

5260

};

5261

5262

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

5263

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

5264

if (!SWIG_IsOK(res1)) {

5265

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

5266

}

5267

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5268

ecode2 = SWIG_AsVal_int(obj1, &val2);

5269

if (!SWIG_IsOK(ecode2)) {

5270

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

5271

}

5272

arg2 = static_cast< int >(val2);

5273

{

5274

PyThreadState* __tstate = wxPyBeginAllowThreads();

5275

result = (int)(arg1)->GetMarginMask(arg2);

5276

wxPyEndAllowThreads(__tstate);

5277

if (PyErr_Occurred()) SWIG_fail;

5278

}

5279

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

5280

return resultobj;

5281

fail:

5282

return NULL;

5283

}

5284

5285

5286

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

5287

PyObject *resultobj = 0;

5288

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5289

int arg2 ;

5290

bool arg3 ;

5291

void *argp1 = 0 ;

5292

int res1 = 0 ;

5293

int val2 ;

5294

int ecode2 = 0 ;

5295

bool val3 ;

5296

int ecode3 = 0 ;

5297

PyObject * obj0 = 0 ;

5298

PyObject * obj1 = 0 ;

5299

PyObject * obj2 = 0 ;

5300

char * kwnames[] = {

5301

(char *) "self",(char *) "margin",(char *) "sensitive", NULL

5302

};

5303

5304

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

5305

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

5306

if (!SWIG_IsOK(res1)) {

5307

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

5308

}

5309

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5310

ecode2 = SWIG_AsVal_int(obj1, &val2);

5311

if (!SWIG_IsOK(ecode2)) {

5312

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

5313

}

5314

arg2 = static_cast< int >(val2);

5315

ecode3 = SWIG_AsVal_bool(obj2, &val3);

5316

if (!SWIG_IsOK(ecode3)) {

5317

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

5318

}

5319

arg3 = static_cast< bool >(val3);

5320

{

5321

PyThreadState* __tstate = wxPyBeginAllowThreads();

5322

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

5323

wxPyEndAllowThreads(__tstate);

5324

if (PyErr_Occurred()) SWIG_fail;

5325

}

5326

resultobj = SWIG_Py_Void();

5327

return resultobj;

5328

fail:

5329

return NULL;

5330

}

5331

5332

5333

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

5334

PyObject *resultobj = 0;

5335

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5336

int arg2 ;

5337

bool result;

5338

void *argp1 = 0 ;

5339

int res1 = 0 ;

5340

int val2 ;

5341

int ecode2 = 0 ;

5342

PyObject * obj0 = 0 ;

5343

PyObject * obj1 = 0 ;

5344

char * kwnames[] = {

5345

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

5346

};

5347

5348

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

5349

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

5350

if (!SWIG_IsOK(res1)) {

5351

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

5352

}

5353

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5354

ecode2 = SWIG_AsVal_int(obj1, &val2);

5355

if (!SWIG_IsOK(ecode2)) {

5356

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

5357

}

5358

arg2 = static_cast< int >(val2);

5359

{

5360

PyThreadState* __tstate = wxPyBeginAllowThreads();

5361

result = (bool)(arg1)->GetMarginSensitive(arg2);

5362

wxPyEndAllowThreads(__tstate);

5363

if (PyErr_Occurred()) SWIG_fail;

5364

}

5365

{

5366

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

5367

}

5368

return resultobj;

5369

fail:

5370

return NULL;

5371

}

5372

5373

5374

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

5375

PyObject *resultobj = 0;

5376

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5377

void *argp1 = 0 ;

5378

int res1 = 0 ;

5379

PyObject *swig_obj[1] ;

5380

5381

if (!args) SWIG_fail;

5382

swig_obj[0] = args;

5383

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

5384

if (!SWIG_IsOK(res1)) {

5385

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

5386

}

5387

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5388

{

5389

PyThreadState* __tstate = wxPyBeginAllowThreads();

5390

(arg1)->StyleClearAll();

5391

wxPyEndAllowThreads(__tstate);

5392

if (PyErr_Occurred()) SWIG_fail;

5393

}

5394

resultobj = SWIG_Py_Void();

5395

return resultobj;

5396

fail:

5397

return NULL;

5398

}

5399

5400

5401

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

5402

PyObject *resultobj = 0;

5403

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5404

int arg2 ;

5405

wxColour *arg3 = 0 ;

5406

void *argp1 = 0 ;

5407

int res1 = 0 ;

5408

int val2 ;

5409

int ecode2 = 0 ;

5410

wxColour temp3 ;

5411

PyObject * obj0 = 0 ;

5412

PyObject * obj1 = 0 ;

5413

PyObject * obj2 = 0 ;

5414

char * kwnames[] = {

5415

(char *) "self",(char *) "style",(char *) "fore", NULL

5416

};

5417

5418

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

5419

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

5420

if (!SWIG_IsOK(res1)) {

5421

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

5422

}

5423

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5424

ecode2 = SWIG_AsVal_int(obj1, &val2);

5425

if (!SWIG_IsOK(ecode2)) {

5426

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

5427

}

5428

arg2 = static_cast< int >(val2);

5429

{

5430

arg3 = &temp3;

5431

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

5432

}

5433

{

5434

PyThreadState* __tstate = wxPyBeginAllowThreads();

5435

(arg1)->StyleSetForeground(arg2,(wxColour const &)*arg3);

5436

wxPyEndAllowThreads(__tstate);

5437

if (PyErr_Occurred()) SWIG_fail;

5438

}

5439

resultobj = SWIG_Py_Void();

5440

return resultobj;

5441

fail:

5442

return NULL;

5443

}

5444

5445

5446

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

5447

PyObject *resultobj = 0;

5448

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5449

int arg2 ;

5450

wxColour *arg3 = 0 ;

5451

void *argp1 = 0 ;

5452

int res1 = 0 ;

5453

int val2 ;

5454

int ecode2 = 0 ;

5455

wxColour temp3 ;

5456

PyObject * obj0 = 0 ;

5457

PyObject * obj1 = 0 ;

5458

PyObject * obj2 = 0 ;

5459

char * kwnames[] = {

5460

(char *) "self",(char *) "style",(char *) "back", NULL

5461

};

5462

5463

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

5464

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

5465

if (!SWIG_IsOK(res1)) {

5466

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

5467

}

5468

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5469

ecode2 = SWIG_AsVal_int(obj1, &val2);

5470

if (!SWIG_IsOK(ecode2)) {

5471

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

5472

}

5473

arg2 = static_cast< int >(val2);

5474

{

5475

arg3 = &temp3;

5476

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

5477

}

5478

{

5479

PyThreadState* __tstate = wxPyBeginAllowThreads();

5480

(arg1)->StyleSetBackground(arg2,(wxColour const &)*arg3);

5481

wxPyEndAllowThreads(__tstate);

5482

if (PyErr_Occurred()) SWIG_fail;

5483

}

5484

resultobj = SWIG_Py_Void();

5485

return resultobj;

5486

fail:

5487

return NULL;

5488

}

5489

5490

5491

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

5492

PyObject *resultobj = 0;

5493

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5494

int arg2 ;

5495

bool arg3 ;

5496

void *argp1 = 0 ;

5497

int res1 = 0 ;

5498

int val2 ;

5499

int ecode2 = 0 ;

5500

bool val3 ;

5501

int ecode3 = 0 ;

5502

PyObject * obj0 = 0 ;

5503

PyObject * obj1 = 0 ;

5504

PyObject * obj2 = 0 ;

5505

char * kwnames[] = {

5506

(char *) "self",(char *) "style",(char *) "bold", NULL

5507

};

5508

5509

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

5510

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

5511

if (!SWIG_IsOK(res1)) {

5512

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

5513

}

5514

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5515

ecode2 = SWIG_AsVal_int(obj1, &val2);

5516

if (!SWIG_IsOK(ecode2)) {

5517

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

5518

}

5519

arg2 = static_cast< int >(val2);

5520

ecode3 = SWIG_AsVal_bool(obj2, &val3);

5521

if (!SWIG_IsOK(ecode3)) {

5522

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

5523

}

5524

arg3 = static_cast< bool >(val3);

5525

{

5526

PyThreadState* __tstate = wxPyBeginAllowThreads();

5527

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

5528

wxPyEndAllowThreads(__tstate);

5529

if (PyErr_Occurred()) SWIG_fail;

5530

}

5531

resultobj = SWIG_Py_Void();

5532

return resultobj;

5533

fail:

5534

return NULL;

5535

}

5536

5537

5538

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

5539

PyObject *resultobj = 0;

5540

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5541

int arg2 ;

5542

bool arg3 ;

5543

void *argp1 = 0 ;

5544

int res1 = 0 ;

5545

int val2 ;

5546

int ecode2 = 0 ;

5547

bool val3 ;

5548

int ecode3 = 0 ;

5549

PyObject * obj0 = 0 ;

5550

PyObject * obj1 = 0 ;

5551

PyObject * obj2 = 0 ;

5552

char * kwnames[] = {

5553

(char *) "self",(char *) "style",(char *) "italic", NULL

5554

};

5555

5556

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

5557

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

5558

if (!SWIG_IsOK(res1)) {

5559

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

5560

}

5561

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5562

ecode2 = SWIG_AsVal_int(obj1, &val2);

5563

if (!SWIG_IsOK(ecode2)) {

5564

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

5565

}

5566

arg2 = static_cast< int >(val2);

5567

ecode3 = SWIG_AsVal_bool(obj2, &val3);

5568

if (!SWIG_IsOK(ecode3)) {

5569

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

5570

}

5571

arg3 = static_cast< bool >(val3);

5572

{

5573

PyThreadState* __tstate = wxPyBeginAllowThreads();

5574

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

5575

wxPyEndAllowThreads(__tstate);

5576

if (PyErr_Occurred()) SWIG_fail;

5577

}

5578

resultobj = SWIG_Py_Void();

5579

return resultobj;

5580

fail:

5581

return NULL;

5582

}

5583

5584

5585

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

5586

PyObject *resultobj = 0;

5587

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5588

int arg2 ;

5589

int arg3 ;

5590

void *argp1 = 0 ;

5591

int res1 = 0 ;

5592

int val2 ;

5593

int ecode2 = 0 ;

5594

int val3 ;

5595

int ecode3 = 0 ;

5596

PyObject * obj0 = 0 ;

5597

PyObject * obj1 = 0 ;

5598

PyObject * obj2 = 0 ;

5599

char * kwnames[] = {

5600

(char *) "self",(char *) "style",(char *) "sizePoints", NULL

5601

};

5602

5603

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

5604

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

5605

if (!SWIG_IsOK(res1)) {

5606

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

5607

}

5608

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5609

ecode2 = SWIG_AsVal_int(obj1, &val2);

5610

if (!SWIG_IsOK(ecode2)) {

5611

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

5612

}

5613

arg2 = static_cast< int >(val2);

5614

ecode3 = SWIG_AsVal_int(obj2, &val3);

5615

if (!SWIG_IsOK(ecode3)) {

5616

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

5617

}

5618

arg3 = static_cast< int >(val3);

5619

{

5620

PyThreadState* __tstate = wxPyBeginAllowThreads();

5621

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

5622

wxPyEndAllowThreads(__tstate);

5623

if (PyErr_Occurred()) SWIG_fail;

5624

}

5625

resultobj = SWIG_Py_Void();

5626

return resultobj;

5627

fail:

5628

return NULL;

5629

}

5630

5631

5632

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

5633

PyObject *resultobj = 0;

5634

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5635

int arg2 ;

5636

wxString *arg3 = 0 ;

5637

void *argp1 = 0 ;

5638

int res1 = 0 ;

5639

int val2 ;

5640

int ecode2 = 0 ;

5641

bool temp3 = false ;

5642

PyObject * obj0 = 0 ;

5643

PyObject * obj1 = 0 ;

5644

PyObject * obj2 = 0 ;

5645

char * kwnames[] = {

5646

(char *) "self",(char *) "style",(char *) "fontName", NULL

5647

};

5648

5649

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

5650

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

5651

if (!SWIG_IsOK(res1)) {

5652

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

5653

}

5654

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5655

ecode2 = SWIG_AsVal_int(obj1, &val2);

5656

if (!SWIG_IsOK(ecode2)) {

5657

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

5658

}

5659

arg2 = static_cast< int >(val2);

5660

{

5661

arg3 = wxString_in_helper(obj2);

5662

if (arg3 == NULL) SWIG_fail;

5663

temp3 = true;

5664

}

5665

{

5666

PyThreadState* __tstate = wxPyBeginAllowThreads();

5667

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

5668

wxPyEndAllowThreads(__tstate);

5669

if (PyErr_Occurred()) SWIG_fail;

5670

}

5671

resultobj = SWIG_Py_Void();

5672

{

5673

if (temp3)

5674

delete arg3;

5675

}

5676

return resultobj;

5677

fail:

5678

{

5679

if (temp3)

5680

delete arg3;

5681

}

5682

return NULL;

5683

}

5684

5685

5686

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

5687

PyObject *resultobj = 0;

5688

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5689

int arg2 ;

5690

bool arg3 ;

5691

void *argp1 = 0 ;

5692

int res1 = 0 ;

5693

int val2 ;

5694

int ecode2 = 0 ;

5695

bool val3 ;

5696

int ecode3 = 0 ;

5697

PyObject * obj0 = 0 ;

5698

PyObject * obj1 = 0 ;

5699

PyObject * obj2 = 0 ;

5700

char * kwnames[] = {

5701

(char *) "self",(char *) "style",(char *) "filled", NULL

5702

};

5703

5704

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

5705

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

5706

if (!SWIG_IsOK(res1)) {

5707

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

5708

}

5709

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5710

ecode2 = SWIG_AsVal_int(obj1, &val2);

5711

if (!SWIG_IsOK(ecode2)) {

5712

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

5713

}

5714

arg2 = static_cast< int >(val2);

5715

ecode3 = SWIG_AsVal_bool(obj2, &val3);

5716

if (!SWIG_IsOK(ecode3)) {

5717

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

5718

}

5719

arg3 = static_cast< bool >(val3);

5720

{

5721

PyThreadState* __tstate = wxPyBeginAllowThreads();

5722

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

5723

wxPyEndAllowThreads(__tstate);

5724

if (PyErr_Occurred()) SWIG_fail;

5725

}

5726

resultobj = SWIG_Py_Void();

5727

return resultobj;

5728

fail:

5729

return NULL;

5730

}

5731

5732

5733

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

5734

PyObject *resultobj = 0;

5735

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5736

void *argp1 = 0 ;

5737

int res1 = 0 ;

5738

PyObject *swig_obj[1] ;

5739

5740

if (!args) SWIG_fail;

5741

swig_obj[0] = args;

5742

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

5743

if (!SWIG_IsOK(res1)) {

5744

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

5745

}

5746

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5747

{

5748

PyThreadState* __tstate = wxPyBeginAllowThreads();

5749

(arg1)->StyleResetDefault();

5750

wxPyEndAllowThreads(__tstate);

5751

if (PyErr_Occurred()) SWIG_fail;

5752

}

5753

resultobj = SWIG_Py_Void();

5754

return resultobj;

5755

fail:

5756

return NULL;

5757

}

5758

5759

5760

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

5761

PyObject *resultobj = 0;

5762

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5763

int arg2 ;

5764

bool arg3 ;

5765

void *argp1 = 0 ;

5766

int res1 = 0 ;

5767

int val2 ;

5768

int ecode2 = 0 ;

5769

bool val3 ;

5770

int ecode3 = 0 ;

5771

PyObject * obj0 = 0 ;

5772

PyObject * obj1 = 0 ;

5773

PyObject * obj2 = 0 ;

5774

char * kwnames[] = {

5775

(char *) "self",(char *) "style",(char *) "underline", NULL

5776

};

5777

5778

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

5779

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

5780

if (!SWIG_IsOK(res1)) {

5781

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

5782

}

5783

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5784

ecode2 = SWIG_AsVal_int(obj1, &val2);

5785

if (!SWIG_IsOK(ecode2)) {

5786

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

5787

}

5788

arg2 = static_cast< int >(val2);

5789

ecode3 = SWIG_AsVal_bool(obj2, &val3);

5790

if (!SWIG_IsOK(ecode3)) {

5791

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

5792

}

5793

arg3 = static_cast< bool >(val3);

5794

{

5795

PyThreadState* __tstate = wxPyBeginAllowThreads();

5796

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

5797

wxPyEndAllowThreads(__tstate);

5798

if (PyErr_Occurred()) SWIG_fail;

5799

}

5800

resultobj = SWIG_Py_Void();

5801

return resultobj;

5802

fail:

5803

return NULL;

5804

}

5805

5806

5807

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

5808

PyObject *resultobj = 0;

5809

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5810

int arg2 ;

5811

int arg3 ;

5812

void *argp1 = 0 ;

5813

int res1 = 0 ;

5814

int val2 ;

5815

int ecode2 = 0 ;

5816

int val3 ;

5817

int ecode3 = 0 ;

5818

PyObject * obj0 = 0 ;

5819

PyObject * obj1 = 0 ;

5820

PyObject * obj2 = 0 ;

5821

char * kwnames[] = {

5822

(char *) "self",(char *) "style",(char *) "caseForce", NULL

5823

};

5824

5825

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

5826

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

5827

if (!SWIG_IsOK(res1)) {

5828

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

5829

}

5830

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5831

ecode2 = SWIG_AsVal_int(obj1, &val2);

5832

if (!SWIG_IsOK(ecode2)) {

5833

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

5834

}

5835

arg2 = static_cast< int >(val2);

5836

ecode3 = SWIG_AsVal_int(obj2, &val3);

5837

if (!SWIG_IsOK(ecode3)) {

5838

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

5839

}

5840

arg3 = static_cast< int >(val3);

5841

{

5842

PyThreadState* __tstate = wxPyBeginAllowThreads();

5843

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

5844

wxPyEndAllowThreads(__tstate);

5845

if (PyErr_Occurred()) SWIG_fail;

5846

}

5847

resultobj = SWIG_Py_Void();

5848

return resultobj;

5849

fail:

5850

return NULL;

5851

}

5852

5853

5854

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

5855

PyObject *resultobj = 0;

5856

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5857

int arg2 ;

5858

bool arg3 ;

5859

void *argp1 = 0 ;

5860

int res1 = 0 ;

5861

int val2 ;

5862

int ecode2 = 0 ;

5863

bool val3 ;

5864

int ecode3 = 0 ;

5865

PyObject * obj0 = 0 ;

5866

PyObject * obj1 = 0 ;

5867

PyObject * obj2 = 0 ;

5868

char * kwnames[] = {

5869

(char *) "self",(char *) "style",(char *) "hotspot", NULL

5870

};

5871

5872

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

5873

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

5874

if (!SWIG_IsOK(res1)) {

5875

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

5876

}

5877

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5878

ecode2 = SWIG_AsVal_int(obj1, &val2);

5879

if (!SWIG_IsOK(ecode2)) {

5880

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

5881

}

5882

arg2 = static_cast< int >(val2);

5883

ecode3 = SWIG_AsVal_bool(obj2, &val3);

5884

if (!SWIG_IsOK(ecode3)) {

5885

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

5886

}

5887

arg3 = static_cast< bool >(val3);

5888

{

5889

PyThreadState* __tstate = wxPyBeginAllowThreads();

5890

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

5891

wxPyEndAllowThreads(__tstate);

5892

if (PyErr_Occurred()) SWIG_fail;

5893

}

5894

resultobj = SWIG_Py_Void();

5895

return resultobj;

5896

fail:

5897

return NULL;

5898

}

5899

5900

5901

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

5902

PyObject *resultobj = 0;

5903

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5904

bool arg2 ;

5905

wxColour *arg3 = 0 ;

5906

void *argp1 = 0 ;

5907

int res1 = 0 ;

5908

bool val2 ;

5909

int ecode2 = 0 ;

5910

wxColour temp3 ;

5911

PyObject * obj0 = 0 ;

5912

PyObject * obj1 = 0 ;

5913

PyObject * obj2 = 0 ;

5914

char * kwnames[] = {

5915

(char *) "self",(char *) "useSetting",(char *) "fore", NULL

5916

};

5917

5918

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

5919

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

5920

if (!SWIG_IsOK(res1)) {

5921

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

5922

}

5923

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5924

ecode2 = SWIG_AsVal_bool(obj1, &val2);

5925

if (!SWIG_IsOK(ecode2)) {

5926

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

5927

}

5928

arg2 = static_cast< bool >(val2);

5929

{

5930

arg3 = &temp3;

5931

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

5932

}

5933

{

5934

PyThreadState* __tstate = wxPyBeginAllowThreads();

5935

(arg1)->SetSelForeground(arg2,(wxColour const &)*arg3);

5936

wxPyEndAllowThreads(__tstate);

5937

if (PyErr_Occurred()) SWIG_fail;

5938

}

5939

resultobj = SWIG_Py_Void();

5940

return resultobj;

5941

fail:

5942

return NULL;

5943

}

5944

5945

5946

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

5947

PyObject *resultobj = 0;

5948

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5949

bool arg2 ;

5950

wxColour *arg3 = 0 ;

5951

void *argp1 = 0 ;

5952

int res1 = 0 ;

5953

bool val2 ;

5954

int ecode2 = 0 ;

5955

wxColour temp3 ;

5956

PyObject * obj0 = 0 ;

5957

PyObject * obj1 = 0 ;

5958

PyObject * obj2 = 0 ;

5959

char * kwnames[] = {

5960

(char *) "self",(char *) "useSetting",(char *) "back", NULL

5961

};

5962

5963

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

5964

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

5965

if (!SWIG_IsOK(res1)) {

5966

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

5967

}

5968

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

5969

ecode2 = SWIG_AsVal_bool(obj1, &val2);

5970

if (!SWIG_IsOK(ecode2)) {

5971

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

5972

}

5973

arg2 = static_cast< bool >(val2);

5974

{

5975

arg3 = &temp3;

5976

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

5977

}

5978

{

5979

PyThreadState* __tstate = wxPyBeginAllowThreads();

5980

(arg1)->SetSelBackground(arg2,(wxColour const &)*arg3);

5981

wxPyEndAllowThreads(__tstate);

5982

if (PyErr_Occurred()) SWIG_fail;

5983

}

5984

resultobj = SWIG_Py_Void();

5985

return resultobj;

5986

fail:

5987

return NULL;

5988

}

5989

5990

5991

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

5992

PyObject *resultobj = 0;

5993

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

5994

int result;

5995

void *argp1 = 0 ;

5996

int res1 = 0 ;

5997

PyObject *swig_obj[1] ;

5998

5999

if (!args) SWIG_fail;

6000

swig_obj[0] = args;

6001

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

6002

if (!SWIG_IsOK(res1)) {

6003

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

6004

}

6005

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6006

{

6007

PyThreadState* __tstate = wxPyBeginAllowThreads();

6008

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

6009

wxPyEndAllowThreads(__tstate);

6010

if (PyErr_Occurred()) SWIG_fail;

6011

}

6012

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

6013

return resultobj;

6014

fail:

6015

return NULL;

6016

}

6017

6018

6019

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

6020

PyObject *resultobj = 0;

6021

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6022

int arg2 ;

6023

void *argp1 = 0 ;

6024

int res1 = 0 ;

6025

int val2 ;

6026

int ecode2 = 0 ;

6027

PyObject * obj0 = 0 ;

6028

PyObject * obj1 = 0 ;

6029

char * kwnames[] = {

6030

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

6031

};

6032

6033

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

6034

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

6035

if (!SWIG_IsOK(res1)) {

6036

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

6037

}

6038

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6039

ecode2 = SWIG_AsVal_int(obj1, &val2);

6040

if (!SWIG_IsOK(ecode2)) {

6041

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

6042

}

6043

arg2 = static_cast< int >(val2);

6044

{

6045

PyThreadState* __tstate = wxPyBeginAllowThreads();

6046

(arg1)->SetSelAlpha(arg2);

6047

wxPyEndAllowThreads(__tstate);

6048

if (PyErr_Occurred()) SWIG_fail;

6049

}

6050

resultobj = SWIG_Py_Void();

6051

return resultobj;

6052

fail:

6053

return NULL;

6054

}

6055

6056

6057

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

6058

PyObject *resultobj = 0;

6059

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6060

wxColour *arg2 = 0 ;

6061

void *argp1 = 0 ;

6062

int res1 = 0 ;

6063

wxColour temp2 ;

6064

PyObject * obj0 = 0 ;

6065

PyObject * obj1 = 0 ;

6066

char * kwnames[] = {

6067

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

6068

};

6069

6070

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

6071

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

6072

if (!SWIG_IsOK(res1)) {

6073

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

6074

}

6075

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6076

{

6077

arg2 = &temp2;

6078

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

6079

}

6080

{

6081

PyThreadState* __tstate = wxPyBeginAllowThreads();

6082

(arg1)->SetCaretForeground((wxColour const &)*arg2);

6083

wxPyEndAllowThreads(__tstate);

6084

if (PyErr_Occurred()) SWIG_fail;

6085

}

6086

resultobj = SWIG_Py_Void();

6087

return resultobj;

6088

fail:

6089

return NULL;

6090

}

6091

6092

6093

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

6094

PyObject *resultobj = 0;

6095

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6096

int arg2 ;

6097

int arg3 ;

6098

int arg4 ;

6099

void *argp1 = 0 ;

6100

int res1 = 0 ;

6101

int val2 ;

6102

int ecode2 = 0 ;

6103

int val3 ;

6104

int ecode3 = 0 ;

6105

int val4 ;

6106

int ecode4 = 0 ;

6107

PyObject * obj0 = 0 ;

6108

PyObject * obj1 = 0 ;

6109

PyObject * obj2 = 0 ;

6110

PyObject * obj3 = 0 ;

6111

char * kwnames[] = {

6112

(char *) "self",(char *) "key",(char *) "modifiers",(char *) "cmd", NULL

6113

};

6114

6115

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

6116

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

6117

if (!SWIG_IsOK(res1)) {

6118

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

6119

}

6120

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6121

ecode2 = SWIG_AsVal_int(obj1, &val2);

6122

if (!SWIG_IsOK(ecode2)) {

6123

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

6124

}

6125

arg2 = static_cast< int >(val2);

6126

ecode3 = SWIG_AsVal_int(obj2, &val3);

6127

if (!SWIG_IsOK(ecode3)) {

6128

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

6129

}

6130

arg3 = static_cast< int >(val3);

6131

ecode4 = SWIG_AsVal_int(obj3, &val4);

6132

if (!SWIG_IsOK(ecode4)) {

6133

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

6134

}

6135

arg4 = static_cast< int >(val4);

6136

{

6137

PyThreadState* __tstate = wxPyBeginAllowThreads();

6138

(arg1)->CmdKeyAssign(arg2,arg3,arg4);

6139

wxPyEndAllowThreads(__tstate);

6140

if (PyErr_Occurred()) SWIG_fail;

6141

}

6142

resultobj = SWIG_Py_Void();

6143

return resultobj;

6144

fail:

6145

return NULL;

6146

}

6147

6148

6149

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

6150

PyObject *resultobj = 0;

6151

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6152

int arg2 ;

6153

int arg3 ;

6154

void *argp1 = 0 ;

6155

int res1 = 0 ;

6156

int val2 ;

6157

int ecode2 = 0 ;

6158

int val3 ;

6159

int ecode3 = 0 ;

6160

PyObject * obj0 = 0 ;

6161

PyObject * obj1 = 0 ;

6162

PyObject * obj2 = 0 ;

6163

char * kwnames[] = {

6164

(char *) "self",(char *) "key",(char *) "modifiers", NULL

6165

};

6166

6167

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

6168

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

6169

if (!SWIG_IsOK(res1)) {

6170

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

6171

}

6172

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6173

ecode2 = SWIG_AsVal_int(obj1, &val2);

6174

if (!SWIG_IsOK(ecode2)) {

6175

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

6176

}

6177

arg2 = static_cast< int >(val2);

6178

ecode3 = SWIG_AsVal_int(obj2, &val3);

6179

if (!SWIG_IsOK(ecode3)) {

6180

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

6181

}

6182

arg3 = static_cast< int >(val3);

6183

{

6184

PyThreadState* __tstate = wxPyBeginAllowThreads();

6185

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

6186

wxPyEndAllowThreads(__tstate);

6187

if (PyErr_Occurred()) SWIG_fail;

6188

}

6189

resultobj = SWIG_Py_Void();

6190

return resultobj;

6191

fail:

6192

return NULL;

6193

}

6194

6195

6196

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

6197

PyObject *resultobj = 0;

6198

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6199

void *argp1 = 0 ;

6200

int res1 = 0 ;

6201

PyObject *swig_obj[1] ;

6202

6203

if (!args) SWIG_fail;

6204

swig_obj[0] = args;

6205

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

6206

if (!SWIG_IsOK(res1)) {

6207

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

6208

}

6209

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6210

{

6211

PyThreadState* __tstate = wxPyBeginAllowThreads();

6212

(arg1)->CmdKeyClearAll();

6213

wxPyEndAllowThreads(__tstate);

6214

if (PyErr_Occurred()) SWIG_fail;

6215

}

6216

resultobj = SWIG_Py_Void();

6217

return resultobj;

6218

fail:

6219

return NULL;

6220

}

6221

6222

6223

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

6224

PyObject *resultobj = 0;

6225

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6226

int arg2 ;

6227

char *arg3 = (char *) 0 ;

6228

void *argp1 = 0 ;

6229

int res1 = 0 ;

6230

int val2 ;

6231

int ecode2 = 0 ;

6232

int res3 ;

6233

char *buf3 = 0 ;

6234

int alloc3 = 0 ;

6235

PyObject * obj0 = 0 ;

6236

PyObject * obj1 = 0 ;

6237

PyObject * obj2 = 0 ;

6238

char * kwnames[] = {

6239

(char *) "self",(char *) "length",(char *) "styleBytes", NULL

6240

};

6241

6242

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

6243

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

6244

if (!SWIG_IsOK(res1)) {

6245

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

6246

}

6247

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6248

ecode2 = SWIG_AsVal_int(obj1, &val2);

6249

if (!SWIG_IsOK(ecode2)) {

6250

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

6251

}

6252

arg2 = static_cast< int >(val2);

6253

res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);

6254

if (!SWIG_IsOK(res3)) {

6255

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StyledTextCtrl_SetStyleBytes" "', expected argument " "3"" of type '" "char *""'");

6256

}

6257

arg3 = buf3;

6258

{

6259

PyThreadState* __tstate = wxPyBeginAllowThreads();

6260

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

6261

wxPyEndAllowThreads(__tstate);

6262

if (PyErr_Occurred()) SWIG_fail;

6263

}

6264

resultobj = SWIG_Py_Void();

6265

if (alloc3 == SWIG_NEWOBJ) delete[] buf3;

6266

return resultobj;

6267

fail:

6268

if (alloc3 == SWIG_NEWOBJ) delete[] buf3;

6269

return NULL;

6270

}

6271

6272

6273

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

6274

PyObject *resultobj = 0;

6275

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6276

int arg2 ;

6277

bool arg3 ;

6278

void *argp1 = 0 ;

6279

int res1 = 0 ;

6280

int val2 ;

6281

int ecode2 = 0 ;

6282

bool val3 ;

6283

int ecode3 = 0 ;

6284

PyObject * obj0 = 0 ;

6285

PyObject * obj1 = 0 ;

6286

PyObject * obj2 = 0 ;

6287

char * kwnames[] = {

6288

(char *) "self",(char *) "style",(char *) "visible", NULL

6289

};

6290

6291

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

6292

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

6293

if (!SWIG_IsOK(res1)) {

6294

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

6295

}

6296

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6297

ecode2 = SWIG_AsVal_int(obj1, &val2);

6298

if (!SWIG_IsOK(ecode2)) {

6299

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

6300

}

6301

arg2 = static_cast< int >(val2);

6302

ecode3 = SWIG_AsVal_bool(obj2, &val3);

6303

if (!SWIG_IsOK(ecode3)) {

6304

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

6305

}

6306

arg3 = static_cast< bool >(val3);

6307

{

6308

PyThreadState* __tstate = wxPyBeginAllowThreads();

6309

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

6310

wxPyEndAllowThreads(__tstate);

6311

if (PyErr_Occurred()) SWIG_fail;

6312

}

6313

resultobj = SWIG_Py_Void();

6314

return resultobj;

6315

fail:

6316

return NULL;

6317

}

6318

6319

6320

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

6321

PyObject *resultobj = 0;

6322

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6323

int result;

6324

void *argp1 = 0 ;

6325

int res1 = 0 ;

6326

PyObject *swig_obj[1] ;

6327

6328

if (!args) SWIG_fail;

6329

swig_obj[0] = args;

6330

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

6331

if (!SWIG_IsOK(res1)) {

6332

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

6333

}

6334

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6335

{

6336

PyThreadState* __tstate = wxPyBeginAllowThreads();

6337

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

6338

wxPyEndAllowThreads(__tstate);

6339

if (PyErr_Occurred()) SWIG_fail;

6340

}

6341

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

6342

return resultobj;

6343

fail:

6344

return NULL;

6345

}

6346

6347

6348

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

6349

PyObject *resultobj = 0;

6350

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6351

int arg2 ;

6352

void *argp1 = 0 ;

6353

int res1 = 0 ;

6354

int val2 ;

6355

int ecode2 = 0 ;

6356

PyObject * obj0 = 0 ;

6357

PyObject * obj1 = 0 ;

6358

char * kwnames[] = {

6359

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

6360

};

6361

6362

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

6363

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

6364

if (!SWIG_IsOK(res1)) {

6365

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

6366

}

6367

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6368

ecode2 = SWIG_AsVal_int(obj1, &val2);

6369

if (!SWIG_IsOK(ecode2)) {

6370

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

6371

}

6372

arg2 = static_cast< int >(val2);

6373

{

6374

PyThreadState* __tstate = wxPyBeginAllowThreads();

6375

(arg1)->SetCaretPeriod(arg2);

6376

wxPyEndAllowThreads(__tstate);

6377

if (PyErr_Occurred()) SWIG_fail;

6378

}

6379

resultobj = SWIG_Py_Void();

6380

return resultobj;

6381

fail:

6382

return NULL;

6383

}

6384

6385

6386

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

6387

PyObject *resultobj = 0;

6388

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6389

wxString *arg2 = 0 ;

6390

void *argp1 = 0 ;

6391

int res1 = 0 ;

6392

bool temp2 = false ;

6393

PyObject * obj0 = 0 ;

6394

PyObject * obj1 = 0 ;

6395

char * kwnames[] = {

6396

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

6397

};

6398

6399

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

6400

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

6401

if (!SWIG_IsOK(res1)) {

6402

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

6403

}

6404

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6405

{

6406

arg2 = wxString_in_helper(obj1);

6407

if (arg2 == NULL) SWIG_fail;

6408

temp2 = true;

6409

}

6410

{

6411

PyThreadState* __tstate = wxPyBeginAllowThreads();

6412

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

6413

wxPyEndAllowThreads(__tstate);

6414

if (PyErr_Occurred()) SWIG_fail;

6415

}

6416

resultobj = SWIG_Py_Void();

6417

{

6418

if (temp2)

6419

delete arg2;

6420

}

6421

return resultobj;

6422

fail:

6423

{

6424

if (temp2)

6425

delete arg2;

6426

}

6427

return NULL;

6428

}

6429

6430

6431

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

6432

PyObject *resultobj = 0;

6433

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6434

void *argp1 = 0 ;

6435

int res1 = 0 ;

6436

PyObject *swig_obj[1] ;

6437

6438

if (!args) SWIG_fail;

6439

swig_obj[0] = args;

6440

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

6441

if (!SWIG_IsOK(res1)) {

6442

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

6443

}

6444

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6445

{

6446

PyThreadState* __tstate = wxPyBeginAllowThreads();

6447

(arg1)->BeginUndoAction();

6448

wxPyEndAllowThreads(__tstate);

6449

if (PyErr_Occurred()) SWIG_fail;

6450

}

6451

resultobj = SWIG_Py_Void();

6452

return resultobj;

6453

fail:

6454

return NULL;

6455

}

6456

6457

6458

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

6459

PyObject *resultobj = 0;

6460

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6461

void *argp1 = 0 ;

6462

int res1 = 0 ;

6463

PyObject *swig_obj[1] ;

6464

6465

if (!args) SWIG_fail;

6466

swig_obj[0] = args;

6467

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

6468

if (!SWIG_IsOK(res1)) {

6469

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

6470

}

6471

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6472

{

6473

PyThreadState* __tstate = wxPyBeginAllowThreads();

6474

(arg1)->EndUndoAction();

6475

wxPyEndAllowThreads(__tstate);

6476

if (PyErr_Occurred()) SWIG_fail;

6477

}

6478

resultobj = SWIG_Py_Void();

6479

return resultobj;

6480

fail:

6481

return NULL;

6482

}

6483

6484

6485

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

6486

PyObject *resultobj = 0;

6487

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6488

int arg2 ;

6489

int arg3 ;

6490

void *argp1 = 0 ;

6491

int res1 = 0 ;

6492

int val2 ;

6493

int ecode2 = 0 ;

6494

int val3 ;

6495

int ecode3 = 0 ;

6496

PyObject * obj0 = 0 ;

6497

PyObject * obj1 = 0 ;

6498

PyObject * obj2 = 0 ;

6499

char * kwnames[] = {

6500

(char *) "self",(char *) "indic",(char *) "style", NULL

6501

};

6502

6503

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

6504

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

6505

if (!SWIG_IsOK(res1)) {

6506

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

6507

}

6508

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6509

ecode2 = SWIG_AsVal_int(obj1, &val2);

6510

if (!SWIG_IsOK(ecode2)) {

6511

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

6512

}

6513

arg2 = static_cast< int >(val2);

6514

ecode3 = SWIG_AsVal_int(obj2, &val3);

6515

if (!SWIG_IsOK(ecode3)) {

6516

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

6517

}

6518

arg3 = static_cast< int >(val3);

6519

{

6520

PyThreadState* __tstate = wxPyBeginAllowThreads();

6521

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

6522

wxPyEndAllowThreads(__tstate);

6523

if (PyErr_Occurred()) SWIG_fail;

6524

}

6525

resultobj = SWIG_Py_Void();

6526

return resultobj;

6527

fail:

6528

return NULL;

6529

}

6530

6531

6532

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

6533

PyObject *resultobj = 0;

6534

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6535

int arg2 ;

6536

int result;

6537

void *argp1 = 0 ;

6538

int res1 = 0 ;

6539

int val2 ;

6540

int ecode2 = 0 ;

6541

PyObject * obj0 = 0 ;

6542

PyObject * obj1 = 0 ;

6543

char * kwnames[] = {

6544

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

6545

};

6546

6547

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

6548

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

6549

if (!SWIG_IsOK(res1)) {

6550

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

6551

}

6552

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6553

ecode2 = SWIG_AsVal_int(obj1, &val2);

6554

if (!SWIG_IsOK(ecode2)) {

6555

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

6556

}

6557

arg2 = static_cast< int >(val2);

6558

{

6559

PyThreadState* __tstate = wxPyBeginAllowThreads();

6560

result = (int)(arg1)->IndicatorGetStyle(arg2);

6561

wxPyEndAllowThreads(__tstate);

6562

if (PyErr_Occurred()) SWIG_fail;

6563

}

6564

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

6565

return resultobj;

6566

fail:

6567

return NULL;

6568

}

6569

6570

6571

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

6572

PyObject *resultobj = 0;

6573

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6574

int arg2 ;

6575

wxColour *arg3 = 0 ;

6576

void *argp1 = 0 ;

6577

int res1 = 0 ;

6578

int val2 ;

6579

int ecode2 = 0 ;

6580

wxColour temp3 ;

6581

PyObject * obj0 = 0 ;

6582

PyObject * obj1 = 0 ;

6583

PyObject * obj2 = 0 ;

6584

char * kwnames[] = {

6585

(char *) "self",(char *) "indic",(char *) "fore", NULL

6586

};

6587

6588

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

6589

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

6590

if (!SWIG_IsOK(res1)) {

6591

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

6592

}

6593

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6594

ecode2 = SWIG_AsVal_int(obj1, &val2);

6595

if (!SWIG_IsOK(ecode2)) {

6596

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

6597

}

6598

arg2 = static_cast< int >(val2);

6599

{

6600

arg3 = &temp3;

6601

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

6602

}

6603

{

6604

PyThreadState* __tstate = wxPyBeginAllowThreads();

6605

(arg1)->IndicatorSetForeground(arg2,(wxColour const &)*arg3);

6606

wxPyEndAllowThreads(__tstate);

6607

if (PyErr_Occurred()) SWIG_fail;

6608

}

6609

resultobj = SWIG_Py_Void();

6610

return resultobj;

6611

fail:

6612

return NULL;

6613

}

6614

6615

6616

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

6617

PyObject *resultobj = 0;

6618

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6619

int arg2 ;

6620

wxColour result;

6621

void *argp1 = 0 ;

6622

int res1 = 0 ;

6623

int val2 ;

6624

int ecode2 = 0 ;

6625

PyObject * obj0 = 0 ;

6626

PyObject * obj1 = 0 ;

6627

char * kwnames[] = {

6628

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

6629

};

6630

6631

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

6632

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

6633

if (!SWIG_IsOK(res1)) {

6634

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

6635

}

6636

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6637

ecode2 = SWIG_AsVal_int(obj1, &val2);

6638

if (!SWIG_IsOK(ecode2)) {

6639

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

6640

}

6641

arg2 = static_cast< int >(val2);

6642

{

6643

PyThreadState* __tstate = wxPyBeginAllowThreads();

6644

result = (arg1)->IndicatorGetForeground(arg2);

6645

wxPyEndAllowThreads(__tstate);

6646

if (PyErr_Occurred()) SWIG_fail;

6647

}

6648

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

6649

return resultobj;

6650

fail:

6651

return NULL;

6652

}

6653

6654

6655

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

6656

PyObject *resultobj = 0;

6657

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6658

bool arg2 ;

6659

wxColour *arg3 = 0 ;

6660

void *argp1 = 0 ;

6661

int res1 = 0 ;

6662

bool val2 ;

6663

int ecode2 = 0 ;

6664

wxColour temp3 ;

6665

PyObject * obj0 = 0 ;

6666

PyObject * obj1 = 0 ;

6667

PyObject * obj2 = 0 ;

6668

char * kwnames[] = {

6669

(char *) "self",(char *) "useSetting",(char *) "fore", NULL

6670

};

6671

6672

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

6673

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

6674

if (!SWIG_IsOK(res1)) {

6675

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

6676

}

6677

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6678

ecode2 = SWIG_AsVal_bool(obj1, &val2);

6679

if (!SWIG_IsOK(ecode2)) {

6680

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

6681

}

6682

arg2 = static_cast< bool >(val2);

6683

{

6684

arg3 = &temp3;

6685

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

6686

}

6687

{

6688

PyThreadState* __tstate = wxPyBeginAllowThreads();

6689

(arg1)->SetWhitespaceForeground(arg2,(wxColour const &)*arg3);

6690

wxPyEndAllowThreads(__tstate);

6691

if (PyErr_Occurred()) SWIG_fail;

6692

}

6693

resultobj = SWIG_Py_Void();

6694

return resultobj;

6695

fail:

6696

return NULL;

6697

}

6698

6699

6700

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

6701

PyObject *resultobj = 0;

6702

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6703

bool arg2 ;

6704

wxColour *arg3 = 0 ;

6705

void *argp1 = 0 ;

6706

int res1 = 0 ;

6707

bool val2 ;

6708

int ecode2 = 0 ;

6709

wxColour temp3 ;

6710

PyObject * obj0 = 0 ;

6711

PyObject * obj1 = 0 ;

6712

PyObject * obj2 = 0 ;

6713

char * kwnames[] = {

6714

(char *) "self",(char *) "useSetting",(char *) "back", NULL

6715

};

6716

6717

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

6718

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

6719

if (!SWIG_IsOK(res1)) {

6720

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

6721

}

6722

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6723

ecode2 = SWIG_AsVal_bool(obj1, &val2);

6724

if (!SWIG_IsOK(ecode2)) {

6725

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

6726

}

6727

arg2 = static_cast< bool >(val2);

6728

{

6729

arg3 = &temp3;

6730

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

6731

}

6732

{

6733

PyThreadState* __tstate = wxPyBeginAllowThreads();

6734

(arg1)->SetWhitespaceBackground(arg2,(wxColour const &)*arg3);

6735

wxPyEndAllowThreads(__tstate);

6736

if (PyErr_Occurred()) SWIG_fail;

6737

}

6738

resultobj = SWIG_Py_Void();

6739

return resultobj;

6740

fail:

6741

return NULL;

6742

}

6743

6744

6745

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

6746

PyObject *resultobj = 0;

6747

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6748

int arg2 ;

6749

void *argp1 = 0 ;

6750

int res1 = 0 ;

6751

int val2 ;

6752

int ecode2 = 0 ;

6753

PyObject * obj0 = 0 ;

6754

PyObject * obj1 = 0 ;

6755

char * kwnames[] = {

6756

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

6757

};

6758

6759

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

6760

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

6761

if (!SWIG_IsOK(res1)) {

6762

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

6763

}

6764

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6765

ecode2 = SWIG_AsVal_int(obj1, &val2);

6766

if (!SWIG_IsOK(ecode2)) {

6767

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

6768

}

6769

arg2 = static_cast< int >(val2);

6770

{

6771

PyThreadState* __tstate = wxPyBeginAllowThreads();

6772

(arg1)->SetStyleBits(arg2);

6773

wxPyEndAllowThreads(__tstate);

6774

if (PyErr_Occurred()) SWIG_fail;

6775

}

6776

resultobj = SWIG_Py_Void();

6777

return resultobj;

6778

fail:

6779

return NULL;

6780

}

6781

6782

6783

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

6784

PyObject *resultobj = 0;

6785

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6786

int result;

6787

void *argp1 = 0 ;

6788

int res1 = 0 ;

6789

PyObject *swig_obj[1] ;

6790

6791

if (!args) SWIG_fail;

6792

swig_obj[0] = args;

6793

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

6794

if (!SWIG_IsOK(res1)) {

6795

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

6796

}

6797

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6798

{

6799

PyThreadState* __tstate = wxPyBeginAllowThreads();

6800

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

6801

wxPyEndAllowThreads(__tstate);

6802

if (PyErr_Occurred()) SWIG_fail;

6803

}

6804

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

6805

return resultobj;

6806

fail:

6807

return NULL;

6808

}

6809

6810

6811

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

6812

PyObject *resultobj = 0;

6813

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6814

int arg2 ;

6815

int arg3 ;

6816

void *argp1 = 0 ;

6817

int res1 = 0 ;

6818

int val2 ;

6819

int ecode2 = 0 ;

6820

int val3 ;

6821

int ecode3 = 0 ;

6822

PyObject * obj0 = 0 ;

6823

PyObject * obj1 = 0 ;

6824

PyObject * obj2 = 0 ;

6825

char * kwnames[] = {

6826

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

6827

};

6828

6829

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

6830

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

6831

if (!SWIG_IsOK(res1)) {

6832

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

6833

}

6834

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6835

ecode2 = SWIG_AsVal_int(obj1, &val2);

6836

if (!SWIG_IsOK(ecode2)) {

6837

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

6838

}

6839

arg2 = static_cast< int >(val2);

6840

ecode3 = SWIG_AsVal_int(obj2, &val3);

6841

if (!SWIG_IsOK(ecode3)) {

6842

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

6843

}

6844

arg3 = static_cast< int >(val3);

6845

{

6846

PyThreadState* __tstate = wxPyBeginAllowThreads();

6847

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

6848

wxPyEndAllowThreads(__tstate);

6849

if (PyErr_Occurred()) SWIG_fail;

6850

}

6851

resultobj = SWIG_Py_Void();

6852

return resultobj;

6853

fail:

6854

return NULL;

6855

}

6856

6857

6858

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

6859

PyObject *resultobj = 0;

6860

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6861

int arg2 ;

6862

int result;

6863

void *argp1 = 0 ;

6864

int res1 = 0 ;

6865

int val2 ;

6866

int ecode2 = 0 ;

6867

PyObject * obj0 = 0 ;

6868

PyObject * obj1 = 0 ;

6869

char * kwnames[] = {

6870

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

6871

};

6872

6873

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

6874

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

6875

if (!SWIG_IsOK(res1)) {

6876

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

6877

}

6878

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6879

ecode2 = SWIG_AsVal_int(obj1, &val2);

6880

if (!SWIG_IsOK(ecode2)) {

6881

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

6882

}

6883

arg2 = static_cast< int >(val2);

6884

{

6885

PyThreadState* __tstate = wxPyBeginAllowThreads();

6886

result = (int)(arg1)->GetLineState(arg2);

6887

wxPyEndAllowThreads(__tstate);

6888

if (PyErr_Occurred()) SWIG_fail;

6889

}

6890

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

6891

return resultobj;

6892

fail:

6893

return NULL;

6894

}

6895

6896

6897

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

6898

PyObject *resultobj = 0;

6899

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6900

int result;

6901

void *argp1 = 0 ;

6902

int res1 = 0 ;

6903

PyObject *swig_obj[1] ;

6904

6905

if (!args) SWIG_fail;

6906

swig_obj[0] = args;

6907

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

6908

if (!SWIG_IsOK(res1)) {

6909

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

6910

}

6911

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6912

{

6913

PyThreadState* __tstate = wxPyBeginAllowThreads();

6914

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

6915

wxPyEndAllowThreads(__tstate);

6916

if (PyErr_Occurred()) SWIG_fail;

6917

}

6918

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

6919

return resultobj;

6920

fail:

6921

return NULL;

6922

}

6923

6924

6925

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

6926

PyObject *resultobj = 0;

6927

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6928

bool result;

6929

void *argp1 = 0 ;

6930

int res1 = 0 ;

6931

PyObject *swig_obj[1] ;

6932

6933

if (!args) SWIG_fail;

6934

swig_obj[0] = args;

6935

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

6936

if (!SWIG_IsOK(res1)) {

6937

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

6938

}

6939

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6940

{

6941

PyThreadState* __tstate = wxPyBeginAllowThreads();

6942

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

6943

wxPyEndAllowThreads(__tstate);

6944

if (PyErr_Occurred()) SWIG_fail;

6945

}

6946

{

6947

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

6948

}

6949

return resultobj;

6950

fail:

6951

return NULL;

6952

}

6953

6954

6955

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

6956

PyObject *resultobj = 0;

6957

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6958

bool arg2 ;

6959

void *argp1 = 0 ;

6960

int res1 = 0 ;

6961

bool val2 ;

6962

int ecode2 = 0 ;

6963

PyObject * obj0 = 0 ;

6964

PyObject * obj1 = 0 ;

6965

char * kwnames[] = {

6966

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

6967

};

6968

6969

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

6970

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

6971

if (!SWIG_IsOK(res1)) {

6972

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

6973

}

6974

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

6975

ecode2 = SWIG_AsVal_bool(obj1, &val2);

6976

if (!SWIG_IsOK(ecode2)) {

6977

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

6978

}

6979

arg2 = static_cast< bool >(val2);

6980

{

6981

PyThreadState* __tstate = wxPyBeginAllowThreads();

6982

(arg1)->SetCaretLineVisible(arg2);

6983

wxPyEndAllowThreads(__tstate);

6984

if (PyErr_Occurred()) SWIG_fail;

6985

}

6986

resultobj = SWIG_Py_Void();

6987

return resultobj;

6988

fail:

6989

return NULL;

6990

}

6991

6992

6993

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

6994

PyObject *resultobj = 0;

6995

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

6996

wxColour result;

6997

void *argp1 = 0 ;

6998

int res1 = 0 ;

6999

PyObject *swig_obj[1] ;

7000

7001

if (!args) SWIG_fail;

7002

swig_obj[0] = args;

7003

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

7004

if (!SWIG_IsOK(res1)) {

7005

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

7006

}

7007

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7008

{

7009

PyThreadState* __tstate = wxPyBeginAllowThreads();

7010

result = (arg1)->GetCaretLineBackground();

7011

wxPyEndAllowThreads(__tstate);

7012

if (PyErr_Occurred()) SWIG_fail;

7013

}

7014

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

7015

return resultobj;

7016

fail:

7017

return NULL;

7018

}

7019

7020

7021

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

7022

PyObject *resultobj = 0;

7023

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7024

wxColour *arg2 = 0 ;

7025

void *argp1 = 0 ;

7026

int res1 = 0 ;

7027

wxColour temp2 ;

7028

PyObject * obj0 = 0 ;

7029

PyObject * obj1 = 0 ;

7030

char * kwnames[] = {

7031

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

7032

};

7033

7034

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

7035

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

7036

if (!SWIG_IsOK(res1)) {

7037

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

7038

}

7039

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7040

{

7041

arg2 = &temp2;

7042

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

7043

}

7044

{

7045

PyThreadState* __tstate = wxPyBeginAllowThreads();

7046

(arg1)->SetCaretLineBackground((wxColour const &)*arg2);

7047

wxPyEndAllowThreads(__tstate);

7048

if (PyErr_Occurred()) SWIG_fail;

7049

}

7050

resultobj = SWIG_Py_Void();

7051

return resultobj;

7052

fail:

7053

return NULL;

7054

}

7055

7056

7057

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

7058

PyObject *resultobj = 0;

7059

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7060

int arg2 ;

7061

bool arg3 ;

7062

void *argp1 = 0 ;

7063

int res1 = 0 ;

7064

int val2 ;

7065

int ecode2 = 0 ;

7066

bool val3 ;

7067

int ecode3 = 0 ;

7068

PyObject * obj0 = 0 ;

7069

PyObject * obj1 = 0 ;

7070

PyObject * obj2 = 0 ;

7071

char * kwnames[] = {

7072

(char *) "self",(char *) "style",(char *) "changeable", NULL

7073

};

7074

7075

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

7076

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

7077

if (!SWIG_IsOK(res1)) {

7078

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

7079

}

7080

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7081

ecode2 = SWIG_AsVal_int(obj1, &val2);

7082

if (!SWIG_IsOK(ecode2)) {

7083

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

7084

}

7085

arg2 = static_cast< int >(val2);

7086

ecode3 = SWIG_AsVal_bool(obj2, &val3);

7087

if (!SWIG_IsOK(ecode3)) {

7088

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

7089

}

7090

arg3 = static_cast< bool >(val3);

7091

{

7092

PyThreadState* __tstate = wxPyBeginAllowThreads();

7093

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

7094

wxPyEndAllowThreads(__tstate);

7095

if (PyErr_Occurred()) SWIG_fail;

7096

}

7097

resultobj = SWIG_Py_Void();

7098

return resultobj;

7099

fail:

7100

return NULL;

7101

}

7102

7103

7104

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

7105

PyObject *resultobj = 0;

7106

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7107

int arg2 ;

7108

wxString *arg3 = 0 ;

7109

void *argp1 = 0 ;

7110

int res1 = 0 ;

7111

int val2 ;

7112

int ecode2 = 0 ;

7113

bool temp3 = false ;

7114

PyObject * obj0 = 0 ;

7115

PyObject * obj1 = 0 ;

7116

PyObject * obj2 = 0 ;

7117

char * kwnames[] = {

7118

(char *) "self",(char *) "lenEntered",(char *) "itemList", NULL

7119

};

7120

7121

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

7122

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

7123

if (!SWIG_IsOK(res1)) {

7124

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

7125

}

7126

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7127

ecode2 = SWIG_AsVal_int(obj1, &val2);

7128

if (!SWIG_IsOK(ecode2)) {

7129

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

7130

}

7131

arg2 = static_cast< int >(val2);

7132

{

7133

arg3 = wxString_in_helper(obj2);

7134

if (arg3 == NULL) SWIG_fail;

7135

temp3 = true;

7136

}

7137

{

7138

PyThreadState* __tstate = wxPyBeginAllowThreads();

7139

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

7140

wxPyEndAllowThreads(__tstate);

7141

if (PyErr_Occurred()) SWIG_fail;

7142

}

7143

resultobj = SWIG_Py_Void();

7144

{

7145

if (temp3)

7146

delete arg3;

7147

}

7148

return resultobj;

7149

fail:

7150

{

7151

if (temp3)

7152

delete arg3;

7153

}

7154

return NULL;

7155

}

7156

7157

7158

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

7159

PyObject *resultobj = 0;

7160

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7161

void *argp1 = 0 ;

7162

int res1 = 0 ;

7163

PyObject *swig_obj[1] ;

7164

7165

if (!args) SWIG_fail;

7166

swig_obj[0] = args;

7167

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

7168

if (!SWIG_IsOK(res1)) {

7169

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

7170

}

7171

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7172

{

7173

PyThreadState* __tstate = wxPyBeginAllowThreads();

7174

(arg1)->AutoCompCancel();

7175

wxPyEndAllowThreads(__tstate);

7176

if (PyErr_Occurred()) SWIG_fail;

7177

}

7178

resultobj = SWIG_Py_Void();

7179

return resultobj;

7180

fail:

7181

return NULL;

7182

}

7183

7184

7185

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

7186

PyObject *resultobj = 0;

7187

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7188

bool result;

7189

void *argp1 = 0 ;

7190

int res1 = 0 ;

7191

PyObject *swig_obj[1] ;

7192

7193

if (!args) SWIG_fail;

7194

swig_obj[0] = args;

7195

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

7196

if (!SWIG_IsOK(res1)) {

7197

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

7198

}

7199

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7200

{

7201

PyThreadState* __tstate = wxPyBeginAllowThreads();

7202

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

7203

wxPyEndAllowThreads(__tstate);

7204

if (PyErr_Occurred()) SWIG_fail;

7205

}

7206

{

7207

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

7208

}

7209

return resultobj;

7210

fail:

7211

return NULL;

7212

}

7213

7214

7215

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

7216

PyObject *resultobj = 0;

7217

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7218

int result;

7219

void *argp1 = 0 ;

7220

int res1 = 0 ;

7221

PyObject *swig_obj[1] ;

7222

7223

if (!args) SWIG_fail;

7224

swig_obj[0] = args;

7225

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

7226

if (!SWIG_IsOK(res1)) {

7227

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

7228

}

7229

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7230

{

7231

PyThreadState* __tstate = wxPyBeginAllowThreads();

7232

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

7233

wxPyEndAllowThreads(__tstate);

7234

if (PyErr_Occurred()) SWIG_fail;

7235

}

7236

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

7237

return resultobj;

7238

fail:

7239

return NULL;

7240

}

7241

7242

7243

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

7244

PyObject *resultobj = 0;

7245

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7246

void *argp1 = 0 ;

7247

int res1 = 0 ;

7248

PyObject *swig_obj[1] ;

7249

7250

if (!args) SWIG_fail;

7251

swig_obj[0] = args;

7252

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

7253

if (!SWIG_IsOK(res1)) {

7254

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

7255

}

7256

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7257

{

7258

PyThreadState* __tstate = wxPyBeginAllowThreads();

7259

(arg1)->AutoCompComplete();

7260

wxPyEndAllowThreads(__tstate);

7261

if (PyErr_Occurred()) SWIG_fail;

7262

}

7263

resultobj = SWIG_Py_Void();

7264

return resultobj;

7265

fail:

7266

return NULL;

7267

}

7268

7269

7270

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

7271

PyObject *resultobj = 0;

7272

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7273

wxString *arg2 = 0 ;

7274

void *argp1 = 0 ;

7275

int res1 = 0 ;

7276

bool temp2 = false ;

7277

PyObject * obj0 = 0 ;

7278

PyObject * obj1 = 0 ;

7279

char * kwnames[] = {

7280

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

7281

};

7282

7283

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

7284

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

7285

if (!SWIG_IsOK(res1)) {

7286

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

7287

}

7288

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7289

{

7290

arg2 = wxString_in_helper(obj1);

7291

if (arg2 == NULL) SWIG_fail;

7292

temp2 = true;

7293

}

7294

{

7295

PyThreadState* __tstate = wxPyBeginAllowThreads();

7296

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

7297

wxPyEndAllowThreads(__tstate);

7298

if (PyErr_Occurred()) SWIG_fail;

7299

}

7300

resultobj = SWIG_Py_Void();

7301

{

7302

if (temp2)

7303

delete arg2;

7304

}

7305

return resultobj;

7306

fail:

7307

{

7308

if (temp2)

7309

delete arg2;

7310

}

7311

return NULL;

7312

}

7313

7314

7315

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

7316

PyObject *resultobj = 0;

7317

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7318

int arg2 ;

7319

void *argp1 = 0 ;

7320

int res1 = 0 ;

7321

int val2 ;

7322

int ecode2 = 0 ;

7323

PyObject * obj0 = 0 ;

7324

PyObject * obj1 = 0 ;

7325

char * kwnames[] = {

7326

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

7327

};

7328

7329

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

7330

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

7331

if (!SWIG_IsOK(res1)) {

7332

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

7333

}

7334

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7335

ecode2 = SWIG_AsVal_int(obj1, &val2);

7336

if (!SWIG_IsOK(ecode2)) {

7337

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

7338

}

7339

arg2 = static_cast< int >(val2);

7340

{

7341

PyThreadState* __tstate = wxPyBeginAllowThreads();

7342

(arg1)->AutoCompSetSeparator(arg2);

7343

wxPyEndAllowThreads(__tstate);

7344

if (PyErr_Occurred()) SWIG_fail;

7345

}

7346

resultobj = SWIG_Py_Void();

7347

return resultobj;

7348

fail:

7349

return NULL;

7350

}

7351

7352

7353

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

7354

PyObject *resultobj = 0;

7355

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7356

int result;

7357

void *argp1 = 0 ;

7358

int res1 = 0 ;

7359

PyObject *swig_obj[1] ;

7360

7361

if (!args) SWIG_fail;

7362

swig_obj[0] = args;

7363

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

7364

if (!SWIG_IsOK(res1)) {

7365

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

7366

}

7367

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7368

{

7369

PyThreadState* __tstate = wxPyBeginAllowThreads();

7370

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

7371

wxPyEndAllowThreads(__tstate);

7372

if (PyErr_Occurred()) SWIG_fail;

7373

}

7374

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

7375

return resultobj;

7376

fail:

7377

return NULL;

7378

}

7379

7380

7381

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

7382

PyObject *resultobj = 0;

7383

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7384

wxString *arg2 = 0 ;

7385

void *argp1 = 0 ;

7386

int res1 = 0 ;

7387

bool temp2 = false ;

7388

PyObject * obj0 = 0 ;

7389

PyObject * obj1 = 0 ;

7390

char * kwnames[] = {

7391

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

7392

};

7393

7394

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

7395

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

7396

if (!SWIG_IsOK(res1)) {

7397

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

7398

}

7399

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7400

{

7401

arg2 = wxString_in_helper(obj1);

7402

if (arg2 == NULL) SWIG_fail;

7403

temp2 = true;

7404

}

7405

{

7406

PyThreadState* __tstate = wxPyBeginAllowThreads();

7407

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

7408

wxPyEndAllowThreads(__tstate);

7409

if (PyErr_Occurred()) SWIG_fail;

7410

}

7411

resultobj = SWIG_Py_Void();

7412

{

7413

if (temp2)

7414

delete arg2;

7415

}

7416

return resultobj;

7417

fail:

7418

{

7419

if (temp2)

7420

delete arg2;

7421

}

7422

return NULL;

7423

}

7424

7425

7426

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

7427

PyObject *resultobj = 0;

7428

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7429

bool arg2 ;

7430

void *argp1 = 0 ;

7431

int res1 = 0 ;

7432

bool val2 ;

7433

int ecode2 = 0 ;

7434

PyObject * obj0 = 0 ;

7435

PyObject * obj1 = 0 ;

7436

char * kwnames[] = {

7437

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

7438

};

7439

7440

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

7441

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

7442

if (!SWIG_IsOK(res1)) {

7443

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

7444

}

7445

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7446

ecode2 = SWIG_AsVal_bool(obj1, &val2);

7447

if (!SWIG_IsOK(ecode2)) {

7448

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

7449

}

7450

arg2 = static_cast< bool >(val2);

7451

{

7452

PyThreadState* __tstate = wxPyBeginAllowThreads();

7453

(arg1)->AutoCompSetCancelAtStart(arg2);

7454

wxPyEndAllowThreads(__tstate);

7455

if (PyErr_Occurred()) SWIG_fail;

7456

}

7457

resultobj = SWIG_Py_Void();

7458

return resultobj;

7459

fail:

7460

return NULL;

7461

}

7462

7463

7464

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

7465

PyObject *resultobj = 0;

7466

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7467

bool result;

7468

void *argp1 = 0 ;

7469

int res1 = 0 ;

7470

PyObject *swig_obj[1] ;

7471

7472

if (!args) SWIG_fail;

7473

swig_obj[0] = args;

7474

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

7475

if (!SWIG_IsOK(res1)) {

7476

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

7477

}

7478

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7479

{

7480

PyThreadState* __tstate = wxPyBeginAllowThreads();

7481

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

7482

wxPyEndAllowThreads(__tstate);

7483

if (PyErr_Occurred()) SWIG_fail;

7484

}

7485

{

7486

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

7487

}

7488

return resultobj;

7489

fail:

7490

return NULL;

7491

}

7492

7493

7494

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

7495

PyObject *resultobj = 0;

7496

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7497

wxString *arg2 = 0 ;

7498

void *argp1 = 0 ;

7499

int res1 = 0 ;

7500

bool temp2 = false ;

7501

PyObject * obj0 = 0 ;

7502

PyObject * obj1 = 0 ;

7503

char * kwnames[] = {

7504

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

7505

};

7506

7507

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

7508

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

7509

if (!SWIG_IsOK(res1)) {

7510

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

7511

}

7512

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7513

{

7514

arg2 = wxString_in_helper(obj1);

7515

if (arg2 == NULL) SWIG_fail;

7516

temp2 = true;

7517

}

7518

{

7519

PyThreadState* __tstate = wxPyBeginAllowThreads();

7520

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

7521

wxPyEndAllowThreads(__tstate);

7522

if (PyErr_Occurred()) SWIG_fail;

7523

}

7524

resultobj = SWIG_Py_Void();

7525

{

7526

if (temp2)

7527

delete arg2;

7528

}

7529

return resultobj;

7530

fail:

7531

{

7532

if (temp2)

7533

delete arg2;

7534

}

7535

return NULL;

7536

}

7537

7538

7539

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

7540

PyObject *resultobj = 0;

7541

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7542

bool arg2 ;

7543

void *argp1 = 0 ;

7544

int res1 = 0 ;

7545

bool val2 ;

7546

int ecode2 = 0 ;

7547

PyObject * obj0 = 0 ;

7548

PyObject * obj1 = 0 ;

7549

char * kwnames[] = {

7550

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

7551

};

7552

7553

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

7554

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

7555

if (!SWIG_IsOK(res1)) {

7556

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

7557

}

7558

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7559

ecode2 = SWIG_AsVal_bool(obj1, &val2);

7560

if (!SWIG_IsOK(ecode2)) {

7561

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

7562

}

7563

arg2 = static_cast< bool >(val2);

7564

{

7565

PyThreadState* __tstate = wxPyBeginAllowThreads();

7566

(arg1)->AutoCompSetChooseSingle(arg2);

7567

wxPyEndAllowThreads(__tstate);

7568

if (PyErr_Occurred()) SWIG_fail;

7569

}

7570

resultobj = SWIG_Py_Void();

7571

return resultobj;

7572

fail:

7573

return NULL;

7574

}

7575

7576

7577

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

7578

PyObject *resultobj = 0;

7579

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7580

bool result;

7581

void *argp1 = 0 ;

7582

int res1 = 0 ;

7583

PyObject *swig_obj[1] ;

7584

7585

if (!args) SWIG_fail;

7586

swig_obj[0] = args;

7587

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

7588

if (!SWIG_IsOK(res1)) {

7589

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

7590

}

7591

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7592

{

7593

PyThreadState* __tstate = wxPyBeginAllowThreads();

7594

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

7595

wxPyEndAllowThreads(__tstate);

7596

if (PyErr_Occurred()) SWIG_fail;

7597

}

7598

{

7599

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

7600

}

7601

return resultobj;

7602

fail:

7603

return NULL;

7604

}

7605

7606

7607

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

7608

PyObject *resultobj = 0;

7609

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7610

bool arg2 ;

7611

void *argp1 = 0 ;

7612

int res1 = 0 ;

7613

bool val2 ;

7614

int ecode2 = 0 ;

7615

PyObject * obj0 = 0 ;

7616

PyObject * obj1 = 0 ;

7617

char * kwnames[] = {

7618

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

7619

};

7620

7621

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

7622

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

7623

if (!SWIG_IsOK(res1)) {

7624

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

7625

}

7626

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7627

ecode2 = SWIG_AsVal_bool(obj1, &val2);

7628

if (!SWIG_IsOK(ecode2)) {

7629

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

7630

}

7631

arg2 = static_cast< bool >(val2);

7632

{

7633

PyThreadState* __tstate = wxPyBeginAllowThreads();

7634

(arg1)->AutoCompSetIgnoreCase(arg2);

7635

wxPyEndAllowThreads(__tstate);

7636

if (PyErr_Occurred()) SWIG_fail;

7637

}

7638

resultobj = SWIG_Py_Void();

7639

return resultobj;

7640

fail:

7641

return NULL;

7642

}

7643

7644

7645

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

7646

PyObject *resultobj = 0;

7647

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7648

bool result;

7649

void *argp1 = 0 ;

7650

int res1 = 0 ;

7651

PyObject *swig_obj[1] ;

7652

7653

if (!args) SWIG_fail;

7654

swig_obj[0] = args;

7655

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

7656

if (!SWIG_IsOK(res1)) {

7657

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

7658

}

7659

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7660

{

7661

PyThreadState* __tstate = wxPyBeginAllowThreads();

7662

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

7663

wxPyEndAllowThreads(__tstate);

7664

if (PyErr_Occurred()) SWIG_fail;

7665

}

7666

{

7667

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

7668

}

7669

return resultobj;

7670

fail:

7671

return NULL;

7672

}

7673

7674

7675

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

7676

PyObject *resultobj = 0;

7677

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7678

int arg2 ;

7679

wxString *arg3 = 0 ;

7680

void *argp1 = 0 ;

7681

int res1 = 0 ;

7682

int val2 ;

7683

int ecode2 = 0 ;

7684

bool temp3 = false ;

7685

PyObject * obj0 = 0 ;

7686

PyObject * obj1 = 0 ;

7687

PyObject * obj2 = 0 ;

7688

char * kwnames[] = {

7689

(char *) "self",(char *) "listType",(char *) "itemList", NULL

7690

};

7691

7692

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

7693

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

7694

if (!SWIG_IsOK(res1)) {

7695

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

7696

}

7697

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7698

ecode2 = SWIG_AsVal_int(obj1, &val2);

7699

if (!SWIG_IsOK(ecode2)) {

7700

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

7701

}

7702

arg2 = static_cast< int >(val2);

7703

{

7704

arg3 = wxString_in_helper(obj2);

7705

if (arg3 == NULL) SWIG_fail;

7706

temp3 = true;

7707

}

7708

{

7709

PyThreadState* __tstate = wxPyBeginAllowThreads();

7710

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

7711

wxPyEndAllowThreads(__tstate);

7712

if (PyErr_Occurred()) SWIG_fail;

7713

}

7714

resultobj = SWIG_Py_Void();

7715

{

7716

if (temp3)

7717

delete arg3;

7718

}

7719

return resultobj;

7720

fail:

7721

{

7722

if (temp3)

7723

delete arg3;

7724

}

7725

return NULL;

7726

}

7727

7728

7729

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

7730

PyObject *resultobj = 0;

7731

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7732

bool arg2 ;

7733

void *argp1 = 0 ;

7734

int res1 = 0 ;

7735

bool val2 ;

7736

int ecode2 = 0 ;

7737

PyObject * obj0 = 0 ;

7738

PyObject * obj1 = 0 ;

7739

char * kwnames[] = {

7740

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

7741

};

7742

7743

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

7744

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

7745

if (!SWIG_IsOK(res1)) {

7746

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

7747

}

7748

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7749

ecode2 = SWIG_AsVal_bool(obj1, &val2);

7750

if (!SWIG_IsOK(ecode2)) {

7751

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

7752

}

7753

arg2 = static_cast< bool >(val2);

7754

{

7755

PyThreadState* __tstate = wxPyBeginAllowThreads();

7756

(arg1)->AutoCompSetAutoHide(arg2);

7757

wxPyEndAllowThreads(__tstate);

7758

if (PyErr_Occurred()) SWIG_fail;

7759

}

7760

resultobj = SWIG_Py_Void();

7761

return resultobj;

7762

fail:

7763

return NULL;

7764

}

7765

7766

7767

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

7768

PyObject *resultobj = 0;

7769

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7770

bool result;

7771

void *argp1 = 0 ;

7772

int res1 = 0 ;

7773

PyObject *swig_obj[1] ;

7774

7775

if (!args) SWIG_fail;

7776

swig_obj[0] = args;

7777

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

7778

if (!SWIG_IsOK(res1)) {

7779

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

7780

}

7781

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7782

{

7783

PyThreadState* __tstate = wxPyBeginAllowThreads();

7784

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

7785

wxPyEndAllowThreads(__tstate);

7786

if (PyErr_Occurred()) SWIG_fail;

7787

}

7788

{

7789

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

7790

}

7791

return resultobj;

7792

fail:

7793

return NULL;

7794

}

7795

7796

7797

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

7798

PyObject *resultobj = 0;

7799

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7800

bool arg2 ;

7801

void *argp1 = 0 ;

7802

int res1 = 0 ;

7803

bool val2 ;

7804

int ecode2 = 0 ;

7805

PyObject * obj0 = 0 ;

7806

PyObject * obj1 = 0 ;

7807

char * kwnames[] = {

7808

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

7809

};

7810

7811

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

7812

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

7813

if (!SWIG_IsOK(res1)) {

7814

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

7815

}

7816

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7817

ecode2 = SWIG_AsVal_bool(obj1, &val2);

7818

if (!SWIG_IsOK(ecode2)) {

7819

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

7820

}

7821

arg2 = static_cast< bool >(val2);

7822

{

7823

PyThreadState* __tstate = wxPyBeginAllowThreads();

7824

(arg1)->AutoCompSetDropRestOfWord(arg2);

7825

wxPyEndAllowThreads(__tstate);

7826

if (PyErr_Occurred()) SWIG_fail;

7827

}

7828

resultobj = SWIG_Py_Void();

7829

return resultobj;

7830

fail:

7831

return NULL;

7832

}

7833

7834

7835

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

7836

PyObject *resultobj = 0;

7837

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7838

bool result;

7839

void *argp1 = 0 ;

7840

int res1 = 0 ;

7841

PyObject *swig_obj[1] ;

7842

7843

if (!args) SWIG_fail;

7844

swig_obj[0] = args;

7845

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

7846

if (!SWIG_IsOK(res1)) {

7847

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

7848

}

7849

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7850

{

7851

PyThreadState* __tstate = wxPyBeginAllowThreads();

7852

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

7853

wxPyEndAllowThreads(__tstate);

7854

if (PyErr_Occurred()) SWIG_fail;

7855

}

7856

{

7857

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

7858

}

7859

return resultobj;

7860

fail:

7861

return NULL;

7862

}

7863

7864

7865

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

7866

PyObject *resultobj = 0;

7867

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7868

int arg2 ;

7869

wxBitmap *arg3 = 0 ;

7870

void *argp1 = 0 ;

7871

int res1 = 0 ;

7872

int val2 ;

7873

int ecode2 = 0 ;

7874

void *argp3 = 0 ;

7875

int res3 = 0 ;

7876

PyObject * obj0 = 0 ;

7877

PyObject * obj1 = 0 ;

7878

PyObject * obj2 = 0 ;

7879

char * kwnames[] = {

7880

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

7881

};

7882

7883

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

7884

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

7885

if (!SWIG_IsOK(res1)) {

7886

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

7887

}

7888

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7889

ecode2 = SWIG_AsVal_int(obj1, &val2);

7890

if (!SWIG_IsOK(ecode2)) {

7891

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

7892

}

7893

arg2 = static_cast< int >(val2);

7894

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

7895

if (!SWIG_IsOK(res3)) {

7896

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

7897

}

7898

if (!argp3) {

7899

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

7900

}

7901

arg3 = reinterpret_cast< wxBitmap * >(argp3);

7902

{

7903

PyThreadState* __tstate = wxPyBeginAllowThreads();

7904

(arg1)->RegisterImage(arg2,(wxBitmap const &)*arg3);

7905

wxPyEndAllowThreads(__tstate);

7906

if (PyErr_Occurred()) SWIG_fail;

7907

}

7908

resultobj = SWIG_Py_Void();

7909

return resultobj;

7910

fail:

7911

return NULL;

7912

}

7913

7914

7915

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

7916

PyObject *resultobj = 0;

7917

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7918

void *argp1 = 0 ;

7919

int res1 = 0 ;

7920

PyObject *swig_obj[1] ;

7921

7922

if (!args) SWIG_fail;

7923

swig_obj[0] = args;

7924

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

7925

if (!SWIG_IsOK(res1)) {

7926

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

7927

}

7928

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7929

{

7930

PyThreadState* __tstate = wxPyBeginAllowThreads();

7931

(arg1)->ClearRegisteredImages();

7932

wxPyEndAllowThreads(__tstate);

7933

if (PyErr_Occurred()) SWIG_fail;

7934

}

7935

resultobj = SWIG_Py_Void();

7936

return resultobj;

7937

fail:

7938

return NULL;

7939

}

7940

7941

7942

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

7943

PyObject *resultobj = 0;

7944

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7945

int result;

7946

void *argp1 = 0 ;

7947

int res1 = 0 ;

7948

PyObject *swig_obj[1] ;

7949

7950

if (!args) SWIG_fail;

7951

swig_obj[0] = args;

7952

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

7953

if (!SWIG_IsOK(res1)) {

7954

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

7955

}

7956

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7957

{

7958

PyThreadState* __tstate = wxPyBeginAllowThreads();

7959

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

7960

wxPyEndAllowThreads(__tstate);

7961

if (PyErr_Occurred()) SWIG_fail;

7962

}

7963

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

7964

return resultobj;

7965

fail:

7966

return NULL;

7967

}

7968

7969

7970

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

7971

PyObject *resultobj = 0;

7972

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

7973

int arg2 ;

7974

void *argp1 = 0 ;

7975

int res1 = 0 ;

7976

int val2 ;

7977

int ecode2 = 0 ;

7978

PyObject * obj0 = 0 ;

7979

PyObject * obj1 = 0 ;

7980

char * kwnames[] = {

7981

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

7982

};

7983

7984

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

7985

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

7986

if (!SWIG_IsOK(res1)) {

7987

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

7988

}

7989

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

7990

ecode2 = SWIG_AsVal_int(obj1, &val2);

7991

if (!SWIG_IsOK(ecode2)) {

7992

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

7993

}

7994

arg2 = static_cast< int >(val2);

7995

{

7996

PyThreadState* __tstate = wxPyBeginAllowThreads();

7997

(arg1)->AutoCompSetTypeSeparator(arg2);

7998

wxPyEndAllowThreads(__tstate);

7999

if (PyErr_Occurred()) SWIG_fail;

8000

}

8001

resultobj = SWIG_Py_Void();

8002

return resultobj;

8003

fail:

8004

return NULL;

8005

}

8006

8007

8008

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

8009

PyObject *resultobj = 0;

8010

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8011

int arg2 ;

8012

void *argp1 = 0 ;

8013

int res1 = 0 ;

8014

int val2 ;

8015

int ecode2 = 0 ;

8016

PyObject * obj0 = 0 ;

8017

PyObject * obj1 = 0 ;

8018

char * kwnames[] = {

8019

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

8020

};

8021

8022

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

8023

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

8024

if (!SWIG_IsOK(res1)) {

8025

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

8026

}

8027

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8028

ecode2 = SWIG_AsVal_int(obj1, &val2);

8029

if (!SWIG_IsOK(ecode2)) {

8030

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

8031

}

8032

arg2 = static_cast< int >(val2);

8033

{

8034

PyThreadState* __tstate = wxPyBeginAllowThreads();

8035

(arg1)->AutoCompSetMaxWidth(arg2);

8036

wxPyEndAllowThreads(__tstate);

8037

if (PyErr_Occurred()) SWIG_fail;

8038

}

8039

resultobj = SWIG_Py_Void();

8040

return resultobj;

8041

fail:

8042

return NULL;

8043

}

8044

8045

8046

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

8047

PyObject *resultobj = 0;

8048

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8049

int result;

8050

void *argp1 = 0 ;

8051

int res1 = 0 ;

8052

PyObject *swig_obj[1] ;

8053

8054

if (!args) SWIG_fail;

8055

swig_obj[0] = args;

8056

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

8057

if (!SWIG_IsOK(res1)) {

8058

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

8059

}

8060

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8061

{

8062

PyThreadState* __tstate = wxPyBeginAllowThreads();

8063

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

8064

wxPyEndAllowThreads(__tstate);

8065

if (PyErr_Occurred()) SWIG_fail;

8066

}

8067

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

8068

return resultobj;

8069

fail:

8070

return NULL;

8071

}

8072

8073

8074

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

8075

PyObject *resultobj = 0;

8076

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8077

int arg2 ;

8078

void *argp1 = 0 ;

8079

int res1 = 0 ;

8080

int val2 ;

8081

int ecode2 = 0 ;

8082

PyObject * obj0 = 0 ;

8083

PyObject * obj1 = 0 ;

8084

char * kwnames[] = {

8085

(char *) "self",(char *) "rowCount", NULL

8086

};

8087

8088

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_AutoCompSetMaxHeight",kwnames,&obj0,&obj1)) SWIG_fail;

8089

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8090

if (!SWIG_IsOK(res1)) {

8091

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_AutoCompSetMaxHeight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8092

}

8093

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8094

ecode2 = SWIG_AsVal_int(obj1, &val2);

8095

if (!SWIG_IsOK(ecode2)) {

8096

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_AutoCompSetMaxHeight" "', expected argument " "2"" of type '" "int""'");

8097

}

8098

arg2 = static_cast< int >(val2);

8099

{

8100

PyThreadState* __tstate = wxPyBeginAllowThreads();

8101

(arg1)->AutoCompSetMaxHeight(arg2);

8102

wxPyEndAllowThreads(__tstate);

8103

if (PyErr_Occurred()) SWIG_fail;

8104

}

8105

resultobj = SWIG_Py_Void();

8106

return resultobj;

8107

fail:

8108

return NULL;

8109

}

8110

8111

8112

SWIGINTERN PyObject *_wrap_StyledTextCtrl_AutoCompGetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8113

PyObject *resultobj = 0;

8114

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8115

int result;

8116

void *argp1 = 0 ;

8117

int res1 = 0 ;

8118

PyObject *swig_obj[1] ;

8119

8120

if (!args) SWIG_fail;

8121

swig_obj[0] = args;

8122

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8123

if (!SWIG_IsOK(res1)) {

8124

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_AutoCompGetMaxHeight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8125

}

8126

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8127

{

8128

PyThreadState* __tstate = wxPyBeginAllowThreads();

8129

result = (int)(arg1)->AutoCompGetMaxHeight();

8130

wxPyEndAllowThreads(__tstate);

8131

if (PyErr_Occurred()) SWIG_fail;

8132

}

8133

resultobj = SWIG_From_int(static_cast< int >(result));

8134

return resultobj;

8135

fail:

8136

return NULL;

8137

}

8138

8139

8140

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8141

PyObject *resultobj = 0;

8142

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8143

int arg2 ;

8144

void *argp1 = 0 ;

8145

int res1 = 0 ;

8146

int val2 ;

8147

int ecode2 = 0 ;

8148

PyObject * obj0 = 0 ;

8149

PyObject * obj1 = 0 ;

8150

char * kwnames[] = {

8151

(char *) "self",(char *) "indentSize", NULL

8152

};

8153

8154

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetIndent",kwnames,&obj0,&obj1)) SWIG_fail;

8155

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8156

if (!SWIG_IsOK(res1)) {

8157

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetIndent" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8158

}

8159

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8160

ecode2 = SWIG_AsVal_int(obj1, &val2);

8161

if (!SWIG_IsOK(ecode2)) {

8162

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetIndent" "', expected argument " "2"" of type '" "int""'");

8163

}

8164

arg2 = static_cast< int >(val2);

8165

{

8166

PyThreadState* __tstate = wxPyBeginAllowThreads();

8167

(arg1)->SetIndent(arg2);

8168

wxPyEndAllowThreads(__tstate);

8169

if (PyErr_Occurred()) SWIG_fail;

8170

}

8171

resultobj = SWIG_Py_Void();

8172

return resultobj;

8173

fail:

8174

return NULL;

8175

}

8176

8177

8178

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8179

PyObject *resultobj = 0;

8180

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8181

int result;

8182

void *argp1 = 0 ;

8183

int res1 = 0 ;

8184

PyObject *swig_obj[1] ;

8185

8186

if (!args) SWIG_fail;

8187

swig_obj[0] = args;

8188

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8189

if (!SWIG_IsOK(res1)) {

8190

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetIndent" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8191

}

8192

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8193

{

8194

PyThreadState* __tstate = wxPyBeginAllowThreads();

8195

result = (int)(arg1)->GetIndent();

8196

wxPyEndAllowThreads(__tstate);

8197

if (PyErr_Occurred()) SWIG_fail;

8198

}

8199

resultobj = SWIG_From_int(static_cast< int >(result));

8200

return resultobj;

8201

fail:

8202

return NULL;

8203

}

8204

8205

8206

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetUseTabs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8207

PyObject *resultobj = 0;

8208

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8209

bool arg2 ;

8210

void *argp1 = 0 ;

8211

int res1 = 0 ;

8212

bool val2 ;

8213

int ecode2 = 0 ;

8214

PyObject * obj0 = 0 ;

8215

PyObject * obj1 = 0 ;

8216

char * kwnames[] = {

8217

(char *) "self",(char *) "useTabs", NULL

8218

};

8219

8220

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetUseTabs",kwnames,&obj0,&obj1)) SWIG_fail;

8221

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8222

if (!SWIG_IsOK(res1)) {

8223

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetUseTabs" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8224

}

8225

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8226

ecode2 = SWIG_AsVal_bool(obj1, &val2);

8227

if (!SWIG_IsOK(ecode2)) {

8228

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetUseTabs" "', expected argument " "2"" of type '" "bool""'");

8229

}

8230

arg2 = static_cast< bool >(val2);

8231

{

8232

PyThreadState* __tstate = wxPyBeginAllowThreads();

8233

(arg1)->SetUseTabs(arg2);

8234

wxPyEndAllowThreads(__tstate);

8235

if (PyErr_Occurred()) SWIG_fail;

8236

}

8237

resultobj = SWIG_Py_Void();

8238

return resultobj;

8239

fail:

8240

return NULL;

8241

}

8242

8243

8244

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetUseTabs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8245

PyObject *resultobj = 0;

8246

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8247

bool result;

8248

void *argp1 = 0 ;

8249

int res1 = 0 ;

8250

PyObject *swig_obj[1] ;

8251

8252

if (!args) SWIG_fail;

8253

swig_obj[0] = args;

8254

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8255

if (!SWIG_IsOK(res1)) {

8256

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetUseTabs" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8257

}

8258

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8259

{

8260

PyThreadState* __tstate = wxPyBeginAllowThreads();

8261

result = (bool)(arg1)->GetUseTabs();

8262

wxPyEndAllowThreads(__tstate);

8263

if (PyErr_Occurred()) SWIG_fail;

8264

}

8265

{

8266

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

8267

}

8268

return resultobj;

8269

fail:

8270

return NULL;

8271

}

8272

8273

8274

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetLineIndentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8275

PyObject *resultobj = 0;

8276

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8277

int arg2 ;

8278

int arg3 ;

8279

void *argp1 = 0 ;

8280

int res1 = 0 ;

8281

int val2 ;

8282

int ecode2 = 0 ;

8283

int val3 ;

8284

int ecode3 = 0 ;

8285

PyObject * obj0 = 0 ;

8286

PyObject * obj1 = 0 ;

8287

PyObject * obj2 = 0 ;

8288

char * kwnames[] = {

8289

(char *) "self",(char *) "line",(char *) "indentSize", NULL

8290

};

8291

8292

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetLineIndentation",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

8293

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8294

if (!SWIG_IsOK(res1)) {

8295

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetLineIndentation" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8296

}

8297

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8298

ecode2 = SWIG_AsVal_int(obj1, &val2);

8299

if (!SWIG_IsOK(ecode2)) {

8300

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetLineIndentation" "', expected argument " "2"" of type '" "int""'");

8301

}

8302

arg2 = static_cast< int >(val2);

8303

ecode3 = SWIG_AsVal_int(obj2, &val3);

8304

if (!SWIG_IsOK(ecode3)) {

8305

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_SetLineIndentation" "', expected argument " "3"" of type '" "int""'");

8306

}

8307

arg3 = static_cast< int >(val3);

8308

{

8309

PyThreadState* __tstate = wxPyBeginAllowThreads();

8310

(arg1)->SetLineIndentation(arg2,arg3);

8311

wxPyEndAllowThreads(__tstate);

8312

if (PyErr_Occurred()) SWIG_fail;

8313

}

8314

resultobj = SWIG_Py_Void();

8315

return resultobj;

8316

fail:

8317

return NULL;

8318

}

8319

8320

8321

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLineIndentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8322

PyObject *resultobj = 0;

8323

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8324

int arg2 ;

8325

int result;

8326

void *argp1 = 0 ;

8327

int res1 = 0 ;

8328

int val2 ;

8329

int ecode2 = 0 ;

8330

PyObject * obj0 = 0 ;

8331

PyObject * obj1 = 0 ;

8332

char * kwnames[] = {

8333

(char *) "self",(char *) "line", NULL

8334

};

8335

8336

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetLineIndentation",kwnames,&obj0,&obj1)) SWIG_fail;

8337

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8338

if (!SWIG_IsOK(res1)) {

8339

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLineIndentation" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8340

}

8341

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8342

ecode2 = SWIG_AsVal_int(obj1, &val2);

8343

if (!SWIG_IsOK(ecode2)) {

8344

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetLineIndentation" "', expected argument " "2"" of type '" "int""'");

8345

}

8346

arg2 = static_cast< int >(val2);

8347

{

8348

PyThreadState* __tstate = wxPyBeginAllowThreads();

8349

result = (int)(arg1)->GetLineIndentation(arg2);

8350

wxPyEndAllowThreads(__tstate);

8351

if (PyErr_Occurred()) SWIG_fail;

8352

}

8353

resultobj = SWIG_From_int(static_cast< int >(result));

8354

return resultobj;

8355

fail:

8356

return NULL;

8357

}

8358

8359

8360

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLineIndentPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8361

PyObject *resultobj = 0;

8362

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8363

int arg2 ;

8364

int result;

8365

void *argp1 = 0 ;

8366

int res1 = 0 ;

8367

int val2 ;

8368

int ecode2 = 0 ;

8369

PyObject * obj0 = 0 ;

8370

PyObject * obj1 = 0 ;

8371

char * kwnames[] = {

8372

(char *) "self",(char *) "line", NULL

8373

};

8374

8375

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetLineIndentPosition",kwnames,&obj0,&obj1)) SWIG_fail;

8376

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8377

if (!SWIG_IsOK(res1)) {

8378

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLineIndentPosition" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8379

}

8380

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8381

ecode2 = SWIG_AsVal_int(obj1, &val2);

8382

if (!SWIG_IsOK(ecode2)) {

8383

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetLineIndentPosition" "', expected argument " "2"" of type '" "int""'");

8384

}

8385

arg2 = static_cast< int >(val2);

8386

{

8387

PyThreadState* __tstate = wxPyBeginAllowThreads();

8388

result = (int)(arg1)->GetLineIndentPosition(arg2);

8389

wxPyEndAllowThreads(__tstate);

8390

if (PyErr_Occurred()) SWIG_fail;

8391

}

8392

resultobj = SWIG_From_int(static_cast< int >(result));

8393

return resultobj;

8394

fail:

8395

return NULL;

8396

}

8397

8398

8399

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8400

PyObject *resultobj = 0;

8401

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8402

int arg2 ;

8403

int result;

8404

void *argp1 = 0 ;

8405

int res1 = 0 ;

8406

int val2 ;

8407

int ecode2 = 0 ;

8408

PyObject * obj0 = 0 ;

8409

PyObject * obj1 = 0 ;

8410

char * kwnames[] = {

8411

(char *) "self",(char *) "pos", NULL

8412

};

8413

8414

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetColumn",kwnames,&obj0,&obj1)) SWIG_fail;

8415

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8416

if (!SWIG_IsOK(res1)) {

8417

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetColumn" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8418

}

8419

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8420

ecode2 = SWIG_AsVal_int(obj1, &val2);

8421

if (!SWIG_IsOK(ecode2)) {

8422

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetColumn" "', expected argument " "2"" of type '" "int""'");

8423

}

8424

arg2 = static_cast< int >(val2);

8425

{

8426

PyThreadState* __tstate = wxPyBeginAllowThreads();

8427

result = (int)(arg1)->GetColumn(arg2);

8428

wxPyEndAllowThreads(__tstate);

8429

if (PyErr_Occurred()) SWIG_fail;

8430

}

8431

resultobj = SWIG_From_int(static_cast< int >(result));

8432

return resultobj;

8433

fail:

8434

return NULL;

8435

}

8436

8437

8438

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetUseHorizontalScrollBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8439

PyObject *resultobj = 0;

8440

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8441

bool arg2 ;

8442

void *argp1 = 0 ;

8443

int res1 = 0 ;

8444

bool val2 ;

8445

int ecode2 = 0 ;

8446

PyObject * obj0 = 0 ;

8447

PyObject * obj1 = 0 ;

8448

char * kwnames[] = {

8449

(char *) "self",(char *) "show", NULL

8450

};

8451

8452

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetUseHorizontalScrollBar",kwnames,&obj0,&obj1)) SWIG_fail;

8453

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8454

if (!SWIG_IsOK(res1)) {

8455

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetUseHorizontalScrollBar" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8456

}

8457

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8458

ecode2 = SWIG_AsVal_bool(obj1, &val2);

8459

if (!SWIG_IsOK(ecode2)) {

8460

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetUseHorizontalScrollBar" "', expected argument " "2"" of type '" "bool""'");

8461

}

8462

arg2 = static_cast< bool >(val2);

8463

{

8464

PyThreadState* __tstate = wxPyBeginAllowThreads();

8465

(arg1)->SetUseHorizontalScrollBar(arg2);

8466

wxPyEndAllowThreads(__tstate);

8467

if (PyErr_Occurred()) SWIG_fail;

8468

}

8469

resultobj = SWIG_Py_Void();

8470

return resultobj;

8471

fail:

8472

return NULL;

8473

}

8474

8475

8476

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetUseHorizontalScrollBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8477

PyObject *resultobj = 0;

8478

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8479

bool result;

8480

void *argp1 = 0 ;

8481

int res1 = 0 ;

8482

PyObject *swig_obj[1] ;

8483

8484

if (!args) SWIG_fail;

8485

swig_obj[0] = args;

8486

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8487

if (!SWIG_IsOK(res1)) {

8488

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetUseHorizontalScrollBar" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8489

}

8490

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8491

{

8492

PyThreadState* __tstate = wxPyBeginAllowThreads();

8493

result = (bool)(arg1)->GetUseHorizontalScrollBar();

8494

wxPyEndAllowThreads(__tstate);

8495

if (PyErr_Occurred()) SWIG_fail;

8496

}

8497

{

8498

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

8499

}

8500

return resultobj;

8501

fail:

8502

return NULL;

8503

}

8504

8505

8506

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetIndentationGuides(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8507

PyObject *resultobj = 0;

8508

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8509

bool arg2 ;

8510

void *argp1 = 0 ;

8511

int res1 = 0 ;

8512

bool val2 ;

8513

int ecode2 = 0 ;

8514

PyObject * obj0 = 0 ;

8515

PyObject * obj1 = 0 ;

8516

char * kwnames[] = {

8517

(char *) "self",(char *) "show", NULL

8518

};

8519

8520

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetIndentationGuides",kwnames,&obj0,&obj1)) SWIG_fail;

8521

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8522

if (!SWIG_IsOK(res1)) {

8523

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetIndentationGuides" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8524

}

8525

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8526

ecode2 = SWIG_AsVal_bool(obj1, &val2);

8527

if (!SWIG_IsOK(ecode2)) {

8528

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetIndentationGuides" "', expected argument " "2"" of type '" "bool""'");

8529

}

8530

arg2 = static_cast< bool >(val2);

8531

{

8532

PyThreadState* __tstate = wxPyBeginAllowThreads();

8533

(arg1)->SetIndentationGuides(arg2);

8534

wxPyEndAllowThreads(__tstate);

8535

if (PyErr_Occurred()) SWIG_fail;

8536

}

8537

resultobj = SWIG_Py_Void();

8538

return resultobj;

8539

fail:

8540

return NULL;

8541

}

8542

8543

8544

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetIndentationGuides(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8545

PyObject *resultobj = 0;

8546

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8547

bool result;

8548

void *argp1 = 0 ;

8549

int res1 = 0 ;

8550

PyObject *swig_obj[1] ;

8551

8552

if (!args) SWIG_fail;

8553

swig_obj[0] = args;

8554

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8555

if (!SWIG_IsOK(res1)) {

8556

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetIndentationGuides" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8557

}

8558

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8559

{

8560

PyThreadState* __tstate = wxPyBeginAllowThreads();

8561

result = (bool)(arg1)->GetIndentationGuides();

8562

wxPyEndAllowThreads(__tstate);

8563

if (PyErr_Occurred()) SWIG_fail;

8564

}

8565

{

8566

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

8567

}

8568

return resultobj;

8569

fail:

8570

return NULL;

8571

}

8572

8573

8574

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetHighlightGuide(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8575

PyObject *resultobj = 0;

8576

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8577

int arg2 ;

8578

void *argp1 = 0 ;

8579

int res1 = 0 ;

8580

int val2 ;

8581

int ecode2 = 0 ;

8582

PyObject * obj0 = 0 ;

8583

PyObject * obj1 = 0 ;

8584

char * kwnames[] = {

8585

(char *) "self",(char *) "column", NULL

8586

};

8587

8588

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetHighlightGuide",kwnames,&obj0,&obj1)) SWIG_fail;

8589

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8590

if (!SWIG_IsOK(res1)) {

8591

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetHighlightGuide" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8592

}

8593

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8594

ecode2 = SWIG_AsVal_int(obj1, &val2);

8595

if (!SWIG_IsOK(ecode2)) {

8596

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetHighlightGuide" "', expected argument " "2"" of type '" "int""'");

8597

}

8598

arg2 = static_cast< int >(val2);

8599

{

8600

PyThreadState* __tstate = wxPyBeginAllowThreads();

8601

(arg1)->SetHighlightGuide(arg2);

8602

wxPyEndAllowThreads(__tstate);

8603

if (PyErr_Occurred()) SWIG_fail;

8604

}

8605

resultobj = SWIG_Py_Void();

8606

return resultobj;

8607

fail:

8608

return NULL;

8609

}

8610

8611

8612

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetHighlightGuide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8613

PyObject *resultobj = 0;

8614

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8615

int result;

8616

void *argp1 = 0 ;

8617

int res1 = 0 ;

8618

PyObject *swig_obj[1] ;

8619

8620

if (!args) SWIG_fail;

8621

swig_obj[0] = args;

8622

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8623

if (!SWIG_IsOK(res1)) {

8624

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetHighlightGuide" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8625

}

8626

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8627

{

8628

PyThreadState* __tstate = wxPyBeginAllowThreads();

8629

result = (int)(arg1)->GetHighlightGuide();

8630

wxPyEndAllowThreads(__tstate);

8631

if (PyErr_Occurred()) SWIG_fail;

8632

}

8633

resultobj = SWIG_From_int(static_cast< int >(result));

8634

return resultobj;

8635

fail:

8636

return NULL;

8637

}

8638

8639

8640

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLineEndPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8641

PyObject *resultobj = 0;

8642

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8643

int arg2 ;

8644

int result;

8645

void *argp1 = 0 ;

8646

int res1 = 0 ;

8647

int val2 ;

8648

int ecode2 = 0 ;

8649

PyObject * obj0 = 0 ;

8650

PyObject * obj1 = 0 ;

8651

char * kwnames[] = {

8652

(char *) "self",(char *) "line", NULL

8653

};

8654

8655

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetLineEndPosition",kwnames,&obj0,&obj1)) SWIG_fail;

8656

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8657

if (!SWIG_IsOK(res1)) {

8658

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLineEndPosition" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8659

}

8660

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8661

ecode2 = SWIG_AsVal_int(obj1, &val2);

8662

if (!SWIG_IsOK(ecode2)) {

8663

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetLineEndPosition" "', expected argument " "2"" of type '" "int""'");

8664

}

8665

arg2 = static_cast< int >(val2);

8666

{

8667

PyThreadState* __tstate = wxPyBeginAllowThreads();

8668

result = (int)(arg1)->GetLineEndPosition(arg2);

8669

wxPyEndAllowThreads(__tstate);

8670

if (PyErr_Occurred()) SWIG_fail;

8671

}

8672

resultobj = SWIG_From_int(static_cast< int >(result));

8673

return resultobj;

8674

fail:

8675

return NULL;

8676

}

8677

8678

8679

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetCodePage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8680

PyObject *resultobj = 0;

8681

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8682

int result;

8683

void *argp1 = 0 ;

8684

int res1 = 0 ;

8685

PyObject *swig_obj[1] ;

8686

8687

if (!args) SWIG_fail;

8688

swig_obj[0] = args;

8689

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8690

if (!SWIG_IsOK(res1)) {

8691

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetCodePage" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8692

}

8693

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8694

{

8695

PyThreadState* __tstate = wxPyBeginAllowThreads();

8696

result = (int)(arg1)->GetCodePage();

8697

wxPyEndAllowThreads(__tstate);

8698

if (PyErr_Occurred()) SWIG_fail;

8699

}

8700

resultobj = SWIG_From_int(static_cast< int >(result));

8701

return resultobj;

8702

fail:

8703

return NULL;

8704

}

8705

8706

8707

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetCaretForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8708

PyObject *resultobj = 0;

8709

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8710

wxColour result;

8711

void *argp1 = 0 ;

8712

int res1 = 0 ;

8713

PyObject *swig_obj[1] ;

8714

8715

if (!args) SWIG_fail;

8716

swig_obj[0] = args;

8717

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8718

if (!SWIG_IsOK(res1)) {

8719

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetCaretForeground" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8720

}

8721

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8722

{

8723

PyThreadState* __tstate = wxPyBeginAllowThreads();

8724

result = (arg1)->GetCaretForeground();

8725

wxPyEndAllowThreads(__tstate);

8726

if (PyErr_Occurred()) SWIG_fail;

8727

}

8728

resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );

8729

return resultobj;

8730

fail:

8731

return NULL;

8732

}

8733

8734

8735

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8736

PyObject *resultobj = 0;

8737

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8738

bool result;

8739

void *argp1 = 0 ;

8740

int res1 = 0 ;

8741

PyObject *swig_obj[1] ;

8742

8743

if (!args) SWIG_fail;

8744

swig_obj[0] = args;

8745

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8746

if (!SWIG_IsOK(res1)) {

8747

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetReadOnly" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8748

}

8749

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8750

{

8751

PyThreadState* __tstate = wxPyBeginAllowThreads();

8752

result = (bool)(arg1)->GetReadOnly();

8753

wxPyEndAllowThreads(__tstate);

8754

if (PyErr_Occurred()) SWIG_fail;

8755

}

8756

{

8757

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

8758

}

8759

return resultobj;

8760

fail:

8761

return NULL;

8762

}

8763

8764

8765

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetCurrentPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8766

PyObject *resultobj = 0;

8767

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8768

int arg2 ;

8769

void *argp1 = 0 ;

8770

int res1 = 0 ;

8771

int val2 ;

8772

int ecode2 = 0 ;

8773

PyObject * obj0 = 0 ;

8774

PyObject * obj1 = 0 ;

8775

char * kwnames[] = {

8776

(char *) "self",(char *) "pos", NULL

8777

};

8778

8779

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetCurrentPos",kwnames,&obj0,&obj1)) SWIG_fail;

8780

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8781

if (!SWIG_IsOK(res1)) {

8782

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetCurrentPos" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8783

}

8784

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8785

ecode2 = SWIG_AsVal_int(obj1, &val2);

8786

if (!SWIG_IsOK(ecode2)) {

8787

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetCurrentPos" "', expected argument " "2"" of type '" "int""'");

8788

}

8789

arg2 = static_cast< int >(val2);

8790

{

8791

PyThreadState* __tstate = wxPyBeginAllowThreads();

8792

(arg1)->SetCurrentPos(arg2);

8793

wxPyEndAllowThreads(__tstate);

8794

if (PyErr_Occurred()) SWIG_fail;

8795

}

8796

resultobj = SWIG_Py_Void();

8797

return resultobj;

8798

fail:

8799

return NULL;

8800

}

8801

8802

8803

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetSelectionStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8804

PyObject *resultobj = 0;

8805

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8806

int arg2 ;

8807

void *argp1 = 0 ;

8808

int res1 = 0 ;

8809

int val2 ;

8810

int ecode2 = 0 ;

8811

PyObject * obj0 = 0 ;

8812

PyObject * obj1 = 0 ;

8813

char * kwnames[] = {

8814

(char *) "self",(char *) "pos", NULL

8815

};

8816

8817

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetSelectionStart",kwnames,&obj0,&obj1)) SWIG_fail;

8818

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8819

if (!SWIG_IsOK(res1)) {

8820

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetSelectionStart" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8821

}

8822

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8823

ecode2 = SWIG_AsVal_int(obj1, &val2);

8824

if (!SWIG_IsOK(ecode2)) {

8825

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetSelectionStart" "', expected argument " "2"" of type '" "int""'");

8826

}

8827

arg2 = static_cast< int >(val2);

8828

{

8829

PyThreadState* __tstate = wxPyBeginAllowThreads();

8830

(arg1)->SetSelectionStart(arg2);

8831

wxPyEndAllowThreads(__tstate);

8832

if (PyErr_Occurred()) SWIG_fail;

8833

}

8834

resultobj = SWIG_Py_Void();

8835

return resultobj;

8836

fail:

8837

return NULL;

8838

}

8839

8840

8841

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetSelectionStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8842

PyObject *resultobj = 0;

8843

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8844

int result;

8845

void *argp1 = 0 ;

8846

int res1 = 0 ;

8847

PyObject *swig_obj[1] ;

8848

8849

if (!args) SWIG_fail;

8850

swig_obj[0] = args;

8851

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8852

if (!SWIG_IsOK(res1)) {

8853

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetSelectionStart" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8854

}

8855

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8856

{

8857

PyThreadState* __tstate = wxPyBeginAllowThreads();

8858

result = (int)(arg1)->GetSelectionStart();

8859

wxPyEndAllowThreads(__tstate);

8860

if (PyErr_Occurred()) SWIG_fail;

8861

}

8862

resultobj = SWIG_From_int(static_cast< int >(result));

8863

return resultobj;

8864

fail:

8865

return NULL;

8866

}

8867

8868

8869

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetSelectionEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8870

PyObject *resultobj = 0;

8871

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8872

int arg2 ;

8873

void *argp1 = 0 ;

8874

int res1 = 0 ;

8875

int val2 ;

8876

int ecode2 = 0 ;

8877

PyObject * obj0 = 0 ;

8878

PyObject * obj1 = 0 ;

8879

char * kwnames[] = {

8880

(char *) "self",(char *) "pos", NULL

8881

};

8882

8883

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetSelectionEnd",kwnames,&obj0,&obj1)) SWIG_fail;

8884

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8885

if (!SWIG_IsOK(res1)) {

8886

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetSelectionEnd" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8887

}

8888

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8889

ecode2 = SWIG_AsVal_int(obj1, &val2);

8890

if (!SWIG_IsOK(ecode2)) {

8891

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetSelectionEnd" "', expected argument " "2"" of type '" "int""'");

8892

}

8893

arg2 = static_cast< int >(val2);

8894

{

8895

PyThreadState* __tstate = wxPyBeginAllowThreads();

8896

(arg1)->SetSelectionEnd(arg2);

8897

wxPyEndAllowThreads(__tstate);

8898

if (PyErr_Occurred()) SWIG_fail;

8899

}

8900

resultobj = SWIG_Py_Void();

8901

return resultobj;

8902

fail:

8903

return NULL;

8904

}

8905

8906

8907

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetSelectionEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8908

PyObject *resultobj = 0;

8909

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8910

int result;

8911

void *argp1 = 0 ;

8912

int res1 = 0 ;

8913

PyObject *swig_obj[1] ;

8914

8915

if (!args) SWIG_fail;

8916

swig_obj[0] = args;

8917

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8918

if (!SWIG_IsOK(res1)) {

8919

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetSelectionEnd" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8920

}

8921

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8922

{

8923

PyThreadState* __tstate = wxPyBeginAllowThreads();

8924

result = (int)(arg1)->GetSelectionEnd();

8925

wxPyEndAllowThreads(__tstate);

8926

if (PyErr_Occurred()) SWIG_fail;

8927

}

8928

resultobj = SWIG_From_int(static_cast< int >(result));

8929

return resultobj;

8930

fail:

8931

return NULL;

8932

}

8933

8934

8935

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetPrintMagnification(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8936

PyObject *resultobj = 0;

8937

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8938

int arg2 ;

8939

void *argp1 = 0 ;

8940

int res1 = 0 ;

8941

int val2 ;

8942

int ecode2 = 0 ;

8943

PyObject * obj0 = 0 ;

8944

PyObject * obj1 = 0 ;

8945

char * kwnames[] = {

8946

(char *) "self",(char *) "magnification", NULL

8947

};

8948

8949

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetPrintMagnification",kwnames,&obj0,&obj1)) SWIG_fail;

8950

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8951

if (!SWIG_IsOK(res1)) {

8952

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetPrintMagnification" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8953

}

8954

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8955

ecode2 = SWIG_AsVal_int(obj1, &val2);

8956

if (!SWIG_IsOK(ecode2)) {

8957

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetPrintMagnification" "', expected argument " "2"" of type '" "int""'");

8958

}

8959

arg2 = static_cast< int >(val2);

8960

{

8961

PyThreadState* __tstate = wxPyBeginAllowThreads();

8962

(arg1)->SetPrintMagnification(arg2);

8963

wxPyEndAllowThreads(__tstate);

8964

if (PyErr_Occurred()) SWIG_fail;

8965

}

8966

resultobj = SWIG_Py_Void();

8967

return resultobj;

8968

fail:

8969

return NULL;

8970

}

8971

8972

8973

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetPrintMagnification(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8974

PyObject *resultobj = 0;

8975

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

8976

int result;

8977

void *argp1 = 0 ;

8978

int res1 = 0 ;

8979

PyObject *swig_obj[1] ;

8980

8981

if (!args) SWIG_fail;

8982

swig_obj[0] = args;

8983

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

8984

if (!SWIG_IsOK(res1)) {

8985

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetPrintMagnification" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

8986

}

8987

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

8988

{

8989

PyThreadState* __tstate = wxPyBeginAllowThreads();

8990

result = (int)(arg1)->GetPrintMagnification();

8991

wxPyEndAllowThreads(__tstate);

8992

if (PyErr_Occurred()) SWIG_fail;

8993

}

8994

resultobj = SWIG_From_int(static_cast< int >(result));

8995

return resultobj;

8996

fail:

8997

return NULL;

8998

}

8999

9000

9001

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetPrintColourMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9002

PyObject *resultobj = 0;

9003

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9004

int arg2 ;

9005

void *argp1 = 0 ;

9006

int res1 = 0 ;

9007

int val2 ;

9008

int ecode2 = 0 ;

9009

PyObject * obj0 = 0 ;

9010

PyObject * obj1 = 0 ;

9011

char * kwnames[] = {

9012

(char *) "self",(char *) "mode", NULL

9013

};

9014

9015

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetPrintColourMode",kwnames,&obj0,&obj1)) SWIG_fail;

9016

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9017

if (!SWIG_IsOK(res1)) {

9018

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetPrintColourMode" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9019

}

9020

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9021

ecode2 = SWIG_AsVal_int(obj1, &val2);

9022

if (!SWIG_IsOK(ecode2)) {

9023

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetPrintColourMode" "', expected argument " "2"" of type '" "int""'");

9024

}

9025

arg2 = static_cast< int >(val2);

9026

{

9027

PyThreadState* __tstate = wxPyBeginAllowThreads();

9028

(arg1)->SetPrintColourMode(arg2);

9029

wxPyEndAllowThreads(__tstate);

9030

if (PyErr_Occurred()) SWIG_fail;

9031

}

9032

resultobj = SWIG_Py_Void();

9033

return resultobj;

9034

fail:

9035

return NULL;

9036

}

9037

9038

9039

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetPrintColourMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9040

PyObject *resultobj = 0;

9041

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9042

int result;

9043

void *argp1 = 0 ;

9044

int res1 = 0 ;

9045

PyObject *swig_obj[1] ;

9046

9047

if (!args) SWIG_fail;

9048

swig_obj[0] = args;

9049

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9050

if (!SWIG_IsOK(res1)) {

9051

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetPrintColourMode" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9052

}

9053

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9054

{

9055

PyThreadState* __tstate = wxPyBeginAllowThreads();

9056

result = (int)(arg1)->GetPrintColourMode();

9057

wxPyEndAllowThreads(__tstate);

9058

if (PyErr_Occurred()) SWIG_fail;

9059

}

9060

resultobj = SWIG_From_int(static_cast< int >(result));

9061

return resultobj;

9062

fail:

9063

return NULL;

9064

}

9065

9066

9067

SWIGINTERN PyObject *_wrap_StyledTextCtrl_FindText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9068

PyObject *resultobj = 0;

9069

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9070

int arg2 ;

9071

int arg3 ;

9072

wxString *arg4 = 0 ;

9073

int arg5 = (int) 0 ;

9074

int result;

9075

void *argp1 = 0 ;

9076

int res1 = 0 ;

9077

int val2 ;

9078

int ecode2 = 0 ;

9079

int val3 ;

9080

int ecode3 = 0 ;

9081

bool temp4 = false ;

9082

int val5 ;

9083

int ecode5 = 0 ;

9084

PyObject * obj0 = 0 ;

9085

PyObject * obj1 = 0 ;

9086

PyObject * obj2 = 0 ;

9087

PyObject * obj3 = 0 ;

9088

PyObject * obj4 = 0 ;

9089

char * kwnames[] = {

9090

(char *) "self",(char *) "minPos",(char *) "maxPos",(char *) "text",(char *) "flags", NULL

9091

};

9092

9093

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:StyledTextCtrl_FindText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

9094

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9095

if (!SWIG_IsOK(res1)) {

9096

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_FindText" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9097

}

9098

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9099

ecode2 = SWIG_AsVal_int(obj1, &val2);

9100

if (!SWIG_IsOK(ecode2)) {

9101

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_FindText" "', expected argument " "2"" of type '" "int""'");

9102

}

9103

arg2 = static_cast< int >(val2);

9104

ecode3 = SWIG_AsVal_int(obj2, &val3);

9105

if (!SWIG_IsOK(ecode3)) {

9106

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_FindText" "', expected argument " "3"" of type '" "int""'");

9107

}

9108

arg3 = static_cast< int >(val3);

9109

{

9110

arg4 = wxString_in_helper(obj3);

9111

if (arg4 == NULL) SWIG_fail;

9112

temp4 = true;

9113

}

9114

if (obj4) {

9115

ecode5 = SWIG_AsVal_int(obj4, &val5);

9116

if (!SWIG_IsOK(ecode5)) {

9117

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StyledTextCtrl_FindText" "', expected argument " "5"" of type '" "int""'");

9118

}

9119

arg5 = static_cast< int >(val5);

9120

}

9121

{

9122

PyThreadState* __tstate = wxPyBeginAllowThreads();

9123

result = (int)(arg1)->FindText(arg2,arg3,(wxString const &)*arg4,arg5);

9124

wxPyEndAllowThreads(__tstate);

9125

if (PyErr_Occurred()) SWIG_fail;

9126

}

9127

resultobj = SWIG_From_int(static_cast< int >(result));

9128

{

9129

if (temp4)

9130

delete arg4;

9131

}

9132

return resultobj;

9133

fail:

9134

{

9135

if (temp4)

9136

delete arg4;

9137

}

9138

return NULL;

9139

}

9140

9141

9142

SWIGINTERN PyObject *_wrap_StyledTextCtrl_FormatRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9143

PyObject *resultobj = 0;

9144

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9145

bool arg2 ;

9146

int arg3 ;

9147

int arg4 ;

9148

wxDC *arg5 = (wxDC *) 0 ;

9149

wxDC *arg6 = (wxDC *) 0 ;

9150

wxRect arg7 ;

9151

wxRect arg8 ;

9152

int result;

9153

void *argp1 = 0 ;

9154

int res1 = 0 ;

9155

bool val2 ;

9156

int ecode2 = 0 ;

9157

int val3 ;

9158

int ecode3 = 0 ;

9159

int val4 ;

9160

int ecode4 = 0 ;

9161

void *argp5 = 0 ;

9162

int res5 = 0 ;

9163

void *argp6 = 0 ;

9164

int res6 = 0 ;

9165

void *argp7 ;

9166

int res7 = 0 ;

9167

void *argp8 ;

9168

int res8 = 0 ;

9169

PyObject * obj0 = 0 ;

9170

PyObject * obj1 = 0 ;

9171

PyObject * obj2 = 0 ;

9172

PyObject * obj3 = 0 ;

9173

PyObject * obj4 = 0 ;

9174

PyObject * obj5 = 0 ;

9175

PyObject * obj6 = 0 ;

9176

PyObject * obj7 = 0 ;

9177

char * kwnames[] = {

9178

(char *) "self",(char *) "doDraw",(char *) "startPos",(char *) "endPos",(char *) "draw",(char *) "target",(char *) "renderRect",(char *) "pageRect", NULL

9179

};

9180

9181

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:StyledTextCtrl_FormatRange",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;

9182

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9183

if (!SWIG_IsOK(res1)) {

9184

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_FormatRange" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9185

}

9186

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9187

ecode2 = SWIG_AsVal_bool(obj1, &val2);

9188

if (!SWIG_IsOK(ecode2)) {

9189

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_FormatRange" "', expected argument " "2"" of type '" "bool""'");

9190

}

9191

arg2 = static_cast< bool >(val2);

9192

ecode3 = SWIG_AsVal_int(obj2, &val3);

9193

if (!SWIG_IsOK(ecode3)) {

9194

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_FormatRange" "', expected argument " "3"" of type '" "int""'");

9195

}

9196

arg3 = static_cast< int >(val3);

9197

ecode4 = SWIG_AsVal_int(obj3, &val4);

9198

if (!SWIG_IsOK(ecode4)) {

9199

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StyledTextCtrl_FormatRange" "', expected argument " "4"" of type '" "int""'");

9200

}

9201

arg4 = static_cast< int >(val4);

9202

res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxDC, 0 | 0 );

9203

if (!SWIG_IsOK(res5)) {

9204

SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "StyledTextCtrl_FormatRange" "', expected argument " "5"" of type '" "wxDC *""'");

9205

}

9206

arg5 = reinterpret_cast< wxDC * >(argp5);

9207

res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxDC, 0 | 0 );

9208

if (!SWIG_IsOK(res6)) {

9209

SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "StyledTextCtrl_FormatRange" "', expected argument " "6"" of type '" "wxDC *""'");

9210

}

9211

arg6 = reinterpret_cast< wxDC * >(argp6);

9212

{

9213

res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxRect, 0 | 0);

9214

if (!SWIG_IsOK(res7)) {

9215

SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "StyledTextCtrl_FormatRange" "', expected argument " "7"" of type '" "wxRect""'");

9216

}

9217

if (!argp7) {

9218

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StyledTextCtrl_FormatRange" "', expected argument " "7"" of type '" "wxRect""'");

9219

} else {

9220

wxRect * temp = reinterpret_cast< wxRect * >(argp7);

9221

arg7 = *temp;

9222

if (SWIG_IsNewObj(res7)) delete temp;

9223

}

9224

}

9225

{

9226

res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxRect, 0 | 0);

9227

if (!SWIG_IsOK(res8)) {

9228

SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "StyledTextCtrl_FormatRange" "', expected argument " "8"" of type '" "wxRect""'");

9229

}

9230

if (!argp8) {

9231

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StyledTextCtrl_FormatRange" "', expected argument " "8"" of type '" "wxRect""'");

9232

} else {

9233

wxRect * temp = reinterpret_cast< wxRect * >(argp8);

9234

arg8 = *temp;

9235

if (SWIG_IsNewObj(res8)) delete temp;

9236

}

9237

}

9238

{

9239

PyThreadState* __tstate = wxPyBeginAllowThreads();

9240

result = (int)(arg1)->FormatRange(arg2,arg3,arg4,arg5,arg6,arg7,arg8);

9241

wxPyEndAllowThreads(__tstate);

9242

if (PyErr_Occurred()) SWIG_fail;

9243

}

9244

resultobj = SWIG_From_int(static_cast< int >(result));

9245

return resultobj;

9246

fail:

9247

return NULL;

9248

}

9249

9250

9251

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetFirstVisibleLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9252

PyObject *resultobj = 0;

9253

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9254

int result;

9255

void *argp1 = 0 ;

9256

int res1 = 0 ;

9257

PyObject *swig_obj[1] ;

9258

9259

if (!args) SWIG_fail;

9260

swig_obj[0] = args;

9261

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9262

if (!SWIG_IsOK(res1)) {

9263

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetFirstVisibleLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9264

}

9265

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9266

{

9267

PyThreadState* __tstate = wxPyBeginAllowThreads();

9268

result = (int)(arg1)->GetFirstVisibleLine();

9269

wxPyEndAllowThreads(__tstate);

9270

if (PyErr_Occurred()) SWIG_fail;

9271

}

9272

resultobj = SWIG_From_int(static_cast< int >(result));

9273

return resultobj;

9274

fail:

9275

return NULL;

9276

}

9277

9278

9279

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9280

PyObject *resultobj = 0;

9281

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9282

int arg2 ;

9283

wxString result;

9284

void *argp1 = 0 ;

9285

int res1 = 0 ;

9286

int val2 ;

9287

int ecode2 = 0 ;

9288

PyObject * obj0 = 0 ;

9289

PyObject * obj1 = 0 ;

9290

char * kwnames[] = {

9291

(char *) "self",(char *) "line", NULL

9292

};

9293

9294

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetLine",kwnames,&obj0,&obj1)) SWIG_fail;

9295

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9296

if (!SWIG_IsOK(res1)) {

9297

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9298

}

9299

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9300

ecode2 = SWIG_AsVal_int(obj1, &val2);

9301

if (!SWIG_IsOK(ecode2)) {

9302

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetLine" "', expected argument " "2"" of type '" "int""'");

9303

}

9304

arg2 = static_cast< int >(val2);

9305

{

9306

PyThreadState* __tstate = wxPyBeginAllowThreads();

9307

result = (arg1)->GetLine(arg2);

9308

wxPyEndAllowThreads(__tstate);

9309

if (PyErr_Occurred()) SWIG_fail;

9310

}

9311

{

9312

#if wxUSE_UNICODE

9313

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

9314

#else

9315

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

9316

#endif

9317

}

9318

return resultobj;

9319

fail:

9320

return NULL;

9321

}

9322

9323

9324

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLineCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9325

PyObject *resultobj = 0;

9326

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9327

int result;

9328

void *argp1 = 0 ;

9329

int res1 = 0 ;

9330

PyObject *swig_obj[1] ;

9331

9332

if (!args) SWIG_fail;

9333

swig_obj[0] = args;

9334

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9335

if (!SWIG_IsOK(res1)) {

9336

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLineCount" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9337

}

9338

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9339

{

9340

PyThreadState* __tstate = wxPyBeginAllowThreads();

9341

result = (int)(arg1)->GetLineCount();

9342

wxPyEndAllowThreads(__tstate);

9343

if (PyErr_Occurred()) SWIG_fail;

9344

}

9345

resultobj = SWIG_From_int(static_cast< int >(result));

9346

return resultobj;

9347

fail:

9348

return NULL;

9349

}

9350

9351

9352

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetMarginLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9353

PyObject *resultobj = 0;

9354

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9355

int arg2 ;

9356

void *argp1 = 0 ;

9357

int res1 = 0 ;

9358

int val2 ;

9359

int ecode2 = 0 ;

9360

PyObject * obj0 = 0 ;

9361

PyObject * obj1 = 0 ;

9362

char * kwnames[] = {

9363

(char *) "self",(char *) "pixelWidth", NULL

9364

};

9365

9366

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetMarginLeft",kwnames,&obj0,&obj1)) SWIG_fail;

9367

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9368

if (!SWIG_IsOK(res1)) {

9369

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetMarginLeft" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9370

}

9371

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9372

ecode2 = SWIG_AsVal_int(obj1, &val2);

9373

if (!SWIG_IsOK(ecode2)) {

9374

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetMarginLeft" "', expected argument " "2"" of type '" "int""'");

9375

}

9376

arg2 = static_cast< int >(val2);

9377

{

9378

PyThreadState* __tstate = wxPyBeginAllowThreads();

9379

(arg1)->SetMarginLeft(arg2);

9380

wxPyEndAllowThreads(__tstate);

9381

if (PyErr_Occurred()) SWIG_fail;

9382

}

9383

resultobj = SWIG_Py_Void();

9384

return resultobj;

9385

fail:

9386

return NULL;

9387

}

9388

9389

9390

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetMarginLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9391

PyObject *resultobj = 0;

9392

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9393

int result;

9394

void *argp1 = 0 ;

9395

int res1 = 0 ;

9396

PyObject *swig_obj[1] ;

9397

9398

if (!args) SWIG_fail;

9399

swig_obj[0] = args;

9400

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9401

if (!SWIG_IsOK(res1)) {

9402

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetMarginLeft" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9403

}

9404

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9405

{

9406

PyThreadState* __tstate = wxPyBeginAllowThreads();

9407

result = (int)(arg1)->GetMarginLeft();

9408

wxPyEndAllowThreads(__tstate);

9409

if (PyErr_Occurred()) SWIG_fail;

9410

}

9411

resultobj = SWIG_From_int(static_cast< int >(result));

9412

return resultobj;

9413

fail:

9414

return NULL;

9415

}

9416

9417

9418

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetMarginRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9419

PyObject *resultobj = 0;

9420

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9421

int arg2 ;

9422

void *argp1 = 0 ;

9423

int res1 = 0 ;

9424

int val2 ;

9425

int ecode2 = 0 ;

9426

PyObject * obj0 = 0 ;

9427

PyObject * obj1 = 0 ;

9428

char * kwnames[] = {

9429

(char *) "self",(char *) "pixelWidth", NULL

9430

};

9431

9432

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetMarginRight",kwnames,&obj0,&obj1)) SWIG_fail;

9433

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9434

if (!SWIG_IsOK(res1)) {

9435

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetMarginRight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9436

}

9437

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9438

ecode2 = SWIG_AsVal_int(obj1, &val2);

9439

if (!SWIG_IsOK(ecode2)) {

9440

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetMarginRight" "', expected argument " "2"" of type '" "int""'");

9441

}

9442

arg2 = static_cast< int >(val2);

9443

{

9444

PyThreadState* __tstate = wxPyBeginAllowThreads();

9445

(arg1)->SetMarginRight(arg2);

9446

wxPyEndAllowThreads(__tstate);

9447

if (PyErr_Occurred()) SWIG_fail;

9448

}

9449

resultobj = SWIG_Py_Void();

9450

return resultobj;

9451

fail:

9452

return NULL;

9453

}

9454

9455

9456

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetMarginRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9457

PyObject *resultobj = 0;

9458

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9459

int result;

9460

void *argp1 = 0 ;

9461

int res1 = 0 ;

9462

PyObject *swig_obj[1] ;

9463

9464

if (!args) SWIG_fail;

9465

swig_obj[0] = args;

9466

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9467

if (!SWIG_IsOK(res1)) {

9468

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetMarginRight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9469

}

9470

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9471

{

9472

PyThreadState* __tstate = wxPyBeginAllowThreads();

9473

result = (int)(arg1)->GetMarginRight();

9474

wxPyEndAllowThreads(__tstate);

9475

if (PyErr_Occurred()) SWIG_fail;

9476

}

9477

resultobj = SWIG_From_int(static_cast< int >(result));

9478

return resultobj;

9479

fail:

9480

return NULL;

9481

}

9482

9483

9484

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetModify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9485

PyObject *resultobj = 0;

9486

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9487

bool result;

9488

void *argp1 = 0 ;

9489

int res1 = 0 ;

9490

PyObject *swig_obj[1] ;

9491

9492

if (!args) SWIG_fail;

9493

swig_obj[0] = args;

9494

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9495

if (!SWIG_IsOK(res1)) {

9496

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetModify" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9497

}

9498

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9499

{

9500

PyThreadState* __tstate = wxPyBeginAllowThreads();

9501

result = (bool)(arg1)->GetModify();

9502

wxPyEndAllowThreads(__tstate);

9503

if (PyErr_Occurred()) SWIG_fail;

9504

}

9505

{

9506

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

9507

}

9508

return resultobj;

9509

fail:

9510

return NULL;

9511

}

9512

9513

9514

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9515

PyObject *resultobj = 0;

9516

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9517

int arg2 ;

9518

int arg3 ;

9519

void *argp1 = 0 ;

9520

int res1 = 0 ;

9521

int val2 ;

9522

int ecode2 = 0 ;

9523

int val3 ;

9524

int ecode3 = 0 ;

9525

PyObject * obj0 = 0 ;

9526

PyObject * obj1 = 0 ;

9527

PyObject * obj2 = 0 ;

9528

char * kwnames[] = {

9529

(char *) "self",(char *) "start",(char *) "end", NULL

9530

};

9531

9532

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9533

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9534

if (!SWIG_IsOK(res1)) {

9535

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetSelection" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9536

}

9537

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9538

ecode2 = SWIG_AsVal_int(obj1, &val2);

9539

if (!SWIG_IsOK(ecode2)) {

9540

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetSelection" "', expected argument " "2"" of type '" "int""'");

9541

}

9542

arg2 = static_cast< int >(val2);

9543

ecode3 = SWIG_AsVal_int(obj2, &val3);

9544

if (!SWIG_IsOK(ecode3)) {

9545

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_SetSelection" "', expected argument " "3"" of type '" "int""'");

9546

}

9547

arg3 = static_cast< int >(val3);

9548

{

9549

PyThreadState* __tstate = wxPyBeginAllowThreads();

9550

(arg1)->SetSelection(arg2,arg3);

9551

wxPyEndAllowThreads(__tstate);

9552

if (PyErr_Occurred()) SWIG_fail;

9553

}

9554

resultobj = SWIG_Py_Void();

9555

return resultobj;

9556

fail:

9557

return NULL;

9558

}

9559

9560

9561

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetSelectedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9562

PyObject *resultobj = 0;

9563

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9564

wxString result;

9565

void *argp1 = 0 ;

9566

int res1 = 0 ;

9567

PyObject *swig_obj[1] ;

9568

9569

if (!args) SWIG_fail;

9570

swig_obj[0] = args;

9571

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9572

if (!SWIG_IsOK(res1)) {

9573

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetSelectedText" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9574

}

9575

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9576

{

9577

PyThreadState* __tstate = wxPyBeginAllowThreads();

9578

result = (arg1)->GetSelectedText();

9579

wxPyEndAllowThreads(__tstate);

9580

if (PyErr_Occurred()) SWIG_fail;

9581

}

9582

{

9583

#if wxUSE_UNICODE

9584

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

9585

#else

9586

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

9587

#endif

9588

}

9589

return resultobj;

9590

fail:

9591

return NULL;

9592

}

9593

9594

9595

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetTextRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9596

PyObject *resultobj = 0;

9597

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9598

int arg2 ;

9599

int arg3 ;

9600

wxString result;

9601

void *argp1 = 0 ;

9602

int res1 = 0 ;

9603

int val2 ;

9604

int ecode2 = 0 ;

9605

int val3 ;

9606

int ecode3 = 0 ;

9607

PyObject * obj0 = 0 ;

9608

PyObject * obj1 = 0 ;

9609

PyObject * obj2 = 0 ;

9610

char * kwnames[] = {

9611

(char *) "self",(char *) "startPos",(char *) "endPos", NULL

9612

};

9613

9614

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_GetTextRange",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9615

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9616

if (!SWIG_IsOK(res1)) {

9617

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetTextRange" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9618

}

9619

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9620

ecode2 = SWIG_AsVal_int(obj1, &val2);

9621

if (!SWIG_IsOK(ecode2)) {

9622

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetTextRange" "', expected argument " "2"" of type '" "int""'");

9623

}

9624

arg2 = static_cast< int >(val2);

9625

ecode3 = SWIG_AsVal_int(obj2, &val3);

9626

if (!SWIG_IsOK(ecode3)) {

9627

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_GetTextRange" "', expected argument " "3"" of type '" "int""'");

9628

}

9629

arg3 = static_cast< int >(val3);

9630

{

9631

PyThreadState* __tstate = wxPyBeginAllowThreads();

9632

result = (arg1)->GetTextRange(arg2,arg3);

9633

wxPyEndAllowThreads(__tstate);

9634

if (PyErr_Occurred()) SWIG_fail;

9635

}

9636

{

9637

#if wxUSE_UNICODE

9638

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

9639

#else

9640

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

9641

#endif

9642

}

9643

return resultobj;

9644

fail:

9645

return NULL;

9646

}

9647

9648

9649

SWIGINTERN PyObject *_wrap_StyledTextCtrl_HideSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9650

PyObject *resultobj = 0;

9651

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9652

bool arg2 ;

9653

void *argp1 = 0 ;

9654

int res1 = 0 ;

9655

bool val2 ;

9656

int ecode2 = 0 ;

9657

PyObject * obj0 = 0 ;

9658

PyObject * obj1 = 0 ;

9659

char * kwnames[] = {

9660

(char *) "self",(char *) "normal", NULL

9661

};

9662

9663

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_HideSelection",kwnames,&obj0,&obj1)) SWIG_fail;

9664

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9665

if (!SWIG_IsOK(res1)) {

9666

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_HideSelection" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9667

}

9668

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9669

ecode2 = SWIG_AsVal_bool(obj1, &val2);

9670

if (!SWIG_IsOK(ecode2)) {

9671

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_HideSelection" "', expected argument " "2"" of type '" "bool""'");

9672

}

9673

arg2 = static_cast< bool >(val2);

9674

{

9675

PyThreadState* __tstate = wxPyBeginAllowThreads();

9676

(arg1)->HideSelection(arg2);

9677

wxPyEndAllowThreads(__tstate);

9678

if (PyErr_Occurred()) SWIG_fail;

9679

}

9680

resultobj = SWIG_Py_Void();

9681

return resultobj;

9682

fail:

9683

return NULL;

9684

}

9685

9686

9687

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineFromPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9688

PyObject *resultobj = 0;

9689

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9690

int arg2 ;

9691

int result;

9692

void *argp1 = 0 ;

9693

int res1 = 0 ;

9694

int val2 ;

9695

int ecode2 = 0 ;

9696

PyObject * obj0 = 0 ;

9697

PyObject * obj1 = 0 ;

9698

char * kwnames[] = {

9699

(char *) "self",(char *) "pos", NULL

9700

};

9701

9702

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_LineFromPosition",kwnames,&obj0,&obj1)) SWIG_fail;

9703

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9704

if (!SWIG_IsOK(res1)) {

9705

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineFromPosition" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9706

}

9707

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9708

ecode2 = SWIG_AsVal_int(obj1, &val2);

9709

if (!SWIG_IsOK(ecode2)) {

9710

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_LineFromPosition" "', expected argument " "2"" of type '" "int""'");

9711

}

9712

arg2 = static_cast< int >(val2);

9713

{

9714

PyThreadState* __tstate = wxPyBeginAllowThreads();

9715

result = (int)(arg1)->LineFromPosition(arg2);

9716

wxPyEndAllowThreads(__tstate);

9717

if (PyErr_Occurred()) SWIG_fail;

9718

}

9719

resultobj = SWIG_From_int(static_cast< int >(result));

9720

return resultobj;

9721

fail:

9722

return NULL;

9723

}

9724

9725

9726

SWIGINTERN PyObject *_wrap_StyledTextCtrl_PositionFromLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9727

PyObject *resultobj = 0;

9728

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9729

int arg2 ;

9730

int result;

9731

void *argp1 = 0 ;

9732

int res1 = 0 ;

9733

int val2 ;

9734

int ecode2 = 0 ;

9735

PyObject * obj0 = 0 ;

9736

PyObject * obj1 = 0 ;

9737

char * kwnames[] = {

9738

(char *) "self",(char *) "line", NULL

9739

};

9740

9741

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_PositionFromLine",kwnames,&obj0,&obj1)) SWIG_fail;

9742

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9743

if (!SWIG_IsOK(res1)) {

9744

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_PositionFromLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9745

}

9746

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9747

ecode2 = SWIG_AsVal_int(obj1, &val2);

9748

if (!SWIG_IsOK(ecode2)) {

9749

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_PositionFromLine" "', expected argument " "2"" of type '" "int""'");

9750

}

9751

arg2 = static_cast< int >(val2);

9752

{

9753

PyThreadState* __tstate = wxPyBeginAllowThreads();

9754

result = (int)(arg1)->PositionFromLine(arg2);

9755

wxPyEndAllowThreads(__tstate);

9756

if (PyErr_Occurred()) SWIG_fail;

9757

}

9758

resultobj = SWIG_From_int(static_cast< int >(result));

9759

return resultobj;

9760

fail:

9761

return NULL;

9762

}

9763

9764

9765

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9766

PyObject *resultobj = 0;

9767

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9768

int arg2 ;

9769

int arg3 ;

9770

void *argp1 = 0 ;

9771

int res1 = 0 ;

9772

int val2 ;

9773

int ecode2 = 0 ;

9774

int val3 ;

9775

int ecode3 = 0 ;

9776

PyObject * obj0 = 0 ;

9777

PyObject * obj1 = 0 ;

9778

PyObject * obj2 = 0 ;

9779

char * kwnames[] = {

9780

(char *) "self",(char *) "columns",(char *) "lines", NULL

9781

};

9782

9783

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_LineScroll",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9784

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9785

if (!SWIG_IsOK(res1)) {

9786

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineScroll" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9787

}

9788

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9789

ecode2 = SWIG_AsVal_int(obj1, &val2);

9790

if (!SWIG_IsOK(ecode2)) {

9791

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_LineScroll" "', expected argument " "2"" of type '" "int""'");

9792

}

9793

arg2 = static_cast< int >(val2);

9794

ecode3 = SWIG_AsVal_int(obj2, &val3);

9795

if (!SWIG_IsOK(ecode3)) {

9796

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_LineScroll" "', expected argument " "3"" of type '" "int""'");

9797

}

9798

arg3 = static_cast< int >(val3);

9799

{

9800

PyThreadState* __tstate = wxPyBeginAllowThreads();

9801

(arg1)->LineScroll(arg2,arg3);

9802

wxPyEndAllowThreads(__tstate);

9803

if (PyErr_Occurred()) SWIG_fail;

9804

}

9805

resultobj = SWIG_Py_Void();

9806

return resultobj;

9807

fail:

9808

return NULL;

9809

}

9810

9811

9812

SWIGINTERN PyObject *_wrap_StyledTextCtrl_EnsureCaretVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9813

PyObject *resultobj = 0;

9814

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9815

void *argp1 = 0 ;

9816

int res1 = 0 ;

9817

PyObject *swig_obj[1] ;

9818

9819

if (!args) SWIG_fail;

9820

swig_obj[0] = args;

9821

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9822

if (!SWIG_IsOK(res1)) {

9823

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_EnsureCaretVisible" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9824

}

9825

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9826

{

9827

PyThreadState* __tstate = wxPyBeginAllowThreads();

9828

(arg1)->EnsureCaretVisible();

9829

wxPyEndAllowThreads(__tstate);

9830

if (PyErr_Occurred()) SWIG_fail;

9831

}

9832

resultobj = SWIG_Py_Void();

9833

return resultobj;

9834

fail:

9835

return NULL;

9836

}

9837

9838

9839

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ReplaceSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9840

PyObject *resultobj = 0;

9841

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9842

wxString *arg2 = 0 ;

9843

void *argp1 = 0 ;

9844

int res1 = 0 ;

9845

bool temp2 = false ;

9846

PyObject * obj0 = 0 ;

9847

PyObject * obj1 = 0 ;

9848

char * kwnames[] = {

9849

(char *) "self",(char *) "text", NULL

9850

};

9851

9852

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_ReplaceSelection",kwnames,&obj0,&obj1)) SWIG_fail;

9853

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9854

if (!SWIG_IsOK(res1)) {

9855

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ReplaceSelection" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9856

}

9857

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9858

{

9859

arg2 = wxString_in_helper(obj1);

9860

if (arg2 == NULL) SWIG_fail;

9861

temp2 = true;

9862

}

9863

{

9864

PyThreadState* __tstate = wxPyBeginAllowThreads();

9865

(arg1)->ReplaceSelection((wxString const &)*arg2);

9866

wxPyEndAllowThreads(__tstate);

9867

if (PyErr_Occurred()) SWIG_fail;

9868

}

9869

resultobj = SWIG_Py_Void();

9870

{

9871

if (temp2)

9872

delete arg2;

9873

}

9874

return resultobj;

9875

fail:

9876

{

9877

if (temp2)

9878

delete arg2;

9879

}

9880

return NULL;

9881

}

9882

9883

9884

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9885

PyObject *resultobj = 0;

9886

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9887

bool arg2 ;

9888

void *argp1 = 0 ;

9889

int res1 = 0 ;

9890

bool val2 ;

9891

int ecode2 = 0 ;

9892

PyObject * obj0 = 0 ;

9893

PyObject * obj1 = 0 ;

9894

char * kwnames[] = {

9895

(char *) "self",(char *) "readOnly", NULL

9896

};

9897

9898

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;

9899

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9900

if (!SWIG_IsOK(res1)) {

9901

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetReadOnly" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9902

}

9903

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9904

ecode2 = SWIG_AsVal_bool(obj1, &val2);

9905

if (!SWIG_IsOK(ecode2)) {

9906

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");

9907

}

9908

arg2 = static_cast< bool >(val2);

9909

{

9910

PyThreadState* __tstate = wxPyBeginAllowThreads();

9911

(arg1)->SetReadOnly(arg2);

9912

wxPyEndAllowThreads(__tstate);

9913

if (PyErr_Occurred()) SWIG_fail;

9914

}

9915

resultobj = SWIG_Py_Void();

9916

return resultobj;

9917

fail:

9918

return NULL;

9919

}

9920

9921

9922

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CanPaste(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9923

PyObject *resultobj = 0;

9924

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9925

bool result;

9926

void *argp1 = 0 ;

9927

int res1 = 0 ;

9928

PyObject *swig_obj[1] ;

9929

9930

if (!args) SWIG_fail;

9931

swig_obj[0] = args;

9932

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9933

if (!SWIG_IsOK(res1)) {

9934

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CanPaste" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9935

}

9936

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9937

{

9938

PyThreadState* __tstate = wxPyBeginAllowThreads();

9939

result = (bool)(arg1)->CanPaste();

9940

wxPyEndAllowThreads(__tstate);

9941

if (PyErr_Occurred()) SWIG_fail;

9942

}

9943

{

9944

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

9945

}

9946

return resultobj;

9947

fail:

9948

return NULL;

9949

}

9950

9951

9952

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CanUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9953

PyObject *resultobj = 0;

9954

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9955

bool result;

9956

void *argp1 = 0 ;

9957

int res1 = 0 ;

9958

PyObject *swig_obj[1] ;

9959

9960

if (!args) SWIG_fail;

9961

swig_obj[0] = args;

9962

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9963

if (!SWIG_IsOK(res1)) {

9964

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CanUndo" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9965

}

9966

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9967

{

9968

PyThreadState* __tstate = wxPyBeginAllowThreads();

9969

result = (bool)(arg1)->CanUndo();

9970

wxPyEndAllowThreads(__tstate);

9971

if (PyErr_Occurred()) SWIG_fail;

9972

}

9973

{

9974

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

9975

}

9976

return resultobj;

9977

fail:

9978

return NULL;

9979

}

9980

9981

9982

SWIGINTERN PyObject *_wrap_StyledTextCtrl_EmptyUndoBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9983

PyObject *resultobj = 0;

9984

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

9985

void *argp1 = 0 ;

9986

int res1 = 0 ;

9987

PyObject *swig_obj[1] ;

9988

9989

if (!args) SWIG_fail;

9990

swig_obj[0] = args;

9991

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

9992

if (!SWIG_IsOK(res1)) {

9993

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_EmptyUndoBuffer" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

9994

}

9995

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

9996

{

9997

PyThreadState* __tstate = wxPyBeginAllowThreads();

9998

(arg1)->EmptyUndoBuffer();

9999

wxPyEndAllowThreads(__tstate);

10000

if (PyErr_Occurred()) SWIG_fail;

10001

}

10002

resultobj = SWIG_Py_Void();

10003

return resultobj;

10004

fail:

10005

return NULL;

10006

}

10007

10008

10009

SWIGINTERN PyObject *_wrap_StyledTextCtrl_Undo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10010

PyObject *resultobj = 0;

10011

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10012

void *argp1 = 0 ;

10013

int res1 = 0 ;

10014

PyObject *swig_obj[1] ;

10015

10016

if (!args) SWIG_fail;

10017

swig_obj[0] = args;

10018

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10019

if (!SWIG_IsOK(res1)) {

10020

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_Undo" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10021

}

10022

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10023

{

10024

PyThreadState* __tstate = wxPyBeginAllowThreads();

10025

(arg1)->Undo();

10026

wxPyEndAllowThreads(__tstate);

10027

if (PyErr_Occurred()) SWIG_fail;

10028

}

10029

resultobj = SWIG_Py_Void();

10030

return resultobj;

10031

fail:

10032

return NULL;

10033

}

10034

10035

10036

SWIGINTERN PyObject *_wrap_StyledTextCtrl_Cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10037

PyObject *resultobj = 0;

10038

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10039

void *argp1 = 0 ;

10040

int res1 = 0 ;

10041

PyObject *swig_obj[1] ;

10042

10043

if (!args) SWIG_fail;

10044

swig_obj[0] = args;

10045

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10046

if (!SWIG_IsOK(res1)) {

10047

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_Cut" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10048

}

10049

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10050

{

10051

PyThreadState* __tstate = wxPyBeginAllowThreads();

10052

(arg1)->Cut();

10053

wxPyEndAllowThreads(__tstate);

10054

if (PyErr_Occurred()) SWIG_fail;

10055

}

10056

resultobj = SWIG_Py_Void();

10057

return resultobj;

10058

fail:

10059

return NULL;

10060

}

10061

10062

10063

SWIGINTERN PyObject *_wrap_StyledTextCtrl_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10064

PyObject *resultobj = 0;

10065

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10066

void *argp1 = 0 ;

10067

int res1 = 0 ;

10068

PyObject *swig_obj[1] ;

10069

10070

if (!args) SWIG_fail;

10071

swig_obj[0] = args;

10072

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10073

if (!SWIG_IsOK(res1)) {

10074

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_Copy" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10075

}

10076

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10077

{

10078

PyThreadState* __tstate = wxPyBeginAllowThreads();

10079

(arg1)->Copy();

10080

wxPyEndAllowThreads(__tstate);

10081

if (PyErr_Occurred()) SWIG_fail;

10082

}

10083

resultobj = SWIG_Py_Void();

10084

return resultobj;

10085

fail:

10086

return NULL;

10087

}

10088

10089

10090

SWIGINTERN PyObject *_wrap_StyledTextCtrl_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10091

PyObject *resultobj = 0;

10092

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10093

void *argp1 = 0 ;

10094

int res1 = 0 ;

10095

PyObject *swig_obj[1] ;

10096

10097

if (!args) SWIG_fail;

10098

swig_obj[0] = args;

10099

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10100

if (!SWIG_IsOK(res1)) {

10101

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_Paste" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10102

}

10103

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10104

{

10105

PyThreadState* __tstate = wxPyBeginAllowThreads();

10106

(arg1)->Paste();

10107

wxPyEndAllowThreads(__tstate);

10108

if (PyErr_Occurred()) SWIG_fail;

10109

}

10110

resultobj = SWIG_Py_Void();

10111

return resultobj;

10112

fail:

10113

return NULL;

10114

}

10115

10116

10117

SWIGINTERN PyObject *_wrap_StyledTextCtrl_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10118

PyObject *resultobj = 0;

10119

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10120

void *argp1 = 0 ;

10121

int res1 = 0 ;

10122

PyObject *swig_obj[1] ;

10123

10124

if (!args) SWIG_fail;

10125

swig_obj[0] = args;

10126

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10127

if (!SWIG_IsOK(res1)) {

10128

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_Clear" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10129

}

10130

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10131

{

10132

PyThreadState* __tstate = wxPyBeginAllowThreads();

10133

(arg1)->Clear();

10134

wxPyEndAllowThreads(__tstate);

10135

if (PyErr_Occurred()) SWIG_fail;

10136

}

10137

resultobj = SWIG_Py_Void();

10138

return resultobj;

10139

fail:

10140

return NULL;

10141

}

10142

10143

10144

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10145

PyObject *resultobj = 0;

10146

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10147

wxString *arg2 = 0 ;

10148

void *argp1 = 0 ;

10149

int res1 = 0 ;

10150

bool temp2 = false ;

10151

PyObject * obj0 = 0 ;

10152

PyObject * obj1 = 0 ;

10153

char * kwnames[] = {

10154

(char *) "self",(char *) "text", NULL

10155

};

10156

10157

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetText",kwnames,&obj0,&obj1)) SWIG_fail;

10158

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10159

if (!SWIG_IsOK(res1)) {

10160

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetText" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10161

}

10162

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10163

{

10164

arg2 = wxString_in_helper(obj1);

10165

if (arg2 == NULL) SWIG_fail;

10166

temp2 = true;

10167

}

10168

{

10169

PyThreadState* __tstate = wxPyBeginAllowThreads();

10170

(arg1)->SetText((wxString const &)*arg2);

10171

wxPyEndAllowThreads(__tstate);

10172

if (PyErr_Occurred()) SWIG_fail;

10173

}

10174

resultobj = SWIG_Py_Void();

10175

{

10176

if (temp2)

10177

delete arg2;

10178

}

10179

return resultobj;

10180

fail:

10181

{

10182

if (temp2)

10183

delete arg2;

10184

}

10185

return NULL;

10186

}

10187

10188

10189

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10190

PyObject *resultobj = 0;

10191

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10192

wxString result;

10193

void *argp1 = 0 ;

10194

int res1 = 0 ;

10195

PyObject *swig_obj[1] ;

10196

10197

if (!args) SWIG_fail;

10198

swig_obj[0] = args;

10199

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10200

if (!SWIG_IsOK(res1)) {

10201

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetText" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10202

}

10203

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10204

{

10205

PyThreadState* __tstate = wxPyBeginAllowThreads();

10206

result = (arg1)->GetText();

10207

wxPyEndAllowThreads(__tstate);

10208

if (PyErr_Occurred()) SWIG_fail;

10209

}

10210

{

10211

#if wxUSE_UNICODE

10212

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

10213

#else

10214

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

10215

#endif

10216

}

10217

return resultobj;

10218

fail:

10219

return NULL;

10220

}

10221

10222

10223

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10224

PyObject *resultobj = 0;

10225

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10226

int result;

10227

void *argp1 = 0 ;

10228

int res1 = 0 ;

10229

PyObject *swig_obj[1] ;

10230

10231

if (!args) SWIG_fail;

10232

swig_obj[0] = args;

10233

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10234

if (!SWIG_IsOK(res1)) {

10235

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetTextLength" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10236

}

10237

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10238

{

10239

PyThreadState* __tstate = wxPyBeginAllowThreads();

10240

result = (int)(arg1)->GetTextLength();

10241

wxPyEndAllowThreads(__tstate);

10242

if (PyErr_Occurred()) SWIG_fail;

10243

}

10244

resultobj = SWIG_From_int(static_cast< int >(result));

10245

return resultobj;

10246

fail:

10247

return NULL;

10248

}

10249

10250

10251

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetOvertype(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10252

PyObject *resultobj = 0;

10253

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10254

bool arg2 ;

10255

void *argp1 = 0 ;

10256

int res1 = 0 ;

10257

bool val2 ;

10258

int ecode2 = 0 ;

10259

PyObject * obj0 = 0 ;

10260

PyObject * obj1 = 0 ;

10261

char * kwnames[] = {

10262

(char *) "self",(char *) "overtype", NULL

10263

};

10264

10265

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetOvertype",kwnames,&obj0,&obj1)) SWIG_fail;

10266

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10267

if (!SWIG_IsOK(res1)) {

10268

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetOvertype" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10269

}

10270

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10271

ecode2 = SWIG_AsVal_bool(obj1, &val2);

10272

if (!SWIG_IsOK(ecode2)) {

10273

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetOvertype" "', expected argument " "2"" of type '" "bool""'");

10274

}

10275

arg2 = static_cast< bool >(val2);

10276

{

10277

PyThreadState* __tstate = wxPyBeginAllowThreads();

10278

(arg1)->SetOvertype(arg2);

10279

wxPyEndAllowThreads(__tstate);

10280

if (PyErr_Occurred()) SWIG_fail;

10281

}

10282

resultobj = SWIG_Py_Void();

10283

return resultobj;

10284

fail:

10285

return NULL;

10286

}

10287

10288

10289

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetOvertype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10290

PyObject *resultobj = 0;

10291

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10292

bool result;

10293

void *argp1 = 0 ;

10294

int res1 = 0 ;

10295

PyObject *swig_obj[1] ;

10296

10297

if (!args) SWIG_fail;

10298

swig_obj[0] = args;

10299

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10300

if (!SWIG_IsOK(res1)) {

10301

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetOvertype" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10302

}

10303

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10304

{

10305

PyThreadState* __tstate = wxPyBeginAllowThreads();

10306

result = (bool)(arg1)->GetOvertype();

10307

wxPyEndAllowThreads(__tstate);

10308

if (PyErr_Occurred()) SWIG_fail;

10309

}

10310

{

10311

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10312

}

10313

return resultobj;

10314

fail:

10315

return NULL;

10316

}

10317

10318

10319

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetCaretWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10320

PyObject *resultobj = 0;

10321

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10322

int arg2 ;

10323

void *argp1 = 0 ;

10324

int res1 = 0 ;

10325

int val2 ;

10326

int ecode2 = 0 ;

10327

PyObject * obj0 = 0 ;

10328

PyObject * obj1 = 0 ;

10329

char * kwnames[] = {

10330

(char *) "self",(char *) "pixelWidth", NULL

10331

};

10332

10333

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetCaretWidth",kwnames,&obj0,&obj1)) SWIG_fail;

10334

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10335

if (!SWIG_IsOK(res1)) {

10336

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetCaretWidth" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10337

}

10338

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10339

ecode2 = SWIG_AsVal_int(obj1, &val2);

10340

if (!SWIG_IsOK(ecode2)) {

10341

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetCaretWidth" "', expected argument " "2"" of type '" "int""'");

10342

}

10343

arg2 = static_cast< int >(val2);

10344

{

10345

PyThreadState* __tstate = wxPyBeginAllowThreads();

10346

(arg1)->SetCaretWidth(arg2);

10347

wxPyEndAllowThreads(__tstate);

10348

if (PyErr_Occurred()) SWIG_fail;

10349

}

10350

resultobj = SWIG_Py_Void();

10351

return resultobj;

10352

fail:

10353

return NULL;

10354

}

10355

10356

10357

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetCaretWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10358

PyObject *resultobj = 0;

10359

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10360

int result;

10361

void *argp1 = 0 ;

10362

int res1 = 0 ;

10363

PyObject *swig_obj[1] ;

10364

10365

if (!args) SWIG_fail;

10366

swig_obj[0] = args;

10367

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10368

if (!SWIG_IsOK(res1)) {

10369

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetCaretWidth" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10370

}

10371

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10372

{

10373

PyThreadState* __tstate = wxPyBeginAllowThreads();

10374

result = (int)(arg1)->GetCaretWidth();

10375

wxPyEndAllowThreads(__tstate);

10376

if (PyErr_Occurred()) SWIG_fail;

10377

}

10378

resultobj = SWIG_From_int(static_cast< int >(result));

10379

return resultobj;

10380

fail:

10381

return NULL;

10382

}

10383

10384

10385

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetTargetStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10386

PyObject *resultobj = 0;

10387

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10388

int arg2 ;

10389

void *argp1 = 0 ;

10390

int res1 = 0 ;

10391

int val2 ;

10392

int ecode2 = 0 ;

10393

PyObject * obj0 = 0 ;

10394

PyObject * obj1 = 0 ;

10395

char * kwnames[] = {

10396

(char *) "self",(char *) "pos", NULL

10397

};

10398

10399

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetTargetStart",kwnames,&obj0,&obj1)) SWIG_fail;

10400

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10401

if (!SWIG_IsOK(res1)) {

10402

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetTargetStart" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10403

}

10404

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10405

ecode2 = SWIG_AsVal_int(obj1, &val2);

10406

if (!SWIG_IsOK(ecode2)) {

10407

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetTargetStart" "', expected argument " "2"" of type '" "int""'");

10408

}

10409

arg2 = static_cast< int >(val2);

10410

{

10411

PyThreadState* __tstate = wxPyBeginAllowThreads();

10412

(arg1)->SetTargetStart(arg2);

10413

wxPyEndAllowThreads(__tstate);

10414

if (PyErr_Occurred()) SWIG_fail;

10415

}

10416

resultobj = SWIG_Py_Void();

10417

return resultobj;

10418

fail:

10419

return NULL;

10420

}

10421

10422

10423

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetTargetStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10424

PyObject *resultobj = 0;

10425

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10426

int result;

10427

void *argp1 = 0 ;

10428

int res1 = 0 ;

10429

PyObject *swig_obj[1] ;

10430

10431

if (!args) SWIG_fail;

10432

swig_obj[0] = args;

10433

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10434

if (!SWIG_IsOK(res1)) {

10435

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetTargetStart" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10436

}

10437

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10438

{

10439

PyThreadState* __tstate = wxPyBeginAllowThreads();

10440

result = (int)(arg1)->GetTargetStart();

10441

wxPyEndAllowThreads(__tstate);

10442

if (PyErr_Occurred()) SWIG_fail;

10443

}

10444

resultobj = SWIG_From_int(static_cast< int >(result));

10445

return resultobj;

10446

fail:

10447

return NULL;

10448

}

10449

10450

10451

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetTargetEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10452

PyObject *resultobj = 0;

10453

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10454

int arg2 ;

10455

void *argp1 = 0 ;

10456

int res1 = 0 ;

10457

int val2 ;

10458

int ecode2 = 0 ;

10459

PyObject * obj0 = 0 ;

10460

PyObject * obj1 = 0 ;

10461

char * kwnames[] = {

10462

(char *) "self",(char *) "pos", NULL

10463

};

10464

10465

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetTargetEnd",kwnames,&obj0,&obj1)) SWIG_fail;

10466

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10467

if (!SWIG_IsOK(res1)) {

10468

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetTargetEnd" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10469

}

10470

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10471

ecode2 = SWIG_AsVal_int(obj1, &val2);

10472

if (!SWIG_IsOK(ecode2)) {

10473

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetTargetEnd" "', expected argument " "2"" of type '" "int""'");

10474

}

10475

arg2 = static_cast< int >(val2);

10476

{

10477

PyThreadState* __tstate = wxPyBeginAllowThreads();

10478

(arg1)->SetTargetEnd(arg2);

10479

wxPyEndAllowThreads(__tstate);

10480

if (PyErr_Occurred()) SWIG_fail;

10481

}

10482

resultobj = SWIG_Py_Void();

10483

return resultobj;

10484

fail:

10485

return NULL;

10486

}

10487

10488

10489

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetTargetEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10490

PyObject *resultobj = 0;

10491

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10492

int result;

10493

void *argp1 = 0 ;

10494

int res1 = 0 ;

10495

PyObject *swig_obj[1] ;

10496

10497

if (!args) SWIG_fail;

10498

swig_obj[0] = args;

10499

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10500

if (!SWIG_IsOK(res1)) {

10501

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetTargetEnd" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10502

}

10503

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10504

{

10505

PyThreadState* __tstate = wxPyBeginAllowThreads();

10506

result = (int)(arg1)->GetTargetEnd();

10507

wxPyEndAllowThreads(__tstate);

10508

if (PyErr_Occurred()) SWIG_fail;

10509

}

10510

resultobj = SWIG_From_int(static_cast< int >(result));

10511

return resultobj;

10512

fail:

10513

return NULL;

10514

}

10515

10516

10517

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ReplaceTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10518

PyObject *resultobj = 0;

10519

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10520

wxString *arg2 = 0 ;

10521

int result;

10522

void *argp1 = 0 ;

10523

int res1 = 0 ;

10524

bool temp2 = false ;

10525

PyObject * obj0 = 0 ;

10526

PyObject * obj1 = 0 ;

10527

char * kwnames[] = {

10528

(char *) "self",(char *) "text", NULL

10529

};

10530

10531

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_ReplaceTarget",kwnames,&obj0,&obj1)) SWIG_fail;

10532

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10533

if (!SWIG_IsOK(res1)) {

10534

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ReplaceTarget" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10535

}

10536

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10537

{

10538

arg2 = wxString_in_helper(obj1);

10539

if (arg2 == NULL) SWIG_fail;

10540

temp2 = true;

10541

}

10542

{

10543

PyThreadState* __tstate = wxPyBeginAllowThreads();

10544

result = (int)(arg1)->ReplaceTarget((wxString const &)*arg2);

10545

wxPyEndAllowThreads(__tstate);

10546

if (PyErr_Occurred()) SWIG_fail;

10547

}

10548

resultobj = SWIG_From_int(static_cast< int >(result));

10549

{

10550

if (temp2)

10551

delete arg2;

10552

}

10553

return resultobj;

10554

fail:

10555

{

10556

if (temp2)

10557

delete arg2;

10558

}

10559

return NULL;

10560

}

10561

10562

10563

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ReplaceTargetRE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10564

PyObject *resultobj = 0;

10565

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10566

wxString *arg2 = 0 ;

10567

int result;

10568

void *argp1 = 0 ;

10569

int res1 = 0 ;

10570

bool temp2 = false ;

10571

PyObject * obj0 = 0 ;

10572

PyObject * obj1 = 0 ;

10573

char * kwnames[] = {

10574

(char *) "self",(char *) "text", NULL

10575

};

10576

10577

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_ReplaceTargetRE",kwnames,&obj0,&obj1)) SWIG_fail;

10578

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10579

if (!SWIG_IsOK(res1)) {

10580

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ReplaceTargetRE" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10581

}

10582

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10583

{

10584

arg2 = wxString_in_helper(obj1);

10585

if (arg2 == NULL) SWIG_fail;

10586

temp2 = true;

10587

}

10588

{

10589

PyThreadState* __tstate = wxPyBeginAllowThreads();

10590

result = (int)(arg1)->ReplaceTargetRE((wxString const &)*arg2);

10591

wxPyEndAllowThreads(__tstate);

10592

if (PyErr_Occurred()) SWIG_fail;

10593

}

10594

resultobj = SWIG_From_int(static_cast< int >(result));

10595

{

10596

if (temp2)

10597

delete arg2;

10598

}

10599

return resultobj;

10600

fail:

10601

{

10602

if (temp2)

10603

delete arg2;

10604

}

10605

return NULL;

10606

}

10607

10608

10609

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SearchInTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10610

PyObject *resultobj = 0;

10611

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10612

wxString *arg2 = 0 ;

10613

int result;

10614

void *argp1 = 0 ;

10615

int res1 = 0 ;

10616

bool temp2 = false ;

10617

PyObject * obj0 = 0 ;

10618

PyObject * obj1 = 0 ;

10619

char * kwnames[] = {

10620

(char *) "self",(char *) "text", NULL

10621

};

10622

10623

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SearchInTarget",kwnames,&obj0,&obj1)) SWIG_fail;

10624

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10625

if (!SWIG_IsOK(res1)) {

10626

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SearchInTarget" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10627

}

10628

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10629

{

10630

arg2 = wxString_in_helper(obj1);

10631

if (arg2 == NULL) SWIG_fail;

10632

temp2 = true;

10633

}

10634

{

10635

PyThreadState* __tstate = wxPyBeginAllowThreads();

10636

result = (int)(arg1)->SearchInTarget((wxString const &)*arg2);

10637

wxPyEndAllowThreads(__tstate);

10638

if (PyErr_Occurred()) SWIG_fail;

10639

}

10640

resultobj = SWIG_From_int(static_cast< int >(result));

10641

{

10642

if (temp2)

10643

delete arg2;

10644

}

10645

return resultobj;

10646

fail:

10647

{

10648

if (temp2)

10649

delete arg2;

10650

}

10651

return NULL;

10652

}

10653

10654

10655

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetSearchFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10656

PyObject *resultobj = 0;

10657

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10658

int arg2 ;

10659

void *argp1 = 0 ;

10660

int res1 = 0 ;

10661

int val2 ;

10662

int ecode2 = 0 ;

10663

PyObject * obj0 = 0 ;

10664

PyObject * obj1 = 0 ;

10665

char * kwnames[] = {

10666

(char *) "self",(char *) "flags", NULL

10667

};

10668

10669

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetSearchFlags",kwnames,&obj0,&obj1)) SWIG_fail;

10670

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10671

if (!SWIG_IsOK(res1)) {

10672

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetSearchFlags" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10673

}

10674

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10675

ecode2 = SWIG_AsVal_int(obj1, &val2);

10676

if (!SWIG_IsOK(ecode2)) {

10677

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetSearchFlags" "', expected argument " "2"" of type '" "int""'");

10678

}

10679

arg2 = static_cast< int >(val2);

10680

{

10681

PyThreadState* __tstate = wxPyBeginAllowThreads();

10682

(arg1)->SetSearchFlags(arg2);

10683

wxPyEndAllowThreads(__tstate);

10684

if (PyErr_Occurred()) SWIG_fail;

10685

}

10686

resultobj = SWIG_Py_Void();

10687

return resultobj;

10688

fail:

10689

return NULL;

10690

}

10691

10692

10693

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetSearchFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10694

PyObject *resultobj = 0;

10695

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10696

int result;

10697

void *argp1 = 0 ;

10698

int res1 = 0 ;

10699

PyObject *swig_obj[1] ;

10700

10701

if (!args) SWIG_fail;

10702

swig_obj[0] = args;

10703

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10704

if (!SWIG_IsOK(res1)) {

10705

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetSearchFlags" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10706

}

10707

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10708

{

10709

PyThreadState* __tstate = wxPyBeginAllowThreads();

10710

result = (int)(arg1)->GetSearchFlags();

10711

wxPyEndAllowThreads(__tstate);

10712

if (PyErr_Occurred()) SWIG_fail;

10713

}

10714

resultobj = SWIG_From_int(static_cast< int >(result));

10715

return resultobj;

10716

fail:

10717

return NULL;

10718

}

10719

10720

10721

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CallTipShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10722

PyObject *resultobj = 0;

10723

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10724

int arg2 ;

10725

wxString *arg3 = 0 ;

10726

void *argp1 = 0 ;

10727

int res1 = 0 ;

10728

int val2 ;

10729

int ecode2 = 0 ;

10730

bool temp3 = false ;

10731

PyObject * obj0 = 0 ;

10732

PyObject * obj1 = 0 ;

10733

PyObject * obj2 = 0 ;

10734

char * kwnames[] = {

10735

(char *) "self",(char *) "pos",(char *) "definition", NULL

10736

};

10737

10738

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_CallTipShow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

10739

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10740

if (!SWIG_IsOK(res1)) {

10741

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CallTipShow" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10742

}

10743

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10744

ecode2 = SWIG_AsVal_int(obj1, &val2);

10745

if (!SWIG_IsOK(ecode2)) {

10746

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_CallTipShow" "', expected argument " "2"" of type '" "int""'");

10747

}

10748

arg2 = static_cast< int >(val2);

10749

{

10750

arg3 = wxString_in_helper(obj2);

10751

if (arg3 == NULL) SWIG_fail;

10752

temp3 = true;

10753

}

10754

{

10755

PyThreadState* __tstate = wxPyBeginAllowThreads();

10756

(arg1)->CallTipShow(arg2,(wxString const &)*arg3);

10757

wxPyEndAllowThreads(__tstate);

10758

if (PyErr_Occurred()) SWIG_fail;

10759

}

10760

resultobj = SWIG_Py_Void();

10761

{

10762

if (temp3)

10763

delete arg3;

10764

}

10765

return resultobj;

10766

fail:

10767

{

10768

if (temp3)

10769

delete arg3;

10770

}

10771

return NULL;

10772

}

10773

10774

10775

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CallTipCancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10776

PyObject *resultobj = 0;

10777

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10778

void *argp1 = 0 ;

10779

int res1 = 0 ;

10780

PyObject *swig_obj[1] ;

10781

10782

if (!args) SWIG_fail;

10783

swig_obj[0] = args;

10784

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10785

if (!SWIG_IsOK(res1)) {

10786

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CallTipCancel" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10787

}

10788

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10789

{

10790

PyThreadState* __tstate = wxPyBeginAllowThreads();

10791

(arg1)->CallTipCancel();

10792

wxPyEndAllowThreads(__tstate);

10793

if (PyErr_Occurred()) SWIG_fail;

10794

}

10795

resultobj = SWIG_Py_Void();

10796

return resultobj;

10797

fail:

10798

return NULL;

10799

}

10800

10801

10802

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CallTipActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10803

PyObject *resultobj = 0;

10804

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10805

bool result;

10806

void *argp1 = 0 ;

10807

int res1 = 0 ;

10808

PyObject *swig_obj[1] ;

10809

10810

if (!args) SWIG_fail;

10811

swig_obj[0] = args;

10812

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10813

if (!SWIG_IsOK(res1)) {

10814

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CallTipActive" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10815

}

10816

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10817

{

10818

PyThreadState* __tstate = wxPyBeginAllowThreads();

10819

result = (bool)(arg1)->CallTipActive();

10820

wxPyEndAllowThreads(__tstate);

10821

if (PyErr_Occurred()) SWIG_fail;

10822

}

10823

{

10824

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10825

}

10826

return resultobj;

10827

fail:

10828

return NULL;

10829

}

10830

10831

10832

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CallTipPosAtStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10833

PyObject *resultobj = 0;

10834

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10835

int result;

10836

void *argp1 = 0 ;

10837

int res1 = 0 ;

10838

PyObject *swig_obj[1] ;

10839

10840

if (!args) SWIG_fail;

10841

swig_obj[0] = args;

10842

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10843

if (!SWIG_IsOK(res1)) {

10844

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CallTipPosAtStart" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10845

}

10846

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10847

{

10848

PyThreadState* __tstate = wxPyBeginAllowThreads();

10849

result = (int)(arg1)->CallTipPosAtStart();

10850

wxPyEndAllowThreads(__tstate);

10851

if (PyErr_Occurred()) SWIG_fail;

10852

}

10853

resultobj = SWIG_From_int(static_cast< int >(result));

10854

return resultobj;

10855

fail:

10856

return NULL;

10857

}

10858

10859

10860

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CallTipSetHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10861

PyObject *resultobj = 0;

10862

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10863

int arg2 ;

10864

int arg3 ;

10865

void *argp1 = 0 ;

10866

int res1 = 0 ;

10867

int val2 ;

10868

int ecode2 = 0 ;

10869

int val3 ;

10870

int ecode3 = 0 ;

10871

PyObject * obj0 = 0 ;

10872

PyObject * obj1 = 0 ;

10873

PyObject * obj2 = 0 ;

10874

char * kwnames[] = {

10875

(char *) "self",(char *) "start",(char *) "end", NULL

10876

};

10877

10878

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_CallTipSetHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

10879

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10880

if (!SWIG_IsOK(res1)) {

10881

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CallTipSetHighlight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10882

}

10883

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10884

ecode2 = SWIG_AsVal_int(obj1, &val2);

10885

if (!SWIG_IsOK(ecode2)) {

10886

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_CallTipSetHighlight" "', expected argument " "2"" of type '" "int""'");

10887

}

10888

arg2 = static_cast< int >(val2);

10889

ecode3 = SWIG_AsVal_int(obj2, &val3);

10890

if (!SWIG_IsOK(ecode3)) {

10891

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_CallTipSetHighlight" "', expected argument " "3"" of type '" "int""'");

10892

}

10893

arg3 = static_cast< int >(val3);

10894

{

10895

PyThreadState* __tstate = wxPyBeginAllowThreads();

10896

(arg1)->CallTipSetHighlight(arg2,arg3);

10897

wxPyEndAllowThreads(__tstate);

10898

if (PyErr_Occurred()) SWIG_fail;

10899

}

10900

resultobj = SWIG_Py_Void();

10901

return resultobj;

10902

fail:

10903

return NULL;

10904

}

10905

10906

10907

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CallTipSetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10908

PyObject *resultobj = 0;

10909

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10910

wxColour *arg2 = 0 ;

10911

void *argp1 = 0 ;

10912

int res1 = 0 ;

10913

wxColour temp2 ;

10914

PyObject * obj0 = 0 ;

10915

PyObject * obj1 = 0 ;

10916

char * kwnames[] = {

10917

(char *) "self",(char *) "back", NULL

10918

};

10919

10920

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_CallTipSetBackground",kwnames,&obj0,&obj1)) SWIG_fail;

10921

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10922

if (!SWIG_IsOK(res1)) {

10923

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CallTipSetBackground" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10924

}

10925

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10926

{

10927

arg2 = &temp2;

10928

if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;

10929

}

10930

{

10931

PyThreadState* __tstate = wxPyBeginAllowThreads();

10932

(arg1)->CallTipSetBackground((wxColour const &)*arg2);

10933

wxPyEndAllowThreads(__tstate);

10934

if (PyErr_Occurred()) SWIG_fail;

10935

}

10936

resultobj = SWIG_Py_Void();

10937

return resultobj;

10938

fail:

10939

return NULL;

10940

}

10941

10942

10943

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CallTipSetForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10944

PyObject *resultobj = 0;

10945

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10946

wxColour *arg2 = 0 ;

10947

void *argp1 = 0 ;

10948

int res1 = 0 ;

10949

wxColour temp2 ;

10950

PyObject * obj0 = 0 ;

10951

PyObject * obj1 = 0 ;

10952

char * kwnames[] = {

10953

(char *) "self",(char *) "fore", NULL

10954

};

10955

10956

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_CallTipSetForeground",kwnames,&obj0,&obj1)) SWIG_fail;

10957

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10958

if (!SWIG_IsOK(res1)) {

10959

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CallTipSetForeground" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10960

}

10961

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10962

{

10963

arg2 = &temp2;

10964

if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;

10965

}

10966

{

10967

PyThreadState* __tstate = wxPyBeginAllowThreads();

10968

(arg1)->CallTipSetForeground((wxColour const &)*arg2);

10969

wxPyEndAllowThreads(__tstate);

10970

if (PyErr_Occurred()) SWIG_fail;

10971

}

10972

resultobj = SWIG_Py_Void();

10973

return resultobj;

10974

fail:

10975

return NULL;

10976

}

10977

10978

10979

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CallTipSetForegroundHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10980

PyObject *resultobj = 0;

10981

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

10982

wxColour *arg2 = 0 ;

10983

void *argp1 = 0 ;

10984

int res1 = 0 ;

10985

wxColour temp2 ;

10986

PyObject * obj0 = 0 ;

10987

PyObject * obj1 = 0 ;

10988

char * kwnames[] = {

10989

(char *) "self",(char *) "fore", NULL

10990

};

10991

10992

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_CallTipSetForegroundHighlight",kwnames,&obj0,&obj1)) SWIG_fail;

10993

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

10994

if (!SWIG_IsOK(res1)) {

10995

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CallTipSetForegroundHighlight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

10996

}

10997

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

10998

{

10999

arg2 = &temp2;

11000

if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;

11001

}

11002

{

11003

PyThreadState* __tstate = wxPyBeginAllowThreads();

11004

(arg1)->CallTipSetForegroundHighlight((wxColour const &)*arg2);

11005

wxPyEndAllowThreads(__tstate);

11006

if (PyErr_Occurred()) SWIG_fail;

11007

}

11008

resultobj = SWIG_Py_Void();

11009

return resultobj;

11010

fail:

11011

return NULL;

11012

}

11013

11014

11015

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CallTipUseStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11016

PyObject *resultobj = 0;

11017

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11018

int arg2 ;

11019

void *argp1 = 0 ;

11020

int res1 = 0 ;

11021

int val2 ;

11022

int ecode2 = 0 ;

11023

PyObject * obj0 = 0 ;

11024

PyObject * obj1 = 0 ;

11025

char * kwnames[] = {

11026

(char *) "self",(char *) "tabSize", NULL

11027

};

11028

11029

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_CallTipUseStyle",kwnames,&obj0,&obj1)) SWIG_fail;

11030

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11031

if (!SWIG_IsOK(res1)) {

11032

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CallTipUseStyle" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11033

}

11034

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11035

ecode2 = SWIG_AsVal_int(obj1, &val2);

11036

if (!SWIG_IsOK(ecode2)) {

11037

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_CallTipUseStyle" "', expected argument " "2"" of type '" "int""'");

11038

}

11039

arg2 = static_cast< int >(val2);

11040

{

11041

PyThreadState* __tstate = wxPyBeginAllowThreads();

11042

(arg1)->CallTipUseStyle(arg2);

11043

wxPyEndAllowThreads(__tstate);

11044

if (PyErr_Occurred()) SWIG_fail;

11045

}

11046

resultobj = SWIG_Py_Void();

11047

return resultobj;

11048

fail:

11049

return NULL;

11050

}

11051

11052

11053

SWIGINTERN PyObject *_wrap_StyledTextCtrl_VisibleFromDocLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11054

PyObject *resultobj = 0;

11055

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11056

int arg2 ;

11057

int result;

11058

void *argp1 = 0 ;

11059

int res1 = 0 ;

11060

int val2 ;

11061

int ecode2 = 0 ;

11062

PyObject * obj0 = 0 ;

11063

PyObject * obj1 = 0 ;

11064

char * kwnames[] = {

11065

(char *) "self",(char *) "line", NULL

11066

};

11067

11068

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_VisibleFromDocLine",kwnames,&obj0,&obj1)) SWIG_fail;

11069

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11070

if (!SWIG_IsOK(res1)) {

11071

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_VisibleFromDocLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11072

}

11073

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11074

ecode2 = SWIG_AsVal_int(obj1, &val2);

11075

if (!SWIG_IsOK(ecode2)) {

11076

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_VisibleFromDocLine" "', expected argument " "2"" of type '" "int""'");

11077

}

11078

arg2 = static_cast< int >(val2);

11079

{

11080

PyThreadState* __tstate = wxPyBeginAllowThreads();

11081

result = (int)(arg1)->VisibleFromDocLine(arg2);

11082

wxPyEndAllowThreads(__tstate);

11083

if (PyErr_Occurred()) SWIG_fail;

11084

}

11085

resultobj = SWIG_From_int(static_cast< int >(result));

11086

return resultobj;

11087

fail:

11088

return NULL;

11089

}

11090

11091

11092

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DocLineFromVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11093

PyObject *resultobj = 0;

11094

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11095

int arg2 ;

11096

int result;

11097

void *argp1 = 0 ;

11098

int res1 = 0 ;

11099

int val2 ;

11100

int ecode2 = 0 ;

11101

PyObject * obj0 = 0 ;

11102

PyObject * obj1 = 0 ;

11103

char * kwnames[] = {

11104

(char *) "self",(char *) "lineDisplay", NULL

11105

};

11106

11107

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_DocLineFromVisible",kwnames,&obj0,&obj1)) SWIG_fail;

11108

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11109

if (!SWIG_IsOK(res1)) {

11110

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DocLineFromVisible" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11111

}

11112

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11113

ecode2 = SWIG_AsVal_int(obj1, &val2);

11114

if (!SWIG_IsOK(ecode2)) {

11115

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_DocLineFromVisible" "', expected argument " "2"" of type '" "int""'");

11116

}

11117

arg2 = static_cast< int >(val2);

11118

{

11119

PyThreadState* __tstate = wxPyBeginAllowThreads();

11120

result = (int)(arg1)->DocLineFromVisible(arg2);

11121

wxPyEndAllowThreads(__tstate);

11122

if (PyErr_Occurred()) SWIG_fail;

11123

}

11124

resultobj = SWIG_From_int(static_cast< int >(result));

11125

return resultobj;

11126

fail:

11127

return NULL;

11128

}

11129

11130

11131

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WrapCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11132

PyObject *resultobj = 0;

11133

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11134

int arg2 ;

11135

int result;

11136

void *argp1 = 0 ;

11137

int res1 = 0 ;

11138

int val2 ;

11139

int ecode2 = 0 ;

11140

PyObject * obj0 = 0 ;

11141

PyObject * obj1 = 0 ;

11142

char * kwnames[] = {

11143

(char *) "self",(char *) "line", NULL

11144

};

11145

11146

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_WrapCount",kwnames,&obj0,&obj1)) SWIG_fail;

11147

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11148

if (!SWIG_IsOK(res1)) {

11149

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WrapCount" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11150

}

11151

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11152

ecode2 = SWIG_AsVal_int(obj1, &val2);

11153

if (!SWIG_IsOK(ecode2)) {

11154

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_WrapCount" "', expected argument " "2"" of type '" "int""'");

11155

}

11156

arg2 = static_cast< int >(val2);

11157

{

11158

PyThreadState* __tstate = wxPyBeginAllowThreads();

11159

result = (int)(arg1)->WrapCount(arg2);

11160

wxPyEndAllowThreads(__tstate);

11161

if (PyErr_Occurred()) SWIG_fail;

11162

}

11163

resultobj = SWIG_From_int(static_cast< int >(result));

11164

return resultobj;

11165

fail:

11166

return NULL;

11167

}

11168

11169

11170

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetFoldLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11171

PyObject *resultobj = 0;

11172

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11173

int arg2 ;

11174

int arg3 ;

11175

void *argp1 = 0 ;

11176

int res1 = 0 ;

11177

int val2 ;

11178

int ecode2 = 0 ;

11179

int val3 ;

11180

int ecode3 = 0 ;

11181

PyObject * obj0 = 0 ;

11182

PyObject * obj1 = 0 ;

11183

PyObject * obj2 = 0 ;

11184

char * kwnames[] = {

11185

(char *) "self",(char *) "line",(char *) "level", NULL

11186

};

11187

11188

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetFoldLevel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11189

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11190

if (!SWIG_IsOK(res1)) {

11191

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetFoldLevel" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11192

}

11193

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11194

ecode2 = SWIG_AsVal_int(obj1, &val2);

11195

if (!SWIG_IsOK(ecode2)) {

11196

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetFoldLevel" "', expected argument " "2"" of type '" "int""'");

11197

}

11198

arg2 = static_cast< int >(val2);

11199

ecode3 = SWIG_AsVal_int(obj2, &val3);

11200

if (!SWIG_IsOK(ecode3)) {

11201

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_SetFoldLevel" "', expected argument " "3"" of type '" "int""'");

11202

}

11203

arg3 = static_cast< int >(val3);

11204

{

11205

PyThreadState* __tstate = wxPyBeginAllowThreads();

11206

(arg1)->SetFoldLevel(arg2,arg3);

11207

wxPyEndAllowThreads(__tstate);

11208

if (PyErr_Occurred()) SWIG_fail;

11209

}

11210

resultobj = SWIG_Py_Void();

11211

return resultobj;

11212

fail:

11213

return NULL;

11214

}

11215

11216

11217

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetFoldLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11218

PyObject *resultobj = 0;

11219

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11220

int arg2 ;

11221

int result;

11222

void *argp1 = 0 ;

11223

int res1 = 0 ;

11224

int val2 ;

11225

int ecode2 = 0 ;

11226

PyObject * obj0 = 0 ;

11227

PyObject * obj1 = 0 ;

11228

char * kwnames[] = {

11229

(char *) "self",(char *) "line", NULL

11230

};

11231

11232

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetFoldLevel",kwnames,&obj0,&obj1)) SWIG_fail;

11233

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11234

if (!SWIG_IsOK(res1)) {

11235

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetFoldLevel" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11236

}

11237

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11238

ecode2 = SWIG_AsVal_int(obj1, &val2);

11239

if (!SWIG_IsOK(ecode2)) {

11240

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetFoldLevel" "', expected argument " "2"" of type '" "int""'");

11241

}

11242

arg2 = static_cast< int >(val2);

11243

{

11244

PyThreadState* __tstate = wxPyBeginAllowThreads();

11245

result = (int)(arg1)->GetFoldLevel(arg2);

11246

wxPyEndAllowThreads(__tstate);

11247

if (PyErr_Occurred()) SWIG_fail;

11248

}

11249

resultobj = SWIG_From_int(static_cast< int >(result));

11250

return resultobj;

11251

fail:

11252

return NULL;

11253

}

11254

11255

11256

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLastChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11257

PyObject *resultobj = 0;

11258

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11259

int arg2 ;

11260

int arg3 ;

11261

int result;

11262

void *argp1 = 0 ;

11263

int res1 = 0 ;

11264

int val2 ;

11265

int ecode2 = 0 ;

11266

int val3 ;

11267

int ecode3 = 0 ;

11268

PyObject * obj0 = 0 ;

11269

PyObject * obj1 = 0 ;

11270

PyObject * obj2 = 0 ;

11271

char * kwnames[] = {

11272

(char *) "self",(char *) "line",(char *) "level", NULL

11273

};

11274

11275

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_GetLastChild",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11276

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11277

if (!SWIG_IsOK(res1)) {

11278

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLastChild" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11279

}

11280

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11281

ecode2 = SWIG_AsVal_int(obj1, &val2);

11282

if (!SWIG_IsOK(ecode2)) {

11283

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetLastChild" "', expected argument " "2"" of type '" "int""'");

11284

}

11285

arg2 = static_cast< int >(val2);

11286

ecode3 = SWIG_AsVal_int(obj2, &val3);

11287

if (!SWIG_IsOK(ecode3)) {

11288

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_GetLastChild" "', expected argument " "3"" of type '" "int""'");

11289

}

11290

arg3 = static_cast< int >(val3);

11291

{

11292

PyThreadState* __tstate = wxPyBeginAllowThreads();

11293

result = (int)(arg1)->GetLastChild(arg2,arg3);

11294

wxPyEndAllowThreads(__tstate);

11295

if (PyErr_Occurred()) SWIG_fail;

11296

}

11297

resultobj = SWIG_From_int(static_cast< int >(result));

11298

return resultobj;

11299

fail:

11300

return NULL;

11301

}

11302

11303

11304

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetFoldParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11305

PyObject *resultobj = 0;

11306

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11307

int arg2 ;

11308

int result;

11309

void *argp1 = 0 ;

11310

int res1 = 0 ;

11311

int val2 ;

11312

int ecode2 = 0 ;

11313

PyObject * obj0 = 0 ;

11314

PyObject * obj1 = 0 ;

11315

char * kwnames[] = {

11316

(char *) "self",(char *) "line", NULL

11317

};

11318

11319

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetFoldParent",kwnames,&obj0,&obj1)) SWIG_fail;

11320

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11321

if (!SWIG_IsOK(res1)) {

11322

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetFoldParent" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11323

}

11324

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11325

ecode2 = SWIG_AsVal_int(obj1, &val2);

11326

if (!SWIG_IsOK(ecode2)) {

11327

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetFoldParent" "', expected argument " "2"" of type '" "int""'");

11328

}

11329

arg2 = static_cast< int >(val2);

11330

{

11331

PyThreadState* __tstate = wxPyBeginAllowThreads();

11332

result = (int)(arg1)->GetFoldParent(arg2);

11333

wxPyEndAllowThreads(__tstate);

11334

if (PyErr_Occurred()) SWIG_fail;

11335

}

11336

resultobj = SWIG_From_int(static_cast< int >(result));

11337

return resultobj;

11338

fail:

11339

return NULL;

11340

}

11341

11342

11343

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ShowLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11344

PyObject *resultobj = 0;

11345

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11346

int arg2 ;

11347

int arg3 ;

11348

void *argp1 = 0 ;

11349

int res1 = 0 ;

11350

int val2 ;

11351

int ecode2 = 0 ;

11352

int val3 ;

11353

int ecode3 = 0 ;

11354

PyObject * obj0 = 0 ;

11355

PyObject * obj1 = 0 ;

11356

PyObject * obj2 = 0 ;

11357

char * kwnames[] = {

11358

(char *) "self",(char *) "lineStart",(char *) "lineEnd", NULL

11359

};

11360

11361

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_ShowLines",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11362

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11363

if (!SWIG_IsOK(res1)) {

11364

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ShowLines" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11365

}

11366

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11367

ecode2 = SWIG_AsVal_int(obj1, &val2);

11368

if (!SWIG_IsOK(ecode2)) {

11369

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_ShowLines" "', expected argument " "2"" of type '" "int""'");

11370

}

11371

arg2 = static_cast< int >(val2);

11372

ecode3 = SWIG_AsVal_int(obj2, &val3);

11373

if (!SWIG_IsOK(ecode3)) {

11374

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_ShowLines" "', expected argument " "3"" of type '" "int""'");

11375

}

11376

arg3 = static_cast< int >(val3);

11377

{

11378

PyThreadState* __tstate = wxPyBeginAllowThreads();

11379

(arg1)->ShowLines(arg2,arg3);

11380

wxPyEndAllowThreads(__tstate);

11381

if (PyErr_Occurred()) SWIG_fail;

11382

}

11383

resultobj = SWIG_Py_Void();

11384

return resultobj;

11385

fail:

11386

return NULL;

11387

}

11388

11389

11390

SWIGINTERN PyObject *_wrap_StyledTextCtrl_HideLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11391

PyObject *resultobj = 0;

11392

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11393

int arg2 ;

11394

int arg3 ;

11395

void *argp1 = 0 ;

11396

int res1 = 0 ;

11397

int val2 ;

11398

int ecode2 = 0 ;

11399

int val3 ;

11400

int ecode3 = 0 ;

11401

PyObject * obj0 = 0 ;

11402

PyObject * obj1 = 0 ;

11403

PyObject * obj2 = 0 ;

11404

char * kwnames[] = {

11405

(char *) "self",(char *) "lineStart",(char *) "lineEnd", NULL

11406

};

11407

11408

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_HideLines",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11409

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11410

if (!SWIG_IsOK(res1)) {

11411

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_HideLines" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11412

}

11413

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11414

ecode2 = SWIG_AsVal_int(obj1, &val2);

11415

if (!SWIG_IsOK(ecode2)) {

11416

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_HideLines" "', expected argument " "2"" of type '" "int""'");

11417

}

11418

arg2 = static_cast< int >(val2);

11419

ecode3 = SWIG_AsVal_int(obj2, &val3);

11420

if (!SWIG_IsOK(ecode3)) {

11421

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_HideLines" "', expected argument " "3"" of type '" "int""'");

11422

}

11423

arg3 = static_cast< int >(val3);

11424

{

11425

PyThreadState* __tstate = wxPyBeginAllowThreads();

11426

(arg1)->HideLines(arg2,arg3);

11427

wxPyEndAllowThreads(__tstate);

11428

if (PyErr_Occurred()) SWIG_fail;

11429

}

11430

resultobj = SWIG_Py_Void();

11431

return resultobj;

11432

fail:

11433

return NULL;

11434

}

11435

11436

11437

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLineVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11438

PyObject *resultobj = 0;

11439

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11440

int arg2 ;

11441

bool result;

11442

void *argp1 = 0 ;

11443

int res1 = 0 ;

11444

int val2 ;

11445

int ecode2 = 0 ;

11446

PyObject * obj0 = 0 ;

11447

PyObject * obj1 = 0 ;

11448

char * kwnames[] = {

11449

(char *) "self",(char *) "line", NULL

11450

};

11451

11452

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetLineVisible",kwnames,&obj0,&obj1)) SWIG_fail;

11453

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11454

if (!SWIG_IsOK(res1)) {

11455

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLineVisible" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11456

}

11457

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11458

ecode2 = SWIG_AsVal_int(obj1, &val2);

11459

if (!SWIG_IsOK(ecode2)) {

11460

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetLineVisible" "', expected argument " "2"" of type '" "int""'");

11461

}

11462

arg2 = static_cast< int >(val2);

11463

{

11464

PyThreadState* __tstate = wxPyBeginAllowThreads();

11465

result = (bool)(arg1)->GetLineVisible(arg2);

11466

wxPyEndAllowThreads(__tstate);

11467

if (PyErr_Occurred()) SWIG_fail;

11468

}

11469

{

11470

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11471

}

11472

return resultobj;

11473

fail:

11474

return NULL;

11475

}

11476

11477

11478

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetFoldExpanded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11479

PyObject *resultobj = 0;

11480

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11481

int arg2 ;

11482

bool arg3 ;

11483

void *argp1 = 0 ;

11484

int res1 = 0 ;

11485

int val2 ;

11486

int ecode2 = 0 ;

11487

bool val3 ;

11488

int ecode3 = 0 ;

11489

PyObject * obj0 = 0 ;

11490

PyObject * obj1 = 0 ;

11491

PyObject * obj2 = 0 ;

11492

char * kwnames[] = {

11493

(char *) "self",(char *) "line",(char *) "expanded", NULL

11494

};

11495

11496

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetFoldExpanded",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11497

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11498

if (!SWIG_IsOK(res1)) {

11499

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetFoldExpanded" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11500

}

11501

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11502

ecode2 = SWIG_AsVal_int(obj1, &val2);

11503

if (!SWIG_IsOK(ecode2)) {

11504

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetFoldExpanded" "', expected argument " "2"" of type '" "int""'");

11505

}

11506

arg2 = static_cast< int >(val2);

11507

ecode3 = SWIG_AsVal_bool(obj2, &val3);

11508

if (!SWIG_IsOK(ecode3)) {

11509

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_SetFoldExpanded" "', expected argument " "3"" of type '" "bool""'");

11510

}

11511

arg3 = static_cast< bool >(val3);

11512

{

11513

PyThreadState* __tstate = wxPyBeginAllowThreads();

11514

(arg1)->SetFoldExpanded(arg2,arg3);

11515

wxPyEndAllowThreads(__tstate);

11516

if (PyErr_Occurred()) SWIG_fail;

11517

}

11518

resultobj = SWIG_Py_Void();

11519

return resultobj;

11520

fail:

11521

return NULL;

11522

}

11523

11524

11525

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetFoldExpanded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11526

PyObject *resultobj = 0;

11527

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11528

int arg2 ;

11529

bool result;

11530

void *argp1 = 0 ;

11531

int res1 = 0 ;

11532

int val2 ;

11533

int ecode2 = 0 ;

11534

PyObject * obj0 = 0 ;

11535

PyObject * obj1 = 0 ;

11536

char * kwnames[] = {

11537

(char *) "self",(char *) "line", NULL

11538

};

11539

11540

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetFoldExpanded",kwnames,&obj0,&obj1)) SWIG_fail;

11541

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11542

if (!SWIG_IsOK(res1)) {

11543

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetFoldExpanded" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11544

}

11545

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11546

ecode2 = SWIG_AsVal_int(obj1, &val2);

11547

if (!SWIG_IsOK(ecode2)) {

11548

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetFoldExpanded" "', expected argument " "2"" of type '" "int""'");

11549

}

11550

arg2 = static_cast< int >(val2);

11551

{

11552

PyThreadState* __tstate = wxPyBeginAllowThreads();

11553

result = (bool)(arg1)->GetFoldExpanded(arg2);

11554

wxPyEndAllowThreads(__tstate);

11555

if (PyErr_Occurred()) SWIG_fail;

11556

}

11557

{

11558

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11559

}

11560

return resultobj;

11561

fail:

11562

return NULL;

11563

}

11564

11565

11566

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ToggleFold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11567

PyObject *resultobj = 0;

11568

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11569

int arg2 ;

11570

void *argp1 = 0 ;

11571

int res1 = 0 ;

11572

int val2 ;

11573

int ecode2 = 0 ;

11574

PyObject * obj0 = 0 ;

11575

PyObject * obj1 = 0 ;

11576

char * kwnames[] = {

11577

(char *) "self",(char *) "line", NULL

11578

};

11579

11580

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_ToggleFold",kwnames,&obj0,&obj1)) SWIG_fail;

11581

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11582

if (!SWIG_IsOK(res1)) {

11583

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ToggleFold" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11584

}

11585

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11586

ecode2 = SWIG_AsVal_int(obj1, &val2);

11587

if (!SWIG_IsOK(ecode2)) {

11588

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_ToggleFold" "', expected argument " "2"" of type '" "int""'");

11589

}

11590

arg2 = static_cast< int >(val2);

11591

{

11592

PyThreadState* __tstate = wxPyBeginAllowThreads();

11593

(arg1)->ToggleFold(arg2);

11594

wxPyEndAllowThreads(__tstate);

11595

if (PyErr_Occurred()) SWIG_fail;

11596

}

11597

resultobj = SWIG_Py_Void();

11598

return resultobj;

11599

fail:

11600

return NULL;

11601

}

11602

11603

11604

SWIGINTERN PyObject *_wrap_StyledTextCtrl_EnsureVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11605

PyObject *resultobj = 0;

11606

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11607

int arg2 ;

11608

void *argp1 = 0 ;

11609

int res1 = 0 ;

11610

int val2 ;

11611

int ecode2 = 0 ;

11612

PyObject * obj0 = 0 ;

11613

PyObject * obj1 = 0 ;

11614

char * kwnames[] = {

11615

(char *) "self",(char *) "line", NULL

11616

};

11617

11618

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_EnsureVisible",kwnames,&obj0,&obj1)) SWIG_fail;

11619

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11620

if (!SWIG_IsOK(res1)) {

11621

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_EnsureVisible" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11622

}

11623

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11624

ecode2 = SWIG_AsVal_int(obj1, &val2);

11625

if (!SWIG_IsOK(ecode2)) {

11626

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_EnsureVisible" "', expected argument " "2"" of type '" "int""'");

11627

}

11628

arg2 = static_cast< int >(val2);

11629

{

11630

PyThreadState* __tstate = wxPyBeginAllowThreads();

11631

(arg1)->EnsureVisible(arg2);

11632

wxPyEndAllowThreads(__tstate);

11633

if (PyErr_Occurred()) SWIG_fail;

11634

}

11635

resultobj = SWIG_Py_Void();

11636

return resultobj;

11637

fail:

11638

return NULL;

11639

}

11640

11641

11642

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetFoldFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11643

PyObject *resultobj = 0;

11644

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11645

int arg2 ;

11646

void *argp1 = 0 ;

11647

int res1 = 0 ;

11648

int val2 ;

11649

int ecode2 = 0 ;

11650

PyObject * obj0 = 0 ;

11651

PyObject * obj1 = 0 ;

11652

char * kwnames[] = {

11653

(char *) "self",(char *) "flags", NULL

11654

};

11655

11656

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetFoldFlags",kwnames,&obj0,&obj1)) SWIG_fail;

11657

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11658

if (!SWIG_IsOK(res1)) {

11659

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetFoldFlags" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11660

}

11661

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11662

ecode2 = SWIG_AsVal_int(obj1, &val2);

11663

if (!SWIG_IsOK(ecode2)) {

11664

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetFoldFlags" "', expected argument " "2"" of type '" "int""'");

11665

}

11666

arg2 = static_cast< int >(val2);

11667

{

11668

PyThreadState* __tstate = wxPyBeginAllowThreads();

11669

(arg1)->SetFoldFlags(arg2);

11670

wxPyEndAllowThreads(__tstate);

11671

if (PyErr_Occurred()) SWIG_fail;

11672

}

11673

resultobj = SWIG_Py_Void();

11674

return resultobj;

11675

fail:

11676

return NULL;

11677

}

11678

11679

11680

SWIGINTERN PyObject *_wrap_StyledTextCtrl_EnsureVisibleEnforcePolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11681

PyObject *resultobj = 0;

11682

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11683

int arg2 ;

11684

void *argp1 = 0 ;

11685

int res1 = 0 ;

11686

int val2 ;

11687

int ecode2 = 0 ;

11688

PyObject * obj0 = 0 ;

11689

PyObject * obj1 = 0 ;

11690

char * kwnames[] = {

11691

(char *) "self",(char *) "line", NULL

11692

};

11693

11694

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_EnsureVisibleEnforcePolicy",kwnames,&obj0,&obj1)) SWIG_fail;

11695

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11696

if (!SWIG_IsOK(res1)) {

11697

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_EnsureVisibleEnforcePolicy" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11698

}

11699

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11700

ecode2 = SWIG_AsVal_int(obj1, &val2);

11701

if (!SWIG_IsOK(ecode2)) {

11702

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_EnsureVisibleEnforcePolicy" "', expected argument " "2"" of type '" "int""'");

11703

}

11704

arg2 = static_cast< int >(val2);

11705

{

11706

PyThreadState* __tstate = wxPyBeginAllowThreads();

11707

(arg1)->EnsureVisibleEnforcePolicy(arg2);

11708

wxPyEndAllowThreads(__tstate);

11709

if (PyErr_Occurred()) SWIG_fail;

11710

}

11711

resultobj = SWIG_Py_Void();

11712

return resultobj;

11713

fail:

11714

return NULL;

11715

}

11716

11717

11718

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetTabIndents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11719

PyObject *resultobj = 0;

11720

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11721

bool arg2 ;

11722

void *argp1 = 0 ;

11723

int res1 = 0 ;

11724

bool val2 ;

11725

int ecode2 = 0 ;

11726

PyObject * obj0 = 0 ;

11727

PyObject * obj1 = 0 ;

11728

char * kwnames[] = {

11729

(char *) "self",(char *) "tabIndents", NULL

11730

};

11731

11732

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetTabIndents",kwnames,&obj0,&obj1)) SWIG_fail;

11733

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11734

if (!SWIG_IsOK(res1)) {

11735

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetTabIndents" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11736

}

11737

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11738

ecode2 = SWIG_AsVal_bool(obj1, &val2);

11739

if (!SWIG_IsOK(ecode2)) {

11740

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetTabIndents" "', expected argument " "2"" of type '" "bool""'");

11741

}

11742

arg2 = static_cast< bool >(val2);

11743

{

11744

PyThreadState* __tstate = wxPyBeginAllowThreads();

11745

(arg1)->SetTabIndents(arg2);

11746

wxPyEndAllowThreads(__tstate);

11747

if (PyErr_Occurred()) SWIG_fail;

11748

}

11749

resultobj = SWIG_Py_Void();

11750

return resultobj;

11751

fail:

11752

return NULL;

11753

}

11754

11755

11756

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetTabIndents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11757

PyObject *resultobj = 0;

11758

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11759

bool result;

11760

void *argp1 = 0 ;

11761

int res1 = 0 ;

11762

PyObject *swig_obj[1] ;

11763

11764

if (!args) SWIG_fail;

11765

swig_obj[0] = args;

11766

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11767

if (!SWIG_IsOK(res1)) {

11768

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetTabIndents" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11769

}

11770

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11771

{

11772

PyThreadState* __tstate = wxPyBeginAllowThreads();

11773

result = (bool)(arg1)->GetTabIndents();

11774

wxPyEndAllowThreads(__tstate);

11775

if (PyErr_Occurred()) SWIG_fail;

11776

}

11777

{

11778

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11779

}

11780

return resultobj;

11781

fail:

11782

return NULL;

11783

}

11784

11785

11786

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetBackSpaceUnIndents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11787

PyObject *resultobj = 0;

11788

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11789

bool arg2 ;

11790

void *argp1 = 0 ;

11791

int res1 = 0 ;

11792

bool val2 ;

11793

int ecode2 = 0 ;

11794

PyObject * obj0 = 0 ;

11795

PyObject * obj1 = 0 ;

11796

char * kwnames[] = {

11797

(char *) "self",(char *) "bsUnIndents", NULL

11798

};

11799

11800

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetBackSpaceUnIndents",kwnames,&obj0,&obj1)) SWIG_fail;

11801

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11802

if (!SWIG_IsOK(res1)) {

11803

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetBackSpaceUnIndents" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11804

}

11805

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11806

ecode2 = SWIG_AsVal_bool(obj1, &val2);

11807

if (!SWIG_IsOK(ecode2)) {

11808

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetBackSpaceUnIndents" "', expected argument " "2"" of type '" "bool""'");

11809

}

11810

arg2 = static_cast< bool >(val2);

11811

{

11812

PyThreadState* __tstate = wxPyBeginAllowThreads();

11813

(arg1)->SetBackSpaceUnIndents(arg2);

11814

wxPyEndAllowThreads(__tstate);

11815

if (PyErr_Occurred()) SWIG_fail;

11816

}

11817

resultobj = SWIG_Py_Void();

11818

return resultobj;

11819

fail:

11820

return NULL;

11821

}

11822

11823

11824

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetBackSpaceUnIndents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11825

PyObject *resultobj = 0;

11826

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11827

bool result;

11828

void *argp1 = 0 ;

11829

int res1 = 0 ;

11830

PyObject *swig_obj[1] ;

11831

11832

if (!args) SWIG_fail;

11833

swig_obj[0] = args;

11834

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11835

if (!SWIG_IsOK(res1)) {

11836

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetBackSpaceUnIndents" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11837

}

11838

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11839

{

11840

PyThreadState* __tstate = wxPyBeginAllowThreads();

11841

result = (bool)(arg1)->GetBackSpaceUnIndents();

11842

wxPyEndAllowThreads(__tstate);

11843

if (PyErr_Occurred()) SWIG_fail;

11844

}

11845

{

11846

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11847

}

11848

return resultobj;

11849

fail:

11850

return NULL;

11851

}

11852

11853

11854

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetMouseDwellTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11855

PyObject *resultobj = 0;

11856

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11857

int arg2 ;

11858

void *argp1 = 0 ;

11859

int res1 = 0 ;

11860

int val2 ;

11861

int ecode2 = 0 ;

11862

PyObject * obj0 = 0 ;

11863

PyObject * obj1 = 0 ;

11864

char * kwnames[] = {

11865

(char *) "self",(char *) "periodMilliseconds", NULL

11866

};

11867

11868

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetMouseDwellTime",kwnames,&obj0,&obj1)) SWIG_fail;

11869

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11870

if (!SWIG_IsOK(res1)) {

11871

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetMouseDwellTime" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11872

}

11873

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11874

ecode2 = SWIG_AsVal_int(obj1, &val2);

11875

if (!SWIG_IsOK(ecode2)) {

11876

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetMouseDwellTime" "', expected argument " "2"" of type '" "int""'");

11877

}

11878

arg2 = static_cast< int >(val2);

11879

{

11880

PyThreadState* __tstate = wxPyBeginAllowThreads();

11881

(arg1)->SetMouseDwellTime(arg2);

11882

wxPyEndAllowThreads(__tstate);

11883

if (PyErr_Occurred()) SWIG_fail;

11884

}

11885

resultobj = SWIG_Py_Void();

11886

return resultobj;

11887

fail:

11888

return NULL;

11889

}

11890

11891

11892

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetMouseDwellTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11893

PyObject *resultobj = 0;

11894

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11895

int result;

11896

void *argp1 = 0 ;

11897

int res1 = 0 ;

11898

PyObject *swig_obj[1] ;

11899

11900

if (!args) SWIG_fail;

11901

swig_obj[0] = args;

11902

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11903

if (!SWIG_IsOK(res1)) {

11904

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetMouseDwellTime" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11905

}

11906

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11907

{

11908

PyThreadState* __tstate = wxPyBeginAllowThreads();

11909

result = (int)(arg1)->GetMouseDwellTime();

11910

wxPyEndAllowThreads(__tstate);

11911

if (PyErr_Occurred()) SWIG_fail;

11912

}

11913

resultobj = SWIG_From_int(static_cast< int >(result));

11914

return resultobj;

11915

fail:

11916

return NULL;

11917

}

11918

11919

11920

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordStartPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11921

PyObject *resultobj = 0;

11922

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11923

int arg2 ;

11924

bool arg3 ;

11925

int result;

11926

void *argp1 = 0 ;

11927

int res1 = 0 ;

11928

int val2 ;

11929

int ecode2 = 0 ;

11930

bool val3 ;

11931

int ecode3 = 0 ;

11932

PyObject * obj0 = 0 ;

11933

PyObject * obj1 = 0 ;

11934

PyObject * obj2 = 0 ;

11935

char * kwnames[] = {

11936

(char *) "self",(char *) "pos",(char *) "onlyWordCharacters", NULL

11937

};

11938

11939

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_WordStartPosition",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11940

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11941

if (!SWIG_IsOK(res1)) {

11942

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordStartPosition" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11943

}

11944

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11945

ecode2 = SWIG_AsVal_int(obj1, &val2);

11946

if (!SWIG_IsOK(ecode2)) {

11947

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_WordStartPosition" "', expected argument " "2"" of type '" "int""'");

11948

}

11949

arg2 = static_cast< int >(val2);

11950

ecode3 = SWIG_AsVal_bool(obj2, &val3);

11951

if (!SWIG_IsOK(ecode3)) {

11952

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_WordStartPosition" "', expected argument " "3"" of type '" "bool""'");

11953

}

11954

arg3 = static_cast< bool >(val3);

11955

{

11956

PyThreadState* __tstate = wxPyBeginAllowThreads();

11957

result = (int)(arg1)->WordStartPosition(arg2,arg3);

11958

wxPyEndAllowThreads(__tstate);

11959

if (PyErr_Occurred()) SWIG_fail;

11960

}

11961

resultobj = SWIG_From_int(static_cast< int >(result));

11962

return resultobj;

11963

fail:

11964

return NULL;

11965

}

11966

11967

11968

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordEndPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11969

PyObject *resultobj = 0;

11970

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

11971

int arg2 ;

11972

bool arg3 ;

11973

int result;

11974

void *argp1 = 0 ;

11975

int res1 = 0 ;

11976

int val2 ;

11977

int ecode2 = 0 ;

11978

bool val3 ;

11979

int ecode3 = 0 ;

11980

PyObject * obj0 = 0 ;

11981

PyObject * obj1 = 0 ;

11982

PyObject * obj2 = 0 ;

11983

char * kwnames[] = {

11984

(char *) "self",(char *) "pos",(char *) "onlyWordCharacters", NULL

11985

};

11986

11987

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_WordEndPosition",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11988

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

11989

if (!SWIG_IsOK(res1)) {

11990

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordEndPosition" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

11991

}

11992

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

11993

ecode2 = SWIG_AsVal_int(obj1, &val2);

11994

if (!SWIG_IsOK(ecode2)) {

11995

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_WordEndPosition" "', expected argument " "2"" of type '" "int""'");

11996

}

11997

arg2 = static_cast< int >(val2);

11998

ecode3 = SWIG_AsVal_bool(obj2, &val3);

11999

if (!SWIG_IsOK(ecode3)) {

12000

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_WordEndPosition" "', expected argument " "3"" of type '" "bool""'");

12001

}

12002

arg3 = static_cast< bool >(val3);

12003

{

12004

PyThreadState* __tstate = wxPyBeginAllowThreads();

12005

result = (int)(arg1)->WordEndPosition(arg2,arg3);

12006

wxPyEndAllowThreads(__tstate);

12007

if (PyErr_Occurred()) SWIG_fail;

12008

}

12009

resultobj = SWIG_From_int(static_cast< int >(result));

12010

return resultobj;

12011

fail:

12012

return NULL;

12013

}

12014

12015

12016

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetWrapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12017

PyObject *resultobj = 0;

12018

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12019

int arg2 ;

12020

void *argp1 = 0 ;

12021

int res1 = 0 ;

12022

int val2 ;

12023

int ecode2 = 0 ;

12024

PyObject * obj0 = 0 ;

12025

PyObject * obj1 = 0 ;

12026

char * kwnames[] = {

12027

(char *) "self",(char *) "mode", NULL

12028

};

12029

12030

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetWrapMode",kwnames,&obj0,&obj1)) SWIG_fail;

12031

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12032

if (!SWIG_IsOK(res1)) {

12033

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetWrapMode" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12034

}

12035

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12036

ecode2 = SWIG_AsVal_int(obj1, &val2);

12037

if (!SWIG_IsOK(ecode2)) {

12038

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetWrapMode" "', expected argument " "2"" of type '" "int""'");

12039

}

12040

arg2 = static_cast< int >(val2);

12041

{

12042

PyThreadState* __tstate = wxPyBeginAllowThreads();

12043

(arg1)->SetWrapMode(arg2);

12044

wxPyEndAllowThreads(__tstate);

12045

if (PyErr_Occurred()) SWIG_fail;

12046

}

12047

resultobj = SWIG_Py_Void();

12048

return resultobj;

12049

fail:

12050

return NULL;

12051

}

12052

12053

12054

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetWrapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12055

PyObject *resultobj = 0;

12056

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12057

int result;

12058

void *argp1 = 0 ;

12059

int res1 = 0 ;

12060

PyObject *swig_obj[1] ;

12061

12062

if (!args) SWIG_fail;

12063

swig_obj[0] = args;

12064

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12065

if (!SWIG_IsOK(res1)) {

12066

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetWrapMode" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12067

}

12068

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12069

{

12070

PyThreadState* __tstate = wxPyBeginAllowThreads();

12071

result = (int)(arg1)->GetWrapMode();

12072

wxPyEndAllowThreads(__tstate);

12073

if (PyErr_Occurred()) SWIG_fail;

12074

}

12075

resultobj = SWIG_From_int(static_cast< int >(result));

12076

return resultobj;

12077

fail:

12078

return NULL;

12079

}

12080

12081

12082

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetWrapVisualFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12083

PyObject *resultobj = 0;

12084

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12085

int arg2 ;

12086

void *argp1 = 0 ;

12087

int res1 = 0 ;

12088

int val2 ;

12089

int ecode2 = 0 ;

12090

PyObject * obj0 = 0 ;

12091

PyObject * obj1 = 0 ;

12092

char * kwnames[] = {

12093

(char *) "self",(char *) "wrapVisualFlags", NULL

12094

};

12095

12096

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetWrapVisualFlags",kwnames,&obj0,&obj1)) SWIG_fail;

12097

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12098

if (!SWIG_IsOK(res1)) {

12099

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetWrapVisualFlags" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12100

}

12101

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12102

ecode2 = SWIG_AsVal_int(obj1, &val2);

12103

if (!SWIG_IsOK(ecode2)) {

12104

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetWrapVisualFlags" "', expected argument " "2"" of type '" "int""'");

12105

}

12106

arg2 = static_cast< int >(val2);

12107

{

12108

PyThreadState* __tstate = wxPyBeginAllowThreads();

12109

(arg1)->SetWrapVisualFlags(arg2);

12110

wxPyEndAllowThreads(__tstate);

12111

if (PyErr_Occurred()) SWIG_fail;

12112

}

12113

resultobj = SWIG_Py_Void();

12114

return resultobj;

12115

fail:

12116

return NULL;

12117

}

12118

12119

12120

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetWrapVisualFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12121

PyObject *resultobj = 0;

12122

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12123

int result;

12124

void *argp1 = 0 ;

12125

int res1 = 0 ;

12126

PyObject *swig_obj[1] ;

12127

12128

if (!args) SWIG_fail;

12129

swig_obj[0] = args;

12130

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12131

if (!SWIG_IsOK(res1)) {

12132

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetWrapVisualFlags" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12133

}

12134

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12135

{

12136

PyThreadState* __tstate = wxPyBeginAllowThreads();

12137

result = (int)(arg1)->GetWrapVisualFlags();

12138

wxPyEndAllowThreads(__tstate);

12139

if (PyErr_Occurred()) SWIG_fail;

12140

}

12141

resultobj = SWIG_From_int(static_cast< int >(result));

12142

return resultobj;

12143

fail:

12144

return NULL;

12145

}

12146

12147

12148

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetWrapVisualFlagsLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12149

PyObject *resultobj = 0;

12150

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12151

int arg2 ;

12152

void *argp1 = 0 ;

12153

int res1 = 0 ;

12154

int val2 ;

12155

int ecode2 = 0 ;

12156

PyObject * obj0 = 0 ;

12157

PyObject * obj1 = 0 ;

12158

char * kwnames[] = {

12159

(char *) "self",(char *) "wrapVisualFlagsLocation", NULL

12160

};

12161

12162

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetWrapVisualFlagsLocation",kwnames,&obj0,&obj1)) SWIG_fail;

12163

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12164

if (!SWIG_IsOK(res1)) {

12165

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetWrapVisualFlagsLocation" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12166

}

12167

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12168

ecode2 = SWIG_AsVal_int(obj1, &val2);

12169

if (!SWIG_IsOK(ecode2)) {

12170

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetWrapVisualFlagsLocation" "', expected argument " "2"" of type '" "int""'");

12171

}

12172

arg2 = static_cast< int >(val2);

12173

{

12174

PyThreadState* __tstate = wxPyBeginAllowThreads();

12175

(arg1)->SetWrapVisualFlagsLocation(arg2);

12176

wxPyEndAllowThreads(__tstate);

12177

if (PyErr_Occurred()) SWIG_fail;

12178

}

12179

resultobj = SWIG_Py_Void();

12180

return resultobj;

12181

fail:

12182

return NULL;

12183

}

12184

12185

12186

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetWrapVisualFlagsLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12187

PyObject *resultobj = 0;

12188

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12189

int result;

12190

void *argp1 = 0 ;

12191

int res1 = 0 ;

12192

PyObject *swig_obj[1] ;

12193

12194

if (!args) SWIG_fail;

12195

swig_obj[0] = args;

12196

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12197

if (!SWIG_IsOK(res1)) {

12198

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetWrapVisualFlagsLocation" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12199

}

12200

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12201

{

12202

PyThreadState* __tstate = wxPyBeginAllowThreads();

12203

result = (int)(arg1)->GetWrapVisualFlagsLocation();

12204

wxPyEndAllowThreads(__tstate);

12205

if (PyErr_Occurred()) SWIG_fail;

12206

}

12207

resultobj = SWIG_From_int(static_cast< int >(result));

12208

return resultobj;

12209

fail:

12210

return NULL;

12211

}

12212

12213

12214

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetWrapStartIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12215

PyObject *resultobj = 0;

12216

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12217

int arg2 ;

12218

void *argp1 = 0 ;

12219

int res1 = 0 ;

12220

int val2 ;

12221

int ecode2 = 0 ;

12222

PyObject * obj0 = 0 ;

12223

PyObject * obj1 = 0 ;

12224

char * kwnames[] = {

12225

(char *) "self",(char *) "indent", NULL

12226

};

12227

12228

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetWrapStartIndent",kwnames,&obj0,&obj1)) SWIG_fail;

12229

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12230

if (!SWIG_IsOK(res1)) {

12231

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetWrapStartIndent" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12232

}

12233

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12234

ecode2 = SWIG_AsVal_int(obj1, &val2);

12235

if (!SWIG_IsOK(ecode2)) {

12236

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetWrapStartIndent" "', expected argument " "2"" of type '" "int""'");

12237

}

12238

arg2 = static_cast< int >(val2);

12239

{

12240

PyThreadState* __tstate = wxPyBeginAllowThreads();

12241

(arg1)->SetWrapStartIndent(arg2);

12242

wxPyEndAllowThreads(__tstate);

12243

if (PyErr_Occurred()) SWIG_fail;

12244

}

12245

resultobj = SWIG_Py_Void();

12246

return resultobj;

12247

fail:

12248

return NULL;

12249

}

12250

12251

12252

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetWrapStartIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12253

PyObject *resultobj = 0;

12254

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12255

int result;

12256

void *argp1 = 0 ;

12257

int res1 = 0 ;

12258

PyObject *swig_obj[1] ;

12259

12260

if (!args) SWIG_fail;

12261

swig_obj[0] = args;

12262

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12263

if (!SWIG_IsOK(res1)) {

12264

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetWrapStartIndent" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12265

}

12266

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12267

{

12268

PyThreadState* __tstate = wxPyBeginAllowThreads();

12269

result = (int)(arg1)->GetWrapStartIndent();

12270

wxPyEndAllowThreads(__tstate);

12271

if (PyErr_Occurred()) SWIG_fail;

12272

}

12273

resultobj = SWIG_From_int(static_cast< int >(result));

12274

return resultobj;

12275

fail:

12276

return NULL;

12277

}

12278

12279

12280

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetLayoutCache(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12281

PyObject *resultobj = 0;

12282

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12283

int arg2 ;

12284

void *argp1 = 0 ;

12285

int res1 = 0 ;

12286

int val2 ;

12287

int ecode2 = 0 ;

12288

PyObject * obj0 = 0 ;

12289

PyObject * obj1 = 0 ;

12290

char * kwnames[] = {

12291

(char *) "self",(char *) "mode", NULL

12292

};

12293

12294

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetLayoutCache",kwnames,&obj0,&obj1)) SWIG_fail;

12295

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12296

if (!SWIG_IsOK(res1)) {

12297

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetLayoutCache" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12298

}

12299

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12300

ecode2 = SWIG_AsVal_int(obj1, &val2);

12301

if (!SWIG_IsOK(ecode2)) {

12302

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetLayoutCache" "', expected argument " "2"" of type '" "int""'");

12303

}

12304

arg2 = static_cast< int >(val2);

12305

{

12306

PyThreadState* __tstate = wxPyBeginAllowThreads();

12307

(arg1)->SetLayoutCache(arg2);

12308

wxPyEndAllowThreads(__tstate);

12309

if (PyErr_Occurred()) SWIG_fail;

12310

}

12311

resultobj = SWIG_Py_Void();

12312

return resultobj;

12313

fail:

12314

return NULL;

12315

}

12316

12317

12318

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLayoutCache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12319

PyObject *resultobj = 0;

12320

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12321

int result;

12322

void *argp1 = 0 ;

12323

int res1 = 0 ;

12324

PyObject *swig_obj[1] ;

12325

12326

if (!args) SWIG_fail;

12327

swig_obj[0] = args;

12328

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12329

if (!SWIG_IsOK(res1)) {

12330

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLayoutCache" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12331

}

12332

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12333

{

12334

PyThreadState* __tstate = wxPyBeginAllowThreads();

12335

result = (int)(arg1)->GetLayoutCache();

12336

wxPyEndAllowThreads(__tstate);

12337

if (PyErr_Occurred()) SWIG_fail;

12338

}

12339

resultobj = SWIG_From_int(static_cast< int >(result));

12340

return resultobj;

12341

fail:

12342

return NULL;

12343

}

12344

12345

12346

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetScrollWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12347

PyObject *resultobj = 0;

12348

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12349

int arg2 ;

12350

void *argp1 = 0 ;

12351

int res1 = 0 ;

12352

int val2 ;

12353

int ecode2 = 0 ;

12354

PyObject * obj0 = 0 ;

12355

PyObject * obj1 = 0 ;

12356

char * kwnames[] = {

12357

(char *) "self",(char *) "pixelWidth", NULL

12358

};

12359

12360

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetScrollWidth",kwnames,&obj0,&obj1)) SWIG_fail;

12361

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12362

if (!SWIG_IsOK(res1)) {

12363

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetScrollWidth" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12364

}

12365

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12366

ecode2 = SWIG_AsVal_int(obj1, &val2);

12367

if (!SWIG_IsOK(ecode2)) {

12368

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetScrollWidth" "', expected argument " "2"" of type '" "int""'");

12369

}

12370

arg2 = static_cast< int >(val2);

12371

{

12372

PyThreadState* __tstate = wxPyBeginAllowThreads();

12373

(arg1)->SetScrollWidth(arg2);

12374

wxPyEndAllowThreads(__tstate);

12375

if (PyErr_Occurred()) SWIG_fail;

12376

}

12377

resultobj = SWIG_Py_Void();

12378

return resultobj;

12379

fail:

12380

return NULL;

12381

}

12382

12383

12384

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetScrollWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12385

PyObject *resultobj = 0;

12386

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12387

int result;

12388

void *argp1 = 0 ;

12389

int res1 = 0 ;

12390

PyObject *swig_obj[1] ;

12391

12392

if (!args) SWIG_fail;

12393

swig_obj[0] = args;

12394

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12395

if (!SWIG_IsOK(res1)) {

12396

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetScrollWidth" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12397

}

12398

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12399

{

12400

PyThreadState* __tstate = wxPyBeginAllowThreads();

12401

result = (int)(arg1)->GetScrollWidth();

12402

wxPyEndAllowThreads(__tstate);

12403

if (PyErr_Occurred()) SWIG_fail;

12404

}

12405

resultobj = SWIG_From_int(static_cast< int >(result));

12406

return resultobj;

12407

fail:

12408

return NULL;

12409

}

12410

12411

12412

SWIGINTERN PyObject *_wrap_StyledTextCtrl_TextWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12413

PyObject *resultobj = 0;

12414

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12415

int arg2 ;

12416

wxString *arg3 = 0 ;

12417

int result;

12418

void *argp1 = 0 ;

12419

int res1 = 0 ;

12420

int val2 ;

12421

int ecode2 = 0 ;

12422

bool temp3 = false ;

12423

PyObject * obj0 = 0 ;

12424

PyObject * obj1 = 0 ;

12425

PyObject * obj2 = 0 ;

12426

char * kwnames[] = {

12427

(char *) "self",(char *) "style",(char *) "text", NULL

12428

};

12429

12430

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_TextWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

12431

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12432

if (!SWIG_IsOK(res1)) {

12433

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_TextWidth" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12434

}

12435

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12436

ecode2 = SWIG_AsVal_int(obj1, &val2);

12437

if (!SWIG_IsOK(ecode2)) {

12438

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_TextWidth" "', expected argument " "2"" of type '" "int""'");

12439

}

12440

arg2 = static_cast< int >(val2);

12441

{

12442

arg3 = wxString_in_helper(obj2);

12443

if (arg3 == NULL) SWIG_fail;

12444

temp3 = true;

12445

}

12446

{

12447

PyThreadState* __tstate = wxPyBeginAllowThreads();

12448

result = (int)(arg1)->TextWidth(arg2,(wxString const &)*arg3);

12449

wxPyEndAllowThreads(__tstate);

12450

if (PyErr_Occurred()) SWIG_fail;

12451

}

12452

resultobj = SWIG_From_int(static_cast< int >(result));

12453

{

12454

if (temp3)

12455

delete arg3;

12456

}

12457

return resultobj;

12458

fail:

12459

{

12460

if (temp3)

12461

delete arg3;

12462

}

12463

return NULL;

12464

}

12465

12466

12467

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetEndAtLastLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12468

PyObject *resultobj = 0;

12469

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12470

bool arg2 ;

12471

void *argp1 = 0 ;

12472

int res1 = 0 ;

12473

bool val2 ;

12474

int ecode2 = 0 ;

12475

PyObject * obj0 = 0 ;

12476

PyObject * obj1 = 0 ;

12477

char * kwnames[] = {

12478

(char *) "self",(char *) "endAtLastLine", NULL

12479

};

12480

12481

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetEndAtLastLine",kwnames,&obj0,&obj1)) SWIG_fail;

12482

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12483

if (!SWIG_IsOK(res1)) {

12484

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetEndAtLastLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12485

}

12486

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12487

ecode2 = SWIG_AsVal_bool(obj1, &val2);

12488

if (!SWIG_IsOK(ecode2)) {

12489

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetEndAtLastLine" "', expected argument " "2"" of type '" "bool""'");

12490

}

12491

arg2 = static_cast< bool >(val2);

12492

{

12493

PyThreadState* __tstate = wxPyBeginAllowThreads();

12494

(arg1)->SetEndAtLastLine(arg2);

12495

wxPyEndAllowThreads(__tstate);

12496

if (PyErr_Occurred()) SWIG_fail;

12497

}

12498

resultobj = SWIG_Py_Void();

12499

return resultobj;

12500

fail:

12501

return NULL;

12502

}

12503

12504

12505

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetEndAtLastLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12506

PyObject *resultobj = 0;

12507

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12508

bool result;

12509

void *argp1 = 0 ;

12510

int res1 = 0 ;

12511

PyObject *swig_obj[1] ;

12512

12513

if (!args) SWIG_fail;

12514

swig_obj[0] = args;

12515

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12516

if (!SWIG_IsOK(res1)) {

12517

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetEndAtLastLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12518

}

12519

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12520

{

12521

PyThreadState* __tstate = wxPyBeginAllowThreads();

12522

result = (bool)(arg1)->GetEndAtLastLine();

12523

wxPyEndAllowThreads(__tstate);

12524

if (PyErr_Occurred()) SWIG_fail;

12525

}

12526

{

12527

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

12528

}

12529

return resultobj;

12530

fail:

12531

return NULL;

12532

}

12533

12534

12535

SWIGINTERN PyObject *_wrap_StyledTextCtrl_TextHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12536

PyObject *resultobj = 0;

12537

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12538

int arg2 ;

12539

int result;

12540

void *argp1 = 0 ;

12541

int res1 = 0 ;

12542

int val2 ;

12543

int ecode2 = 0 ;

12544

PyObject * obj0 = 0 ;

12545

PyObject * obj1 = 0 ;

12546

char * kwnames[] = {

12547

(char *) "self",(char *) "line", NULL

12548

};

12549

12550

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_TextHeight",kwnames,&obj0,&obj1)) SWIG_fail;

12551

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12552

if (!SWIG_IsOK(res1)) {

12553

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_TextHeight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12554

}

12555

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12556

ecode2 = SWIG_AsVal_int(obj1, &val2);

12557

if (!SWIG_IsOK(ecode2)) {

12558

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_TextHeight" "', expected argument " "2"" of type '" "int""'");

12559

}

12560

arg2 = static_cast< int >(val2);

12561

{

12562

PyThreadState* __tstate = wxPyBeginAllowThreads();

12563

result = (int)(arg1)->TextHeight(arg2);

12564

wxPyEndAllowThreads(__tstate);

12565

if (PyErr_Occurred()) SWIG_fail;

12566

}

12567

resultobj = SWIG_From_int(static_cast< int >(result));

12568

return resultobj;

12569

fail:

12570

return NULL;

12571

}

12572

12573

12574

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetUseVerticalScrollBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12575

PyObject *resultobj = 0;

12576

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12577

bool arg2 ;

12578

void *argp1 = 0 ;

12579

int res1 = 0 ;

12580

bool val2 ;

12581

int ecode2 = 0 ;

12582

PyObject * obj0 = 0 ;

12583

PyObject * obj1 = 0 ;

12584

char * kwnames[] = {

12585

(char *) "self",(char *) "show", NULL

12586

};

12587

12588

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetUseVerticalScrollBar",kwnames,&obj0,&obj1)) SWIG_fail;

12589

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12590

if (!SWIG_IsOK(res1)) {

12591

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetUseVerticalScrollBar" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12592

}

12593

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12594

ecode2 = SWIG_AsVal_bool(obj1, &val2);

12595

if (!SWIG_IsOK(ecode2)) {

12596

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetUseVerticalScrollBar" "', expected argument " "2"" of type '" "bool""'");

12597

}

12598

arg2 = static_cast< bool >(val2);

12599

{

12600

PyThreadState* __tstate = wxPyBeginAllowThreads();

12601

(arg1)->SetUseVerticalScrollBar(arg2);

12602

wxPyEndAllowThreads(__tstate);

12603

if (PyErr_Occurred()) SWIG_fail;

12604

}

12605

resultobj = SWIG_Py_Void();

12606

return resultobj;

12607

fail:

12608

return NULL;

12609

}

12610

12611

12612

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetUseVerticalScrollBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12613

PyObject *resultobj = 0;

12614

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12615

bool result;

12616

void *argp1 = 0 ;

12617

int res1 = 0 ;

12618

PyObject *swig_obj[1] ;

12619

12620

if (!args) SWIG_fail;

12621

swig_obj[0] = args;

12622

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12623

if (!SWIG_IsOK(res1)) {

12624

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetUseVerticalScrollBar" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12625

}

12626

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12627

{

12628

PyThreadState* __tstate = wxPyBeginAllowThreads();

12629

result = (bool)(arg1)->GetUseVerticalScrollBar();

12630

wxPyEndAllowThreads(__tstate);

12631

if (PyErr_Occurred()) SWIG_fail;

12632

}

12633

{

12634

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

12635

}

12636

return resultobj;

12637

fail:

12638

return NULL;

12639

}

12640

12641

12642

SWIGINTERN PyObject *_wrap_StyledTextCtrl_AppendText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12643

PyObject *resultobj = 0;

12644

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12645

wxString *arg2 = 0 ;

12646

void *argp1 = 0 ;

12647

int res1 = 0 ;

12648

bool temp2 = false ;

12649

PyObject * obj0 = 0 ;

12650

PyObject * obj1 = 0 ;

12651

char * kwnames[] = {

12652

(char *) "self",(char *) "text", NULL

12653

};

12654

12655

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_AppendText",kwnames,&obj0,&obj1)) SWIG_fail;

12656

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12657

if (!SWIG_IsOK(res1)) {

12658

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_AppendText" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12659

}

12660

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12661

{

12662

arg2 = wxString_in_helper(obj1);

12663

if (arg2 == NULL) SWIG_fail;

12664

temp2 = true;

12665

}

12666

{

12667

PyThreadState* __tstate = wxPyBeginAllowThreads();

12668

(arg1)->AppendText((wxString const &)*arg2);

12669

wxPyEndAllowThreads(__tstate);

12670

if (PyErr_Occurred()) SWIG_fail;

12671

}

12672

resultobj = SWIG_Py_Void();

12673

{

12674

if (temp2)

12675

delete arg2;

12676

}

12677

return resultobj;

12678

fail:

12679

{

12680

if (temp2)

12681

delete arg2;

12682

}

12683

return NULL;

12684

}

12685

12686

12687

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetTwoPhaseDraw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12688

PyObject *resultobj = 0;

12689

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12690

bool result;

12691

void *argp1 = 0 ;

12692

int res1 = 0 ;

12693

PyObject *swig_obj[1] ;

12694

12695

if (!args) SWIG_fail;

12696

swig_obj[0] = args;

12697

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12698

if (!SWIG_IsOK(res1)) {

12699

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetTwoPhaseDraw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12700

}

12701

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12702

{

12703

PyThreadState* __tstate = wxPyBeginAllowThreads();

12704

result = (bool)(arg1)->GetTwoPhaseDraw();

12705

wxPyEndAllowThreads(__tstate);

12706

if (PyErr_Occurred()) SWIG_fail;

12707

}

12708

{

12709

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

12710

}

12711

return resultobj;

12712

fail:

12713

return NULL;

12714

}

12715

12716

12717

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetTwoPhaseDraw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12718

PyObject *resultobj = 0;

12719

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12720

bool arg2 ;

12721

void *argp1 = 0 ;

12722

int res1 = 0 ;

12723

bool val2 ;

12724

int ecode2 = 0 ;

12725

PyObject * obj0 = 0 ;

12726

PyObject * obj1 = 0 ;

12727

char * kwnames[] = {

12728

(char *) "self",(char *) "twoPhase", NULL

12729

};

12730

12731

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetTwoPhaseDraw",kwnames,&obj0,&obj1)) SWIG_fail;

12732

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12733

if (!SWIG_IsOK(res1)) {

12734

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetTwoPhaseDraw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12735

}

12736

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12737

ecode2 = SWIG_AsVal_bool(obj1, &val2);

12738

if (!SWIG_IsOK(ecode2)) {

12739

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetTwoPhaseDraw" "', expected argument " "2"" of type '" "bool""'");

12740

}

12741

arg2 = static_cast< bool >(val2);

12742

{

12743

PyThreadState* __tstate = wxPyBeginAllowThreads();

12744

(arg1)->SetTwoPhaseDraw(arg2);

12745

wxPyEndAllowThreads(__tstate);

12746

if (PyErr_Occurred()) SWIG_fail;

12747

}

12748

resultobj = SWIG_Py_Void();

12749

return resultobj;

12750

fail:

12751

return NULL;

12752

}

12753

12754

12755

SWIGINTERN PyObject *_wrap_StyledTextCtrl_TargetFromSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12756

PyObject *resultobj = 0;

12757

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12758

void *argp1 = 0 ;

12759

int res1 = 0 ;

12760

PyObject *swig_obj[1] ;

12761

12762

if (!args) SWIG_fail;

12763

swig_obj[0] = args;

12764

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12765

if (!SWIG_IsOK(res1)) {

12766

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_TargetFromSelection" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12767

}

12768

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12769

{

12770

PyThreadState* __tstate = wxPyBeginAllowThreads();

12771

(arg1)->TargetFromSelection();

12772

wxPyEndAllowThreads(__tstate);

12773

if (PyErr_Occurred()) SWIG_fail;

12774

}

12775

resultobj = SWIG_Py_Void();

12776

return resultobj;

12777

fail:

12778

return NULL;

12779

}

12780

12781

12782

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LinesJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12783

PyObject *resultobj = 0;

12784

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12785

void *argp1 = 0 ;

12786

int res1 = 0 ;

12787

PyObject *swig_obj[1] ;

12788

12789

if (!args) SWIG_fail;

12790

swig_obj[0] = args;

12791

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12792

if (!SWIG_IsOK(res1)) {

12793

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LinesJoin" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12794

}

12795

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12796

{

12797

PyThreadState* __tstate = wxPyBeginAllowThreads();

12798

(arg1)->LinesJoin();

12799

wxPyEndAllowThreads(__tstate);

12800

if (PyErr_Occurred()) SWIG_fail;

12801

}

12802

resultobj = SWIG_Py_Void();

12803

return resultobj;

12804

fail:

12805

return NULL;

12806

}

12807

12808

12809

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LinesSplit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12810

PyObject *resultobj = 0;

12811

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12812

int arg2 ;

12813

void *argp1 = 0 ;

12814

int res1 = 0 ;

12815

int val2 ;

12816

int ecode2 = 0 ;

12817

PyObject * obj0 = 0 ;

12818

PyObject * obj1 = 0 ;

12819

char * kwnames[] = {

12820

(char *) "self",(char *) "pixelWidth", NULL

12821

};

12822

12823

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_LinesSplit",kwnames,&obj0,&obj1)) SWIG_fail;

12824

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12825

if (!SWIG_IsOK(res1)) {

12826

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LinesSplit" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12827

}

12828

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12829

ecode2 = SWIG_AsVal_int(obj1, &val2);

12830

if (!SWIG_IsOK(ecode2)) {

12831

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_LinesSplit" "', expected argument " "2"" of type '" "int""'");

12832

}

12833

arg2 = static_cast< int >(val2);

12834

{

12835

PyThreadState* __tstate = wxPyBeginAllowThreads();

12836

(arg1)->LinesSplit(arg2);

12837

wxPyEndAllowThreads(__tstate);

12838

if (PyErr_Occurred()) SWIG_fail;

12839

}

12840

resultobj = SWIG_Py_Void();

12841

return resultobj;

12842

fail:

12843

return NULL;

12844

}

12845

12846

12847

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetFoldMarginColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12848

PyObject *resultobj = 0;

12849

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12850

bool arg2 ;

12851

wxColour *arg3 = 0 ;

12852

void *argp1 = 0 ;

12853

int res1 = 0 ;

12854

bool val2 ;

12855

int ecode2 = 0 ;

12856

wxColour temp3 ;

12857

PyObject * obj0 = 0 ;

12858

PyObject * obj1 = 0 ;

12859

PyObject * obj2 = 0 ;

12860

char * kwnames[] = {

12861

(char *) "self",(char *) "useSetting",(char *) "back", NULL

12862

};

12863

12864

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetFoldMarginColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

12865

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12866

if (!SWIG_IsOK(res1)) {

12867

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetFoldMarginColour" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12868

}

12869

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12870

ecode2 = SWIG_AsVal_bool(obj1, &val2);

12871

if (!SWIG_IsOK(ecode2)) {

12872

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetFoldMarginColour" "', expected argument " "2"" of type '" "bool""'");

12873

}

12874

arg2 = static_cast< bool >(val2);

12875

{

12876

arg3 = &temp3;

12877

if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;

12878

}

12879

{

12880

PyThreadState* __tstate = wxPyBeginAllowThreads();

12881

(arg1)->SetFoldMarginColour(arg2,(wxColour const &)*arg3);

12882

wxPyEndAllowThreads(__tstate);

12883

if (PyErr_Occurred()) SWIG_fail;

12884

}

12885

resultobj = SWIG_Py_Void();

12886

return resultobj;

12887

fail:

12888

return NULL;

12889

}

12890

12891

12892

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetFoldMarginHiColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12893

PyObject *resultobj = 0;

12894

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12895

bool arg2 ;

12896

wxColour *arg3 = 0 ;

12897

void *argp1 = 0 ;

12898

int res1 = 0 ;

12899

bool val2 ;

12900

int ecode2 = 0 ;

12901

wxColour temp3 ;

12902

PyObject * obj0 = 0 ;

12903

PyObject * obj1 = 0 ;

12904

PyObject * obj2 = 0 ;

12905

char * kwnames[] = {

12906

(char *) "self",(char *) "useSetting",(char *) "fore", NULL

12907

};

12908

12909

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetFoldMarginHiColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

12910

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12911

if (!SWIG_IsOK(res1)) {

12912

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetFoldMarginHiColour" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12913

}

12914

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12915

ecode2 = SWIG_AsVal_bool(obj1, &val2);

12916

if (!SWIG_IsOK(ecode2)) {

12917

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetFoldMarginHiColour" "', expected argument " "2"" of type '" "bool""'");

12918

}

12919

arg2 = static_cast< bool >(val2);

12920

{

12921

arg3 = &temp3;

12922

if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;

12923

}

12924

{

12925

PyThreadState* __tstate = wxPyBeginAllowThreads();

12926

(arg1)->SetFoldMarginHiColour(arg2,(wxColour const &)*arg3);

12927

wxPyEndAllowThreads(__tstate);

12928

if (PyErr_Occurred()) SWIG_fail;

12929

}

12930

resultobj = SWIG_Py_Void();

12931

return resultobj;

12932

fail:

12933

return NULL;

12934

}

12935

12936

12937

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12938

PyObject *resultobj = 0;

12939

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12940

void *argp1 = 0 ;

12941

int res1 = 0 ;

12942

PyObject *swig_obj[1] ;

12943

12944

if (!args) SWIG_fail;

12945

swig_obj[0] = args;

12946

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12947

if (!SWIG_IsOK(res1)) {

12948

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineDown" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12949

}

12950

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12951

{

12952

PyThreadState* __tstate = wxPyBeginAllowThreads();

12953

(arg1)->LineDown();

12954

wxPyEndAllowThreads(__tstate);

12955

if (PyErr_Occurred()) SWIG_fail;

12956

}

12957

resultobj = SWIG_Py_Void();

12958

return resultobj;

12959

fail:

12960

return NULL;

12961

}

12962

12963

12964

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineDownExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12965

PyObject *resultobj = 0;

12966

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12967

void *argp1 = 0 ;

12968

int res1 = 0 ;

12969

PyObject *swig_obj[1] ;

12970

12971

if (!args) SWIG_fail;

12972

swig_obj[0] = args;

12973

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

12974

if (!SWIG_IsOK(res1)) {

12975

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineDownExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

12976

}

12977

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

12978

{

12979

PyThreadState* __tstate = wxPyBeginAllowThreads();

12980

(arg1)->LineDownExtend();

12981

wxPyEndAllowThreads(__tstate);

12982

if (PyErr_Occurred()) SWIG_fail;

12983

}

12984

resultobj = SWIG_Py_Void();

12985

return resultobj;

12986

fail:

12987

return NULL;

12988

}

12989

12990

12991

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12992

PyObject *resultobj = 0;

12993

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

12994

void *argp1 = 0 ;

12995

int res1 = 0 ;

12996

PyObject *swig_obj[1] ;

12997

12998

if (!args) SWIG_fail;

12999

swig_obj[0] = args;

13000

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13001

if (!SWIG_IsOK(res1)) {

13002

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineUp" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13003

}

13004

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13005

{

13006

PyThreadState* __tstate = wxPyBeginAllowThreads();

13007

(arg1)->LineUp();

13008

wxPyEndAllowThreads(__tstate);

13009

if (PyErr_Occurred()) SWIG_fail;

13010

}

13011

resultobj = SWIG_Py_Void();

13012

return resultobj;

13013

fail:

13014

return NULL;

13015

}

13016

13017

13018

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineUpExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13019

PyObject *resultobj = 0;

13020

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13021

void *argp1 = 0 ;

13022

int res1 = 0 ;

13023

PyObject *swig_obj[1] ;

13024

13025

if (!args) SWIG_fail;

13026

swig_obj[0] = args;

13027

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13028

if (!SWIG_IsOK(res1)) {

13029

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineUpExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13030

}

13031

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13032

{

13033

PyThreadState* __tstate = wxPyBeginAllowThreads();

13034

(arg1)->LineUpExtend();

13035

wxPyEndAllowThreads(__tstate);

13036

if (PyErr_Occurred()) SWIG_fail;

13037

}

13038

resultobj = SWIG_Py_Void();

13039

return resultobj;

13040

fail:

13041

return NULL;

13042

}

13043

13044

13045

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CharLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13046

PyObject *resultobj = 0;

13047

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13048

void *argp1 = 0 ;

13049

int res1 = 0 ;

13050

PyObject *swig_obj[1] ;

13051

13052

if (!args) SWIG_fail;

13053

swig_obj[0] = args;

13054

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13055

if (!SWIG_IsOK(res1)) {

13056

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CharLeft" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13057

}

13058

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13059

{

13060

PyThreadState* __tstate = wxPyBeginAllowThreads();

13061

(arg1)->CharLeft();

13062

wxPyEndAllowThreads(__tstate);

13063

if (PyErr_Occurred()) SWIG_fail;

13064

}

13065

resultobj = SWIG_Py_Void();

13066

return resultobj;

13067

fail:

13068

return NULL;

13069

}

13070

13071

13072

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CharLeftExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13073

PyObject *resultobj = 0;

13074

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13075

void *argp1 = 0 ;

13076

int res1 = 0 ;

13077

PyObject *swig_obj[1] ;

13078

13079

if (!args) SWIG_fail;

13080

swig_obj[0] = args;

13081

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13082

if (!SWIG_IsOK(res1)) {

13083

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CharLeftExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13084

}

13085

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13086

{

13087

PyThreadState* __tstate = wxPyBeginAllowThreads();

13088

(arg1)->CharLeftExtend();

13089

wxPyEndAllowThreads(__tstate);

13090

if (PyErr_Occurred()) SWIG_fail;

13091

}

13092

resultobj = SWIG_Py_Void();

13093

return resultobj;

13094

fail:

13095

return NULL;

13096

}

13097

13098

13099

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CharRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13100

PyObject *resultobj = 0;

13101

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13102

void *argp1 = 0 ;

13103

int res1 = 0 ;

13104

PyObject *swig_obj[1] ;

13105

13106

if (!args) SWIG_fail;

13107

swig_obj[0] = args;

13108

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13109

if (!SWIG_IsOK(res1)) {

13110

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CharRight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13111

}

13112

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13113

{

13114

PyThreadState* __tstate = wxPyBeginAllowThreads();

13115

(arg1)->CharRight();

13116

wxPyEndAllowThreads(__tstate);

13117

if (PyErr_Occurred()) SWIG_fail;

13118

}

13119

resultobj = SWIG_Py_Void();

13120

return resultobj;

13121

fail:

13122

return NULL;

13123

}

13124

13125

13126

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CharRightExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13127

PyObject *resultobj = 0;

13128

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13129

void *argp1 = 0 ;

13130

int res1 = 0 ;

13131

PyObject *swig_obj[1] ;

13132

13133

if (!args) SWIG_fail;

13134

swig_obj[0] = args;

13135

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13136

if (!SWIG_IsOK(res1)) {

13137

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CharRightExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13138

}

13139

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13140

{

13141

PyThreadState* __tstate = wxPyBeginAllowThreads();

13142

(arg1)->CharRightExtend();

13143

wxPyEndAllowThreads(__tstate);

13144

if (PyErr_Occurred()) SWIG_fail;

13145

}

13146

resultobj = SWIG_Py_Void();

13147

return resultobj;

13148

fail:

13149

return NULL;

13150

}

13151

13152

13153

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13154

PyObject *resultobj = 0;

13155

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13156

void *argp1 = 0 ;

13157

int res1 = 0 ;

13158

PyObject *swig_obj[1] ;

13159

13160

if (!args) SWIG_fail;

13161

swig_obj[0] = args;

13162

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13163

if (!SWIG_IsOK(res1)) {

13164

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordLeft" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13165

}

13166

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13167

{

13168

PyThreadState* __tstate = wxPyBeginAllowThreads();

13169

(arg1)->WordLeft();

13170

wxPyEndAllowThreads(__tstate);

13171

if (PyErr_Occurred()) SWIG_fail;

13172

}

13173

resultobj = SWIG_Py_Void();

13174

return resultobj;

13175

fail:

13176

return NULL;

13177

}

13178

13179

13180

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordLeftExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13181

PyObject *resultobj = 0;

13182

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13183

void *argp1 = 0 ;

13184

int res1 = 0 ;

13185

PyObject *swig_obj[1] ;

13186

13187

if (!args) SWIG_fail;

13188

swig_obj[0] = args;

13189

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13190

if (!SWIG_IsOK(res1)) {

13191

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordLeftExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13192

}

13193

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13194

{

13195

PyThreadState* __tstate = wxPyBeginAllowThreads();

13196

(arg1)->WordLeftExtend();

13197

wxPyEndAllowThreads(__tstate);

13198

if (PyErr_Occurred()) SWIG_fail;

13199

}

13200

resultobj = SWIG_Py_Void();

13201

return resultobj;

13202

fail:

13203

return NULL;

13204

}

13205

13206

13207

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13208

PyObject *resultobj = 0;

13209

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13210

void *argp1 = 0 ;

13211

int res1 = 0 ;

13212

PyObject *swig_obj[1] ;

13213

13214

if (!args) SWIG_fail;

13215

swig_obj[0] = args;

13216

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13217

if (!SWIG_IsOK(res1)) {

13218

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordRight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13219

}

13220

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13221

{

13222

PyThreadState* __tstate = wxPyBeginAllowThreads();

13223

(arg1)->WordRight();

13224

wxPyEndAllowThreads(__tstate);

13225

if (PyErr_Occurred()) SWIG_fail;

13226

}

13227

resultobj = SWIG_Py_Void();

13228

return resultobj;

13229

fail:

13230

return NULL;

13231

}

13232

13233

13234

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordRightExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13235

PyObject *resultobj = 0;

13236

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13237

void *argp1 = 0 ;

13238

int res1 = 0 ;

13239

PyObject *swig_obj[1] ;

13240

13241

if (!args) SWIG_fail;

13242

swig_obj[0] = args;

13243

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13244

if (!SWIG_IsOK(res1)) {

13245

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordRightExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13246

}

13247

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13248

{

13249

PyThreadState* __tstate = wxPyBeginAllowThreads();

13250

(arg1)->WordRightExtend();

13251

wxPyEndAllowThreads(__tstate);

13252

if (PyErr_Occurred()) SWIG_fail;

13253

}

13254

resultobj = SWIG_Py_Void();

13255

return resultobj;

13256

fail:

13257

return NULL;

13258

}

13259

13260

13261

SWIGINTERN PyObject *_wrap_StyledTextCtrl_Home(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13262

PyObject *resultobj = 0;

13263

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13264

void *argp1 = 0 ;

13265

int res1 = 0 ;

13266

PyObject *swig_obj[1] ;

13267

13268

if (!args) SWIG_fail;

13269

swig_obj[0] = args;

13270

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13271

if (!SWIG_IsOK(res1)) {

13272

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_Home" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13273

}

13274

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13275

{

13276

PyThreadState* __tstate = wxPyBeginAllowThreads();

13277

(arg1)->Home();

13278

wxPyEndAllowThreads(__tstate);

13279

if (PyErr_Occurred()) SWIG_fail;

13280

}

13281

resultobj = SWIG_Py_Void();

13282

return resultobj;

13283

fail:

13284

return NULL;

13285

}

13286

13287

13288

SWIGINTERN PyObject *_wrap_StyledTextCtrl_HomeExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13289

PyObject *resultobj = 0;

13290

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13291

void *argp1 = 0 ;

13292

int res1 = 0 ;

13293

PyObject *swig_obj[1] ;

13294

13295

if (!args) SWIG_fail;

13296

swig_obj[0] = args;

13297

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13298

if (!SWIG_IsOK(res1)) {

13299

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_HomeExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13300

}

13301

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13302

{

13303

PyThreadState* __tstate = wxPyBeginAllowThreads();

13304

(arg1)->HomeExtend();

13305

wxPyEndAllowThreads(__tstate);

13306

if (PyErr_Occurred()) SWIG_fail;

13307

}

13308

resultobj = SWIG_Py_Void();

13309

return resultobj;

13310

fail:

13311

return NULL;

13312

}

13313

13314

13315

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13316

PyObject *resultobj = 0;

13317

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13318

void *argp1 = 0 ;

13319

int res1 = 0 ;

13320

PyObject *swig_obj[1] ;

13321

13322

if (!args) SWIG_fail;

13323

swig_obj[0] = args;

13324

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13325

if (!SWIG_IsOK(res1)) {

13326

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineEnd" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13327

}

13328

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13329

{

13330

PyThreadState* __tstate = wxPyBeginAllowThreads();

13331

(arg1)->LineEnd();

13332

wxPyEndAllowThreads(__tstate);

13333

if (PyErr_Occurred()) SWIG_fail;

13334

}

13335

resultobj = SWIG_Py_Void();

13336

return resultobj;

13337

fail:

13338

return NULL;

13339

}

13340

13341

13342

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineEndExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13343

PyObject *resultobj = 0;

13344

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13345

void *argp1 = 0 ;

13346

int res1 = 0 ;

13347

PyObject *swig_obj[1] ;

13348

13349

if (!args) SWIG_fail;

13350

swig_obj[0] = args;

13351

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13352

if (!SWIG_IsOK(res1)) {

13353

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineEndExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13354

}

13355

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13356

{

13357

PyThreadState* __tstate = wxPyBeginAllowThreads();

13358

(arg1)->LineEndExtend();

13359

wxPyEndAllowThreads(__tstate);

13360

if (PyErr_Occurred()) SWIG_fail;

13361

}

13362

resultobj = SWIG_Py_Void();

13363

return resultobj;

13364

fail:

13365

return NULL;

13366

}

13367

13368

13369

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DocumentStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13370

PyObject *resultobj = 0;

13371

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13372

void *argp1 = 0 ;

13373

int res1 = 0 ;

13374

PyObject *swig_obj[1] ;

13375

13376

if (!args) SWIG_fail;

13377

swig_obj[0] = args;

13378

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13379

if (!SWIG_IsOK(res1)) {

13380

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DocumentStart" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13381

}

13382

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13383

{

13384

PyThreadState* __tstate = wxPyBeginAllowThreads();

13385

(arg1)->DocumentStart();

13386

wxPyEndAllowThreads(__tstate);

13387

if (PyErr_Occurred()) SWIG_fail;

13388

}

13389

resultobj = SWIG_Py_Void();

13390

return resultobj;

13391

fail:

13392

return NULL;

13393

}

13394

13395

13396

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DocumentStartExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13397

PyObject *resultobj = 0;

13398

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13399

void *argp1 = 0 ;

13400

int res1 = 0 ;

13401

PyObject *swig_obj[1] ;

13402

13403

if (!args) SWIG_fail;

13404

swig_obj[0] = args;

13405

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13406

if (!SWIG_IsOK(res1)) {

13407

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DocumentStartExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13408

}

13409

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13410

{

13411

PyThreadState* __tstate = wxPyBeginAllowThreads();

13412

(arg1)->DocumentStartExtend();

13413

wxPyEndAllowThreads(__tstate);

13414

if (PyErr_Occurred()) SWIG_fail;

13415

}

13416

resultobj = SWIG_Py_Void();

13417

return resultobj;

13418

fail:

13419

return NULL;

13420

}

13421

13422

13423

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DocumentEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13424

PyObject *resultobj = 0;

13425

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13426

void *argp1 = 0 ;

13427

int res1 = 0 ;

13428

PyObject *swig_obj[1] ;

13429

13430

if (!args) SWIG_fail;

13431

swig_obj[0] = args;

13432

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13433

if (!SWIG_IsOK(res1)) {

13434

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DocumentEnd" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13435

}

13436

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13437

{

13438

PyThreadState* __tstate = wxPyBeginAllowThreads();

13439

(arg1)->DocumentEnd();

13440

wxPyEndAllowThreads(__tstate);

13441

if (PyErr_Occurred()) SWIG_fail;

13442

}

13443

resultobj = SWIG_Py_Void();

13444

return resultobj;

13445

fail:

13446

return NULL;

13447

}

13448

13449

13450

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DocumentEndExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13451

PyObject *resultobj = 0;

13452

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13453

void *argp1 = 0 ;

13454

int res1 = 0 ;

13455

PyObject *swig_obj[1] ;

13456

13457

if (!args) SWIG_fail;

13458

swig_obj[0] = args;

13459

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13460

if (!SWIG_IsOK(res1)) {

13461

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DocumentEndExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13462

}

13463

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13464

{

13465

PyThreadState* __tstate = wxPyBeginAllowThreads();

13466

(arg1)->DocumentEndExtend();

13467

wxPyEndAllowThreads(__tstate);

13468

if (PyErr_Occurred()) SWIG_fail;

13469

}

13470

resultobj = SWIG_Py_Void();

13471

return resultobj;

13472

fail:

13473

return NULL;

13474

}

13475

13476

13477

SWIGINTERN PyObject *_wrap_StyledTextCtrl_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13478

PyObject *resultobj = 0;

13479

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13480

void *argp1 = 0 ;

13481

int res1 = 0 ;

13482

PyObject *swig_obj[1] ;

13483

13484

if (!args) SWIG_fail;

13485

swig_obj[0] = args;

13486

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13487

if (!SWIG_IsOK(res1)) {

13488

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_PageUp" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13489

}

13490

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13491

{

13492

PyThreadState* __tstate = wxPyBeginAllowThreads();

13493

(arg1)->PageUp();

13494

wxPyEndAllowThreads(__tstate);

13495

if (PyErr_Occurred()) SWIG_fail;

13496

}

13497

resultobj = SWIG_Py_Void();

13498

return resultobj;

13499

fail:

13500

return NULL;

13501

}

13502

13503

13504

SWIGINTERN PyObject *_wrap_StyledTextCtrl_PageUpExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13505

PyObject *resultobj = 0;

13506

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13507

void *argp1 = 0 ;

13508

int res1 = 0 ;

13509

PyObject *swig_obj[1] ;

13510

13511

if (!args) SWIG_fail;

13512

swig_obj[0] = args;

13513

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13514

if (!SWIG_IsOK(res1)) {

13515

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_PageUpExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13516

}

13517

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13518

{

13519

PyThreadState* __tstate = wxPyBeginAllowThreads();

13520

(arg1)->PageUpExtend();

13521

wxPyEndAllowThreads(__tstate);

13522

if (PyErr_Occurred()) SWIG_fail;

13523

}

13524

resultobj = SWIG_Py_Void();

13525

return resultobj;

13526

fail:

13527

return NULL;

13528

}

13529

13530

13531

SWIGINTERN PyObject *_wrap_StyledTextCtrl_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13532

PyObject *resultobj = 0;

13533

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13534

void *argp1 = 0 ;

13535

int res1 = 0 ;

13536

PyObject *swig_obj[1] ;

13537

13538

if (!args) SWIG_fail;

13539

swig_obj[0] = args;

13540

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13541

if (!SWIG_IsOK(res1)) {

13542

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_PageDown" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13543

}

13544

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13545

{

13546

PyThreadState* __tstate = wxPyBeginAllowThreads();

13547

(arg1)->PageDown();

13548

wxPyEndAllowThreads(__tstate);

13549

if (PyErr_Occurred()) SWIG_fail;

13550

}

13551

resultobj = SWIG_Py_Void();

13552

return resultobj;

13553

fail:

13554

return NULL;

13555

}

13556

13557

13558

SWIGINTERN PyObject *_wrap_StyledTextCtrl_PageDownExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13559

PyObject *resultobj = 0;

13560

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13561

void *argp1 = 0 ;

13562

int res1 = 0 ;

13563

PyObject *swig_obj[1] ;

13564

13565

if (!args) SWIG_fail;

13566

swig_obj[0] = args;

13567

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13568

if (!SWIG_IsOK(res1)) {

13569

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_PageDownExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13570

}

13571

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13572

{

13573

PyThreadState* __tstate = wxPyBeginAllowThreads();

13574

(arg1)->PageDownExtend();

13575

wxPyEndAllowThreads(__tstate);

13576

if (PyErr_Occurred()) SWIG_fail;

13577

}

13578

resultobj = SWIG_Py_Void();

13579

return resultobj;

13580

fail:

13581

return NULL;

13582

}

13583

13584

13585

SWIGINTERN PyObject *_wrap_StyledTextCtrl_EditToggleOvertype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13586

PyObject *resultobj = 0;

13587

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13588

void *argp1 = 0 ;

13589

int res1 = 0 ;

13590

PyObject *swig_obj[1] ;

13591

13592

if (!args) SWIG_fail;

13593

swig_obj[0] = args;

13594

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13595

if (!SWIG_IsOK(res1)) {

13596

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_EditToggleOvertype" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13597

}

13598

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13599

{

13600

PyThreadState* __tstate = wxPyBeginAllowThreads();

13601

(arg1)->EditToggleOvertype();

13602

wxPyEndAllowThreads(__tstate);

13603

if (PyErr_Occurred()) SWIG_fail;

13604

}

13605

resultobj = SWIG_Py_Void();

13606

return resultobj;

13607

fail:

13608

return NULL;

13609

}

13610

13611

13612

SWIGINTERN PyObject *_wrap_StyledTextCtrl_Cancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13613

PyObject *resultobj = 0;

13614

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13615

void *argp1 = 0 ;

13616

int res1 = 0 ;

13617

PyObject *swig_obj[1] ;

13618

13619

if (!args) SWIG_fail;

13620

swig_obj[0] = args;

13621

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13622

if (!SWIG_IsOK(res1)) {

13623

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_Cancel" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13624

}

13625

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13626

{

13627

PyThreadState* __tstate = wxPyBeginAllowThreads();

13628

(arg1)->Cancel();

13629

wxPyEndAllowThreads(__tstate);

13630

if (PyErr_Occurred()) SWIG_fail;

13631

}

13632

resultobj = SWIG_Py_Void();

13633

return resultobj;

13634

fail:

13635

return NULL;

13636

}

13637

13638

13639

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DeleteBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13640

PyObject *resultobj = 0;

13641

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13642

void *argp1 = 0 ;

13643

int res1 = 0 ;

13644

PyObject *swig_obj[1] ;

13645

13646

if (!args) SWIG_fail;

13647

swig_obj[0] = args;

13648

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13649

if (!SWIG_IsOK(res1)) {

13650

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DeleteBack" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13651

}

13652

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13653

{

13654

PyThreadState* __tstate = wxPyBeginAllowThreads();

13655

(arg1)->DeleteBack();

13656

wxPyEndAllowThreads(__tstate);

13657

if (PyErr_Occurred()) SWIG_fail;

13658

}

13659

resultobj = SWIG_Py_Void();

13660

return resultobj;

13661

fail:

13662

return NULL;

13663

}

13664

13665

13666

SWIGINTERN PyObject *_wrap_StyledTextCtrl_Tab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13667

PyObject *resultobj = 0;

13668

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13669

void *argp1 = 0 ;

13670

int res1 = 0 ;

13671

PyObject *swig_obj[1] ;

13672

13673

if (!args) SWIG_fail;

13674

swig_obj[0] = args;

13675

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13676

if (!SWIG_IsOK(res1)) {

13677

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_Tab" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13678

}

13679

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13680

{

13681

PyThreadState* __tstate = wxPyBeginAllowThreads();

13682

(arg1)->Tab();

13683

wxPyEndAllowThreads(__tstate);

13684

if (PyErr_Occurred()) SWIG_fail;

13685

}

13686

resultobj = SWIG_Py_Void();

13687

return resultobj;

13688

fail:

13689

return NULL;

13690

}

13691

13692

13693

SWIGINTERN PyObject *_wrap_StyledTextCtrl_BackTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13694

PyObject *resultobj = 0;

13695

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13696

void *argp1 = 0 ;

13697

int res1 = 0 ;

13698

PyObject *swig_obj[1] ;

13699

13700

if (!args) SWIG_fail;

13701

swig_obj[0] = args;

13702

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13703

if (!SWIG_IsOK(res1)) {

13704

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_BackTab" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13705

}

13706

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13707

{

13708

PyThreadState* __tstate = wxPyBeginAllowThreads();

13709

(arg1)->BackTab();

13710

wxPyEndAllowThreads(__tstate);

13711

if (PyErr_Occurred()) SWIG_fail;

13712

}

13713

resultobj = SWIG_Py_Void();

13714

return resultobj;

13715

fail:

13716

return NULL;

13717

}

13718

13719

13720

SWIGINTERN PyObject *_wrap_StyledTextCtrl_NewLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13721

PyObject *resultobj = 0;

13722

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13723

void *argp1 = 0 ;

13724

int res1 = 0 ;

13725

PyObject *swig_obj[1] ;

13726

13727

if (!args) SWIG_fail;

13728

swig_obj[0] = args;

13729

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13730

if (!SWIG_IsOK(res1)) {

13731

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_NewLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13732

}

13733

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13734

{

13735

PyThreadState* __tstate = wxPyBeginAllowThreads();

13736

(arg1)->NewLine();

13737

wxPyEndAllowThreads(__tstate);

13738

if (PyErr_Occurred()) SWIG_fail;

13739

}

13740

resultobj = SWIG_Py_Void();

13741

return resultobj;

13742

fail:

13743

return NULL;

13744

}

13745

13746

13747

SWIGINTERN PyObject *_wrap_StyledTextCtrl_FormFeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13748

PyObject *resultobj = 0;

13749

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13750

void *argp1 = 0 ;

13751

int res1 = 0 ;

13752

PyObject *swig_obj[1] ;

13753

13754

if (!args) SWIG_fail;

13755

swig_obj[0] = args;

13756

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13757

if (!SWIG_IsOK(res1)) {

13758

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_FormFeed" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13759

}

13760

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13761

{

13762

PyThreadState* __tstate = wxPyBeginAllowThreads();

13763

(arg1)->FormFeed();

13764

wxPyEndAllowThreads(__tstate);

13765

if (PyErr_Occurred()) SWIG_fail;

13766

}

13767

resultobj = SWIG_Py_Void();

13768

return resultobj;

13769

fail:

13770

return NULL;

13771

}

13772

13773

13774

SWIGINTERN PyObject *_wrap_StyledTextCtrl_VCHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13775

PyObject *resultobj = 0;

13776

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13777

void *argp1 = 0 ;

13778

int res1 = 0 ;

13779

PyObject *swig_obj[1] ;

13780

13781

if (!args) SWIG_fail;

13782

swig_obj[0] = args;

13783

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13784

if (!SWIG_IsOK(res1)) {

13785

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_VCHome" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13786

}

13787

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13788

{

13789

PyThreadState* __tstate = wxPyBeginAllowThreads();

13790

(arg1)->VCHome();

13791

wxPyEndAllowThreads(__tstate);

13792

if (PyErr_Occurred()) SWIG_fail;

13793

}

13794

resultobj = SWIG_Py_Void();

13795

return resultobj;

13796

fail:

13797

return NULL;

13798

}

13799

13800

13801

SWIGINTERN PyObject *_wrap_StyledTextCtrl_VCHomeExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13802

PyObject *resultobj = 0;

13803

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13804

void *argp1 = 0 ;

13805

int res1 = 0 ;

13806

PyObject *swig_obj[1] ;

13807

13808

if (!args) SWIG_fail;

13809

swig_obj[0] = args;

13810

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13811

if (!SWIG_IsOK(res1)) {

13812

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_VCHomeExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13813

}

13814

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13815

{

13816

PyThreadState* __tstate = wxPyBeginAllowThreads();

13817

(arg1)->VCHomeExtend();

13818

wxPyEndAllowThreads(__tstate);

13819

if (PyErr_Occurred()) SWIG_fail;

13820

}

13821

resultobj = SWIG_Py_Void();

13822

return resultobj;

13823

fail:

13824

return NULL;

13825

}

13826

13827

13828

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ZoomIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13829

PyObject *resultobj = 0;

13830

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13831

void *argp1 = 0 ;

13832

int res1 = 0 ;

13833

PyObject *swig_obj[1] ;

13834

13835

if (!args) SWIG_fail;

13836

swig_obj[0] = args;

13837

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13838

if (!SWIG_IsOK(res1)) {

13839

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ZoomIn" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13840

}

13841

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13842

{

13843

PyThreadState* __tstate = wxPyBeginAllowThreads();

13844

(arg1)->ZoomIn();

13845

wxPyEndAllowThreads(__tstate);

13846

if (PyErr_Occurred()) SWIG_fail;

13847

}

13848

resultobj = SWIG_Py_Void();

13849

return resultobj;

13850

fail:

13851

return NULL;

13852

}

13853

13854

13855

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ZoomOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13856

PyObject *resultobj = 0;

13857

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13858

void *argp1 = 0 ;

13859

int res1 = 0 ;

13860

PyObject *swig_obj[1] ;

13861

13862

if (!args) SWIG_fail;

13863

swig_obj[0] = args;

13864

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13865

if (!SWIG_IsOK(res1)) {

13866

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ZoomOut" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13867

}

13868

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13869

{

13870

PyThreadState* __tstate = wxPyBeginAllowThreads();

13871

(arg1)->ZoomOut();

13872

wxPyEndAllowThreads(__tstate);

13873

if (PyErr_Occurred()) SWIG_fail;

13874

}

13875

resultobj = SWIG_Py_Void();

13876

return resultobj;

13877

fail:

13878

return NULL;

13879

}

13880

13881

13882

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DelWordLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13883

PyObject *resultobj = 0;

13884

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13885

void *argp1 = 0 ;

13886

int res1 = 0 ;

13887

PyObject *swig_obj[1] ;

13888

13889

if (!args) SWIG_fail;

13890

swig_obj[0] = args;

13891

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13892

if (!SWIG_IsOK(res1)) {

13893

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DelWordLeft" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13894

}

13895

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13896

{

13897

PyThreadState* __tstate = wxPyBeginAllowThreads();

13898

(arg1)->DelWordLeft();

13899

wxPyEndAllowThreads(__tstate);

13900

if (PyErr_Occurred()) SWIG_fail;

13901

}

13902

resultobj = SWIG_Py_Void();

13903

return resultobj;

13904

fail:

13905

return NULL;

13906

}

13907

13908

13909

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DelWordRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13910

PyObject *resultobj = 0;

13911

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13912

void *argp1 = 0 ;

13913

int res1 = 0 ;

13914

PyObject *swig_obj[1] ;

13915

13916

if (!args) SWIG_fail;

13917

swig_obj[0] = args;

13918

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13919

if (!SWIG_IsOK(res1)) {

13920

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DelWordRight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13921

}

13922

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13923

{

13924

PyThreadState* __tstate = wxPyBeginAllowThreads();

13925

(arg1)->DelWordRight();

13926

wxPyEndAllowThreads(__tstate);

13927

if (PyErr_Occurred()) SWIG_fail;

13928

}

13929

resultobj = SWIG_Py_Void();

13930

return resultobj;

13931

fail:

13932

return NULL;

13933

}

13934

13935

13936

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineCut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13937

PyObject *resultobj = 0;

13938

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13939

void *argp1 = 0 ;

13940

int res1 = 0 ;

13941

PyObject *swig_obj[1] ;

13942

13943

if (!args) SWIG_fail;

13944

swig_obj[0] = args;

13945

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13946

if (!SWIG_IsOK(res1)) {

13947

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineCut" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13948

}

13949

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13950

{

13951

PyThreadState* __tstate = wxPyBeginAllowThreads();

13952

(arg1)->LineCut();

13953

wxPyEndAllowThreads(__tstate);

13954

if (PyErr_Occurred()) SWIG_fail;

13955

}

13956

resultobj = SWIG_Py_Void();

13957

return resultobj;

13958

fail:

13959

return NULL;

13960

}

13961

13962

13963

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13964

PyObject *resultobj = 0;

13965

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13966

void *argp1 = 0 ;

13967

int res1 = 0 ;

13968

PyObject *swig_obj[1] ;

13969

13970

if (!args) SWIG_fail;

13971

swig_obj[0] = args;

13972

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

13973

if (!SWIG_IsOK(res1)) {

13974

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineDelete" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

13975

}

13976

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

13977

{

13978

PyThreadState* __tstate = wxPyBeginAllowThreads();

13979

(arg1)->LineDelete();

13980

wxPyEndAllowThreads(__tstate);

13981

if (PyErr_Occurred()) SWIG_fail;

13982

}

13983

resultobj = SWIG_Py_Void();

13984

return resultobj;

13985

fail:

13986

return NULL;

13987

}

13988

13989

13990

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13991

PyObject *resultobj = 0;

13992

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

13993

void *argp1 = 0 ;

13994

int res1 = 0 ;

13995

PyObject *swig_obj[1] ;

13996

13997

if (!args) SWIG_fail;

13998

swig_obj[0] = args;

13999

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14000

if (!SWIG_IsOK(res1)) {

14001

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineTranspose" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14002

}

14003

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14004

{

14005

PyThreadState* __tstate = wxPyBeginAllowThreads();

14006

(arg1)->LineTranspose();

14007

wxPyEndAllowThreads(__tstate);

14008

if (PyErr_Occurred()) SWIG_fail;

14009

}

14010

resultobj = SWIG_Py_Void();

14011

return resultobj;

14012

fail:

14013

return NULL;

14014

}

14015

14016

14017

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineDuplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14018

PyObject *resultobj = 0;

14019

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14020

void *argp1 = 0 ;

14021

int res1 = 0 ;

14022

PyObject *swig_obj[1] ;

14023

14024

if (!args) SWIG_fail;

14025

swig_obj[0] = args;

14026

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14027

if (!SWIG_IsOK(res1)) {

14028

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineDuplicate" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14029

}

14030

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14031

{

14032

PyThreadState* __tstate = wxPyBeginAllowThreads();

14033

(arg1)->LineDuplicate();

14034

wxPyEndAllowThreads(__tstate);

14035

if (PyErr_Occurred()) SWIG_fail;

14036

}

14037

resultobj = SWIG_Py_Void();

14038

return resultobj;

14039

fail:

14040

return NULL;

14041

}

14042

14043

14044

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LowerCase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14045

PyObject *resultobj = 0;

14046

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14047

void *argp1 = 0 ;

14048

int res1 = 0 ;

14049

PyObject *swig_obj[1] ;

14050

14051

if (!args) SWIG_fail;

14052

swig_obj[0] = args;

14053

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14054

if (!SWIG_IsOK(res1)) {

14055

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LowerCase" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14056

}

14057

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14058

{

14059

PyThreadState* __tstate = wxPyBeginAllowThreads();

14060

(arg1)->LowerCase();

14061

wxPyEndAllowThreads(__tstate);

14062

if (PyErr_Occurred()) SWIG_fail;

14063

}

14064

resultobj = SWIG_Py_Void();

14065

return resultobj;

14066

fail:

14067

return NULL;

14068

}

14069

14070

14071

SWIGINTERN PyObject *_wrap_StyledTextCtrl_UpperCase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14072

PyObject *resultobj = 0;

14073

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14074

void *argp1 = 0 ;

14075

int res1 = 0 ;

14076

PyObject *swig_obj[1] ;

14077

14078

if (!args) SWIG_fail;

14079

swig_obj[0] = args;

14080

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14081

if (!SWIG_IsOK(res1)) {

14082

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_UpperCase" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14083

}

14084

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14085

{

14086

PyThreadState* __tstate = wxPyBeginAllowThreads();

14087

(arg1)->UpperCase();

14088

wxPyEndAllowThreads(__tstate);

14089

if (PyErr_Occurred()) SWIG_fail;

14090

}

14091

resultobj = SWIG_Py_Void();

14092

return resultobj;

14093

fail:

14094

return NULL;

14095

}

14096

14097

14098

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineScrollDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14099

PyObject *resultobj = 0;

14100

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14101

void *argp1 = 0 ;

14102

int res1 = 0 ;

14103

PyObject *swig_obj[1] ;

14104

14105

if (!args) SWIG_fail;

14106

swig_obj[0] = args;

14107

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14108

if (!SWIG_IsOK(res1)) {

14109

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineScrollDown" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14110

}

14111

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14112

{

14113

PyThreadState* __tstate = wxPyBeginAllowThreads();

14114

(arg1)->LineScrollDown();

14115

wxPyEndAllowThreads(__tstate);

14116

if (PyErr_Occurred()) SWIG_fail;

14117

}

14118

resultobj = SWIG_Py_Void();

14119

return resultobj;

14120

fail:

14121

return NULL;

14122

}

14123

14124

14125

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineScrollUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14126

PyObject *resultobj = 0;

14127

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14128

void *argp1 = 0 ;

14129

int res1 = 0 ;

14130

PyObject *swig_obj[1] ;

14131

14132

if (!args) SWIG_fail;

14133

swig_obj[0] = args;

14134

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14135

if (!SWIG_IsOK(res1)) {

14136

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineScrollUp" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14137

}

14138

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14139

{

14140

PyThreadState* __tstate = wxPyBeginAllowThreads();

14141

(arg1)->LineScrollUp();

14142

wxPyEndAllowThreads(__tstate);

14143

if (PyErr_Occurred()) SWIG_fail;

14144

}

14145

resultobj = SWIG_Py_Void();

14146

return resultobj;

14147

fail:

14148

return NULL;

14149

}

14150

14151

14152

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DeleteBackNotLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14153

PyObject *resultobj = 0;

14154

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14155

void *argp1 = 0 ;

14156

int res1 = 0 ;

14157

PyObject *swig_obj[1] ;

14158

14159

if (!args) SWIG_fail;

14160

swig_obj[0] = args;

14161

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14162

if (!SWIG_IsOK(res1)) {

14163

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DeleteBackNotLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14164

}

14165

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14166

{

14167

PyThreadState* __tstate = wxPyBeginAllowThreads();

14168

(arg1)->DeleteBackNotLine();

14169

wxPyEndAllowThreads(__tstate);

14170

if (PyErr_Occurred()) SWIG_fail;

14171

}

14172

resultobj = SWIG_Py_Void();

14173

return resultobj;

14174

fail:

14175

return NULL;

14176

}

14177

14178

14179

SWIGINTERN PyObject *_wrap_StyledTextCtrl_HomeDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14180

PyObject *resultobj = 0;

14181

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14182

void *argp1 = 0 ;

14183

int res1 = 0 ;

14184

PyObject *swig_obj[1] ;

14185

14186

if (!args) SWIG_fail;

14187

swig_obj[0] = args;

14188

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14189

if (!SWIG_IsOK(res1)) {

14190

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_HomeDisplay" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14191

}

14192

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14193

{

14194

PyThreadState* __tstate = wxPyBeginAllowThreads();

14195

(arg1)->HomeDisplay();

14196

wxPyEndAllowThreads(__tstate);

14197

if (PyErr_Occurred()) SWIG_fail;

14198

}

14199

resultobj = SWIG_Py_Void();

14200

return resultobj;

14201

fail:

14202

return NULL;

14203

}

14204

14205

14206

SWIGINTERN PyObject *_wrap_StyledTextCtrl_HomeDisplayExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14207

PyObject *resultobj = 0;

14208

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14209

void *argp1 = 0 ;

14210

int res1 = 0 ;

14211

PyObject *swig_obj[1] ;

14212

14213

if (!args) SWIG_fail;

14214

swig_obj[0] = args;

14215

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14216

if (!SWIG_IsOK(res1)) {

14217

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_HomeDisplayExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14218

}

14219

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14220

{

14221

PyThreadState* __tstate = wxPyBeginAllowThreads();

14222

(arg1)->HomeDisplayExtend();

14223

wxPyEndAllowThreads(__tstate);

14224

if (PyErr_Occurred()) SWIG_fail;

14225

}

14226

resultobj = SWIG_Py_Void();

14227

return resultobj;

14228

fail:

14229

return NULL;

14230

}

14231

14232

14233

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineEndDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14234

PyObject *resultobj = 0;

14235

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14236

void *argp1 = 0 ;

14237

int res1 = 0 ;

14238

PyObject *swig_obj[1] ;

14239

14240

if (!args) SWIG_fail;

14241

swig_obj[0] = args;

14242

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14243

if (!SWIG_IsOK(res1)) {

14244

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineEndDisplay" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14245

}

14246

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14247

{

14248

PyThreadState* __tstate = wxPyBeginAllowThreads();

14249

(arg1)->LineEndDisplay();

14250

wxPyEndAllowThreads(__tstate);

14251

if (PyErr_Occurred()) SWIG_fail;

14252

}

14253

resultobj = SWIG_Py_Void();

14254

return resultobj;

14255

fail:

14256

return NULL;

14257

}

14258

14259

14260

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineEndDisplayExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14261

PyObject *resultobj = 0;

14262

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14263

void *argp1 = 0 ;

14264

int res1 = 0 ;

14265

PyObject *swig_obj[1] ;

14266

14267

if (!args) SWIG_fail;

14268

swig_obj[0] = args;

14269

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14270

if (!SWIG_IsOK(res1)) {

14271

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineEndDisplayExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14272

}

14273

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14274

{

14275

PyThreadState* __tstate = wxPyBeginAllowThreads();

14276

(arg1)->LineEndDisplayExtend();

14277

wxPyEndAllowThreads(__tstate);

14278

if (PyErr_Occurred()) SWIG_fail;

14279

}

14280

resultobj = SWIG_Py_Void();

14281

return resultobj;

14282

fail:

14283

return NULL;

14284

}

14285

14286

14287

SWIGINTERN PyObject *_wrap_StyledTextCtrl_HomeWrap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14288

PyObject *resultobj = 0;

14289

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14290

void *argp1 = 0 ;

14291

int res1 = 0 ;

14292

PyObject *swig_obj[1] ;

14293

14294

if (!args) SWIG_fail;

14295

swig_obj[0] = args;

14296

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14297

if (!SWIG_IsOK(res1)) {

14298

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_HomeWrap" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14299

}

14300

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14301

{

14302

PyThreadState* __tstate = wxPyBeginAllowThreads();

14303

(arg1)->HomeWrap();

14304

wxPyEndAllowThreads(__tstate);

14305

if (PyErr_Occurred()) SWIG_fail;

14306

}

14307

resultobj = SWIG_Py_Void();

14308

return resultobj;

14309

fail:

14310

return NULL;

14311

}

14312

14313

14314

SWIGINTERN PyObject *_wrap_StyledTextCtrl_HomeWrapExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14315

PyObject *resultobj = 0;

14316

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14317

void *argp1 = 0 ;

14318

int res1 = 0 ;

14319

PyObject *swig_obj[1] ;

14320

14321

if (!args) SWIG_fail;

14322

swig_obj[0] = args;

14323

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14324

if (!SWIG_IsOK(res1)) {

14325

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_HomeWrapExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14326

}

14327

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14328

{

14329

PyThreadState* __tstate = wxPyBeginAllowThreads();

14330

(arg1)->HomeWrapExtend();

14331

wxPyEndAllowThreads(__tstate);

14332

if (PyErr_Occurred()) SWIG_fail;

14333

}

14334

resultobj = SWIG_Py_Void();

14335

return resultobj;

14336

fail:

14337

return NULL;

14338

}

14339

14340

14341

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineEndWrap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14342

PyObject *resultobj = 0;

14343

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14344

void *argp1 = 0 ;

14345

int res1 = 0 ;

14346

PyObject *swig_obj[1] ;

14347

14348

if (!args) SWIG_fail;

14349

swig_obj[0] = args;

14350

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14351

if (!SWIG_IsOK(res1)) {

14352

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineEndWrap" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14353

}

14354

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14355

{

14356

PyThreadState* __tstate = wxPyBeginAllowThreads();

14357

(arg1)->LineEndWrap();

14358

wxPyEndAllowThreads(__tstate);

14359

if (PyErr_Occurred()) SWIG_fail;

14360

}

14361

resultobj = SWIG_Py_Void();

14362

return resultobj;

14363

fail:

14364

return NULL;

14365

}

14366

14367

14368

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineEndWrapExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14369

PyObject *resultobj = 0;

14370

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14371

void *argp1 = 0 ;

14372

int res1 = 0 ;

14373

PyObject *swig_obj[1] ;

14374

14375

if (!args) SWIG_fail;

14376

swig_obj[0] = args;

14377

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14378

if (!SWIG_IsOK(res1)) {

14379

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineEndWrapExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14380

}

14381

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14382

{

14383

PyThreadState* __tstate = wxPyBeginAllowThreads();

14384

(arg1)->LineEndWrapExtend();

14385

wxPyEndAllowThreads(__tstate);

14386

if (PyErr_Occurred()) SWIG_fail;

14387

}

14388

resultobj = SWIG_Py_Void();

14389

return resultobj;

14390

fail:

14391

return NULL;

14392

}

14393

14394

14395

SWIGINTERN PyObject *_wrap_StyledTextCtrl_VCHomeWrap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14396

PyObject *resultobj = 0;

14397

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14398

void *argp1 = 0 ;

14399

int res1 = 0 ;

14400

PyObject *swig_obj[1] ;

14401

14402

if (!args) SWIG_fail;

14403

swig_obj[0] = args;

14404

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14405

if (!SWIG_IsOK(res1)) {

14406

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_VCHomeWrap" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14407

}

14408

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14409

{

14410

PyThreadState* __tstate = wxPyBeginAllowThreads();

14411

(arg1)->VCHomeWrap();

14412

wxPyEndAllowThreads(__tstate);

14413

if (PyErr_Occurred()) SWIG_fail;

14414

}

14415

resultobj = SWIG_Py_Void();

14416

return resultobj;

14417

fail:

14418

return NULL;

14419

}

14420

14421

14422

SWIGINTERN PyObject *_wrap_StyledTextCtrl_VCHomeWrapExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14423

PyObject *resultobj = 0;

14424

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14425

void *argp1 = 0 ;

14426

int res1 = 0 ;

14427

PyObject *swig_obj[1] ;

14428

14429

if (!args) SWIG_fail;

14430

swig_obj[0] = args;

14431

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14432

if (!SWIG_IsOK(res1)) {

14433

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_VCHomeWrapExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14434

}

14435

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14436

{

14437

PyThreadState* __tstate = wxPyBeginAllowThreads();

14438

(arg1)->VCHomeWrapExtend();

14439

wxPyEndAllowThreads(__tstate);

14440

if (PyErr_Occurred()) SWIG_fail;

14441

}

14442

resultobj = SWIG_Py_Void();

14443

return resultobj;

14444

fail:

14445

return NULL;

14446

}

14447

14448

14449

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14450

PyObject *resultobj = 0;

14451

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14452

void *argp1 = 0 ;

14453

int res1 = 0 ;

14454

PyObject *swig_obj[1] ;

14455

14456

if (!args) SWIG_fail;

14457

swig_obj[0] = args;

14458

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14459

if (!SWIG_IsOK(res1)) {

14460

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineCopy" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14461

}

14462

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14463

{

14464

PyThreadState* __tstate = wxPyBeginAllowThreads();

14465

(arg1)->LineCopy();

14466

wxPyEndAllowThreads(__tstate);

14467

if (PyErr_Occurred()) SWIG_fail;

14468

}

14469

resultobj = SWIG_Py_Void();

14470

return resultobj;

14471

fail:

14472

return NULL;

14473

}

14474

14475

14476

SWIGINTERN PyObject *_wrap_StyledTextCtrl_MoveCaretInsideView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14477

PyObject *resultobj = 0;

14478

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14479

void *argp1 = 0 ;

14480

int res1 = 0 ;

14481

PyObject *swig_obj[1] ;

14482

14483

if (!args) SWIG_fail;

14484

swig_obj[0] = args;

14485

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14486

if (!SWIG_IsOK(res1)) {

14487

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_MoveCaretInsideView" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14488

}

14489

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14490

{

14491

PyThreadState* __tstate = wxPyBeginAllowThreads();

14492

(arg1)->MoveCaretInsideView();

14493

wxPyEndAllowThreads(__tstate);

14494

if (PyErr_Occurred()) SWIG_fail;

14495

}

14496

resultobj = SWIG_Py_Void();

14497

return resultobj;

14498

fail:

14499

return NULL;

14500

}

14501

14502

14503

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14504

PyObject *resultobj = 0;

14505

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14506

int arg2 ;

14507

int result;

14508

void *argp1 = 0 ;

14509

int res1 = 0 ;

14510

int val2 ;

14511

int ecode2 = 0 ;

14512

PyObject * obj0 = 0 ;

14513

PyObject * obj1 = 0 ;

14514

char * kwnames[] = {

14515

(char *) "self",(char *) "line", NULL

14516

};

14517

14518

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_LineLength",kwnames,&obj0,&obj1)) SWIG_fail;

14519

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14520

if (!SWIG_IsOK(res1)) {

14521

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineLength" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14522

}

14523

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14524

ecode2 = SWIG_AsVal_int(obj1, &val2);

14525

if (!SWIG_IsOK(ecode2)) {

14526

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_LineLength" "', expected argument " "2"" of type '" "int""'");

14527

}

14528

arg2 = static_cast< int >(val2);

14529

{

14530

PyThreadState* __tstate = wxPyBeginAllowThreads();

14531

result = (int)(arg1)->LineLength(arg2);

14532

wxPyEndAllowThreads(__tstate);

14533

if (PyErr_Occurred()) SWIG_fail;

14534

}

14535

resultobj = SWIG_From_int(static_cast< int >(result));

14536

return resultobj;

14537

fail:

14538

return NULL;

14539

}

14540

14541

14542

SWIGINTERN PyObject *_wrap_StyledTextCtrl_BraceHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14543

PyObject *resultobj = 0;

14544

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14545

int arg2 ;

14546

int arg3 ;

14547

void *argp1 = 0 ;

14548

int res1 = 0 ;

14549

int val2 ;

14550

int ecode2 = 0 ;

14551

int val3 ;

14552

int ecode3 = 0 ;

14553

PyObject * obj0 = 0 ;

14554

PyObject * obj1 = 0 ;

14555

PyObject * obj2 = 0 ;

14556

char * kwnames[] = {

14557

(char *) "self",(char *) "pos1",(char *) "pos2", NULL

14558

};

14559

14560

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_BraceHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

14561

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14562

if (!SWIG_IsOK(res1)) {

14563

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_BraceHighlight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14564

}

14565

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14566

ecode2 = SWIG_AsVal_int(obj1, &val2);

14567

if (!SWIG_IsOK(ecode2)) {

14568

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_BraceHighlight" "', expected argument " "2"" of type '" "int""'");

14569

}

14570

arg2 = static_cast< int >(val2);

14571

ecode3 = SWIG_AsVal_int(obj2, &val3);

14572

if (!SWIG_IsOK(ecode3)) {

14573

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_BraceHighlight" "', expected argument " "3"" of type '" "int""'");

14574

}

14575

arg3 = static_cast< int >(val3);

14576

{

14577

PyThreadState* __tstate = wxPyBeginAllowThreads();

14578

(arg1)->BraceHighlight(arg2,arg3);

14579

wxPyEndAllowThreads(__tstate);

14580

if (PyErr_Occurred()) SWIG_fail;

14581

}

14582

resultobj = SWIG_Py_Void();

14583

return resultobj;

14584

fail:

14585

return NULL;

14586

}

14587

14588

14589

SWIGINTERN PyObject *_wrap_StyledTextCtrl_BraceBadLight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14590

PyObject *resultobj = 0;

14591

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14592

int arg2 ;

14593

void *argp1 = 0 ;

14594

int res1 = 0 ;

14595

int val2 ;

14596

int ecode2 = 0 ;

14597

PyObject * obj0 = 0 ;

14598

PyObject * obj1 = 0 ;

14599

char * kwnames[] = {

14600

(char *) "self",(char *) "pos", NULL

14601

};

14602

14603

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_BraceBadLight",kwnames,&obj0,&obj1)) SWIG_fail;

14604

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14605

if (!SWIG_IsOK(res1)) {

14606

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_BraceBadLight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14607

}

14608

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14609

ecode2 = SWIG_AsVal_int(obj1, &val2);

14610

if (!SWIG_IsOK(ecode2)) {

14611

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_BraceBadLight" "', expected argument " "2"" of type '" "int""'");

14612

}

14613

arg2 = static_cast< int >(val2);

14614

{

14615

PyThreadState* __tstate = wxPyBeginAllowThreads();

14616

(arg1)->BraceBadLight(arg2);

14617

wxPyEndAllowThreads(__tstate);

14618

if (PyErr_Occurred()) SWIG_fail;

14619

}

14620

resultobj = SWIG_Py_Void();

14621

return resultobj;

14622

fail:

14623

return NULL;

14624

}

14625

14626

14627

SWIGINTERN PyObject *_wrap_StyledTextCtrl_BraceMatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14628

PyObject *resultobj = 0;

14629

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14630

int arg2 ;

14631

int result;

14632

void *argp1 = 0 ;

14633

int res1 = 0 ;

14634

int val2 ;

14635

int ecode2 = 0 ;

14636

PyObject * obj0 = 0 ;

14637

PyObject * obj1 = 0 ;

14638

char * kwnames[] = {

14639

(char *) "self",(char *) "pos", NULL

14640

};

14641

14642

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_BraceMatch",kwnames,&obj0,&obj1)) SWIG_fail;

14643

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14644

if (!SWIG_IsOK(res1)) {

14645

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_BraceMatch" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14646

}

14647

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14648

ecode2 = SWIG_AsVal_int(obj1, &val2);

14649

if (!SWIG_IsOK(ecode2)) {

14650

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_BraceMatch" "', expected argument " "2"" of type '" "int""'");

14651

}

14652

arg2 = static_cast< int >(val2);

14653

{

14654

PyThreadState* __tstate = wxPyBeginAllowThreads();

14655

result = (int)(arg1)->BraceMatch(arg2);

14656

wxPyEndAllowThreads(__tstate);

14657

if (PyErr_Occurred()) SWIG_fail;

14658

}

14659

resultobj = SWIG_From_int(static_cast< int >(result));

14660

return resultobj;

14661

fail:

14662

return NULL;

14663

}

14664

14665

14666

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetViewEOL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14667

PyObject *resultobj = 0;

14668

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14669

bool result;

14670

void *argp1 = 0 ;

14671

int res1 = 0 ;

14672

PyObject *swig_obj[1] ;

14673

14674

if (!args) SWIG_fail;

14675

swig_obj[0] = args;

14676

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14677

if (!SWIG_IsOK(res1)) {

14678

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetViewEOL" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14679

}

14680

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14681

{

14682

PyThreadState* __tstate = wxPyBeginAllowThreads();

14683

result = (bool)(arg1)->GetViewEOL();

14684

wxPyEndAllowThreads(__tstate);

14685

if (PyErr_Occurred()) SWIG_fail;

14686

}

14687

{

14688

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14689

}

14690

return resultobj;

14691

fail:

14692

return NULL;

14693

}

14694

14695

14696

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetViewEOL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14697

PyObject *resultobj = 0;

14698

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14699

bool arg2 ;

14700

void *argp1 = 0 ;

14701

int res1 = 0 ;

14702

bool val2 ;

14703

int ecode2 = 0 ;

14704

PyObject * obj0 = 0 ;

14705

PyObject * obj1 = 0 ;

14706

char * kwnames[] = {

14707

(char *) "self",(char *) "visible", NULL

14708

};

14709

14710

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetViewEOL",kwnames,&obj0,&obj1)) SWIG_fail;

14711

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14712

if (!SWIG_IsOK(res1)) {

14713

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetViewEOL" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14714

}

14715

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14716

ecode2 = SWIG_AsVal_bool(obj1, &val2);

14717

if (!SWIG_IsOK(ecode2)) {

14718

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetViewEOL" "', expected argument " "2"" of type '" "bool""'");

14719

}

14720

arg2 = static_cast< bool >(val2);

14721

{

14722

PyThreadState* __tstate = wxPyBeginAllowThreads();

14723

(arg1)->SetViewEOL(arg2);

14724

wxPyEndAllowThreads(__tstate);

14725

if (PyErr_Occurred()) SWIG_fail;

14726

}

14727

resultobj = SWIG_Py_Void();

14728

return resultobj;

14729

fail:

14730

return NULL;

14731

}

14732

14733

14734

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetDocPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14735

PyObject *resultobj = 0;

14736

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14737

void *result = 0 ;

14738

void *argp1 = 0 ;

14739

int res1 = 0 ;

14740

PyObject *swig_obj[1] ;

14741

14742

if (!args) SWIG_fail;

14743

swig_obj[0] = args;

14744

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14745

if (!SWIG_IsOK(res1)) {

14746

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetDocPointer" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14747

}

14748

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14749

{

14750

PyThreadState* __tstate = wxPyBeginAllowThreads();

14751

result = (void *)(arg1)->GetDocPointer();

14752

wxPyEndAllowThreads(__tstate);

14753

if (PyErr_Occurred()) SWIG_fail;

14754

}

14755

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );

14756

return resultobj;

14757

fail:

14758

return NULL;

14759

}

14760

14761

14762

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetDocPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14763

PyObject *resultobj = 0;

14764

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14765

void *arg2 = (void *) 0 ;

14766

void *argp1 = 0 ;

14767

int res1 = 0 ;

14768

int res2 ;

14769

PyObject * obj0 = 0 ;

14770

PyObject * obj1 = 0 ;

14771

char * kwnames[] = {

14772

(char *) "self",(char *) "docPointer", NULL

14773

};

14774

14775

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetDocPointer",kwnames,&obj0,&obj1)) SWIG_fail;

14776

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14777

if (!SWIG_IsOK(res1)) {

14778

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetDocPointer" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14779

}

14780

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14781

res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);

14782

if (!SWIG_IsOK(res2)) {

14783

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyledTextCtrl_SetDocPointer" "', expected argument " "2"" of type '" "void *""'");

14784

}

14785

{

14786

PyThreadState* __tstate = wxPyBeginAllowThreads();

14787

(arg1)->SetDocPointer(arg2);

14788

wxPyEndAllowThreads(__tstate);

14789

if (PyErr_Occurred()) SWIG_fail;

14790

}

14791

resultobj = SWIG_Py_Void();

14792

return resultobj;

14793

fail:

14794

return NULL;

14795

}

14796

14797

14798

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetModEventMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14799

PyObject *resultobj = 0;

14800

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14801

int arg2 ;

14802

void *argp1 = 0 ;

14803

int res1 = 0 ;

14804

int val2 ;

14805

int ecode2 = 0 ;

14806

PyObject * obj0 = 0 ;

14807

PyObject * obj1 = 0 ;

14808

char * kwnames[] = {

14809

(char *) "self",(char *) "mask", NULL

14810

};

14811

14812

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetModEventMask",kwnames,&obj0,&obj1)) SWIG_fail;

14813

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14814

if (!SWIG_IsOK(res1)) {

14815

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetModEventMask" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14816

}

14817

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14818

ecode2 = SWIG_AsVal_int(obj1, &val2);

14819

if (!SWIG_IsOK(ecode2)) {

14820

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetModEventMask" "', expected argument " "2"" of type '" "int""'");

14821

}

14822

arg2 = static_cast< int >(val2);

14823

{

14824

PyThreadState* __tstate = wxPyBeginAllowThreads();

14825

(arg1)->SetModEventMask(arg2);

14826

wxPyEndAllowThreads(__tstate);

14827

if (PyErr_Occurred()) SWIG_fail;

14828

}

14829

resultobj = SWIG_Py_Void();

14830

return resultobj;

14831

fail:

14832

return NULL;

14833

}

14834

14835

14836

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetEdgeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14837

PyObject *resultobj = 0;

14838

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14839

int result;

14840

void *argp1 = 0 ;

14841

int res1 = 0 ;

14842

PyObject *swig_obj[1] ;

14843

14844

if (!args) SWIG_fail;

14845

swig_obj[0] = args;

14846

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14847

if (!SWIG_IsOK(res1)) {

14848

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetEdgeColumn" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14849

}

14850

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14851

{

14852

PyThreadState* __tstate = wxPyBeginAllowThreads();

14853

result = (int)(arg1)->GetEdgeColumn();

14854

wxPyEndAllowThreads(__tstate);

14855

if (PyErr_Occurred()) SWIG_fail;

14856

}

14857

resultobj = SWIG_From_int(static_cast< int >(result));

14858

return resultobj;

14859

fail:

14860

return NULL;

14861

}

14862

14863

14864

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetEdgeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14865

PyObject *resultobj = 0;

14866

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14867

int arg2 ;

14868

void *argp1 = 0 ;

14869

int res1 = 0 ;

14870

int val2 ;

14871

int ecode2 = 0 ;

14872

PyObject * obj0 = 0 ;

14873

PyObject * obj1 = 0 ;

14874

char * kwnames[] = {

14875

(char *) "self",(char *) "column", NULL

14876

};

14877

14878

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetEdgeColumn",kwnames,&obj0,&obj1)) SWIG_fail;

14879

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14880

if (!SWIG_IsOK(res1)) {

14881

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetEdgeColumn" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14882

}

14883

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14884

ecode2 = SWIG_AsVal_int(obj1, &val2);

14885

if (!SWIG_IsOK(ecode2)) {

14886

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetEdgeColumn" "', expected argument " "2"" of type '" "int""'");

14887

}

14888

arg2 = static_cast< int >(val2);

14889

{

14890

PyThreadState* __tstate = wxPyBeginAllowThreads();

14891

(arg1)->SetEdgeColumn(arg2);

14892

wxPyEndAllowThreads(__tstate);

14893

if (PyErr_Occurred()) SWIG_fail;

14894

}

14895

resultobj = SWIG_Py_Void();

14896

return resultobj;

14897

fail:

14898

return NULL;

14899

}

14900

14901

14902

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetEdgeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14903

PyObject *resultobj = 0;

14904

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14905

int result;

14906

void *argp1 = 0 ;

14907

int res1 = 0 ;

14908

PyObject *swig_obj[1] ;

14909

14910

if (!args) SWIG_fail;

14911

swig_obj[0] = args;

14912

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14913

if (!SWIG_IsOK(res1)) {

14914

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetEdgeMode" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14915

}

14916

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14917

{

14918

PyThreadState* __tstate = wxPyBeginAllowThreads();

14919

result = (int)(arg1)->GetEdgeMode();

14920

wxPyEndAllowThreads(__tstate);

14921

if (PyErr_Occurred()) SWIG_fail;

14922

}

14923

resultobj = SWIG_From_int(static_cast< int >(result));

14924

return resultobj;

14925

fail:

14926

return NULL;

14927

}

14928

14929

14930

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetEdgeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14931

PyObject *resultobj = 0;

14932

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14933

int arg2 ;

14934

void *argp1 = 0 ;

14935

int res1 = 0 ;

14936

int val2 ;

14937

int ecode2 = 0 ;

14938

PyObject * obj0 = 0 ;

14939

PyObject * obj1 = 0 ;

14940

char * kwnames[] = {

14941

(char *) "self",(char *) "mode", NULL

14942

};

14943

14944

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetEdgeMode",kwnames,&obj0,&obj1)) SWIG_fail;

14945

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14946

if (!SWIG_IsOK(res1)) {

14947

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetEdgeMode" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14948

}

14949

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14950

ecode2 = SWIG_AsVal_int(obj1, &val2);

14951

if (!SWIG_IsOK(ecode2)) {

14952

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetEdgeMode" "', expected argument " "2"" of type '" "int""'");

14953

}

14954

arg2 = static_cast< int >(val2);

14955

{

14956

PyThreadState* __tstate = wxPyBeginAllowThreads();

14957

(arg1)->SetEdgeMode(arg2);

14958

wxPyEndAllowThreads(__tstate);

14959

if (PyErr_Occurred()) SWIG_fail;

14960

}

14961

resultobj = SWIG_Py_Void();

14962

return resultobj;

14963

fail:

14964

return NULL;

14965

}

14966

14967

14968

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetEdgeColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14969

PyObject *resultobj = 0;

14970

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14971

wxColour result;

14972

void *argp1 = 0 ;

14973

int res1 = 0 ;

14974

PyObject *swig_obj[1] ;

14975

14976

if (!args) SWIG_fail;

14977

swig_obj[0] = args;

14978

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

14979

if (!SWIG_IsOK(res1)) {

14980

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetEdgeColour" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

14981

}

14982

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

14983

{

14984

PyThreadState* __tstate = wxPyBeginAllowThreads();

14985

result = (arg1)->GetEdgeColour();

14986

wxPyEndAllowThreads(__tstate);

14987

if (PyErr_Occurred()) SWIG_fail;

14988

}

14989

resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );

14990

return resultobj;

14991

fail:

14992

return NULL;

14993

}

14994

14995

14996

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetEdgeColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14997

PyObject *resultobj = 0;

14998

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

14999

wxColour *arg2 = 0 ;

15000

void *argp1 = 0 ;

15001

int res1 = 0 ;

15002

wxColour temp2 ;

15003

PyObject * obj0 = 0 ;

15004

PyObject * obj1 = 0 ;

15005

char * kwnames[] = {

15006

(char *) "self",(char *) "edgeColour", NULL

15007

};

15008

15009

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetEdgeColour",kwnames,&obj0,&obj1)) SWIG_fail;

15010

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15011

if (!SWIG_IsOK(res1)) {

15012

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetEdgeColour" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15013

}

15014

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15015

{

15016

arg2 = &temp2;

15017

if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;

15018

}

15019

{

15020

PyThreadState* __tstate = wxPyBeginAllowThreads();

15021

(arg1)->SetEdgeColour((wxColour const &)*arg2);

15022

wxPyEndAllowThreads(__tstate);

15023

if (PyErr_Occurred()) SWIG_fail;

15024

}

15025

resultobj = SWIG_Py_Void();

15026

return resultobj;

15027

fail:

15028

return NULL;

15029

}

15030

15031

15032

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SearchAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15033

PyObject *resultobj = 0;

15034

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15035

void *argp1 = 0 ;

15036

int res1 = 0 ;

15037

PyObject *swig_obj[1] ;

15038

15039

if (!args) SWIG_fail;

15040

swig_obj[0] = args;

15041

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15042

if (!SWIG_IsOK(res1)) {

15043

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SearchAnchor" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15044

}

15045

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15046

{

15047

PyThreadState* __tstate = wxPyBeginAllowThreads();

15048

(arg1)->SearchAnchor();

15049

wxPyEndAllowThreads(__tstate);

15050

if (PyErr_Occurred()) SWIG_fail;

15051

}

15052

resultobj = SWIG_Py_Void();

15053

return resultobj;

15054

fail:

15055

return NULL;

15056

}

15057

15058

15059

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SearchNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15060

PyObject *resultobj = 0;

15061

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15062

int arg2 ;

15063

wxString *arg3 = 0 ;

15064

int result;

15065

void *argp1 = 0 ;

15066

int res1 = 0 ;

15067

int val2 ;

15068

int ecode2 = 0 ;

15069

bool temp3 = false ;

15070

PyObject * obj0 = 0 ;

15071

PyObject * obj1 = 0 ;

15072

PyObject * obj2 = 0 ;

15073

char * kwnames[] = {

15074

(char *) "self",(char *) "flags",(char *) "text", NULL

15075

};

15076

15077

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SearchNext",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

15078

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15079

if (!SWIG_IsOK(res1)) {

15080

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SearchNext" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15081

}

15082

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15083

ecode2 = SWIG_AsVal_int(obj1, &val2);

15084

if (!SWIG_IsOK(ecode2)) {

15085

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SearchNext" "', expected argument " "2"" of type '" "int""'");

15086

}

15087

arg2 = static_cast< int >(val2);

15088

{

15089

arg3 = wxString_in_helper(obj2);

15090

if (arg3 == NULL) SWIG_fail;

15091

temp3 = true;

15092

}

15093

{

15094

PyThreadState* __tstate = wxPyBeginAllowThreads();

15095

result = (int)(arg1)->SearchNext(arg2,(wxString const &)*arg3);

15096

wxPyEndAllowThreads(__tstate);

15097

if (PyErr_Occurred()) SWIG_fail;

15098

}

15099

resultobj = SWIG_From_int(static_cast< int >(result));

15100

{

15101

if (temp3)

15102

delete arg3;

15103

}

15104

return resultobj;

15105

fail:

15106

{

15107

if (temp3)

15108

delete arg3;

15109

}

15110

return NULL;

15111

}

15112

15113

15114

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SearchPrev(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15115

PyObject *resultobj = 0;

15116

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15117

int arg2 ;

15118

wxString *arg3 = 0 ;

15119

int result;

15120

void *argp1 = 0 ;

15121

int res1 = 0 ;

15122

int val2 ;

15123

int ecode2 = 0 ;

15124

bool temp3 = false ;

15125

PyObject * obj0 = 0 ;

15126

PyObject * obj1 = 0 ;

15127

PyObject * obj2 = 0 ;

15128

char * kwnames[] = {

15129

(char *) "self",(char *) "flags",(char *) "text", NULL

15130

};

15131

15132

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SearchPrev",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

15133

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15134

if (!SWIG_IsOK(res1)) {

15135

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SearchPrev" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15136

}

15137

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15138

ecode2 = SWIG_AsVal_int(obj1, &val2);

15139

if (!SWIG_IsOK(ecode2)) {

15140

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SearchPrev" "', expected argument " "2"" of type '" "int""'");

15141

}

15142

arg2 = static_cast< int >(val2);

15143

{

15144

arg3 = wxString_in_helper(obj2);

15145

if (arg3 == NULL) SWIG_fail;

15146

temp3 = true;

15147

}

15148

{

15149

PyThreadState* __tstate = wxPyBeginAllowThreads();

15150

result = (int)(arg1)->SearchPrev(arg2,(wxString const &)*arg3);

15151

wxPyEndAllowThreads(__tstate);

15152

if (PyErr_Occurred()) SWIG_fail;

15153

}

15154

resultobj = SWIG_From_int(static_cast< int >(result));

15155

{

15156

if (temp3)

15157

delete arg3;

15158

}

15159

return resultobj;

15160

fail:

15161

{

15162

if (temp3)

15163

delete arg3;

15164

}

15165

return NULL;

15166

}

15167

15168

15169

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LinesOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15170

PyObject *resultobj = 0;

15171

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15172

int result;

15173

void *argp1 = 0 ;

15174

int res1 = 0 ;

15175

PyObject *swig_obj[1] ;

15176

15177

if (!args) SWIG_fail;

15178

swig_obj[0] = args;

15179

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15180

if (!SWIG_IsOK(res1)) {

15181

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LinesOnScreen" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15182

}

15183

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15184

{

15185

PyThreadState* __tstate = wxPyBeginAllowThreads();

15186

result = (int)(arg1)->LinesOnScreen();

15187

wxPyEndAllowThreads(__tstate);

15188

if (PyErr_Occurred()) SWIG_fail;

15189

}

15190

resultobj = SWIG_From_int(static_cast< int >(result));

15191

return resultobj;

15192

fail:

15193

return NULL;

15194

}

15195

15196

15197

SWIGINTERN PyObject *_wrap_StyledTextCtrl_UsePopUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15198

PyObject *resultobj = 0;

15199

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15200

bool arg2 ;

15201

void *argp1 = 0 ;

15202

int res1 = 0 ;

15203

bool val2 ;

15204

int ecode2 = 0 ;

15205

PyObject * obj0 = 0 ;

15206

PyObject * obj1 = 0 ;

15207

char * kwnames[] = {

15208

(char *) "self",(char *) "allowPopUp", NULL

15209

};

15210

15211

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_UsePopUp",kwnames,&obj0,&obj1)) SWIG_fail;

15212

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15213

if (!SWIG_IsOK(res1)) {

15214

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_UsePopUp" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15215

}

15216

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15217

ecode2 = SWIG_AsVal_bool(obj1, &val2);

15218

if (!SWIG_IsOK(ecode2)) {

15219

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_UsePopUp" "', expected argument " "2"" of type '" "bool""'");

15220

}

15221

arg2 = static_cast< bool >(val2);

15222

{

15223

PyThreadState* __tstate = wxPyBeginAllowThreads();

15224

(arg1)->UsePopUp(arg2);

15225

wxPyEndAllowThreads(__tstate);

15226

if (PyErr_Occurred()) SWIG_fail;

15227

}

15228

resultobj = SWIG_Py_Void();

15229

return resultobj;

15230

fail:

15231

return NULL;

15232

}

15233

15234

15235

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SelectionIsRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15236

PyObject *resultobj = 0;

15237

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15238

bool result;

15239

void *argp1 = 0 ;

15240

int res1 = 0 ;

15241

PyObject *swig_obj[1] ;

15242

15243

if (!args) SWIG_fail;

15244

swig_obj[0] = args;

15245

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15246

if (!SWIG_IsOK(res1)) {

15247

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SelectionIsRectangle" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15248

}

15249

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15250

{

15251

PyThreadState* __tstate = wxPyBeginAllowThreads();

15252

result = (bool)(arg1)->SelectionIsRectangle();

15253

wxPyEndAllowThreads(__tstate);

15254

if (PyErr_Occurred()) SWIG_fail;

15255

}

15256

{

15257

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15258

}

15259

return resultobj;

15260

fail:

15261

return NULL;

15262

}

15263

15264

15265

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetZoom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15266

PyObject *resultobj = 0;

15267

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15268

int arg2 ;

15269

void *argp1 = 0 ;

15270

int res1 = 0 ;

15271

int val2 ;

15272

int ecode2 = 0 ;

15273

PyObject * obj0 = 0 ;

15274

PyObject * obj1 = 0 ;

15275

char * kwnames[] = {

15276

(char *) "self",(char *) "zoom", NULL

15277

};

15278

15279

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetZoom",kwnames,&obj0,&obj1)) SWIG_fail;

15280

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15281

if (!SWIG_IsOK(res1)) {

15282

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetZoom" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15283

}

15284

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15285

ecode2 = SWIG_AsVal_int(obj1, &val2);

15286

if (!SWIG_IsOK(ecode2)) {

15287

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetZoom" "', expected argument " "2"" of type '" "int""'");

15288

}

15289

arg2 = static_cast< int >(val2);

15290

{

15291

PyThreadState* __tstate = wxPyBeginAllowThreads();

15292

(arg1)->SetZoom(arg2);

15293

wxPyEndAllowThreads(__tstate);

15294

if (PyErr_Occurred()) SWIG_fail;

15295

}

15296

resultobj = SWIG_Py_Void();

15297

return resultobj;

15298

fail:

15299

return NULL;

15300

}

15301

15302

15303

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetZoom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15304

PyObject *resultobj = 0;

15305

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15306

int result;

15307

void *argp1 = 0 ;

15308

int res1 = 0 ;

15309

PyObject *swig_obj[1] ;

15310

15311

if (!args) SWIG_fail;

15312

swig_obj[0] = args;

15313

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15314

if (!SWIG_IsOK(res1)) {

15315

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetZoom" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15316

}

15317

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15318

{

15319

PyThreadState* __tstate = wxPyBeginAllowThreads();

15320

result = (int)(arg1)->GetZoom();

15321

wxPyEndAllowThreads(__tstate);

15322

if (PyErr_Occurred()) SWIG_fail;

15323

}

15324

resultobj = SWIG_From_int(static_cast< int >(result));

15325

return resultobj;

15326

fail:

15327

return NULL;

15328

}

15329

15330

15331

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CreateDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15332

PyObject *resultobj = 0;

15333

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15334

void *result = 0 ;

15335

void *argp1 = 0 ;

15336

int res1 = 0 ;

15337

PyObject *swig_obj[1] ;

15338

15339

if (!args) SWIG_fail;

15340

swig_obj[0] = args;

15341

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15342

if (!SWIG_IsOK(res1)) {

15343

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CreateDocument" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15344

}

15345

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15346

{

15347

PyThreadState* __tstate = wxPyBeginAllowThreads();

15348

result = (void *)(arg1)->CreateDocument();

15349

wxPyEndAllowThreads(__tstate);

15350

if (PyErr_Occurred()) SWIG_fail;

15351

}

15352

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );

15353

return resultobj;

15354

fail:

15355

return NULL;

15356

}

15357

15358

15359

SWIGINTERN PyObject *_wrap_StyledTextCtrl_AddRefDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15360

PyObject *resultobj = 0;

15361

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15362

void *arg2 = (void *) 0 ;

15363

void *argp1 = 0 ;

15364

int res1 = 0 ;

15365

int res2 ;

15366

PyObject * obj0 = 0 ;

15367

PyObject * obj1 = 0 ;

15368

char * kwnames[] = {

15369

(char *) "self",(char *) "docPointer", NULL

15370

};

15371

15372

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_AddRefDocument",kwnames,&obj0,&obj1)) SWIG_fail;

15373

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15374

if (!SWIG_IsOK(res1)) {

15375

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_AddRefDocument" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15376

}

15377

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15378

res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);

15379

if (!SWIG_IsOK(res2)) {

15380

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyledTextCtrl_AddRefDocument" "', expected argument " "2"" of type '" "void *""'");

15381

}

15382

{

15383

PyThreadState* __tstate = wxPyBeginAllowThreads();

15384

(arg1)->AddRefDocument(arg2);

15385

wxPyEndAllowThreads(__tstate);

15386

if (PyErr_Occurred()) SWIG_fail;

15387

}

15388

resultobj = SWIG_Py_Void();

15389

return resultobj;

15390

fail:

15391

return NULL;

15392

}

15393

15394

15395

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ReleaseDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15396

PyObject *resultobj = 0;

15397

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15398

void *arg2 = (void *) 0 ;

15399

void *argp1 = 0 ;

15400

int res1 = 0 ;

15401

int res2 ;

15402

PyObject * obj0 = 0 ;

15403

PyObject * obj1 = 0 ;

15404

char * kwnames[] = {

15405

(char *) "self",(char *) "docPointer", NULL

15406

};

15407

15408

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_ReleaseDocument",kwnames,&obj0,&obj1)) SWIG_fail;

15409

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15410

if (!SWIG_IsOK(res1)) {

15411

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ReleaseDocument" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15412

}

15413

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15414

res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);

15415

if (!SWIG_IsOK(res2)) {

15416

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyledTextCtrl_ReleaseDocument" "', expected argument " "2"" of type '" "void *""'");

15417

}

15418

{

15419

PyThreadState* __tstate = wxPyBeginAllowThreads();

15420

(arg1)->ReleaseDocument(arg2);

15421

wxPyEndAllowThreads(__tstate);

15422

if (PyErr_Occurred()) SWIG_fail;

15423

}

15424

resultobj = SWIG_Py_Void();

15425

return resultobj;

15426

fail:

15427

return NULL;

15428

}

15429

15430

15431

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetModEventMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15432

PyObject *resultobj = 0;

15433

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15434

int result;

15435

void *argp1 = 0 ;

15436

int res1 = 0 ;

15437

PyObject *swig_obj[1] ;

15438

15439

if (!args) SWIG_fail;

15440

swig_obj[0] = args;

15441

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15442

if (!SWIG_IsOK(res1)) {

15443

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetModEventMask" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15444

}

15445

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15446

{

15447

PyThreadState* __tstate = wxPyBeginAllowThreads();

15448

result = (int)(arg1)->GetModEventMask();

15449

wxPyEndAllowThreads(__tstate);

15450

if (PyErr_Occurred()) SWIG_fail;

15451

}

15452

resultobj = SWIG_From_int(static_cast< int >(result));

15453

return resultobj;

15454

fail:

15455

return NULL;

15456

}

15457

15458

15459

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetSTCFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15460

PyObject *resultobj = 0;

15461

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15462

bool arg2 ;

15463

void *argp1 = 0 ;

15464

int res1 = 0 ;

15465

bool val2 ;

15466

int ecode2 = 0 ;

15467

PyObject * obj0 = 0 ;

15468

PyObject * obj1 = 0 ;

15469

char * kwnames[] = {

15470

(char *) "self",(char *) "focus", NULL

15471

};

15472

15473

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetSTCFocus",kwnames,&obj0,&obj1)) SWIG_fail;

15474

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15475

if (!SWIG_IsOK(res1)) {

15476

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetSTCFocus" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15477

}

15478

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15479

ecode2 = SWIG_AsVal_bool(obj1, &val2);

15480

if (!SWIG_IsOK(ecode2)) {

15481

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetSTCFocus" "', expected argument " "2"" of type '" "bool""'");

15482

}

15483

arg2 = static_cast< bool >(val2);

15484

{

15485

PyThreadState* __tstate = wxPyBeginAllowThreads();

15486

(arg1)->SetSTCFocus(arg2);

15487

wxPyEndAllowThreads(__tstate);

15488

if (PyErr_Occurred()) SWIG_fail;

15489

}

15490

resultobj = SWIG_Py_Void();

15491

return resultobj;

15492

fail:

15493

return NULL;

15494

}

15495

15496

15497

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetSTCFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15498

PyObject *resultobj = 0;

15499

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15500

bool result;

15501

void *argp1 = 0 ;

15502

int res1 = 0 ;

15503

PyObject *swig_obj[1] ;

15504

15505

if (!args) SWIG_fail;

15506

swig_obj[0] = args;

15507

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15508

if (!SWIG_IsOK(res1)) {

15509

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetSTCFocus" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15510

}

15511

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15512

{

15513

PyThreadState* __tstate = wxPyBeginAllowThreads();

15514

result = (bool)(arg1)->GetSTCFocus();

15515

wxPyEndAllowThreads(__tstate);

15516

if (PyErr_Occurred()) SWIG_fail;

15517

}

15518

{

15519

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15520

}

15521

return resultobj;

15522

fail:

15523

return NULL;

15524

}

15525

15526

15527

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15528

PyObject *resultobj = 0;

15529

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15530

int arg2 ;

15531

void *argp1 = 0 ;

15532

int res1 = 0 ;

15533

int val2 ;

15534

int ecode2 = 0 ;

15535

PyObject * obj0 = 0 ;

15536

PyObject * obj1 = 0 ;

15537

char * kwnames[] = {

15538

(char *) "self",(char *) "statusCode", NULL

15539

};

15540

15541

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetStatus",kwnames,&obj0,&obj1)) SWIG_fail;

15542

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15543

if (!SWIG_IsOK(res1)) {

15544

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetStatus" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15545

}

15546

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15547

ecode2 = SWIG_AsVal_int(obj1, &val2);

15548

if (!SWIG_IsOK(ecode2)) {

15549

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetStatus" "', expected argument " "2"" of type '" "int""'");

15550

}

15551

arg2 = static_cast< int >(val2);

15552

{

15553

PyThreadState* __tstate = wxPyBeginAllowThreads();

15554

(arg1)->SetStatus(arg2);

15555

wxPyEndAllowThreads(__tstate);

15556

if (PyErr_Occurred()) SWIG_fail;

15557

}

15558

resultobj = SWIG_Py_Void();

15559

return resultobj;

15560

fail:

15561

return NULL;

15562

}

15563

15564

15565

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15566

PyObject *resultobj = 0;

15567

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15568

int result;

15569

void *argp1 = 0 ;

15570

int res1 = 0 ;

15571

PyObject *swig_obj[1] ;

15572

15573

if (!args) SWIG_fail;

15574

swig_obj[0] = args;

15575

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15576

if (!SWIG_IsOK(res1)) {

15577

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetStatus" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15578

}

15579

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15580

{

15581

PyThreadState* __tstate = wxPyBeginAllowThreads();

15582

result = (int)(arg1)->GetStatus();

15583

wxPyEndAllowThreads(__tstate);

15584

if (PyErr_Occurred()) SWIG_fail;

15585

}

15586

resultobj = SWIG_From_int(static_cast< int >(result));

15587

return resultobj;

15588

fail:

15589

return NULL;

15590

}

15591

15592

15593

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetMouseDownCaptures(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15594

PyObject *resultobj = 0;

15595

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15596

bool arg2 ;

15597

void *argp1 = 0 ;

15598

int res1 = 0 ;

15599

bool val2 ;

15600

int ecode2 = 0 ;

15601

PyObject * obj0 = 0 ;

15602

PyObject * obj1 = 0 ;

15603

char * kwnames[] = {

15604

(char *) "self",(char *) "captures", NULL

15605

};

15606

15607

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetMouseDownCaptures",kwnames,&obj0,&obj1)) SWIG_fail;

15608

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15609

if (!SWIG_IsOK(res1)) {

15610

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetMouseDownCaptures" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15611

}

15612

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15613

ecode2 = SWIG_AsVal_bool(obj1, &val2);

15614

if (!SWIG_IsOK(ecode2)) {

15615

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetMouseDownCaptures" "', expected argument " "2"" of type '" "bool""'");

15616

}

15617

arg2 = static_cast< bool >(val2);

15618

{

15619

PyThreadState* __tstate = wxPyBeginAllowThreads();

15620

(arg1)->SetMouseDownCaptures(arg2);

15621

wxPyEndAllowThreads(__tstate);

15622

if (PyErr_Occurred()) SWIG_fail;

15623

}

15624

resultobj = SWIG_Py_Void();

15625

return resultobj;

15626

fail:

15627

return NULL;

15628

}

15629

15630

15631

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetMouseDownCaptures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15632

PyObject *resultobj = 0;

15633

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15634

bool result;

15635

void *argp1 = 0 ;

15636

int res1 = 0 ;

15637

PyObject *swig_obj[1] ;

15638

15639

if (!args) SWIG_fail;

15640

swig_obj[0] = args;

15641

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15642

if (!SWIG_IsOK(res1)) {

15643

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetMouseDownCaptures" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15644

}

15645

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15646

{

15647

PyThreadState* __tstate = wxPyBeginAllowThreads();

15648

result = (bool)(arg1)->GetMouseDownCaptures();

15649

wxPyEndAllowThreads(__tstate);

15650

if (PyErr_Occurred()) SWIG_fail;

15651

}

15652

{

15653

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15654

}

15655

return resultobj;

15656

fail:

15657

return NULL;

15658

}

15659

15660

15661

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetSTCCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15662

PyObject *resultobj = 0;

15663

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15664

int arg2 ;

15665

void *argp1 = 0 ;

15666

int res1 = 0 ;

15667

int val2 ;

15668

int ecode2 = 0 ;

15669

PyObject * obj0 = 0 ;

15670

PyObject * obj1 = 0 ;

15671

char * kwnames[] = {

15672

(char *) "self",(char *) "cursorType", NULL

15673

};

15674

15675

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetSTCCursor",kwnames,&obj0,&obj1)) SWIG_fail;

15676

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15677

if (!SWIG_IsOK(res1)) {

15678

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetSTCCursor" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15679

}

15680

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15681

ecode2 = SWIG_AsVal_int(obj1, &val2);

15682

if (!SWIG_IsOK(ecode2)) {

15683

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetSTCCursor" "', expected argument " "2"" of type '" "int""'");

15684

}

15685

arg2 = static_cast< int >(val2);

15686

{

15687

PyThreadState* __tstate = wxPyBeginAllowThreads();

15688

(arg1)->SetSTCCursor(arg2);

15689

wxPyEndAllowThreads(__tstate);

15690

if (PyErr_Occurred()) SWIG_fail;

15691

}

15692

resultobj = SWIG_Py_Void();

15693

return resultobj;

15694

fail:

15695

return NULL;

15696

}

15697

15698

15699

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetSTCCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15700

PyObject *resultobj = 0;

15701

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15702

int result;

15703

void *argp1 = 0 ;

15704

int res1 = 0 ;

15705

PyObject *swig_obj[1] ;

15706

15707

if (!args) SWIG_fail;

15708

swig_obj[0] = args;

15709

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15710

if (!SWIG_IsOK(res1)) {

15711

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetSTCCursor" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15712

}

15713

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15714

{

15715

PyThreadState* __tstate = wxPyBeginAllowThreads();

15716

result = (int)(arg1)->GetSTCCursor();

15717

wxPyEndAllowThreads(__tstate);

15718

if (PyErr_Occurred()) SWIG_fail;

15719

}

15720

resultobj = SWIG_From_int(static_cast< int >(result));

15721

return resultobj;

15722

fail:

15723

return NULL;

15724

}

15725

15726

15727

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetControlCharSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15728

PyObject *resultobj = 0;

15729

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15730

int arg2 ;

15731

void *argp1 = 0 ;

15732

int res1 = 0 ;

15733

int val2 ;

15734

int ecode2 = 0 ;

15735

PyObject * obj0 = 0 ;

15736

PyObject * obj1 = 0 ;

15737

char * kwnames[] = {

15738

(char *) "self",(char *) "symbol", NULL

15739

};

15740

15741

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetControlCharSymbol",kwnames,&obj0,&obj1)) SWIG_fail;

15742

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15743

if (!SWIG_IsOK(res1)) {

15744

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetControlCharSymbol" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15745

}

15746

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15747

ecode2 = SWIG_AsVal_int(obj1, &val2);

15748

if (!SWIG_IsOK(ecode2)) {

15749

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetControlCharSymbol" "', expected argument " "2"" of type '" "int""'");

15750

}

15751

arg2 = static_cast< int >(val2);

15752

{

15753

PyThreadState* __tstate = wxPyBeginAllowThreads();

15754

(arg1)->SetControlCharSymbol(arg2);

15755

wxPyEndAllowThreads(__tstate);

15756

if (PyErr_Occurred()) SWIG_fail;

15757

}

15758

resultobj = SWIG_Py_Void();

15759

return resultobj;

15760

fail:

15761

return NULL;

15762

}

15763

15764

15765

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetControlCharSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15766

PyObject *resultobj = 0;

15767

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15768

int result;

15769

void *argp1 = 0 ;

15770

int res1 = 0 ;

15771

PyObject *swig_obj[1] ;

15772

15773

if (!args) SWIG_fail;

15774

swig_obj[0] = args;

15775

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15776

if (!SWIG_IsOK(res1)) {

15777

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetControlCharSymbol" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15778

}

15779

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15780

{

15781

PyThreadState* __tstate = wxPyBeginAllowThreads();

15782

result = (int)(arg1)->GetControlCharSymbol();

15783

wxPyEndAllowThreads(__tstate);

15784

if (PyErr_Occurred()) SWIG_fail;

15785

}

15786

resultobj = SWIG_From_int(static_cast< int >(result));

15787

return resultobj;

15788

fail:

15789

return NULL;

15790

}

15791

15792

15793

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordPartLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15794

PyObject *resultobj = 0;

15795

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15796

void *argp1 = 0 ;

15797

int res1 = 0 ;

15798

PyObject *swig_obj[1] ;

15799

15800

if (!args) SWIG_fail;

15801

swig_obj[0] = args;

15802

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15803

if (!SWIG_IsOK(res1)) {

15804

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordPartLeft" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15805

}

15806

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15807

{

15808

PyThreadState* __tstate = wxPyBeginAllowThreads();

15809

(arg1)->WordPartLeft();

15810

wxPyEndAllowThreads(__tstate);

15811

if (PyErr_Occurred()) SWIG_fail;

15812

}

15813

resultobj = SWIG_Py_Void();

15814

return resultobj;

15815

fail:

15816

return NULL;

15817

}

15818

15819

15820

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordPartLeftExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15821

PyObject *resultobj = 0;

15822

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15823

void *argp1 = 0 ;

15824

int res1 = 0 ;

15825

PyObject *swig_obj[1] ;

15826

15827

if (!args) SWIG_fail;

15828

swig_obj[0] = args;

15829

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15830

if (!SWIG_IsOK(res1)) {

15831

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordPartLeftExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15832

}

15833

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15834

{

15835

PyThreadState* __tstate = wxPyBeginAllowThreads();

15836

(arg1)->WordPartLeftExtend();

15837

wxPyEndAllowThreads(__tstate);

15838

if (PyErr_Occurred()) SWIG_fail;

15839

}

15840

resultobj = SWIG_Py_Void();

15841

return resultobj;

15842

fail:

15843

return NULL;

15844

}

15845

15846

15847

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordPartRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15848

PyObject *resultobj = 0;

15849

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15850

void *argp1 = 0 ;

15851

int res1 = 0 ;

15852

PyObject *swig_obj[1] ;

15853

15854

if (!args) SWIG_fail;

15855

swig_obj[0] = args;

15856

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15857

if (!SWIG_IsOK(res1)) {

15858

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordPartRight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15859

}

15860

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15861

{

15862

PyThreadState* __tstate = wxPyBeginAllowThreads();

15863

(arg1)->WordPartRight();

15864

wxPyEndAllowThreads(__tstate);

15865

if (PyErr_Occurred()) SWIG_fail;

15866

}

15867

resultobj = SWIG_Py_Void();

15868

return resultobj;

15869

fail:

15870

return NULL;

15871

}

15872

15873

15874

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordPartRightExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15875

PyObject *resultobj = 0;

15876

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15877

void *argp1 = 0 ;

15878

int res1 = 0 ;

15879

PyObject *swig_obj[1] ;

15880

15881

if (!args) SWIG_fail;

15882

swig_obj[0] = args;

15883

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15884

if (!SWIG_IsOK(res1)) {

15885

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordPartRightExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15886

}

15887

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15888

{

15889

PyThreadState* __tstate = wxPyBeginAllowThreads();

15890

(arg1)->WordPartRightExtend();

15891

wxPyEndAllowThreads(__tstate);

15892

if (PyErr_Occurred()) SWIG_fail;

15893

}

15894

resultobj = SWIG_Py_Void();

15895

return resultobj;

15896

fail:

15897

return NULL;

15898

}

15899

15900

15901

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetVisiblePolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15902

PyObject *resultobj = 0;

15903

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15904

int arg2 ;

15905

int arg3 ;

15906

void *argp1 = 0 ;

15907

int res1 = 0 ;

15908

int val2 ;

15909

int ecode2 = 0 ;

15910

int val3 ;

15911

int ecode3 = 0 ;

15912

PyObject * obj0 = 0 ;

15913

PyObject * obj1 = 0 ;

15914

PyObject * obj2 = 0 ;

15915

char * kwnames[] = {

15916

(char *) "self",(char *) "visiblePolicy",(char *) "visibleSlop", NULL

15917

};

15918

15919

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetVisiblePolicy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

15920

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15921

if (!SWIG_IsOK(res1)) {

15922

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetVisiblePolicy" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15923

}

15924

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15925

ecode2 = SWIG_AsVal_int(obj1, &val2);

15926

if (!SWIG_IsOK(ecode2)) {

15927

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetVisiblePolicy" "', expected argument " "2"" of type '" "int""'");

15928

}

15929

arg2 = static_cast< int >(val2);

15930

ecode3 = SWIG_AsVal_int(obj2, &val3);

15931

if (!SWIG_IsOK(ecode3)) {

15932

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_SetVisiblePolicy" "', expected argument " "3"" of type '" "int""'");

15933

}

15934

arg3 = static_cast< int >(val3);

15935

{

15936

PyThreadState* __tstate = wxPyBeginAllowThreads();

15937

(arg1)->SetVisiblePolicy(arg2,arg3);

15938

wxPyEndAllowThreads(__tstate);

15939

if (PyErr_Occurred()) SWIG_fail;

15940

}

15941

resultobj = SWIG_Py_Void();

15942

return resultobj;

15943

fail:

15944

return NULL;

15945

}

15946

15947

15948

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DelLineLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15949

PyObject *resultobj = 0;

15950

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15951

void *argp1 = 0 ;

15952

int res1 = 0 ;

15953

PyObject *swig_obj[1] ;

15954

15955

if (!args) SWIG_fail;

15956

swig_obj[0] = args;

15957

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15958

if (!SWIG_IsOK(res1)) {

15959

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DelLineLeft" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15960

}

15961

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15962

{

15963

PyThreadState* __tstate = wxPyBeginAllowThreads();

15964

(arg1)->DelLineLeft();

15965

wxPyEndAllowThreads(__tstate);

15966

if (PyErr_Occurred()) SWIG_fail;

15967

}

15968

resultobj = SWIG_Py_Void();

15969

return resultobj;

15970

fail:

15971

return NULL;

15972

}

15973

15974

15975

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DelLineRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15976

PyObject *resultobj = 0;

15977

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

15978

void *argp1 = 0 ;

15979

int res1 = 0 ;

15980

PyObject *swig_obj[1] ;

15981

15982

if (!args) SWIG_fail;

15983

swig_obj[0] = args;

15984

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

15985

if (!SWIG_IsOK(res1)) {

15986

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DelLineRight" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

15987

}

15988

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

15989

{

15990

PyThreadState* __tstate = wxPyBeginAllowThreads();

15991

(arg1)->DelLineRight();

15992

wxPyEndAllowThreads(__tstate);

15993

if (PyErr_Occurred()) SWIG_fail;

15994

}

15995

resultobj = SWIG_Py_Void();

15996

return resultobj;

15997

fail:

15998

return NULL;

15999

}

16000

16001

16002

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetXOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16003

PyObject *resultobj = 0;

16004

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16005

int arg2 ;

16006

void *argp1 = 0 ;

16007

int res1 = 0 ;

16008

int val2 ;

16009

int ecode2 = 0 ;

16010

PyObject * obj0 = 0 ;

16011

PyObject * obj1 = 0 ;

16012

char * kwnames[] = {

16013

(char *) "self",(char *) "newOffset", NULL

16014

};

16015

16016

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetXOffset",kwnames,&obj0,&obj1)) SWIG_fail;

16017

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16018

if (!SWIG_IsOK(res1)) {

16019

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetXOffset" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16020

}

16021

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16022

ecode2 = SWIG_AsVal_int(obj1, &val2);

16023

if (!SWIG_IsOK(ecode2)) {

16024

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetXOffset" "', expected argument " "2"" of type '" "int""'");

16025

}

16026

arg2 = static_cast< int >(val2);

16027

{

16028

PyThreadState* __tstate = wxPyBeginAllowThreads();

16029

(arg1)->SetXOffset(arg2);

16030

wxPyEndAllowThreads(__tstate);

16031

if (PyErr_Occurred()) SWIG_fail;

16032

}

16033

resultobj = SWIG_Py_Void();

16034

return resultobj;

16035

fail:

16036

return NULL;

16037

}

16038

16039

16040

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetXOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16041

PyObject *resultobj = 0;

16042

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16043

int result;

16044

void *argp1 = 0 ;

16045

int res1 = 0 ;

16046

PyObject *swig_obj[1] ;

16047

16048

if (!args) SWIG_fail;

16049

swig_obj[0] = args;

16050

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16051

if (!SWIG_IsOK(res1)) {

16052

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetXOffset" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16053

}

16054

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16055

{

16056

PyThreadState* __tstate = wxPyBeginAllowThreads();

16057

result = (int)(arg1)->GetXOffset();

16058

wxPyEndAllowThreads(__tstate);

16059

if (PyErr_Occurred()) SWIG_fail;

16060

}

16061

resultobj = SWIG_From_int(static_cast< int >(result));

16062

return resultobj;

16063

fail:

16064

return NULL;

16065

}

16066

16067

16068

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ChooseCaretX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16069

PyObject *resultobj = 0;

16070

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16071

void *argp1 = 0 ;

16072

int res1 = 0 ;

16073

PyObject *swig_obj[1] ;

16074

16075

if (!args) SWIG_fail;

16076

swig_obj[0] = args;

16077

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16078

if (!SWIG_IsOK(res1)) {

16079

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ChooseCaretX" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16080

}

16081

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16082

{

16083

PyThreadState* __tstate = wxPyBeginAllowThreads();

16084

(arg1)->ChooseCaretX();

16085

wxPyEndAllowThreads(__tstate);

16086

if (PyErr_Occurred()) SWIG_fail;

16087

}

16088

resultobj = SWIG_Py_Void();

16089

return resultobj;

16090

fail:

16091

return NULL;

16092

}

16093

16094

16095

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetXCaretPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16096

PyObject *resultobj = 0;

16097

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16098

int arg2 ;

16099

int arg3 ;

16100

void *argp1 = 0 ;

16101

int res1 = 0 ;

16102

int val2 ;

16103

int ecode2 = 0 ;

16104

int val3 ;

16105

int ecode3 = 0 ;

16106

PyObject * obj0 = 0 ;

16107

PyObject * obj1 = 0 ;

16108

PyObject * obj2 = 0 ;

16109

char * kwnames[] = {

16110

(char *) "self",(char *) "caretPolicy",(char *) "caretSlop", NULL

16111

};

16112

16113

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetXCaretPolicy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

16114

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16115

if (!SWIG_IsOK(res1)) {

16116

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetXCaretPolicy" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16117

}

16118

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16119

ecode2 = SWIG_AsVal_int(obj1, &val2);

16120

if (!SWIG_IsOK(ecode2)) {

16121

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetXCaretPolicy" "', expected argument " "2"" of type '" "int""'");

16122

}

16123

arg2 = static_cast< int >(val2);

16124

ecode3 = SWIG_AsVal_int(obj2, &val3);

16125

if (!SWIG_IsOK(ecode3)) {

16126

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_SetXCaretPolicy" "', expected argument " "3"" of type '" "int""'");

16127

}

16128

arg3 = static_cast< int >(val3);

16129

{

16130

PyThreadState* __tstate = wxPyBeginAllowThreads();

16131

(arg1)->SetXCaretPolicy(arg2,arg3);

16132

wxPyEndAllowThreads(__tstate);

16133

if (PyErr_Occurred()) SWIG_fail;

16134

}

16135

resultobj = SWIG_Py_Void();

16136

return resultobj;

16137

fail:

16138

return NULL;

16139

}

16140

16141

16142

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetYCaretPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16143

PyObject *resultobj = 0;

16144

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16145

int arg2 ;

16146

int arg3 ;

16147

void *argp1 = 0 ;

16148

int res1 = 0 ;

16149

int val2 ;

16150

int ecode2 = 0 ;

16151

int val3 ;

16152

int ecode3 = 0 ;

16153

PyObject * obj0 = 0 ;

16154

PyObject * obj1 = 0 ;

16155

PyObject * obj2 = 0 ;

16156

char * kwnames[] = {

16157

(char *) "self",(char *) "caretPolicy",(char *) "caretSlop", NULL

16158

};

16159

16160

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetYCaretPolicy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

16161

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16162

if (!SWIG_IsOK(res1)) {

16163

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetYCaretPolicy" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16164

}

16165

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16166

ecode2 = SWIG_AsVal_int(obj1, &val2);

16167

if (!SWIG_IsOK(ecode2)) {

16168

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetYCaretPolicy" "', expected argument " "2"" of type '" "int""'");

16169

}

16170

arg2 = static_cast< int >(val2);

16171

ecode3 = SWIG_AsVal_int(obj2, &val3);

16172

if (!SWIG_IsOK(ecode3)) {

16173

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_SetYCaretPolicy" "', expected argument " "3"" of type '" "int""'");

16174

}

16175

arg3 = static_cast< int >(val3);

16176

{

16177

PyThreadState* __tstate = wxPyBeginAllowThreads();

16178

(arg1)->SetYCaretPolicy(arg2,arg3);

16179

wxPyEndAllowThreads(__tstate);

16180

if (PyErr_Occurred()) SWIG_fail;

16181

}

16182

resultobj = SWIG_Py_Void();

16183

return resultobj;

16184

fail:

16185

return NULL;

16186

}

16187

16188

16189

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetPrintWrapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16190

PyObject *resultobj = 0;

16191

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16192

int arg2 ;

16193

void *argp1 = 0 ;

16194

int res1 = 0 ;

16195

int val2 ;

16196

int ecode2 = 0 ;

16197

PyObject * obj0 = 0 ;

16198

PyObject * obj1 = 0 ;

16199

char * kwnames[] = {

16200

(char *) "self",(char *) "mode", NULL

16201

};

16202

16203

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetPrintWrapMode",kwnames,&obj0,&obj1)) SWIG_fail;

16204

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16205

if (!SWIG_IsOK(res1)) {

16206

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetPrintWrapMode" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16207

}

16208

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16209

ecode2 = SWIG_AsVal_int(obj1, &val2);

16210

if (!SWIG_IsOK(ecode2)) {

16211

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetPrintWrapMode" "', expected argument " "2"" of type '" "int""'");

16212

}

16213

arg2 = static_cast< int >(val2);

16214

{

16215

PyThreadState* __tstate = wxPyBeginAllowThreads();

16216

(arg1)->SetPrintWrapMode(arg2);

16217

wxPyEndAllowThreads(__tstate);

16218

if (PyErr_Occurred()) SWIG_fail;

16219

}

16220

resultobj = SWIG_Py_Void();

16221

return resultobj;

16222

fail:

16223

return NULL;

16224

}

16225

16226

16227

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetPrintWrapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16228

PyObject *resultobj = 0;

16229

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16230

int result;

16231

void *argp1 = 0 ;

16232

int res1 = 0 ;

16233

PyObject *swig_obj[1] ;

16234

16235

if (!args) SWIG_fail;

16236

swig_obj[0] = args;

16237

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16238

if (!SWIG_IsOK(res1)) {

16239

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetPrintWrapMode" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16240

}

16241

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16242

{

16243

PyThreadState* __tstate = wxPyBeginAllowThreads();

16244

result = (int)(arg1)->GetPrintWrapMode();

16245

wxPyEndAllowThreads(__tstate);

16246

if (PyErr_Occurred()) SWIG_fail;

16247

}

16248

resultobj = SWIG_From_int(static_cast< int >(result));

16249

return resultobj;

16250

fail:

16251

return NULL;

16252

}

16253

16254

16255

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetHotspotActiveForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16256

PyObject *resultobj = 0;

16257

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16258

bool arg2 ;

16259

wxColour *arg3 = 0 ;

16260

void *argp1 = 0 ;

16261

int res1 = 0 ;

16262

bool val2 ;

16263

int ecode2 = 0 ;

16264

wxColour temp3 ;

16265

PyObject * obj0 = 0 ;

16266

PyObject * obj1 = 0 ;

16267

PyObject * obj2 = 0 ;

16268

char * kwnames[] = {

16269

(char *) "self",(char *) "useSetting",(char *) "fore", NULL

16270

};

16271

16272

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetHotspotActiveForeground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

16273

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16274

if (!SWIG_IsOK(res1)) {

16275

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetHotspotActiveForeground" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16276

}

16277

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16278

ecode2 = SWIG_AsVal_bool(obj1, &val2);

16279

if (!SWIG_IsOK(ecode2)) {

16280

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetHotspotActiveForeground" "', expected argument " "2"" of type '" "bool""'");

16281

}

16282

arg2 = static_cast< bool >(val2);

16283

{

16284

arg3 = &temp3;

16285

if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;

16286

}

16287

{

16288

PyThreadState* __tstate = wxPyBeginAllowThreads();

16289

(arg1)->SetHotspotActiveForeground(arg2,(wxColour const &)*arg3);

16290

wxPyEndAllowThreads(__tstate);

16291

if (PyErr_Occurred()) SWIG_fail;

16292

}

16293

resultobj = SWIG_Py_Void();

16294

return resultobj;

16295

fail:

16296

return NULL;

16297

}

16298

16299

16300

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetHotspotActiveBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16301

PyObject *resultobj = 0;

16302

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16303

bool arg2 ;

16304

wxColour *arg3 = 0 ;

16305

void *argp1 = 0 ;

16306

int res1 = 0 ;

16307

bool val2 ;

16308

int ecode2 = 0 ;

16309

wxColour temp3 ;

16310

PyObject * obj0 = 0 ;

16311

PyObject * obj1 = 0 ;

16312

PyObject * obj2 = 0 ;

16313

char * kwnames[] = {

16314

(char *) "self",(char *) "useSetting",(char *) "back", NULL

16315

};

16316

16317

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetHotspotActiveBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

16318

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16319

if (!SWIG_IsOK(res1)) {

16320

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetHotspotActiveBackground" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16321

}

16322

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16323

ecode2 = SWIG_AsVal_bool(obj1, &val2);

16324

if (!SWIG_IsOK(ecode2)) {

16325

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetHotspotActiveBackground" "', expected argument " "2"" of type '" "bool""'");

16326

}

16327

arg2 = static_cast< bool >(val2);

16328

{

16329

arg3 = &temp3;

16330

if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;

16331

}

16332

{

16333

PyThreadState* __tstate = wxPyBeginAllowThreads();

16334

(arg1)->SetHotspotActiveBackground(arg2,(wxColour const &)*arg3);

16335

wxPyEndAllowThreads(__tstate);

16336

if (PyErr_Occurred()) SWIG_fail;

16337

}

16338

resultobj = SWIG_Py_Void();

16339

return resultobj;

16340

fail:

16341

return NULL;

16342

}

16343

16344

16345

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetHotspotActiveUnderline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16346

PyObject *resultobj = 0;

16347

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16348

bool arg2 ;

16349

void *argp1 = 0 ;

16350

int res1 = 0 ;

16351

bool val2 ;

16352

int ecode2 = 0 ;

16353

PyObject * obj0 = 0 ;

16354

PyObject * obj1 = 0 ;

16355

char * kwnames[] = {

16356

(char *) "self",(char *) "underline", NULL

16357

};

16358

16359

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetHotspotActiveUnderline",kwnames,&obj0,&obj1)) SWIG_fail;

16360

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16361

if (!SWIG_IsOK(res1)) {

16362

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetHotspotActiveUnderline" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16363

}

16364

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16365

ecode2 = SWIG_AsVal_bool(obj1, &val2);

16366

if (!SWIG_IsOK(ecode2)) {

16367

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetHotspotActiveUnderline" "', expected argument " "2"" of type '" "bool""'");

16368

}

16369

arg2 = static_cast< bool >(val2);

16370

{

16371

PyThreadState* __tstate = wxPyBeginAllowThreads();

16372

(arg1)->SetHotspotActiveUnderline(arg2);

16373

wxPyEndAllowThreads(__tstate);

16374

if (PyErr_Occurred()) SWIG_fail;

16375

}

16376

resultobj = SWIG_Py_Void();

16377

return resultobj;

16378

fail:

16379

return NULL;

16380

}

16381

16382

16383

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetHotspotSingleLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16384

PyObject *resultobj = 0;

16385

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16386

bool arg2 ;

16387

void *argp1 = 0 ;

16388

int res1 = 0 ;

16389

bool val2 ;

16390

int ecode2 = 0 ;

16391

PyObject * obj0 = 0 ;

16392

PyObject * obj1 = 0 ;

16393

char * kwnames[] = {

16394

(char *) "self",(char *) "singleLine", NULL

16395

};

16396

16397

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetHotspotSingleLine",kwnames,&obj0,&obj1)) SWIG_fail;

16398

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16399

if (!SWIG_IsOK(res1)) {

16400

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetHotspotSingleLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16401

}

16402

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16403

ecode2 = SWIG_AsVal_bool(obj1, &val2);

16404

if (!SWIG_IsOK(ecode2)) {

16405

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetHotspotSingleLine" "', expected argument " "2"" of type '" "bool""'");

16406

}

16407

arg2 = static_cast< bool >(val2);

16408

{

16409

PyThreadState* __tstate = wxPyBeginAllowThreads();

16410

(arg1)->SetHotspotSingleLine(arg2);

16411

wxPyEndAllowThreads(__tstate);

16412

if (PyErr_Occurred()) SWIG_fail;

16413

}

16414

resultobj = SWIG_Py_Void();

16415

return resultobj;

16416

fail:

16417

return NULL;

16418

}

16419

16420

16421

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ParaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16422

PyObject *resultobj = 0;

16423

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16424

void *argp1 = 0 ;

16425

int res1 = 0 ;

16426

PyObject *swig_obj[1] ;

16427

16428

if (!args) SWIG_fail;

16429

swig_obj[0] = args;

16430

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16431

if (!SWIG_IsOK(res1)) {

16432

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ParaDown" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16433

}

16434

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16435

{

16436

PyThreadState* __tstate = wxPyBeginAllowThreads();

16437

(arg1)->ParaDown();

16438

wxPyEndAllowThreads(__tstate);

16439

if (PyErr_Occurred()) SWIG_fail;

16440

}

16441

resultobj = SWIG_Py_Void();

16442

return resultobj;

16443

fail:

16444

return NULL;

16445

}

16446

16447

16448

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ParaDownExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16449

PyObject *resultobj = 0;

16450

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16451

void *argp1 = 0 ;

16452

int res1 = 0 ;

16453

PyObject *swig_obj[1] ;

16454

16455

if (!args) SWIG_fail;

16456

swig_obj[0] = args;

16457

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16458

if (!SWIG_IsOK(res1)) {

16459

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ParaDownExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16460

}

16461

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16462

{

16463

PyThreadState* __tstate = wxPyBeginAllowThreads();

16464

(arg1)->ParaDownExtend();

16465

wxPyEndAllowThreads(__tstate);

16466

if (PyErr_Occurred()) SWIG_fail;

16467

}

16468

resultobj = SWIG_Py_Void();

16469

return resultobj;

16470

fail:

16471

return NULL;

16472

}

16473

16474

16475

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ParaUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16476

PyObject *resultobj = 0;

16477

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16478

void *argp1 = 0 ;

16479

int res1 = 0 ;

16480

PyObject *swig_obj[1] ;

16481

16482

if (!args) SWIG_fail;

16483

swig_obj[0] = args;

16484

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16485

if (!SWIG_IsOK(res1)) {

16486

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ParaUp" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16487

}

16488

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16489

{

16490

PyThreadState* __tstate = wxPyBeginAllowThreads();

16491

(arg1)->ParaUp();

16492

wxPyEndAllowThreads(__tstate);

16493

if (PyErr_Occurred()) SWIG_fail;

16494

}

16495

resultobj = SWIG_Py_Void();

16496

return resultobj;

16497

fail:

16498

return NULL;

16499

}

16500

16501

16502

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ParaUpExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16503

PyObject *resultobj = 0;

16504

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16505

void *argp1 = 0 ;

16506

int res1 = 0 ;

16507

PyObject *swig_obj[1] ;

16508

16509

if (!args) SWIG_fail;

16510

swig_obj[0] = args;

16511

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16512

if (!SWIG_IsOK(res1)) {

16513

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ParaUpExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16514

}

16515

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16516

{

16517

PyThreadState* __tstate = wxPyBeginAllowThreads();

16518

(arg1)->ParaUpExtend();

16519

wxPyEndAllowThreads(__tstate);

16520

if (PyErr_Occurred()) SWIG_fail;

16521

}

16522

resultobj = SWIG_Py_Void();

16523

return resultobj;

16524

fail:

16525

return NULL;

16526

}

16527

16528

16529

SWIGINTERN PyObject *_wrap_StyledTextCtrl_PositionBefore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16530

PyObject *resultobj = 0;

16531

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16532

int arg2 ;

16533

int result;

16534

void *argp1 = 0 ;

16535

int res1 = 0 ;

16536

int val2 ;

16537

int ecode2 = 0 ;

16538

PyObject * obj0 = 0 ;

16539

PyObject * obj1 = 0 ;

16540

char * kwnames[] = {

16541

(char *) "self",(char *) "pos", NULL

16542

};

16543

16544

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_PositionBefore",kwnames,&obj0,&obj1)) SWIG_fail;

16545

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16546

if (!SWIG_IsOK(res1)) {

16547

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_PositionBefore" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16548

}

16549

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16550

ecode2 = SWIG_AsVal_int(obj1, &val2);

16551

if (!SWIG_IsOK(ecode2)) {

16552

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_PositionBefore" "', expected argument " "2"" of type '" "int""'");

16553

}

16554

arg2 = static_cast< int >(val2);

16555

{

16556

PyThreadState* __tstate = wxPyBeginAllowThreads();

16557

result = (int)(arg1)->PositionBefore(arg2);

16558

wxPyEndAllowThreads(__tstate);

16559

if (PyErr_Occurred()) SWIG_fail;

16560

}

16561

resultobj = SWIG_From_int(static_cast< int >(result));

16562

return resultobj;

16563

fail:

16564

return NULL;

16565

}

16566

16567

16568

SWIGINTERN PyObject *_wrap_StyledTextCtrl_PositionAfter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16569

PyObject *resultobj = 0;

16570

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16571

int arg2 ;

16572

int result;

16573

void *argp1 = 0 ;

16574

int res1 = 0 ;

16575

int val2 ;

16576

int ecode2 = 0 ;

16577

PyObject * obj0 = 0 ;

16578

PyObject * obj1 = 0 ;

16579

char * kwnames[] = {

16580

(char *) "self",(char *) "pos", NULL

16581

};

16582

16583

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_PositionAfter",kwnames,&obj0,&obj1)) SWIG_fail;

16584

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16585

if (!SWIG_IsOK(res1)) {

16586

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_PositionAfter" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16587

}

16588

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16589

ecode2 = SWIG_AsVal_int(obj1, &val2);

16590

if (!SWIG_IsOK(ecode2)) {

16591

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_PositionAfter" "', expected argument " "2"" of type '" "int""'");

16592

}

16593

arg2 = static_cast< int >(val2);

16594

{

16595

PyThreadState* __tstate = wxPyBeginAllowThreads();

16596

result = (int)(arg1)->PositionAfter(arg2);

16597

wxPyEndAllowThreads(__tstate);

16598

if (PyErr_Occurred()) SWIG_fail;

16599

}

16600

resultobj = SWIG_From_int(static_cast< int >(result));

16601

return resultobj;

16602

fail:

16603

return NULL;

16604

}

16605

16606

16607

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CopyRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16608

PyObject *resultobj = 0;

16609

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16610

int arg2 ;

16611

int arg3 ;

16612

void *argp1 = 0 ;

16613

int res1 = 0 ;

16614

int val2 ;

16615

int ecode2 = 0 ;

16616

int val3 ;

16617

int ecode3 = 0 ;

16618

PyObject * obj0 = 0 ;

16619

PyObject * obj1 = 0 ;

16620

PyObject * obj2 = 0 ;

16621

char * kwnames[] = {

16622

(char *) "self",(char *) "start",(char *) "end", NULL

16623

};

16624

16625

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_CopyRange",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

16626

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16627

if (!SWIG_IsOK(res1)) {

16628

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CopyRange" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16629

}

16630

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16631

ecode2 = SWIG_AsVal_int(obj1, &val2);

16632

if (!SWIG_IsOK(ecode2)) {

16633

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_CopyRange" "', expected argument " "2"" of type '" "int""'");

16634

}

16635

arg2 = static_cast< int >(val2);

16636

ecode3 = SWIG_AsVal_int(obj2, &val3);

16637

if (!SWIG_IsOK(ecode3)) {

16638

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_CopyRange" "', expected argument " "3"" of type '" "int""'");

16639

}

16640

arg3 = static_cast< int >(val3);

16641

{

16642

PyThreadState* __tstate = wxPyBeginAllowThreads();

16643

(arg1)->CopyRange(arg2,arg3);

16644

wxPyEndAllowThreads(__tstate);

16645

if (PyErr_Occurred()) SWIG_fail;

16646

}

16647

resultobj = SWIG_Py_Void();

16648

return resultobj;

16649

fail:

16650

return NULL;

16651

}

16652

16653

16654

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CopyText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16655

PyObject *resultobj = 0;

16656

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16657

int arg2 ;

16658

wxString *arg3 = 0 ;

16659

void *argp1 = 0 ;

16660

int res1 = 0 ;

16661

int val2 ;

16662

int ecode2 = 0 ;

16663

bool temp3 = false ;

16664

PyObject * obj0 = 0 ;

16665

PyObject * obj1 = 0 ;

16666

PyObject * obj2 = 0 ;

16667

char * kwnames[] = {

16668

(char *) "self",(char *) "length",(char *) "text", NULL

16669

};

16670

16671

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_CopyText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

16672

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16673

if (!SWIG_IsOK(res1)) {

16674

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CopyText" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16675

}

16676

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16677

ecode2 = SWIG_AsVal_int(obj1, &val2);

16678

if (!SWIG_IsOK(ecode2)) {

16679

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_CopyText" "', expected argument " "2"" of type '" "int""'");

16680

}

16681

arg2 = static_cast< int >(val2);

16682

{

16683

arg3 = wxString_in_helper(obj2);

16684

if (arg3 == NULL) SWIG_fail;

16685

temp3 = true;

16686

}

16687

{

16688

PyThreadState* __tstate = wxPyBeginAllowThreads();

16689

(arg1)->CopyText(arg2,(wxString const &)*arg3);

16690

wxPyEndAllowThreads(__tstate);

16691

if (PyErr_Occurred()) SWIG_fail;

16692

}

16693

resultobj = SWIG_Py_Void();

16694

{

16695

if (temp3)

16696

delete arg3;

16697

}

16698

return resultobj;

16699

fail:

16700

{

16701

if (temp3)

16702

delete arg3;

16703

}

16704

return NULL;

16705

}

16706

16707

16708

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16709

PyObject *resultobj = 0;

16710

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16711

int arg2 ;

16712

void *argp1 = 0 ;

16713

int res1 = 0 ;

16714

int val2 ;

16715

int ecode2 = 0 ;

16716

PyObject * obj0 = 0 ;

16717

PyObject * obj1 = 0 ;

16718

char * kwnames[] = {

16719

(char *) "self",(char *) "mode", NULL

16720

};

16721

16722

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;

16723

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16724

if (!SWIG_IsOK(res1)) {

16725

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetSelectionMode" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16726

}

16727

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16728

ecode2 = SWIG_AsVal_int(obj1, &val2);

16729

if (!SWIG_IsOK(ecode2)) {

16730

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetSelectionMode" "', expected argument " "2"" of type '" "int""'");

16731

}

16732

arg2 = static_cast< int >(val2);

16733

{

16734

PyThreadState* __tstate = wxPyBeginAllowThreads();

16735

(arg1)->SetSelectionMode(arg2);

16736

wxPyEndAllowThreads(__tstate);

16737

if (PyErr_Occurred()) SWIG_fail;

16738

}

16739

resultobj = SWIG_Py_Void();

16740

return resultobj;

16741

fail:

16742

return NULL;

16743

}

16744

16745

16746

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16747

PyObject *resultobj = 0;

16748

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16749

int result;

16750

void *argp1 = 0 ;

16751

int res1 = 0 ;

16752

PyObject *swig_obj[1] ;

16753

16754

if (!args) SWIG_fail;

16755

swig_obj[0] = args;

16756

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16757

if (!SWIG_IsOK(res1)) {

16758

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetSelectionMode" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16759

}

16760

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16761

{

16762

PyThreadState* __tstate = wxPyBeginAllowThreads();

16763

result = (int)(arg1)->GetSelectionMode();

16764

wxPyEndAllowThreads(__tstate);

16765

if (PyErr_Occurred()) SWIG_fail;

16766

}

16767

resultobj = SWIG_From_int(static_cast< int >(result));

16768

return resultobj;

16769

fail:

16770

return NULL;

16771

}

16772

16773

16774

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLineSelStartPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16775

PyObject *resultobj = 0;

16776

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16777

int arg2 ;

16778

int result;

16779

void *argp1 = 0 ;

16780

int res1 = 0 ;

16781

int val2 ;

16782

int ecode2 = 0 ;

16783

PyObject * obj0 = 0 ;

16784

PyObject * obj1 = 0 ;

16785

char * kwnames[] = {

16786

(char *) "self",(char *) "line", NULL

16787

};

16788

16789

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetLineSelStartPosition",kwnames,&obj0,&obj1)) SWIG_fail;

16790

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16791

if (!SWIG_IsOK(res1)) {

16792

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLineSelStartPosition" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16793

}

16794

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16795

ecode2 = SWIG_AsVal_int(obj1, &val2);

16796

if (!SWIG_IsOK(ecode2)) {

16797

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetLineSelStartPosition" "', expected argument " "2"" of type '" "int""'");

16798

}

16799

arg2 = static_cast< int >(val2);

16800

{

16801

PyThreadState* __tstate = wxPyBeginAllowThreads();

16802

result = (int)(arg1)->GetLineSelStartPosition(arg2);

16803

wxPyEndAllowThreads(__tstate);

16804

if (PyErr_Occurred()) SWIG_fail;

16805

}

16806

resultobj = SWIG_From_int(static_cast< int >(result));

16807

return resultobj;

16808

fail:

16809

return NULL;

16810

}

16811

16812

16813

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLineSelEndPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16814

PyObject *resultobj = 0;

16815

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16816

int arg2 ;

16817

int result;

16818

void *argp1 = 0 ;

16819

int res1 = 0 ;

16820

int val2 ;

16821

int ecode2 = 0 ;

16822

PyObject * obj0 = 0 ;

16823

PyObject * obj1 = 0 ;

16824

char * kwnames[] = {

16825

(char *) "self",(char *) "line", NULL

16826

};

16827

16828

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetLineSelEndPosition",kwnames,&obj0,&obj1)) SWIG_fail;

16829

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16830

if (!SWIG_IsOK(res1)) {

16831

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLineSelEndPosition" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16832

}

16833

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16834

ecode2 = SWIG_AsVal_int(obj1, &val2);

16835

if (!SWIG_IsOK(ecode2)) {

16836

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetLineSelEndPosition" "', expected argument " "2"" of type '" "int""'");

16837

}

16838

arg2 = static_cast< int >(val2);

16839

{

16840

PyThreadState* __tstate = wxPyBeginAllowThreads();

16841

result = (int)(arg1)->GetLineSelEndPosition(arg2);

16842

wxPyEndAllowThreads(__tstate);

16843

if (PyErr_Occurred()) SWIG_fail;

16844

}

16845

resultobj = SWIG_From_int(static_cast< int >(result));

16846

return resultobj;

16847

fail:

16848

return NULL;

16849

}

16850

16851

16852

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineDownRectExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16853

PyObject *resultobj = 0;

16854

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16855

void *argp1 = 0 ;

16856

int res1 = 0 ;

16857

PyObject *swig_obj[1] ;

16858

16859

if (!args) SWIG_fail;

16860

swig_obj[0] = args;

16861

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16862

if (!SWIG_IsOK(res1)) {

16863

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineDownRectExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16864

}

16865

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16866

{

16867

PyThreadState* __tstate = wxPyBeginAllowThreads();

16868

(arg1)->LineDownRectExtend();

16869

wxPyEndAllowThreads(__tstate);

16870

if (PyErr_Occurred()) SWIG_fail;

16871

}

16872

resultobj = SWIG_Py_Void();

16873

return resultobj;

16874

fail:

16875

return NULL;

16876

}

16877

16878

16879

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineUpRectExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16880

PyObject *resultobj = 0;

16881

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16882

void *argp1 = 0 ;

16883

int res1 = 0 ;

16884

PyObject *swig_obj[1] ;

16885

16886

if (!args) SWIG_fail;

16887

swig_obj[0] = args;

16888

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16889

if (!SWIG_IsOK(res1)) {

16890

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineUpRectExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16891

}

16892

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16893

{

16894

PyThreadState* __tstate = wxPyBeginAllowThreads();

16895

(arg1)->LineUpRectExtend();

16896

wxPyEndAllowThreads(__tstate);

16897

if (PyErr_Occurred()) SWIG_fail;

16898

}

16899

resultobj = SWIG_Py_Void();

16900

return resultobj;

16901

fail:

16902

return NULL;

16903

}

16904

16905

16906

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CharLeftRectExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16907

PyObject *resultobj = 0;

16908

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16909

void *argp1 = 0 ;

16910

int res1 = 0 ;

16911

PyObject *swig_obj[1] ;

16912

16913

if (!args) SWIG_fail;

16914

swig_obj[0] = args;

16915

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16916

if (!SWIG_IsOK(res1)) {

16917

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CharLeftRectExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16918

}

16919

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16920

{

16921

PyThreadState* __tstate = wxPyBeginAllowThreads();

16922

(arg1)->CharLeftRectExtend();

16923

wxPyEndAllowThreads(__tstate);

16924

if (PyErr_Occurred()) SWIG_fail;

16925

}

16926

resultobj = SWIG_Py_Void();

16927

return resultobj;

16928

fail:

16929

return NULL;

16930

}

16931

16932

16933

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CharRightRectExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16934

PyObject *resultobj = 0;

16935

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16936

void *argp1 = 0 ;

16937

int res1 = 0 ;

16938

PyObject *swig_obj[1] ;

16939

16940

if (!args) SWIG_fail;

16941

swig_obj[0] = args;

16942

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16943

if (!SWIG_IsOK(res1)) {

16944

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CharRightRectExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16945

}

16946

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16947

{

16948

PyThreadState* __tstate = wxPyBeginAllowThreads();

16949

(arg1)->CharRightRectExtend();

16950

wxPyEndAllowThreads(__tstate);

16951

if (PyErr_Occurred()) SWIG_fail;

16952

}

16953

resultobj = SWIG_Py_Void();

16954

return resultobj;

16955

fail:

16956

return NULL;

16957

}

16958

16959

16960

SWIGINTERN PyObject *_wrap_StyledTextCtrl_HomeRectExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16961

PyObject *resultobj = 0;

16962

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16963

void *argp1 = 0 ;

16964

int res1 = 0 ;

16965

PyObject *swig_obj[1] ;

16966

16967

if (!args) SWIG_fail;

16968

swig_obj[0] = args;

16969

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16970

if (!SWIG_IsOK(res1)) {

16971

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_HomeRectExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16972

}

16973

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

16974

{

16975

PyThreadState* __tstate = wxPyBeginAllowThreads();

16976

(arg1)->HomeRectExtend();

16977

wxPyEndAllowThreads(__tstate);

16978

if (PyErr_Occurred()) SWIG_fail;

16979

}

16980

resultobj = SWIG_Py_Void();

16981

return resultobj;

16982

fail:

16983

return NULL;

16984

}

16985

16986

16987

SWIGINTERN PyObject *_wrap_StyledTextCtrl_VCHomeRectExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16988

PyObject *resultobj = 0;

16989

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

16990

void *argp1 = 0 ;

16991

int res1 = 0 ;

16992

PyObject *swig_obj[1] ;

16993

16994

if (!args) SWIG_fail;

16995

swig_obj[0] = args;

16996

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

16997

if (!SWIG_IsOK(res1)) {

16998

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_VCHomeRectExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

16999

}

17000

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17001

{

17002

PyThreadState* __tstate = wxPyBeginAllowThreads();

17003

(arg1)->VCHomeRectExtend();

17004

wxPyEndAllowThreads(__tstate);

17005

if (PyErr_Occurred()) SWIG_fail;

17006

}

17007

resultobj = SWIG_Py_Void();

17008

return resultobj;

17009

fail:

17010

return NULL;

17011

}

17012

17013

17014

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LineEndRectExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17015

PyObject *resultobj = 0;

17016

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17017

void *argp1 = 0 ;

17018

int res1 = 0 ;

17019

PyObject *swig_obj[1] ;

17020

17021

if (!args) SWIG_fail;

17022

swig_obj[0] = args;

17023

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17024

if (!SWIG_IsOK(res1)) {

17025

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LineEndRectExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17026

}

17027

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17028

{

17029

PyThreadState* __tstate = wxPyBeginAllowThreads();

17030

(arg1)->LineEndRectExtend();

17031

wxPyEndAllowThreads(__tstate);

17032

if (PyErr_Occurred()) SWIG_fail;

17033

}

17034

resultobj = SWIG_Py_Void();

17035

return resultobj;

17036

fail:

17037

return NULL;

17038

}

17039

17040

17041

SWIGINTERN PyObject *_wrap_StyledTextCtrl_PageUpRectExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17042

PyObject *resultobj = 0;

17043

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17044

void *argp1 = 0 ;

17045

int res1 = 0 ;

17046

PyObject *swig_obj[1] ;

17047

17048

if (!args) SWIG_fail;

17049

swig_obj[0] = args;

17050

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17051

if (!SWIG_IsOK(res1)) {

17052

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_PageUpRectExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17053

}

17054

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17055

{

17056

PyThreadState* __tstate = wxPyBeginAllowThreads();

17057

(arg1)->PageUpRectExtend();

17058

wxPyEndAllowThreads(__tstate);

17059

if (PyErr_Occurred()) SWIG_fail;

17060

}

17061

resultobj = SWIG_Py_Void();

17062

return resultobj;

17063

fail:

17064

return NULL;

17065

}

17066

17067

17068

SWIGINTERN PyObject *_wrap_StyledTextCtrl_PageDownRectExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17069

PyObject *resultobj = 0;

17070

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17071

void *argp1 = 0 ;

17072

int res1 = 0 ;

17073

PyObject *swig_obj[1] ;

17074

17075

if (!args) SWIG_fail;

17076

swig_obj[0] = args;

17077

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17078

if (!SWIG_IsOK(res1)) {

17079

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_PageDownRectExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17080

}

17081

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17082

{

17083

PyThreadState* __tstate = wxPyBeginAllowThreads();

17084

(arg1)->PageDownRectExtend();

17085

wxPyEndAllowThreads(__tstate);

17086

if (PyErr_Occurred()) SWIG_fail;

17087

}

17088

resultobj = SWIG_Py_Void();

17089

return resultobj;

17090

fail:

17091

return NULL;

17092

}

17093

17094

17095

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StutteredPageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17096

PyObject *resultobj = 0;

17097

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17098

void *argp1 = 0 ;

17099

int res1 = 0 ;

17100

PyObject *swig_obj[1] ;

17101

17102

if (!args) SWIG_fail;

17103

swig_obj[0] = args;

17104

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17105

if (!SWIG_IsOK(res1)) {

17106

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StutteredPageUp" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17107

}

17108

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17109

{

17110

PyThreadState* __tstate = wxPyBeginAllowThreads();

17111

(arg1)->StutteredPageUp();

17112

wxPyEndAllowThreads(__tstate);

17113

if (PyErr_Occurred()) SWIG_fail;

17114

}

17115

resultobj = SWIG_Py_Void();

17116

return resultobj;

17117

fail:

17118

return NULL;

17119

}

17120

17121

17122

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StutteredPageUpExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17123

PyObject *resultobj = 0;

17124

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17125

void *argp1 = 0 ;

17126

int res1 = 0 ;

17127

PyObject *swig_obj[1] ;

17128

17129

if (!args) SWIG_fail;

17130

swig_obj[0] = args;

17131

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17132

if (!SWIG_IsOK(res1)) {

17133

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StutteredPageUpExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17134

}

17135

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17136

{

17137

PyThreadState* __tstate = wxPyBeginAllowThreads();

17138

(arg1)->StutteredPageUpExtend();

17139

wxPyEndAllowThreads(__tstate);

17140

if (PyErr_Occurred()) SWIG_fail;

17141

}

17142

resultobj = SWIG_Py_Void();

17143

return resultobj;

17144

fail:

17145

return NULL;

17146

}

17147

17148

17149

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StutteredPageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17150

PyObject *resultobj = 0;

17151

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17152

void *argp1 = 0 ;

17153

int res1 = 0 ;

17154

PyObject *swig_obj[1] ;

17155

17156

if (!args) SWIG_fail;

17157

swig_obj[0] = args;

17158

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17159

if (!SWIG_IsOK(res1)) {

17160

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StutteredPageDown" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17161

}

17162

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17163

{

17164

PyThreadState* __tstate = wxPyBeginAllowThreads();

17165

(arg1)->StutteredPageDown();

17166

wxPyEndAllowThreads(__tstate);

17167

if (PyErr_Occurred()) SWIG_fail;

17168

}

17169

resultobj = SWIG_Py_Void();

17170

return resultobj;

17171

fail:

17172

return NULL;

17173

}

17174

17175

17176

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StutteredPageDownExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17177

PyObject *resultobj = 0;

17178

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17179

void *argp1 = 0 ;

17180

int res1 = 0 ;

17181

PyObject *swig_obj[1] ;

17182

17183

if (!args) SWIG_fail;

17184

swig_obj[0] = args;

17185

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17186

if (!SWIG_IsOK(res1)) {

17187

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StutteredPageDownExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17188

}

17189

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17190

{

17191

PyThreadState* __tstate = wxPyBeginAllowThreads();

17192

(arg1)->StutteredPageDownExtend();

17193

wxPyEndAllowThreads(__tstate);

17194

if (PyErr_Occurred()) SWIG_fail;

17195

}

17196

resultobj = SWIG_Py_Void();

17197

return resultobj;

17198

fail:

17199

return NULL;

17200

}

17201

17202

17203

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordLeftEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17204

PyObject *resultobj = 0;

17205

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17206

void *argp1 = 0 ;

17207

int res1 = 0 ;

17208

PyObject *swig_obj[1] ;

17209

17210

if (!args) SWIG_fail;

17211

swig_obj[0] = args;

17212

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17213

if (!SWIG_IsOK(res1)) {

17214

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordLeftEnd" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17215

}

17216

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17217

{

17218

PyThreadState* __tstate = wxPyBeginAllowThreads();

17219

(arg1)->WordLeftEnd();

17220

wxPyEndAllowThreads(__tstate);

17221

if (PyErr_Occurred()) SWIG_fail;

17222

}

17223

resultobj = SWIG_Py_Void();

17224

return resultobj;

17225

fail:

17226

return NULL;

17227

}

17228

17229

17230

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordLeftEndExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17231

PyObject *resultobj = 0;

17232

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17233

void *argp1 = 0 ;

17234

int res1 = 0 ;

17235

PyObject *swig_obj[1] ;

17236

17237

if (!args) SWIG_fail;

17238

swig_obj[0] = args;

17239

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17240

if (!SWIG_IsOK(res1)) {

17241

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordLeftEndExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17242

}

17243

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17244

{

17245

PyThreadState* __tstate = wxPyBeginAllowThreads();

17246

(arg1)->WordLeftEndExtend();

17247

wxPyEndAllowThreads(__tstate);

17248

if (PyErr_Occurred()) SWIG_fail;

17249

}

17250

resultobj = SWIG_Py_Void();

17251

return resultobj;

17252

fail:

17253

return NULL;

17254

}

17255

17256

17257

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordRightEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17258

PyObject *resultobj = 0;

17259

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17260

void *argp1 = 0 ;

17261

int res1 = 0 ;

17262

PyObject *swig_obj[1] ;

17263

17264

if (!args) SWIG_fail;

17265

swig_obj[0] = args;

17266

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17267

if (!SWIG_IsOK(res1)) {

17268

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordRightEnd" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17269

}

17270

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17271

{

17272

PyThreadState* __tstate = wxPyBeginAllowThreads();

17273

(arg1)->WordRightEnd();

17274

wxPyEndAllowThreads(__tstate);

17275

if (PyErr_Occurred()) SWIG_fail;

17276

}

17277

resultobj = SWIG_Py_Void();

17278

return resultobj;

17279

fail:

17280

return NULL;

17281

}

17282

17283

17284

SWIGINTERN PyObject *_wrap_StyledTextCtrl_WordRightEndExtend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17285

PyObject *resultobj = 0;

17286

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17287

void *argp1 = 0 ;

17288

int res1 = 0 ;

17289

PyObject *swig_obj[1] ;

17290

17291

if (!args) SWIG_fail;

17292

swig_obj[0] = args;

17293

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17294

if (!SWIG_IsOK(res1)) {

17295

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_WordRightEndExtend" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17296

}

17297

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17298

{

17299

PyThreadState* __tstate = wxPyBeginAllowThreads();

17300

(arg1)->WordRightEndExtend();

17301

wxPyEndAllowThreads(__tstate);

17302

if (PyErr_Occurred()) SWIG_fail;

17303

}

17304

resultobj = SWIG_Py_Void();

17305

return resultobj;

17306

fail:

17307

return NULL;

17308

}

17309

17310

17311

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetWhitespaceChars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17312

PyObject *resultobj = 0;

17313

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17314

wxString *arg2 = 0 ;

17315

void *argp1 = 0 ;

17316

int res1 = 0 ;

17317

bool temp2 = false ;

17318

PyObject * obj0 = 0 ;

17319

PyObject * obj1 = 0 ;

17320

char * kwnames[] = {

17321

(char *) "self",(char *) "characters", NULL

17322

};

17323

17324

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetWhitespaceChars",kwnames,&obj0,&obj1)) SWIG_fail;

17325

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17326

if (!SWIG_IsOK(res1)) {

17327

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetWhitespaceChars" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17328

}

17329

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17330

{

17331

arg2 = wxString_in_helper(obj1);

17332

if (arg2 == NULL) SWIG_fail;

17333

temp2 = true;

17334

}

17335

{

17336

PyThreadState* __tstate = wxPyBeginAllowThreads();

17337

(arg1)->SetWhitespaceChars((wxString const &)*arg2);

17338

wxPyEndAllowThreads(__tstate);

17339

if (PyErr_Occurred()) SWIG_fail;

17340

}

17341

resultobj = SWIG_Py_Void();

17342

{

17343

if (temp2)

17344

delete arg2;

17345

}

17346

return resultobj;

17347

fail:

17348

{

17349

if (temp2)

17350

delete arg2;

17351

}

17352

return NULL;

17353

}

17354

17355

17356

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetCharsDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17357

PyObject *resultobj = 0;

17358

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17359

void *argp1 = 0 ;

17360

int res1 = 0 ;

17361

PyObject *swig_obj[1] ;

17362

17363

if (!args) SWIG_fail;

17364

swig_obj[0] = args;

17365

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17366

if (!SWIG_IsOK(res1)) {

17367

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetCharsDefault" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17368

}

17369

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17370

{

17371

PyThreadState* __tstate = wxPyBeginAllowThreads();

17372

(arg1)->SetCharsDefault();

17373

wxPyEndAllowThreads(__tstate);

17374

if (PyErr_Occurred()) SWIG_fail;

17375

}

17376

resultobj = SWIG_Py_Void();

17377

return resultobj;

17378

fail:

17379

return NULL;

17380

}

17381

17382

17383

SWIGINTERN PyObject *_wrap_StyledTextCtrl_AutoCompGetCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17384

PyObject *resultobj = 0;

17385

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17386

int result;

17387

void *argp1 = 0 ;

17388

int res1 = 0 ;

17389

PyObject *swig_obj[1] ;

17390

17391

if (!args) SWIG_fail;

17392

swig_obj[0] = args;

17393

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17394

if (!SWIG_IsOK(res1)) {

17395

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_AutoCompGetCurrent" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17396

}

17397

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17398

{

17399

PyThreadState* __tstate = wxPyBeginAllowThreads();

17400

result = (int)(arg1)->AutoCompGetCurrent();

17401

wxPyEndAllowThreads(__tstate);

17402

if (PyErr_Occurred()) SWIG_fail;

17403

}

17404

resultobj = SWIG_From_int(static_cast< int >(result));

17405

return resultobj;

17406

fail:

17407

return NULL;

17408

}

17409

17410

17411

SWIGINTERN PyObject *_wrap_StyledTextCtrl_Allocate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17412

PyObject *resultobj = 0;

17413

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17414

int arg2 ;

17415

void *argp1 = 0 ;

17416

int res1 = 0 ;

17417

int val2 ;

17418

int ecode2 = 0 ;

17419

PyObject * obj0 = 0 ;

17420

PyObject * obj1 = 0 ;

17421

char * kwnames[] = {

17422

(char *) "self",(char *) "bytes", NULL

17423

};

17424

17425

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_Allocate",kwnames,&obj0,&obj1)) SWIG_fail;

17426

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17427

if (!SWIG_IsOK(res1)) {

17428

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_Allocate" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17429

}

17430

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17431

ecode2 = SWIG_AsVal_int(obj1, &val2);

17432

if (!SWIG_IsOK(ecode2)) {

17433

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_Allocate" "', expected argument " "2"" of type '" "int""'");

17434

}

17435

arg2 = static_cast< int >(val2);

17436

{

17437

PyThreadState* __tstate = wxPyBeginAllowThreads();

17438

(arg1)->Allocate(arg2);

17439

wxPyEndAllowThreads(__tstate);

17440

if (PyErr_Occurred()) SWIG_fail;

17441

}

17442

resultobj = SWIG_Py_Void();

17443

return resultobj;

17444

fail:

17445

return NULL;

17446

}

17447

17448

17449

SWIGINTERN PyObject *_wrap_StyledTextCtrl_FindColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17450

PyObject *resultobj = 0;

17451

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17452

int arg2 ;

17453

int arg3 ;

17454

int result;

17455

void *argp1 = 0 ;

17456

int res1 = 0 ;

17457

int val2 ;

17458

int ecode2 = 0 ;

17459

int val3 ;

17460

int ecode3 = 0 ;

17461

PyObject * obj0 = 0 ;

17462

PyObject * obj1 = 0 ;

17463

PyObject * obj2 = 0 ;

17464

char * kwnames[] = {

17465

(char *) "self",(char *) "line",(char *) "column", NULL

17466

};

17467

17468

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_FindColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

17469

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17470

if (!SWIG_IsOK(res1)) {

17471

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_FindColumn" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17472

}

17473

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17474

ecode2 = SWIG_AsVal_int(obj1, &val2);

17475

if (!SWIG_IsOK(ecode2)) {

17476

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_FindColumn" "', expected argument " "2"" of type '" "int""'");

17477

}

17478

arg2 = static_cast< int >(val2);

17479

ecode3 = SWIG_AsVal_int(obj2, &val3);

17480

if (!SWIG_IsOK(ecode3)) {

17481

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_FindColumn" "', expected argument " "3"" of type '" "int""'");

17482

}

17483

arg3 = static_cast< int >(val3);

17484

{

17485

PyThreadState* __tstate = wxPyBeginAllowThreads();

17486

result = (int)(arg1)->FindColumn(arg2,arg3);

17487

wxPyEndAllowThreads(__tstate);

17488

if (PyErr_Occurred()) SWIG_fail;

17489

}

17490

resultobj = SWIG_From_int(static_cast< int >(result));

17491

return resultobj;

17492

fail:

17493

return NULL;

17494

}

17495

17496

17497

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetCaretSticky(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17498

PyObject *resultobj = 0;

17499

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17500

bool result;

17501

void *argp1 = 0 ;

17502

int res1 = 0 ;

17503

PyObject *swig_obj[1] ;

17504

17505

if (!args) SWIG_fail;

17506

swig_obj[0] = args;

17507

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17508

if (!SWIG_IsOK(res1)) {

17509

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetCaretSticky" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17510

}

17511

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17512

{

17513

PyThreadState* __tstate = wxPyBeginAllowThreads();

17514

result = (bool)(arg1)->GetCaretSticky();

17515

wxPyEndAllowThreads(__tstate);

17516

if (PyErr_Occurred()) SWIG_fail;

17517

}

17518

{

17519

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

17520

}

17521

return resultobj;

17522

fail:

17523

return NULL;

17524

}

17525

17526

17527

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetCaretSticky(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17528

PyObject *resultobj = 0;

17529

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17530

bool arg2 ;

17531

void *argp1 = 0 ;

17532

int res1 = 0 ;

17533

bool val2 ;

17534

int ecode2 = 0 ;

17535

PyObject * obj0 = 0 ;

17536

PyObject * obj1 = 0 ;

17537

char * kwnames[] = {

17538

(char *) "self",(char *) "useCaretStickyBehaviour", NULL

17539

};

17540

17541

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetCaretSticky",kwnames,&obj0,&obj1)) SWIG_fail;

17542

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17543

if (!SWIG_IsOK(res1)) {

17544

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetCaretSticky" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17545

}

17546

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17547

ecode2 = SWIG_AsVal_bool(obj1, &val2);

17548

if (!SWIG_IsOK(ecode2)) {

17549

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetCaretSticky" "', expected argument " "2"" of type '" "bool""'");

17550

}

17551

arg2 = static_cast< bool >(val2);

17552

{

17553

PyThreadState* __tstate = wxPyBeginAllowThreads();

17554

(arg1)->SetCaretSticky(arg2);

17555

wxPyEndAllowThreads(__tstate);

17556

if (PyErr_Occurred()) SWIG_fail;

17557

}

17558

resultobj = SWIG_Py_Void();

17559

return resultobj;

17560

fail:

17561

return NULL;

17562

}

17563

17564

17565

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ToggleCaretSticky(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17566

PyObject *resultobj = 0;

17567

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17568

void *argp1 = 0 ;

17569

int res1 = 0 ;

17570

PyObject *swig_obj[1] ;

17571

17572

if (!args) SWIG_fail;

17573

swig_obj[0] = args;

17574

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17575

if (!SWIG_IsOK(res1)) {

17576

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ToggleCaretSticky" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17577

}

17578

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17579

{

17580

PyThreadState* __tstate = wxPyBeginAllowThreads();

17581

(arg1)->ToggleCaretSticky();

17582

wxPyEndAllowThreads(__tstate);

17583

if (PyErr_Occurred()) SWIG_fail;

17584

}

17585

resultobj = SWIG_Py_Void();

17586

return resultobj;

17587

fail:

17588

return NULL;

17589

}

17590

17591

17592

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetPasteConvertEndings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17593

PyObject *resultobj = 0;

17594

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17595

bool arg2 ;

17596

void *argp1 = 0 ;

17597

int res1 = 0 ;

17598

bool val2 ;

17599

int ecode2 = 0 ;

17600

PyObject * obj0 = 0 ;

17601

PyObject * obj1 = 0 ;

17602

char * kwnames[] = {

17603

(char *) "self",(char *) "convert", NULL

17604

};

17605

17606

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetPasteConvertEndings",kwnames,&obj0,&obj1)) SWIG_fail;

17607

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17608

if (!SWIG_IsOK(res1)) {

17609

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetPasteConvertEndings" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17610

}

17611

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17612

ecode2 = SWIG_AsVal_bool(obj1, &val2);

17613

if (!SWIG_IsOK(ecode2)) {

17614

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetPasteConvertEndings" "', expected argument " "2"" of type '" "bool""'");

17615

}

17616

arg2 = static_cast< bool >(val2);

17617

{

17618

PyThreadState* __tstate = wxPyBeginAllowThreads();

17619

(arg1)->SetPasteConvertEndings(arg2);

17620

wxPyEndAllowThreads(__tstate);

17621

if (PyErr_Occurred()) SWIG_fail;

17622

}

17623

resultobj = SWIG_Py_Void();

17624

return resultobj;

17625

fail:

17626

return NULL;

17627

}

17628

17629

17630

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetPasteConvertEndings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17631

PyObject *resultobj = 0;

17632

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17633

bool result;

17634

void *argp1 = 0 ;

17635

int res1 = 0 ;

17636

PyObject *swig_obj[1] ;

17637

17638

if (!args) SWIG_fail;

17639

swig_obj[0] = args;

17640

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17641

if (!SWIG_IsOK(res1)) {

17642

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetPasteConvertEndings" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17643

}

17644

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17645

{

17646

PyThreadState* __tstate = wxPyBeginAllowThreads();

17647

result = (bool)(arg1)->GetPasteConvertEndings();

17648

wxPyEndAllowThreads(__tstate);

17649

if (PyErr_Occurred()) SWIG_fail;

17650

}

17651

{

17652

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

17653

}

17654

return resultobj;

17655

fail:

17656

return NULL;

17657

}

17658

17659

17660

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SelectionDuplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17661

PyObject *resultobj = 0;

17662

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17663

void *argp1 = 0 ;

17664

int res1 = 0 ;

17665

PyObject *swig_obj[1] ;

17666

17667

if (!args) SWIG_fail;

17668

swig_obj[0] = args;

17669

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17670

if (!SWIG_IsOK(res1)) {

17671

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SelectionDuplicate" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17672

}

17673

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17674

{

17675

PyThreadState* __tstate = wxPyBeginAllowThreads();

17676

(arg1)->SelectionDuplicate();

17677

wxPyEndAllowThreads(__tstate);

17678

if (PyErr_Occurred()) SWIG_fail;

17679

}

17680

resultobj = SWIG_Py_Void();

17681

return resultobj;

17682

fail:

17683

return NULL;

17684

}

17685

17686

17687

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetCaretLineBackAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17688

PyObject *resultobj = 0;

17689

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17690

int arg2 ;

17691

void *argp1 = 0 ;

17692

int res1 = 0 ;

17693

int val2 ;

17694

int ecode2 = 0 ;

17695

PyObject * obj0 = 0 ;

17696

PyObject * obj1 = 0 ;

17697

char * kwnames[] = {

17698

(char *) "self",(char *) "alpha", NULL

17699

};

17700

17701

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetCaretLineBackAlpha",kwnames,&obj0,&obj1)) SWIG_fail;

17702

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17703

if (!SWIG_IsOK(res1)) {

17704

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetCaretLineBackAlpha" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17705

}

17706

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17707

ecode2 = SWIG_AsVal_int(obj1, &val2);

17708

if (!SWIG_IsOK(ecode2)) {

17709

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetCaretLineBackAlpha" "', expected argument " "2"" of type '" "int""'");

17710

}

17711

arg2 = static_cast< int >(val2);

17712

{

17713

PyThreadState* __tstate = wxPyBeginAllowThreads();

17714

(arg1)->SetCaretLineBackAlpha(arg2);

17715

wxPyEndAllowThreads(__tstate);

17716

if (PyErr_Occurred()) SWIG_fail;

17717

}

17718

resultobj = SWIG_Py_Void();

17719

return resultobj;

17720

fail:

17721

return NULL;

17722

}

17723

17724

17725

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetCaretLineBackAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17726

PyObject *resultobj = 0;

17727

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17728

int result;

17729

void *argp1 = 0 ;

17730

int res1 = 0 ;

17731

PyObject *swig_obj[1] ;

17732

17733

if (!args) SWIG_fail;

17734

swig_obj[0] = args;

17735

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17736

if (!SWIG_IsOK(res1)) {

17737

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetCaretLineBackAlpha" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17738

}

17739

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17740

{

17741

PyThreadState* __tstate = wxPyBeginAllowThreads();

17742

result = (int)(arg1)->GetCaretLineBackAlpha();

17743

wxPyEndAllowThreads(__tstate);

17744

if (PyErr_Occurred()) SWIG_fail;

17745

}

17746

resultobj = SWIG_From_int(static_cast< int >(result));

17747

return resultobj;

17748

fail:

17749

return NULL;

17750

}

17751

17752

17753

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StartRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17754

PyObject *resultobj = 0;

17755

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17756

void *argp1 = 0 ;

17757

int res1 = 0 ;

17758

PyObject *swig_obj[1] ;

17759

17760

if (!args) SWIG_fail;

17761

swig_obj[0] = args;

17762

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17763

if (!SWIG_IsOK(res1)) {

17764

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StartRecord" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17765

}

17766

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17767

{

17768

PyThreadState* __tstate = wxPyBeginAllowThreads();

17769

(arg1)->StartRecord();

17770

wxPyEndAllowThreads(__tstate);

17771

if (PyErr_Occurred()) SWIG_fail;

17772

}

17773

resultobj = SWIG_Py_Void();

17774

return resultobj;

17775

fail:

17776

return NULL;

17777

}

17778

17779

17780

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StopRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17781

PyObject *resultobj = 0;

17782

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17783

void *argp1 = 0 ;

17784

int res1 = 0 ;

17785

PyObject *swig_obj[1] ;

17786

17787

if (!args) SWIG_fail;

17788

swig_obj[0] = args;

17789

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17790

if (!SWIG_IsOK(res1)) {

17791

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StopRecord" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17792

}

17793

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17794

{

17795

PyThreadState* __tstate = wxPyBeginAllowThreads();

17796

(arg1)->StopRecord();

17797

wxPyEndAllowThreads(__tstate);

17798

if (PyErr_Occurred()) SWIG_fail;

17799

}

17800

resultobj = SWIG_Py_Void();

17801

return resultobj;

17802

fail:

17803

return NULL;

17804

}

17805

17806

17807

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetLexer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17808

PyObject *resultobj = 0;

17809

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17810

int arg2 ;

17811

void *argp1 = 0 ;

17812

int res1 = 0 ;

17813

int val2 ;

17814

int ecode2 = 0 ;

17815

PyObject * obj0 = 0 ;

17816

PyObject * obj1 = 0 ;

17817

char * kwnames[] = {

17818

(char *) "self",(char *) "lexer", NULL

17819

};

17820

17821

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetLexer",kwnames,&obj0,&obj1)) SWIG_fail;

17822

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17823

if (!SWIG_IsOK(res1)) {

17824

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetLexer" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17825

}

17826

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17827

ecode2 = SWIG_AsVal_int(obj1, &val2);

17828

if (!SWIG_IsOK(ecode2)) {

17829

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetLexer" "', expected argument " "2"" of type '" "int""'");

17830

}

17831

arg2 = static_cast< int >(val2);

17832

{

17833

PyThreadState* __tstate = wxPyBeginAllowThreads();

17834

(arg1)->SetLexer(arg2);

17835

wxPyEndAllowThreads(__tstate);

17836

if (PyErr_Occurred()) SWIG_fail;

17837

}

17838

resultobj = SWIG_Py_Void();

17839

return resultobj;

17840

fail:

17841

return NULL;

17842

}

17843

17844

17845

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLexer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17846

PyObject *resultobj = 0;

17847

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17848

int result;

17849

void *argp1 = 0 ;

17850

int res1 = 0 ;

17851

PyObject *swig_obj[1] ;

17852

17853

if (!args) SWIG_fail;

17854

swig_obj[0] = args;

17855

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17856

if (!SWIG_IsOK(res1)) {

17857

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLexer" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17858

}

17859

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17860

{

17861

PyThreadState* __tstate = wxPyBeginAllowThreads();

17862

result = (int)(arg1)->GetLexer();

17863

wxPyEndAllowThreads(__tstate);

17864

if (PyErr_Occurred()) SWIG_fail;

17865

}

17866

resultobj = SWIG_From_int(static_cast< int >(result));

17867

return resultobj;

17868

fail:

17869

return NULL;

17870

}

17871

17872

17873

SWIGINTERN PyObject *_wrap_StyledTextCtrl_Colourise(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17874

PyObject *resultobj = 0;

17875

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17876

int arg2 ;

17877

int arg3 ;

17878

void *argp1 = 0 ;

17879

int res1 = 0 ;

17880

int val2 ;

17881

int ecode2 = 0 ;

17882

int val3 ;

17883

int ecode3 = 0 ;

17884

PyObject * obj0 = 0 ;

17885

PyObject * obj1 = 0 ;

17886

PyObject * obj2 = 0 ;

17887

char * kwnames[] = {

17888

(char *) "self",(char *) "start",(char *) "end", NULL

17889

};

17890

17891

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_Colourise",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

17892

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17893

if (!SWIG_IsOK(res1)) {

17894

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_Colourise" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17895

}

17896

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17897

ecode2 = SWIG_AsVal_int(obj1, &val2);

17898

if (!SWIG_IsOK(ecode2)) {

17899

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_Colourise" "', expected argument " "2"" of type '" "int""'");

17900

}

17901

arg2 = static_cast< int >(val2);

17902

ecode3 = SWIG_AsVal_int(obj2, &val3);

17903

if (!SWIG_IsOK(ecode3)) {

17904

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_Colourise" "', expected argument " "3"" of type '" "int""'");

17905

}

17906

arg3 = static_cast< int >(val3);

17907

{

17908

PyThreadState* __tstate = wxPyBeginAllowThreads();

17909

(arg1)->Colourise(arg2,arg3);

17910

wxPyEndAllowThreads(__tstate);

17911

if (PyErr_Occurred()) SWIG_fail;

17912

}

17913

resultobj = SWIG_Py_Void();

17914

return resultobj;

17915

fail:

17916

return NULL;

17917

}

17918

17919

17920

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetProperty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17921

PyObject *resultobj = 0;

17922

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17923

wxString *arg2 = 0 ;

17924

wxString *arg3 = 0 ;

17925

void *argp1 = 0 ;

17926

int res1 = 0 ;

17927

bool temp2 = false ;

17928

bool temp3 = false ;

17929

PyObject * obj0 = 0 ;

17930

PyObject * obj1 = 0 ;

17931

PyObject * obj2 = 0 ;

17932

char * kwnames[] = {

17933

(char *) "self",(char *) "key",(char *) "value", NULL

17934

};

17935

17936

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetProperty",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

17937

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

17938

if (!SWIG_IsOK(res1)) {

17939

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetProperty" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

17940

}

17941

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

17942

{

17943

arg2 = wxString_in_helper(obj1);

17944

if (arg2 == NULL) SWIG_fail;

17945

temp2 = true;

17946

}

17947

{

17948

arg3 = wxString_in_helper(obj2);

17949

if (arg3 == NULL) SWIG_fail;

17950

temp3 = true;

17951

}

17952

{

17953

PyThreadState* __tstate = wxPyBeginAllowThreads();

17954

(arg1)->SetProperty((wxString const &)*arg2,(wxString const &)*arg3);

17955

wxPyEndAllowThreads(__tstate);

17956

if (PyErr_Occurred()) SWIG_fail;

17957

}

17958

resultobj = SWIG_Py_Void();

17959

{

17960

if (temp2)

17961

delete arg2;

17962

}

17963

{

17964

if (temp3)

17965

delete arg3;

17966

}

17967

return resultobj;

17968

fail:

17969

{

17970

if (temp2)

17971

delete arg2;

17972

}

17973

{

17974

if (temp3)

17975

delete arg3;

17976

}

17977

return NULL;

17978

}

17979

17980

17981

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetKeyWords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17982

PyObject *resultobj = 0;

17983

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

17984

int arg2 ;

17985

wxString *arg3 = 0 ;

17986

void *argp1 = 0 ;

17987

int res1 = 0 ;

17988

int val2 ;

17989

int ecode2 = 0 ;

17990

bool temp3 = false ;

17991

PyObject * obj0 = 0 ;

17992

PyObject * obj1 = 0 ;

17993

PyObject * obj2 = 0 ;

17994

char * kwnames[] = {

17995

(char *) "self",(char *) "keywordSet",(char *) "keyWords", NULL

17996

};

17997

17998

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetKeyWords",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

17999

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18000

if (!SWIG_IsOK(res1)) {

18001

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetKeyWords" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18002

}

18003

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18004

ecode2 = SWIG_AsVal_int(obj1, &val2);

18005

if (!SWIG_IsOK(ecode2)) {

18006

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetKeyWords" "', expected argument " "2"" of type '" "int""'");

18007

}

18008

arg2 = static_cast< int >(val2);

18009

{

18010

arg3 = wxString_in_helper(obj2);

18011

if (arg3 == NULL) SWIG_fail;

18012

temp3 = true;

18013

}

18014

{

18015

PyThreadState* __tstate = wxPyBeginAllowThreads();

18016

(arg1)->SetKeyWords(arg2,(wxString const &)*arg3);

18017

wxPyEndAllowThreads(__tstate);

18018

if (PyErr_Occurred()) SWIG_fail;

18019

}

18020

resultobj = SWIG_Py_Void();

18021

{

18022

if (temp3)

18023

delete arg3;

18024

}

18025

return resultobj;

18026

fail:

18027

{

18028

if (temp3)

18029

delete arg3;

18030

}

18031

return NULL;

18032

}

18033

18034

18035

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetLexerLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18036

PyObject *resultobj = 0;

18037

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18038

wxString *arg2 = 0 ;

18039

void *argp1 = 0 ;

18040

int res1 = 0 ;

18041

bool temp2 = false ;

18042

PyObject * obj0 = 0 ;

18043

PyObject * obj1 = 0 ;

18044

char * kwnames[] = {

18045

(char *) "self",(char *) "language", NULL

18046

};

18047

18048

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetLexerLanguage",kwnames,&obj0,&obj1)) SWIG_fail;

18049

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18050

if (!SWIG_IsOK(res1)) {

18051

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetLexerLanguage" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18052

}

18053

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18054

{

18055

arg2 = wxString_in_helper(obj1);

18056

if (arg2 == NULL) SWIG_fail;

18057

temp2 = true;

18058

}

18059

{

18060

PyThreadState* __tstate = wxPyBeginAllowThreads();

18061

(arg1)->SetLexerLanguage((wxString const &)*arg2);

18062

wxPyEndAllowThreads(__tstate);

18063

if (PyErr_Occurred()) SWIG_fail;

18064

}

18065

resultobj = SWIG_Py_Void();

18066

{

18067

if (temp2)

18068

delete arg2;

18069

}

18070

return resultobj;

18071

fail:

18072

{

18073

if (temp2)

18074

delete arg2;

18075

}

18076

return NULL;

18077

}

18078

18079

18080

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetProperty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18081

PyObject *resultobj = 0;

18082

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18083

wxString *arg2 = 0 ;

18084

wxString result;

18085

void *argp1 = 0 ;

18086

int res1 = 0 ;

18087

bool temp2 = false ;

18088

PyObject * obj0 = 0 ;

18089

PyObject * obj1 = 0 ;

18090

char * kwnames[] = {

18091

(char *) "self",(char *) "key", NULL

18092

};

18093

18094

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetProperty",kwnames,&obj0,&obj1)) SWIG_fail;

18095

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18096

if (!SWIG_IsOK(res1)) {

18097

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetProperty" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18098

}

18099

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18100

{

18101

arg2 = wxString_in_helper(obj1);

18102

if (arg2 == NULL) SWIG_fail;

18103

temp2 = true;

18104

}

18105

{

18106

PyThreadState* __tstate = wxPyBeginAllowThreads();

18107

result = (arg1)->GetProperty((wxString const &)*arg2);

18108

wxPyEndAllowThreads(__tstate);

18109

if (PyErr_Occurred()) SWIG_fail;

18110

}

18111

{

18112

#if wxUSE_UNICODE

18113

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

18114

#else

18115

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

18116

#endif

18117

}

18118

{

18119

if (temp2)

18120

delete arg2;

18121

}

18122

return resultobj;

18123

fail:

18124

{

18125

if (temp2)

18126

delete arg2;

18127

}

18128

return NULL;

18129

}

18130

18131

18132

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetPropertyExpanded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18133

PyObject *resultobj = 0;

18134

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18135

wxString *arg2 = 0 ;

18136

wxString result;

18137

void *argp1 = 0 ;

18138

int res1 = 0 ;

18139

bool temp2 = false ;

18140

PyObject * obj0 = 0 ;

18141

PyObject * obj1 = 0 ;

18142

char * kwnames[] = {

18143

(char *) "self",(char *) "key", NULL

18144

};

18145

18146

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetPropertyExpanded",kwnames,&obj0,&obj1)) SWIG_fail;

18147

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18148

if (!SWIG_IsOK(res1)) {

18149

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetPropertyExpanded" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18150

}

18151

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18152

{

18153

arg2 = wxString_in_helper(obj1);

18154

if (arg2 == NULL) SWIG_fail;

18155

temp2 = true;

18156

}

18157

{

18158

PyThreadState* __tstate = wxPyBeginAllowThreads();

18159

result = (arg1)->GetPropertyExpanded((wxString const &)*arg2);

18160

wxPyEndAllowThreads(__tstate);

18161

if (PyErr_Occurred()) SWIG_fail;

18162

}

18163

{

18164

#if wxUSE_UNICODE

18165

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

18166

#else

18167

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

18168

#endif

18169

}

18170

{

18171

if (temp2)

18172

delete arg2;

18173

}

18174

return resultobj;

18175

fail:

18176

{

18177

if (temp2)

18178

delete arg2;

18179

}

18180

return NULL;

18181

}

18182

18183

18184

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetPropertyInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18185

PyObject *resultobj = 0;

18186

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18187

wxString *arg2 = 0 ;

18188

int result;

18189

void *argp1 = 0 ;

18190

int res1 = 0 ;

18191

bool temp2 = false ;

18192

PyObject * obj0 = 0 ;

18193

PyObject * obj1 = 0 ;

18194

char * kwnames[] = {

18195

(char *) "self",(char *) "key", NULL

18196

};

18197

18198

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetPropertyInt",kwnames,&obj0,&obj1)) SWIG_fail;

18199

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18200

if (!SWIG_IsOK(res1)) {

18201

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetPropertyInt" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18202

}

18203

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18204

{

18205

arg2 = wxString_in_helper(obj1);

18206

if (arg2 == NULL) SWIG_fail;

18207

temp2 = true;

18208

}

18209

{

18210

PyThreadState* __tstate = wxPyBeginAllowThreads();

18211

result = (int)(arg1)->GetPropertyInt((wxString const &)*arg2);

18212

wxPyEndAllowThreads(__tstate);

18213

if (PyErr_Occurred()) SWIG_fail;

18214

}

18215

resultobj = SWIG_From_int(static_cast< int >(result));

18216

{

18217

if (temp2)

18218

delete arg2;

18219

}

18220

return resultobj;

18221

fail:

18222

{

18223

if (temp2)

18224

delete arg2;

18225

}

18226

return NULL;

18227

}

18228

18229

18230

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetStyleBitsNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18231

PyObject *resultobj = 0;

18232

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18233

int result;

18234

void *argp1 = 0 ;

18235

int res1 = 0 ;

18236

PyObject *swig_obj[1] ;

18237

18238

if (!args) SWIG_fail;

18239

swig_obj[0] = args;

18240

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18241

if (!SWIG_IsOK(res1)) {

18242

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetStyleBitsNeeded" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18243

}

18244

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18245

{

18246

PyThreadState* __tstate = wxPyBeginAllowThreads();

18247

result = (int)(arg1)->GetStyleBitsNeeded();

18248

wxPyEndAllowThreads(__tstate);

18249

if (PyErr_Occurred()) SWIG_fail;

18250

}

18251

resultobj = SWIG_From_int(static_cast< int >(result));

18252

return resultobj;

18253

fail:

18254

return NULL;

18255

}

18256

18257

18258

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetCurrentLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18259

PyObject *resultobj = 0;

18260

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18261

int result;

18262

void *argp1 = 0 ;

18263

int res1 = 0 ;

18264

PyObject *swig_obj[1] ;

18265

18266

if (!args) SWIG_fail;

18267

swig_obj[0] = args;

18268

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18269

if (!SWIG_IsOK(res1)) {

18270

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetCurrentLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18271

}

18272

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18273

{

18274

PyThreadState* __tstate = wxPyBeginAllowThreads();

18275

result = (int)(arg1)->GetCurrentLine();

18276

wxPyEndAllowThreads(__tstate);

18277

if (PyErr_Occurred()) SWIG_fail;

18278

}

18279

resultobj = SWIG_From_int(static_cast< int >(result));

18280

return resultobj;

18281

fail:

18282

return NULL;

18283

}

18284

18285

18286

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StyleSetSpec(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18287

PyObject *resultobj = 0;

18288

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18289

int arg2 ;

18290

wxString *arg3 = 0 ;

18291

void *argp1 = 0 ;

18292

int res1 = 0 ;

18293

int val2 ;

18294

int ecode2 = 0 ;

18295

bool temp3 = false ;

18296

PyObject * obj0 = 0 ;

18297

PyObject * obj1 = 0 ;

18298

PyObject * obj2 = 0 ;

18299

char * kwnames[] = {

18300

(char *) "self",(char *) "styleNum",(char *) "spec", NULL

18301

};

18302

18303

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_StyleSetSpec",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

18304

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18305

if (!SWIG_IsOK(res1)) {

18306

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StyleSetSpec" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18307

}

18308

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18309

ecode2 = SWIG_AsVal_int(obj1, &val2);

18310

if (!SWIG_IsOK(ecode2)) {

18311

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_StyleSetSpec" "', expected argument " "2"" of type '" "int""'");

18312

}

18313

arg2 = static_cast< int >(val2);

18314

{

18315

arg3 = wxString_in_helper(obj2);

18316

if (arg3 == NULL) SWIG_fail;

18317

temp3 = true;

18318

}

18319

{

18320

PyThreadState* __tstate = wxPyBeginAllowThreads();

18321

(arg1)->StyleSetSpec(arg2,(wxString const &)*arg3);

18322

wxPyEndAllowThreads(__tstate);

18323

if (PyErr_Occurred()) SWIG_fail;

18324

}

18325

resultobj = SWIG_Py_Void();

18326

{

18327

if (temp3)

18328

delete arg3;

18329

}

18330

return resultobj;

18331

fail:

18332

{

18333

if (temp3)

18334

delete arg3;

18335

}

18336

return NULL;

18337

}

18338

18339

18340

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StyleSetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18341

PyObject *resultobj = 0;

18342

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18343

int arg2 ;

18344

wxFont *arg3 = 0 ;

18345

void *argp1 = 0 ;

18346

int res1 = 0 ;

18347

int val2 ;

18348

int ecode2 = 0 ;

18349

void *argp3 = 0 ;

18350

int res3 = 0 ;

18351

PyObject * obj0 = 0 ;

18352

PyObject * obj1 = 0 ;

18353

PyObject * obj2 = 0 ;

18354

char * kwnames[] = {

18355

(char *) "self",(char *) "styleNum",(char *) "font", NULL

18356

};

18357

18358

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_StyleSetFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

18359

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18360

if (!SWIG_IsOK(res1)) {

18361

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StyleSetFont" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18362

}

18363

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18364

ecode2 = SWIG_AsVal_int(obj1, &val2);

18365

if (!SWIG_IsOK(ecode2)) {

18366

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_StyleSetFont" "', expected argument " "2"" of type '" "int""'");

18367

}

18368

arg2 = static_cast< int >(val2);

18369

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxFont, 0 );

18370

if (!SWIG_IsOK(res3)) {

18371

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StyledTextCtrl_StyleSetFont" "', expected argument " "3"" of type '" "wxFont &""'");

18372

}

18373

if (!argp3) {

18374

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StyledTextCtrl_StyleSetFont" "', expected argument " "3"" of type '" "wxFont &""'");

18375

}

18376

arg3 = reinterpret_cast< wxFont * >(argp3);

18377

{

18378

PyThreadState* __tstate = wxPyBeginAllowThreads();

18379

(arg1)->StyleSetFont(arg2,*arg3);

18380

wxPyEndAllowThreads(__tstate);

18381

if (PyErr_Occurred()) SWIG_fail;

18382

}

18383

resultobj = SWIG_Py_Void();

18384

return resultobj;

18385

fail:

18386

return NULL;

18387

}

18388

18389

18390

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StyleSetFontAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18391

PyObject *resultobj = 0;

18392

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18393

int arg2 ;

18394

int arg3 ;

18395

wxString *arg4 = 0 ;

18396

bool arg5 ;

18397

bool arg6 ;

18398

bool arg7 ;

18399

wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;

18400

void *argp1 = 0 ;

18401

int res1 = 0 ;

18402

int val2 ;

18403

int ecode2 = 0 ;

18404

int val3 ;

18405

int ecode3 = 0 ;

18406

bool temp4 = false ;

18407

bool val5 ;

18408

int ecode5 = 0 ;

18409

bool val6 ;

18410

int ecode6 = 0 ;

18411

bool val7 ;

18412

int ecode7 = 0 ;

18413

int val8 ;

18414

int ecode8 = 0 ;

18415

PyObject * obj0 = 0 ;

18416

PyObject * obj1 = 0 ;

18417

PyObject * obj2 = 0 ;

18418

PyObject * obj3 = 0 ;

18419

PyObject * obj4 = 0 ;

18420

PyObject * obj5 = 0 ;

18421

PyObject * obj6 = 0 ;

18422

PyObject * obj7 = 0 ;

18423

char * kwnames[] = {

18424

(char *) "self",(char *) "styleNum",(char *) "size",(char *) "faceName",(char *) "bold",(char *) "italic",(char *) "underline",(char *) "encoding", NULL

18425

};

18426

18427

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO|O:StyledTextCtrl_StyleSetFontAttr",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;

18428

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18429

if (!SWIG_IsOK(res1)) {

18430

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StyleSetFontAttr" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18431

}

18432

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18433

ecode2 = SWIG_AsVal_int(obj1, &val2);

18434

if (!SWIG_IsOK(ecode2)) {

18435

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_StyleSetFontAttr" "', expected argument " "2"" of type '" "int""'");

18436

}

18437

arg2 = static_cast< int >(val2);

18438

ecode3 = SWIG_AsVal_int(obj2, &val3);

18439

if (!SWIG_IsOK(ecode3)) {

18440

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_StyleSetFontAttr" "', expected argument " "3"" of type '" "int""'");

18441

}

18442

arg3 = static_cast< int >(val3);

18443

{

18444

arg4 = wxString_in_helper(obj3);

18445

if (arg4 == NULL) SWIG_fail;

18446

temp4 = true;

18447

}

18448

ecode5 = SWIG_AsVal_bool(obj4, &val5);

18449

if (!SWIG_IsOK(ecode5)) {

18450

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StyledTextCtrl_StyleSetFontAttr" "', expected argument " "5"" of type '" "bool""'");

18451

}

18452

arg5 = static_cast< bool >(val5);

18453

ecode6 = SWIG_AsVal_bool(obj5, &val6);

18454

if (!SWIG_IsOK(ecode6)) {

18455

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "StyledTextCtrl_StyleSetFontAttr" "', expected argument " "6"" of type '" "bool""'");

18456

}

18457

arg6 = static_cast< bool >(val6);

18458

ecode7 = SWIG_AsVal_bool(obj6, &val7);

18459

if (!SWIG_IsOK(ecode7)) {

18460

SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "StyledTextCtrl_StyleSetFontAttr" "', expected argument " "7"" of type '" "bool""'");

18461

}

18462

arg7 = static_cast< bool >(val7);

18463

if (obj7) {

18464

ecode8 = SWIG_AsVal_int(obj7, &val8);

18465

if (!SWIG_IsOK(ecode8)) {

18466

SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "StyledTextCtrl_StyleSetFontAttr" "', expected argument " "8"" of type '" "wxFontEncoding""'");

18467

}

18468

arg8 = static_cast< wxFontEncoding >(val8);

18469

}

18470

{

18471

PyThreadState* __tstate = wxPyBeginAllowThreads();

18472

(arg1)->StyleSetFontAttr(arg2,arg3,(wxString const &)*arg4,arg5,arg6,arg7,arg8);

18473

wxPyEndAllowThreads(__tstate);

18474

if (PyErr_Occurred()) SWIG_fail;

18475

}

18476

resultobj = SWIG_Py_Void();

18477

{

18478

if (temp4)

18479

delete arg4;

18480

}

18481

return resultobj;

18482

fail:

18483

{

18484

if (temp4)

18485

delete arg4;

18486

}

18487

return NULL;

18488

}

18489

18490

18491

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StyleSetCharacterSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18492

PyObject *resultobj = 0;

18493

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18494

int arg2 ;

18495

int arg3 ;

18496

void *argp1 = 0 ;

18497

int res1 = 0 ;

18498

int val2 ;

18499

int ecode2 = 0 ;

18500

int val3 ;

18501

int ecode3 = 0 ;

18502

PyObject * obj0 = 0 ;

18503

PyObject * obj1 = 0 ;

18504

PyObject * obj2 = 0 ;

18505

char * kwnames[] = {

18506

(char *) "self",(char *) "style",(char *) "characterSet", NULL

18507

};

18508

18509

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_StyleSetCharacterSet",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

18510

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18511

if (!SWIG_IsOK(res1)) {

18512

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StyleSetCharacterSet" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18513

}

18514

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18515

ecode2 = SWIG_AsVal_int(obj1, &val2);

18516

if (!SWIG_IsOK(ecode2)) {

18517

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_StyleSetCharacterSet" "', expected argument " "2"" of type '" "int""'");

18518

}

18519

arg2 = static_cast< int >(val2);

18520

ecode3 = SWIG_AsVal_int(obj2, &val3);

18521

if (!SWIG_IsOK(ecode3)) {

18522

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_StyleSetCharacterSet" "', expected argument " "3"" of type '" "int""'");

18523

}

18524

arg3 = static_cast< int >(val3);

18525

{

18526

PyThreadState* __tstate = wxPyBeginAllowThreads();

18527

(arg1)->StyleSetCharacterSet(arg2,arg3);

18528

wxPyEndAllowThreads(__tstate);

18529

if (PyErr_Occurred()) SWIG_fail;

18530

}

18531

resultobj = SWIG_Py_Void();

18532

return resultobj;

18533

fail:

18534

return NULL;

18535

}

18536

18537

18538

SWIGINTERN PyObject *_wrap_StyledTextCtrl_StyleSetFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18539

PyObject *resultobj = 0;

18540

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18541

int arg2 ;

18542

wxFontEncoding arg3 ;

18543

void *argp1 = 0 ;

18544

int res1 = 0 ;

18545

int val2 ;

18546

int ecode2 = 0 ;

18547

int val3 ;

18548

int ecode3 = 0 ;

18549

PyObject * obj0 = 0 ;

18550

PyObject * obj1 = 0 ;

18551

PyObject * obj2 = 0 ;

18552

char * kwnames[] = {

18553

(char *) "self",(char *) "style",(char *) "encoding", NULL

18554

};

18555

18556

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_StyleSetFontEncoding",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

18557

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18558

if (!SWIG_IsOK(res1)) {

18559

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_StyleSetFontEncoding" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18560

}

18561

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18562

ecode2 = SWIG_AsVal_int(obj1, &val2);

18563

if (!SWIG_IsOK(ecode2)) {

18564

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_StyleSetFontEncoding" "', expected argument " "2"" of type '" "int""'");

18565

}

18566

arg2 = static_cast< int >(val2);

18567

ecode3 = SWIG_AsVal_int(obj2, &val3);

18568

if (!SWIG_IsOK(ecode3)) {

18569

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_StyleSetFontEncoding" "', expected argument " "3"" of type '" "wxFontEncoding""'");

18570

}

18571

arg3 = static_cast< wxFontEncoding >(val3);

18572

{

18573

PyThreadState* __tstate = wxPyBeginAllowThreads();

18574

(arg1)->StyleSetFontEncoding(arg2,arg3);

18575

wxPyEndAllowThreads(__tstate);

18576

if (PyErr_Occurred()) SWIG_fail;

18577

}

18578

resultobj = SWIG_Py_Void();

18579

return resultobj;

18580

fail:

18581

return NULL;

18582

}

18583

18584

18585

SWIGINTERN PyObject *_wrap_StyledTextCtrl_CmdKeyExecute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18586

PyObject *resultobj = 0;

18587

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18588

int arg2 ;

18589

void *argp1 = 0 ;

18590

int res1 = 0 ;

18591

int val2 ;

18592

int ecode2 = 0 ;

18593

PyObject * obj0 = 0 ;

18594

PyObject * obj1 = 0 ;

18595

char * kwnames[] = {

18596

(char *) "self",(char *) "cmd", NULL

18597

};

18598

18599

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_CmdKeyExecute",kwnames,&obj0,&obj1)) SWIG_fail;

18600

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18601

if (!SWIG_IsOK(res1)) {

18602

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_CmdKeyExecute" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18603

}

18604

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18605

ecode2 = SWIG_AsVal_int(obj1, &val2);

18606

if (!SWIG_IsOK(ecode2)) {

18607

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_CmdKeyExecute" "', expected argument " "2"" of type '" "int""'");

18608

}

18609

arg2 = static_cast< int >(val2);

18610

{

18611

PyThreadState* __tstate = wxPyBeginAllowThreads();

18612

(arg1)->CmdKeyExecute(arg2);

18613

wxPyEndAllowThreads(__tstate);

18614

if (PyErr_Occurred()) SWIG_fail;

18615

}

18616

resultobj = SWIG_Py_Void();

18617

return resultobj;

18618

fail:

18619

return NULL;

18620

}

18621

18622

18623

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18624

PyObject *resultobj = 0;

18625

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18626

int arg2 ;

18627

int arg3 ;

18628

void *argp1 = 0 ;

18629

int res1 = 0 ;

18630

int val2 ;

18631

int ecode2 = 0 ;

18632

int val3 ;

18633

int ecode3 = 0 ;

18634

PyObject * obj0 = 0 ;

18635

PyObject * obj1 = 0 ;

18636

PyObject * obj2 = 0 ;

18637

char * kwnames[] = {

18638

(char *) "self",(char *) "left",(char *) "right", NULL

18639

};

18640

18641

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

18642

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18643

if (!SWIG_IsOK(res1)) {

18644

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetMargins" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18645

}

18646

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18647

ecode2 = SWIG_AsVal_int(obj1, &val2);

18648

if (!SWIG_IsOK(ecode2)) {

18649

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetMargins" "', expected argument " "2"" of type '" "int""'");

18650

}

18651

arg2 = static_cast< int >(val2);

18652

ecode3 = SWIG_AsVal_int(obj2, &val3);

18653

if (!SWIG_IsOK(ecode3)) {

18654

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_SetMargins" "', expected argument " "3"" of type '" "int""'");

18655

}

18656

arg3 = static_cast< int >(val3);

18657

{

18658

PyThreadState* __tstate = wxPyBeginAllowThreads();

18659

(arg1)->SetMargins(arg2,arg3);

18660

wxPyEndAllowThreads(__tstate);

18661

if (PyErr_Occurred()) SWIG_fail;

18662

}

18663

resultobj = SWIG_Py_Void();

18664

return resultobj;

18665

fail:

18666

return NULL;

18667

}

18668

18669

18670

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18671

PyObject *resultobj = 0;

18672

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18673

int *arg2 = (int *) 0 ;

18674

int *arg3 = (int *) 0 ;

18675

void *argp1 = 0 ;

18676

int res1 = 0 ;

18677

int temp2 ;

18678

int res2 = SWIG_TMPOBJ ;

18679

int temp3 ;

18680

int res3 = SWIG_TMPOBJ ;

18681

PyObject *swig_obj[1] ;

18682

18683

arg2 = &temp2;

18684

arg3 = &temp3;

18685

if (!args) SWIG_fail;

18686

swig_obj[0] = args;

18687

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18688

if (!SWIG_IsOK(res1)) {

18689

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetSelection" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18690

}

18691

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18692

{

18693

PyThreadState* __tstate = wxPyBeginAllowThreads();

18694

(arg1)->GetSelection(arg2,arg3);

18695

wxPyEndAllowThreads(__tstate);

18696

if (PyErr_Occurred()) SWIG_fail;

18697

}

18698

resultobj = SWIG_Py_Void();

18699

if (SWIG_IsTmpObj(res2)) {

18700

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));

18701

} else {

18702

int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

18703

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));

18704

}

18705

if (SWIG_IsTmpObj(res3)) {

18706

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));

18707

} else {

18708

int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

18709

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));

18710

}

18711

return resultobj;

18712

fail:

18713

return NULL;

18714

}

18715

18716

18717

SWIGINTERN PyObject *_wrap_StyledTextCtrl_PointFromPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18718

PyObject *resultobj = 0;

18719

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18720

int arg2 ;

18721

wxPoint result;

18722

void *argp1 = 0 ;

18723

int res1 = 0 ;

18724

int val2 ;

18725

int ecode2 = 0 ;

18726

PyObject * obj0 = 0 ;

18727

PyObject * obj1 = 0 ;

18728

char * kwnames[] = {

18729

(char *) "self",(char *) "pos", NULL

18730

};

18731

18732

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_PointFromPosition",kwnames,&obj0,&obj1)) SWIG_fail;

18733

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18734

if (!SWIG_IsOK(res1)) {

18735

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_PointFromPosition" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18736

}

18737

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18738

ecode2 = SWIG_AsVal_int(obj1, &val2);

18739

if (!SWIG_IsOK(ecode2)) {

18740

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_PointFromPosition" "', expected argument " "2"" of type '" "int""'");

18741

}

18742

arg2 = static_cast< int >(val2);

18743

{

18744

PyThreadState* __tstate = wxPyBeginAllowThreads();

18745

result = (arg1)->PointFromPosition(arg2);

18746

wxPyEndAllowThreads(__tstate);

18747

if (PyErr_Occurred()) SWIG_fail;

18748

}

18749

resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );

18750

return resultobj;

18751

fail:

18752

return NULL;

18753

}

18754

18755

18756

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ScrollToLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18757

PyObject *resultobj = 0;

18758

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18759

int arg2 ;

18760

void *argp1 = 0 ;

18761

int res1 = 0 ;

18762

int val2 ;

18763

int ecode2 = 0 ;

18764

PyObject * obj0 = 0 ;

18765

PyObject * obj1 = 0 ;

18766

char * kwnames[] = {

18767

(char *) "self",(char *) "line", NULL

18768

};

18769

18770

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_ScrollToLine",kwnames,&obj0,&obj1)) SWIG_fail;

18771

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18772

if (!SWIG_IsOK(res1)) {

18773

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ScrollToLine" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18774

}

18775

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18776

ecode2 = SWIG_AsVal_int(obj1, &val2);

18777

if (!SWIG_IsOK(ecode2)) {

18778

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_ScrollToLine" "', expected argument " "2"" of type '" "int""'");

18779

}

18780

arg2 = static_cast< int >(val2);

18781

{

18782

PyThreadState* __tstate = wxPyBeginAllowThreads();

18783

(arg1)->ScrollToLine(arg2);

18784

wxPyEndAllowThreads(__tstate);

18785

if (PyErr_Occurred()) SWIG_fail;

18786

}

18787

resultobj = SWIG_Py_Void();

18788

return resultobj;

18789

fail:

18790

return NULL;

18791

}

18792

18793

18794

SWIGINTERN PyObject *_wrap_StyledTextCtrl_ScrollToColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18795

PyObject *resultobj = 0;

18796

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18797

int arg2 ;

18798

void *argp1 = 0 ;

18799

int res1 = 0 ;

18800

int val2 ;

18801

int ecode2 = 0 ;

18802

PyObject * obj0 = 0 ;

18803

PyObject * obj1 = 0 ;

18804

char * kwnames[] = {

18805

(char *) "self",(char *) "column", NULL

18806

};

18807

18808

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_ScrollToColumn",kwnames,&obj0,&obj1)) SWIG_fail;

18809

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18810

if (!SWIG_IsOK(res1)) {

18811

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_ScrollToColumn" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18812

}

18813

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18814

ecode2 = SWIG_AsVal_int(obj1, &val2);

18815

if (!SWIG_IsOK(ecode2)) {

18816

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_ScrollToColumn" "', expected argument " "2"" of type '" "int""'");

18817

}

18818

arg2 = static_cast< int >(val2);

18819

{

18820

PyThreadState* __tstate = wxPyBeginAllowThreads();

18821

(arg1)->ScrollToColumn(arg2);

18822

wxPyEndAllowThreads(__tstate);

18823

if (PyErr_Occurred()) SWIG_fail;

18824

}

18825

resultobj = SWIG_Py_Void();

18826

return resultobj;

18827

fail:

18828

return NULL;

18829

}

18830

18831

18832

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SendMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18833

PyObject *resultobj = 0;

18834

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18835

int arg2 ;

18836

wxUIntPtr arg3 = (wxUIntPtr) 0 ;

18837

wxIntPtr arg4 = (wxIntPtr) 0 ;

18838

wxIntPtr result;

18839

void *argp1 = 0 ;

18840

int res1 = 0 ;

18841

int val2 ;

18842

int ecode2 = 0 ;

18843

unsigned long val3 ;

18844

int ecode3 = 0 ;

18845

void *argp4 ;

18846

int res4 = 0 ;

18847

PyObject * obj0 = 0 ;

18848

PyObject * obj1 = 0 ;

18849

PyObject * obj2 = 0 ;

18850

PyObject * obj3 = 0 ;

18851

char * kwnames[] = {

18852

(char *) "self",(char *) "msg",(char *) "wp",(char *) "lp", NULL

18853

};

18854

18855

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:StyledTextCtrl_SendMsg",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

18856

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18857

if (!SWIG_IsOK(res1)) {

18858

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SendMsg" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18859

}

18860

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18861

ecode2 = SWIG_AsVal_int(obj1, &val2);

18862

if (!SWIG_IsOK(ecode2)) {

18863

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SendMsg" "', expected argument " "2"" of type '" "int""'");

18864

}

18865

arg2 = static_cast< int >(val2);

18866

if (obj2) {

18867

ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);

18868

if (!SWIG_IsOK(ecode3)) {

18869

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_SendMsg" "', expected argument " "3"" of type '" "wxUIntPtr""'");

18870

}

18871

arg3 = static_cast< wxUIntPtr >(val3);

18872

}

18873

if (obj3) {

18874

{

18875

res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIntPtr, 0 | 0);

18876

if (!SWIG_IsOK(res4)) {

18877

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StyledTextCtrl_SendMsg" "', expected argument " "4"" of type '" "wxIntPtr""'");

18878

}

18879

if (!argp4) {

18880

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StyledTextCtrl_SendMsg" "', expected argument " "4"" of type '" "wxIntPtr""'");

18881

} else {

18882

wxIntPtr * temp = reinterpret_cast< wxIntPtr * >(argp4);

18883

arg4 = *temp;

18884

if (SWIG_IsNewObj(res4)) delete temp;

18885

}

18886

}

18887

}

18888

{

18889

PyThreadState* __tstate = wxPyBeginAllowThreads();

18890

result = (arg1)->SendMsg(arg2,arg3,arg4);

18891

wxPyEndAllowThreads(__tstate);

18892

if (PyErr_Occurred()) SWIG_fail;

18893

}

18894

resultobj = SWIG_NewPointerObj((new wxIntPtr(static_cast< const wxIntPtr& >(result))), SWIGTYPE_p_wxIntPtr, SWIG_POINTER_OWN | 0 );

18895

return resultobj;

18896

fail:

18897

return NULL;

18898

}

18899

18900

18901

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetVScrollBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18902

PyObject *resultobj = 0;

18903

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18904

wxScrollBar *arg2 = (wxScrollBar *) 0 ;

18905

void *argp1 = 0 ;

18906

int res1 = 0 ;

18907

void *argp2 = 0 ;

18908

int res2 = 0 ;

18909

PyObject * obj0 = 0 ;

18910

PyObject * obj1 = 0 ;

18911

char * kwnames[] = {

18912

(char *) "self",(char *) "bar", NULL

18913

};

18914

18915

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetVScrollBar",kwnames,&obj0,&obj1)) SWIG_fail;

18916

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18917

if (!SWIG_IsOK(res1)) {

18918

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetVScrollBar" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18919

}

18920

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18921

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxScrollBar, 0 | 0 );

18922

if (!SWIG_IsOK(res2)) {

18923

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyledTextCtrl_SetVScrollBar" "', expected argument " "2"" of type '" "wxScrollBar *""'");

18924

}

18925

arg2 = reinterpret_cast< wxScrollBar * >(argp2);

18926

{

18927

PyThreadState* __tstate = wxPyBeginAllowThreads();

18928

(arg1)->SetVScrollBar(arg2);

18929

wxPyEndAllowThreads(__tstate);

18930

if (PyErr_Occurred()) SWIG_fail;

18931

}

18932

resultobj = SWIG_Py_Void();

18933

return resultobj;

18934

fail:

18935

return NULL;

18936

}

18937

18938

18939

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetHScrollBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18940

PyObject *resultobj = 0;

18941

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18942

wxScrollBar *arg2 = (wxScrollBar *) 0 ;

18943

void *argp1 = 0 ;

18944

int res1 = 0 ;

18945

void *argp2 = 0 ;

18946

int res2 = 0 ;

18947

PyObject * obj0 = 0 ;

18948

PyObject * obj1 = 0 ;

18949

char * kwnames[] = {

18950

(char *) "self",(char *) "bar", NULL

18951

};

18952

18953

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetHScrollBar",kwnames,&obj0,&obj1)) SWIG_fail;

18954

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18955

if (!SWIG_IsOK(res1)) {

18956

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetHScrollBar" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18957

}

18958

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18959

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxScrollBar, 0 | 0 );

18960

if (!SWIG_IsOK(res2)) {

18961

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyledTextCtrl_SetHScrollBar" "', expected argument " "2"" of type '" "wxScrollBar *""'");

18962

}

18963

arg2 = reinterpret_cast< wxScrollBar * >(argp2);

18964

{

18965

PyThreadState* __tstate = wxPyBeginAllowThreads();

18966

(arg1)->SetHScrollBar(arg2);

18967

wxPyEndAllowThreads(__tstate);

18968

if (PyErr_Occurred()) SWIG_fail;

18969

}

18970

resultobj = SWIG_Py_Void();

18971

return resultobj;

18972

fail:

18973

return NULL;

18974

}

18975

18976

18977

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLastKeydownProcessed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18978

PyObject *resultobj = 0;

18979

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

18980

bool result;

18981

void *argp1 = 0 ;

18982

int res1 = 0 ;

18983

PyObject *swig_obj[1] ;

18984

18985

if (!args) SWIG_fail;

18986

swig_obj[0] = args;

18987

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

18988

if (!SWIG_IsOK(res1)) {

18989

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLastKeydownProcessed" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

18990

}

18991

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

18992

{

18993

PyThreadState* __tstate = wxPyBeginAllowThreads();

18994

result = (bool)(arg1)->GetLastKeydownProcessed();

18995

wxPyEndAllowThreads(__tstate);

18996

if (PyErr_Occurred()) SWIG_fail;

18997

}

18998

{

18999

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19000

}

19001

return resultobj;

19002

fail:

19003

return NULL;

19004

}

19005

19006

19007

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetLastKeydownProcessed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19008

PyObject *resultobj = 0;

19009

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19010

bool arg2 ;

19011

void *argp1 = 0 ;

19012

int res1 = 0 ;

19013

bool val2 ;

19014

int ecode2 = 0 ;

19015

PyObject * obj0 = 0 ;

19016

PyObject * obj1 = 0 ;

19017

char * kwnames[] = {

19018

(char *) "self",(char *) "val", NULL

19019

};

19020

19021

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetLastKeydownProcessed",kwnames,&obj0,&obj1)) SWIG_fail;

19022

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19023

if (!SWIG_IsOK(res1)) {

19024

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetLastKeydownProcessed" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19025

}

19026

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19027

ecode2 = SWIG_AsVal_bool(obj1, &val2);

19028

if (!SWIG_IsOK(ecode2)) {

19029

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetLastKeydownProcessed" "', expected argument " "2"" of type '" "bool""'");

19030

}

19031

arg2 = static_cast< bool >(val2);

19032

{

19033

PyThreadState* __tstate = wxPyBeginAllowThreads();

19034

(arg1)->SetLastKeydownProcessed(arg2);

19035

wxPyEndAllowThreads(__tstate);

19036

if (PyErr_Occurred()) SWIG_fail;

19037

}

19038

resultobj = SWIG_Py_Void();

19039

return resultobj;

19040

fail:

19041

return NULL;

19042

}

19043

19044

19045

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19046

PyObject *resultobj = 0;

19047

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19048

wxString *arg2 = 0 ;

19049

bool result;

19050

void *argp1 = 0 ;

19051

int res1 = 0 ;

19052

bool temp2 = false ;

19053

PyObject * obj0 = 0 ;

19054

PyObject * obj1 = 0 ;

19055

char * kwnames[] = {

19056

(char *) "self",(char *) "filename", NULL

19057

};

19058

19059

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SaveFile",kwnames,&obj0,&obj1)) SWIG_fail;

19060

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19061

if (!SWIG_IsOK(res1)) {

19062

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SaveFile" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19063

}

19064

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19065

{

19066

arg2 = wxString_in_helper(obj1);

19067

if (arg2 == NULL) SWIG_fail;

19068

temp2 = true;

19069

}

19070

{

19071

PyThreadState* __tstate = wxPyBeginAllowThreads();

19072

result = (bool)(arg1)->SaveFile((wxString const &)*arg2);

19073

wxPyEndAllowThreads(__tstate);

19074

if (PyErr_Occurred()) SWIG_fail;

19075

}

19076

{

19077

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19078

}

19079

{

19080

if (temp2)

19081

delete arg2;

19082

}

19083

return resultobj;

19084

fail:

19085

{

19086

if (temp2)

19087

delete arg2;

19088

}

19089

return NULL;

19090

}

19091

19092

19093

SWIGINTERN PyObject *_wrap_StyledTextCtrl_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19094

PyObject *resultobj = 0;

19095

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19096

wxString *arg2 = 0 ;

19097

bool result;

19098

void *argp1 = 0 ;

19099

int res1 = 0 ;

19100

bool temp2 = false ;

19101

PyObject * obj0 = 0 ;

19102

PyObject * obj1 = 0 ;

19103

char * kwnames[] = {

19104

(char *) "self",(char *) "filename", NULL

19105

};

19106

19107

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_LoadFile",kwnames,&obj0,&obj1)) SWIG_fail;

19108

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19109

if (!SWIG_IsOK(res1)) {

19110

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_LoadFile" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19111

}

19112

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19113

{

19114

arg2 = wxString_in_helper(obj1);

19115

if (arg2 == NULL) SWIG_fail;

19116

temp2 = true;

19117

}

19118

{

19119

PyThreadState* __tstate = wxPyBeginAllowThreads();

19120

result = (bool)(arg1)->LoadFile((wxString const &)*arg2);

19121

wxPyEndAllowThreads(__tstate);

19122

if (PyErr_Occurred()) SWIG_fail;

19123

}

19124

{

19125

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19126

}

19127

{

19128

if (temp2)

19129

delete arg2;

19130

}

19131

return resultobj;

19132

fail:

19133

{

19134

if (temp2)

19135

delete arg2;

19136

}

19137

return NULL;

19138

}

19139

19140

19141

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DoDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19142

PyObject *resultobj = 0;

19143

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19144

int arg2 ;

19145

int arg3 ;

19146

wxDragResult arg4 ;

19147

wxDragResult result;

19148

void *argp1 = 0 ;

19149

int res1 = 0 ;

19150

int val2 ;

19151

int ecode2 = 0 ;

19152

int val3 ;

19153

int ecode3 = 0 ;

19154

int val4 ;

19155

int ecode4 = 0 ;

19156

PyObject * obj0 = 0 ;

19157

PyObject * obj1 = 0 ;

19158

PyObject * obj2 = 0 ;

19159

PyObject * obj3 = 0 ;

19160

char * kwnames[] = {

19161

(char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL

19162

};

19163

19164

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:StyledTextCtrl_DoDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

19165

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19166

if (!SWIG_IsOK(res1)) {

19167

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DoDragOver" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19168

}

19169

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19170

ecode2 = SWIG_AsVal_int(obj1, &val2);

19171

if (!SWIG_IsOK(ecode2)) {

19172

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_DoDragOver" "', expected argument " "2"" of type '" "int""'");

19173

}

19174

arg2 = static_cast< int >(val2);

19175

ecode3 = SWIG_AsVal_int(obj2, &val3);

19176

if (!SWIG_IsOK(ecode3)) {

19177

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_DoDragOver" "', expected argument " "3"" of type '" "int""'");

19178

}

19179

arg3 = static_cast< int >(val3);

19180

ecode4 = SWIG_AsVal_int(obj3, &val4);

19181

if (!SWIG_IsOK(ecode4)) {

19182

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StyledTextCtrl_DoDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");

19183

}

19184

arg4 = static_cast< wxDragResult >(val4);

19185

{

19186

PyThreadState* __tstate = wxPyBeginAllowThreads();

19187

result = (wxDragResult)(arg1)->DoDragOver(arg2,arg3,arg4);

19188

wxPyEndAllowThreads(__tstate);

19189

if (PyErr_Occurred()) SWIG_fail;

19190

}

19191

resultobj = SWIG_From_int(static_cast< int >(result));

19192

return resultobj;

19193

fail:

19194

return NULL;

19195

}

19196

19197

19198

SWIGINTERN PyObject *_wrap_StyledTextCtrl_DoDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19199

PyObject *resultobj = 0;

19200

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19201

long arg2 ;

19202

long arg3 ;

19203

wxString *arg4 = 0 ;

19204

bool result;

19205

void *argp1 = 0 ;

19206

int res1 = 0 ;

19207

long val2 ;

19208

int ecode2 = 0 ;

19209

long val3 ;

19210

int ecode3 = 0 ;

19211

bool temp4 = false ;

19212

PyObject * obj0 = 0 ;

19213

PyObject * obj1 = 0 ;

19214

PyObject * obj2 = 0 ;

19215

PyObject * obj3 = 0 ;

19216

char * kwnames[] = {

19217

(char *) "self",(char *) "x",(char *) "y",(char *) "data", NULL

19218

};

19219

19220

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:StyledTextCtrl_DoDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

19221

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19222

if (!SWIG_IsOK(res1)) {

19223

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_DoDropText" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19224

}

19225

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19226

ecode2 = SWIG_AsVal_long(obj1, &val2);

19227

if (!SWIG_IsOK(ecode2)) {

19228

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_DoDropText" "', expected argument " "2"" of type '" "long""'");

19229

}

19230

arg2 = static_cast< long >(val2);

19231

ecode3 = SWIG_AsVal_long(obj2, &val3);

19232

if (!SWIG_IsOK(ecode3)) {

19233

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_DoDropText" "', expected argument " "3"" of type '" "long""'");

19234

}

19235

arg3 = static_cast< long >(val3);

19236

{

19237

arg4 = wxString_in_helper(obj3);

19238

if (arg4 == NULL) SWIG_fail;

19239

temp4 = true;

19240

}

19241

{

19242

PyThreadState* __tstate = wxPyBeginAllowThreads();

19243

result = (bool)(arg1)->DoDropText(arg2,arg3,(wxString const &)*arg4);

19244

wxPyEndAllowThreads(__tstate);

19245

if (PyErr_Occurred()) SWIG_fail;

19246

}

19247

{

19248

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19249

}

19250

{

19251

if (temp4)

19252

delete arg4;

19253

}

19254

return resultobj;

19255

fail:

19256

{

19257

if (temp4)

19258

delete arg4;

19259

}

19260

return NULL;

19261

}

19262

19263

19264

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetUseAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19265

PyObject *resultobj = 0;

19266

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19267

bool arg2 ;

19268

void *argp1 = 0 ;

19269

int res1 = 0 ;

19270

bool val2 ;

19271

int ecode2 = 0 ;

19272

PyObject * obj0 = 0 ;

19273

PyObject * obj1 = 0 ;

19274

char * kwnames[] = {

19275

(char *) "self",(char *) "useAA", NULL

19276

};

19277

19278

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetUseAntiAliasing",kwnames,&obj0,&obj1)) SWIG_fail;

19279

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19280

if (!SWIG_IsOK(res1)) {

19281

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetUseAntiAliasing" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19282

}

19283

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19284

ecode2 = SWIG_AsVal_bool(obj1, &val2);

19285

if (!SWIG_IsOK(ecode2)) {

19286

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_SetUseAntiAliasing" "', expected argument " "2"" of type '" "bool""'");

19287

}

19288

arg2 = static_cast< bool >(val2);

19289

{

19290

PyThreadState* __tstate = wxPyBeginAllowThreads();

19291

(arg1)->SetUseAntiAliasing(arg2);

19292

wxPyEndAllowThreads(__tstate);

19293

if (PyErr_Occurred()) SWIG_fail;

19294

}

19295

resultobj = SWIG_Py_Void();

19296

return resultobj;

19297

fail:

19298

return NULL;

19299

}

19300

19301

19302

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetUseAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19303

PyObject *resultobj = 0;

19304

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19305

bool result;

19306

void *argp1 = 0 ;

19307

int res1 = 0 ;

19308

PyObject *swig_obj[1] ;

19309

19310

if (!args) SWIG_fail;

19311

swig_obj[0] = args;

19312

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19313

if (!SWIG_IsOK(res1)) {

19314

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetUseAntiAliasing" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19315

}

19316

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19317

{

19318

PyThreadState* __tstate = wxPyBeginAllowThreads();

19319

result = (bool)(arg1)->GetUseAntiAliasing();

19320

wxPyEndAllowThreads(__tstate);

19321

if (PyErr_Occurred()) SWIG_fail;

19322

}

19323

{

19324

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19325

}

19326

return resultobj;

19327

fail:

19328

return NULL;

19329

}

19330

19331

19332

SWIGINTERN PyObject *_wrap_StyledTextCtrl_AddTextRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19333

PyObject *resultobj = 0;

19334

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19335

char *arg2 = (char *) 0 ;

19336

void *argp1 = 0 ;

19337

int res1 = 0 ;

19338

int res2 ;

19339

char *buf2 = 0 ;

19340

int alloc2 = 0 ;

19341

PyObject * obj0 = 0 ;

19342

PyObject * obj1 = 0 ;

19343

char * kwnames[] = {

19344

(char *) "self",(char *) "text", NULL

19345

};

19346

19347

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_AddTextRaw",kwnames,&obj0,&obj1)) SWIG_fail;

19348

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19349

if (!SWIG_IsOK(res1)) {

19350

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_AddTextRaw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19351

}

19352

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19353

res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);

19354

if (!SWIG_IsOK(res2)) {

19355

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyledTextCtrl_AddTextRaw" "', expected argument " "2"" of type '" "char const *""'");

19356

}

19357

arg2 = buf2;

19358

{

19359

PyThreadState* __tstate = wxPyBeginAllowThreads();

19360

(arg1)->AddTextRaw((char const *)arg2);

19361

wxPyEndAllowThreads(__tstate);

19362

if (PyErr_Occurred()) SWIG_fail;

19363

}

19364

resultobj = SWIG_Py_Void();

19365

if (alloc2 == SWIG_NEWOBJ) delete[] buf2;

19366

return resultobj;

19367

fail:

19368

if (alloc2 == SWIG_NEWOBJ) delete[] buf2;

19369

return NULL;

19370

}

19371

19372

19373

SWIGINTERN PyObject *_wrap_StyledTextCtrl_InsertTextRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19374

PyObject *resultobj = 0;

19375

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19376

int arg2 ;

19377

char *arg3 = (char *) 0 ;

19378

void *argp1 = 0 ;

19379

int res1 = 0 ;

19380

int val2 ;

19381

int ecode2 = 0 ;

19382

int res3 ;

19383

char *buf3 = 0 ;

19384

int alloc3 = 0 ;

19385

PyObject * obj0 = 0 ;

19386

PyObject * obj1 = 0 ;

19387

PyObject * obj2 = 0 ;

19388

char * kwnames[] = {

19389

(char *) "self",(char *) "pos",(char *) "text", NULL

19390

};

19391

19392

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_InsertTextRaw",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

19393

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19394

if (!SWIG_IsOK(res1)) {

19395

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_InsertTextRaw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19396

}

19397

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19398

ecode2 = SWIG_AsVal_int(obj1, &val2);

19399

if (!SWIG_IsOK(ecode2)) {

19400

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_InsertTextRaw" "', expected argument " "2"" of type '" "int""'");

19401

}

19402

arg2 = static_cast< int >(val2);

19403

res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);

19404

if (!SWIG_IsOK(res3)) {

19405

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StyledTextCtrl_InsertTextRaw" "', expected argument " "3"" of type '" "char const *""'");

19406

}

19407

arg3 = buf3;

19408

{

19409

PyThreadState* __tstate = wxPyBeginAllowThreads();

19410

(arg1)->InsertTextRaw(arg2,(char const *)arg3);

19411

wxPyEndAllowThreads(__tstate);

19412

if (PyErr_Occurred()) SWIG_fail;

19413

}

19414

resultobj = SWIG_Py_Void();

19415

if (alloc3 == SWIG_NEWOBJ) delete[] buf3;

19416

return resultobj;

19417

fail:

19418

if (alloc3 == SWIG_NEWOBJ) delete[] buf3;

19419

return NULL;

19420

}

19421

19422

19423

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetCurLineRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19424

PyObject *resultobj = 0;

19425

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19426

int *arg2 = (int *) 0 ;

19427

wxCharBuffer result;

19428

void *argp1 = 0 ;

19429

int res1 = 0 ;

19430

int temp2 ;

19431

int res2 = SWIG_TMPOBJ ;

19432

PyObject *swig_obj[1] ;

19433

19434

arg2 = &temp2;

19435

if (!args) SWIG_fail;

19436

swig_obj[0] = args;

19437

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19438

if (!SWIG_IsOK(res1)) {

19439

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetCurLineRaw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19440

}

19441

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19442

{

19443

PyThreadState* __tstate = wxPyBeginAllowThreads();

19444

result = (arg1)->GetCurLineRaw(arg2);

19445

wxPyEndAllowThreads(__tstate);

19446

if (PyErr_Occurred()) SWIG_fail;

19447

}

19448

{

19449

if ((&result)->data())

19450

resultobj = PyString_FromString((char*)(&result)->data());

19451

else

19452

resultobj = PyString_FromString("");

19453

}

19454

if (SWIG_IsTmpObj(res2)) {

19455

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));

19456

} else {

19457

int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

19458

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));

19459

}

19460

return resultobj;

19461

fail:

19462

return NULL;

19463

}

19464

19465

19466

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetLineRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19467

PyObject *resultobj = 0;

19468

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19469

int arg2 ;

19470

wxCharBuffer result;

19471

void *argp1 = 0 ;

19472

int res1 = 0 ;

19473

int val2 ;

19474

int ecode2 = 0 ;

19475

PyObject * obj0 = 0 ;

19476

PyObject * obj1 = 0 ;

19477

char * kwnames[] = {

19478

(char *) "self",(char *) "line", NULL

19479

};

19480

19481

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_GetLineRaw",kwnames,&obj0,&obj1)) SWIG_fail;

19482

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19483

if (!SWIG_IsOK(res1)) {

19484

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetLineRaw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19485

}

19486

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19487

ecode2 = SWIG_AsVal_int(obj1, &val2);

19488

if (!SWIG_IsOK(ecode2)) {

19489

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetLineRaw" "', expected argument " "2"" of type '" "int""'");

19490

}

19491

arg2 = static_cast< int >(val2);

19492

{

19493

PyThreadState* __tstate = wxPyBeginAllowThreads();

19494

result = (arg1)->GetLineRaw(arg2);

19495

wxPyEndAllowThreads(__tstate);

19496

if (PyErr_Occurred()) SWIG_fail;

19497

}

19498

{

19499

if ((&result)->data())

19500

resultobj = PyString_FromString((char*)(&result)->data());

19501

else

19502

resultobj = PyString_FromString("");

19503

}

19504

return resultobj;

19505

fail:

19506

return NULL;

19507

}

19508

19509

19510

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetSelectedTextRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19511

PyObject *resultobj = 0;

19512

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19513

wxCharBuffer result;

19514

void *argp1 = 0 ;

19515

int res1 = 0 ;

19516

PyObject *swig_obj[1] ;

19517

19518

if (!args) SWIG_fail;

19519

swig_obj[0] = args;

19520

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19521

if (!SWIG_IsOK(res1)) {

19522

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetSelectedTextRaw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19523

}

19524

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19525

{

19526

PyThreadState* __tstate = wxPyBeginAllowThreads();

19527

result = (arg1)->GetSelectedTextRaw();

19528

wxPyEndAllowThreads(__tstate);

19529

if (PyErr_Occurred()) SWIG_fail;

19530

}

19531

{

19532

if ((&result)->data())

19533

resultobj = PyString_FromString((char*)(&result)->data());

19534

else

19535

resultobj = PyString_FromString("");

19536

}

19537

return resultobj;

19538

fail:

19539

return NULL;

19540

}

19541

19542

19543

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetTextRangeRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19544

PyObject *resultobj = 0;

19545

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19546

int arg2 ;

19547

int arg3 ;

19548

wxCharBuffer result;

19549

void *argp1 = 0 ;

19550

int res1 = 0 ;

19551

int val2 ;

19552

int ecode2 = 0 ;

19553

int val3 ;

19554

int ecode3 = 0 ;

19555

PyObject * obj0 = 0 ;

19556

PyObject * obj1 = 0 ;

19557

PyObject * obj2 = 0 ;

19558

char * kwnames[] = {

19559

(char *) "self",(char *) "startPos",(char *) "endPos", NULL

19560

};

19561

19562

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:StyledTextCtrl_GetTextRangeRaw",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

19563

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19564

if (!SWIG_IsOK(res1)) {

19565

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetTextRangeRaw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19566

}

19567

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19568

ecode2 = SWIG_AsVal_int(obj1, &val2);

19569

if (!SWIG_IsOK(ecode2)) {

19570

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextCtrl_GetTextRangeRaw" "', expected argument " "2"" of type '" "int""'");

19571

}

19572

arg2 = static_cast< int >(val2);

19573

ecode3 = SWIG_AsVal_int(obj2, &val3);

19574

if (!SWIG_IsOK(ecode3)) {

19575

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StyledTextCtrl_GetTextRangeRaw" "', expected argument " "3"" of type '" "int""'");

19576

}

19577

arg3 = static_cast< int >(val3);

19578

{

19579

PyThreadState* __tstate = wxPyBeginAllowThreads();

19580

result = (arg1)->GetTextRangeRaw(arg2,arg3);

19581

wxPyEndAllowThreads(__tstate);

19582

if (PyErr_Occurred()) SWIG_fail;

19583

}

19584

{

19585

if ((&result)->data())

19586

resultobj = PyString_FromString((char*)(&result)->data());

19587

else

19588

resultobj = PyString_FromString("");

19589

}

19590

return resultobj;

19591

fail:

19592

return NULL;

19593

}

19594

19595

19596

SWIGINTERN PyObject *_wrap_StyledTextCtrl_SetTextRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19597

PyObject *resultobj = 0;

19598

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19599

char *arg2 = (char *) 0 ;

19600

void *argp1 = 0 ;

19601

int res1 = 0 ;

19602

int res2 ;

19603

char *buf2 = 0 ;

19604

int alloc2 = 0 ;

19605

PyObject * obj0 = 0 ;

19606

PyObject * obj1 = 0 ;

19607

char * kwnames[] = {

19608

(char *) "self",(char *) "text", NULL

19609

};

19610

19611

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_SetTextRaw",kwnames,&obj0,&obj1)) SWIG_fail;

19612

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19613

if (!SWIG_IsOK(res1)) {

19614

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_SetTextRaw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19615

}

19616

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19617

res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);

19618

if (!SWIG_IsOK(res2)) {

19619

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyledTextCtrl_SetTextRaw" "', expected argument " "2"" of type '" "char const *""'");

19620

}

19621

arg2 = buf2;

19622

{

19623

PyThreadState* __tstate = wxPyBeginAllowThreads();

19624

(arg1)->SetTextRaw((char const *)arg2);

19625

wxPyEndAllowThreads(__tstate);

19626

if (PyErr_Occurred()) SWIG_fail;

19627

}

19628

resultobj = SWIG_Py_Void();

19629

if (alloc2 == SWIG_NEWOBJ) delete[] buf2;

19630

return resultobj;

19631

fail:

19632

if (alloc2 == SWIG_NEWOBJ) delete[] buf2;

19633

return NULL;

19634

}

19635

19636

19637

SWIGINTERN PyObject *_wrap_StyledTextCtrl_GetTextRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19638

PyObject *resultobj = 0;

19639

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19640

wxCharBuffer result;

19641

void *argp1 = 0 ;

19642

int res1 = 0 ;

19643

PyObject *swig_obj[1] ;

19644

19645

if (!args) SWIG_fail;

19646

swig_obj[0] = args;

19647

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19648

if (!SWIG_IsOK(res1)) {

19649

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_GetTextRaw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19650

}

19651

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19652

{

19653

PyThreadState* __tstate = wxPyBeginAllowThreads();

19654

result = (arg1)->GetTextRaw();

19655

wxPyEndAllowThreads(__tstate);

19656

if (PyErr_Occurred()) SWIG_fail;

19657

}

19658

{

19659

if ((&result)->data())

19660

resultobj = PyString_FromString((char*)(&result)->data());

19661

else

19662

resultobj = PyString_FromString("");

19663

}

19664

return resultobj;

19665

fail:

19666

return NULL;

19667

}

19668

19669

19670

SWIGINTERN PyObject *_wrap_StyledTextCtrl_AppendTextRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19671

PyObject *resultobj = 0;

19672

wxStyledTextCtrl *arg1 = (wxStyledTextCtrl *) 0 ;

19673

char *arg2 = (char *) 0 ;

19674

void *argp1 = 0 ;

19675

int res1 = 0 ;

19676

int res2 ;

19677

char *buf2 = 0 ;

19678

int alloc2 = 0 ;

19679

PyObject * obj0 = 0 ;

19680

PyObject * obj1 = 0 ;

19681

char * kwnames[] = {

19682

(char *) "self",(char *) "text", NULL

19683

};

19684

19685

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextCtrl_AppendTextRaw",kwnames,&obj0,&obj1)) SWIG_fail;

19686

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextCtrl, 0 | 0 );

19687

if (!SWIG_IsOK(res1)) {

19688

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextCtrl_AppendTextRaw" "', expected argument " "1"" of type '" "wxStyledTextCtrl *""'");

19689

}

19690

arg1 = reinterpret_cast< wxStyledTextCtrl * >(argp1);

19691

res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);

19692

if (!SWIG_IsOK(res2)) {

19693

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StyledTextCtrl_AppendTextRaw" "', expected argument " "2"" of type '" "char const *""'");

19694

}

19695

arg2 = buf2;

19696

{

19697

PyThreadState* __tstate = wxPyBeginAllowThreads();

19698

(arg1)->AppendTextRaw((char const *)arg2);

19699

wxPyEndAllowThreads(__tstate);

19700

if (PyErr_Occurred()) SWIG_fail;

19701

}

19702

resultobj = SWIG_Py_Void();

19703

if (alloc2 == SWIG_NEWOBJ) delete[] buf2;

19704

return resultobj;

19705

fail:

19706

if (alloc2 == SWIG_NEWOBJ) delete[] buf2;

19707

return NULL;

19708

}

19709

19710

19711

SWIGINTERN PyObject *StyledTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19712

PyObject *obj;

19713

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

19714

SWIG_TypeNewClientData(SWIGTYPE_p_wxStyledTextCtrl, SWIG_NewClientData(obj));

19715

return SWIG_Py_Void();

19716

}

19717

19718

SWIGINTERN PyObject *StyledTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19719

return SWIG_Python_InitShadowInstance(args);

19720

}

19721

19722

SWIGINTERN PyObject *_wrap_new_StyledTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19723

PyObject *resultobj = 0;

19724

wxEventType arg1 = (wxEventType) 0 ;

19725

int arg2 = (int) 0 ;

19726

wxStyledTextEvent *result = 0 ;

19727

int val1 ;

19728

int ecode1 = 0 ;

19729

int val2 ;

19730

int ecode2 = 0 ;

19731

PyObject * obj0 = 0 ;

19732

PyObject * obj1 = 0 ;

19733

char * kwnames[] = {

19734

(char *) "commandType",(char *) "id", NULL

19735

};

19736

19737

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_StyledTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;

19738

if (obj0) {

19739

ecode1 = SWIG_AsVal_int(obj0, &val1);

19740

if (!SWIG_IsOK(ecode1)) {

19741

SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StyledTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");

19742

}

19743

arg1 = static_cast< wxEventType >(val1);

19744

}

19745

if (obj1) {

19746

ecode2 = SWIG_AsVal_int(obj1, &val2);

19747

if (!SWIG_IsOK(ecode2)) {

19748

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StyledTextEvent" "', expected argument " "2"" of type '" "int""'");

19749

}

19750

arg2 = static_cast< int >(val2);

19751

}

19752

{

19753

PyThreadState* __tstate = wxPyBeginAllowThreads();

19754

result = (wxStyledTextEvent *)new wxStyledTextEvent(arg1,arg2);

19755

wxPyEndAllowThreads(__tstate);

19756

if (PyErr_Occurred()) SWIG_fail;

19757

}

19758

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStyledTextEvent, SWIG_POINTER_NEW | 0 );

19759

return resultobj;

19760

fail:

19761

return NULL;

19762

}

19763

19764

19765

SWIGINTERN PyObject *_wrap_delete_StyledTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19766

PyObject *resultobj = 0;

19767

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

19768

void *argp1 = 0 ;

19769

int res1 = 0 ;

19770

PyObject *swig_obj[1] ;

19771

19772

if (!args) SWIG_fail;

19773

swig_obj[0] = args;

19774

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, SWIG_POINTER_DISOWN | 0 );

19775

if (!SWIG_IsOK(res1)) {

19776

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StyledTextEvent" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

19777

}

19778

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

19779

{

19780

PyThreadState* __tstate = wxPyBeginAllowThreads();

19781

delete arg1;

19782

19783

wxPyEndAllowThreads(__tstate);

19784

if (PyErr_Occurred()) SWIG_fail;

19785

}

19786

resultobj = SWIG_Py_Void();

19787

return resultobj;

19788

fail:

19789

return NULL;

19790

}

19791

19792

19793

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19794

PyObject *resultobj = 0;

19795

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

19796

int arg2 ;

19797

void *argp1 = 0 ;

19798

int res1 = 0 ;

19799

int val2 ;

19800

int ecode2 = 0 ;

19801

PyObject * obj0 = 0 ;

19802

PyObject * obj1 = 0 ;

19803

char * kwnames[] = {

19804

(char *) "self",(char *) "pos", NULL

19805

};

19806

19807

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;

19808

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

19809

if (!SWIG_IsOK(res1)) {

19810

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetPosition" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

19811

}

19812

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

19813

ecode2 = SWIG_AsVal_int(obj1, &val2);

19814

if (!SWIG_IsOK(ecode2)) {

19815

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");

19816

}

19817

arg2 = static_cast< int >(val2);

19818

{

19819

PyThreadState* __tstate = wxPyBeginAllowThreads();

19820

(arg1)->SetPosition(arg2);

19821

wxPyEndAllowThreads(__tstate);

19822

if (PyErr_Occurred()) SWIG_fail;

19823

}

19824

resultobj = SWIG_Py_Void();

19825

return resultobj;

19826

fail:

19827

return NULL;

19828

}

19829

19830

19831

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19832

PyObject *resultobj = 0;

19833

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

19834

int arg2 ;

19835

void *argp1 = 0 ;

19836

int res1 = 0 ;

19837

int val2 ;

19838

int ecode2 = 0 ;

19839

PyObject * obj0 = 0 ;

19840

PyObject * obj1 = 0 ;

19841

char * kwnames[] = {

19842

(char *) "self",(char *) "k", NULL

19843

};

19844

19845

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetKey",kwnames,&obj0,&obj1)) SWIG_fail;

19846

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

19847

if (!SWIG_IsOK(res1)) {

19848

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetKey" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

19849

}

19850

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

19851

ecode2 = SWIG_AsVal_int(obj1, &val2);

19852

if (!SWIG_IsOK(ecode2)) {

19853

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetKey" "', expected argument " "2"" of type '" "int""'");

19854

}

19855

arg2 = static_cast< int >(val2);

19856

{

19857

PyThreadState* __tstate = wxPyBeginAllowThreads();

19858

(arg1)->SetKey(arg2);

19859

wxPyEndAllowThreads(__tstate);

19860

if (PyErr_Occurred()) SWIG_fail;

19861

}

19862

resultobj = SWIG_Py_Void();

19863

return resultobj;

19864

fail:

19865

return NULL;

19866

}

19867

19868

19869

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19870

PyObject *resultobj = 0;

19871

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

19872

int arg2 ;

19873

void *argp1 = 0 ;

19874

int res1 = 0 ;

19875

int val2 ;

19876

int ecode2 = 0 ;

19877

PyObject * obj0 = 0 ;

19878

PyObject * obj1 = 0 ;

19879

char * kwnames[] = {

19880

(char *) "self",(char *) "m", NULL

19881

};

19882

19883

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetModifiers",kwnames,&obj0,&obj1)) SWIG_fail;

19884

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

19885

if (!SWIG_IsOK(res1)) {

19886

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetModifiers" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

19887

}

19888

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

19889

ecode2 = SWIG_AsVal_int(obj1, &val2);

19890

if (!SWIG_IsOK(ecode2)) {

19891

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetModifiers" "', expected argument " "2"" of type '" "int""'");

19892

}

19893

arg2 = static_cast< int >(val2);

19894

{

19895

PyThreadState* __tstate = wxPyBeginAllowThreads();

19896

(arg1)->SetModifiers(arg2);

19897

wxPyEndAllowThreads(__tstate);

19898

if (PyErr_Occurred()) SWIG_fail;

19899

}

19900

resultobj = SWIG_Py_Void();

19901

return resultobj;

19902

fail:

19903

return NULL;

19904

}

19905

19906

19907

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetModificationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19908

PyObject *resultobj = 0;

19909

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

19910

int arg2 ;

19911

void *argp1 = 0 ;

19912

int res1 = 0 ;

19913

int val2 ;

19914

int ecode2 = 0 ;

19915

PyObject * obj0 = 0 ;

19916

PyObject * obj1 = 0 ;

19917

char * kwnames[] = {

19918

(char *) "self",(char *) "t", NULL

19919

};

19920

19921

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetModificationType",kwnames,&obj0,&obj1)) SWIG_fail;

19922

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

19923

if (!SWIG_IsOK(res1)) {

19924

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetModificationType" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

19925

}

19926

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

19927

ecode2 = SWIG_AsVal_int(obj1, &val2);

19928

if (!SWIG_IsOK(ecode2)) {

19929

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetModificationType" "', expected argument " "2"" of type '" "int""'");

19930

}

19931

arg2 = static_cast< int >(val2);

19932

{

19933

PyThreadState* __tstate = wxPyBeginAllowThreads();

19934

(arg1)->SetModificationType(arg2);

19935

wxPyEndAllowThreads(__tstate);

19936

if (PyErr_Occurred()) SWIG_fail;

19937

}

19938

resultobj = SWIG_Py_Void();

19939

return resultobj;

19940

fail:

19941

return NULL;

19942

}

19943

19944

19945

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19946

PyObject *resultobj = 0;

19947

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

19948

wxString *arg2 = 0 ;

19949

void *argp1 = 0 ;

19950

int res1 = 0 ;

19951

bool temp2 = false ;

19952

PyObject * obj0 = 0 ;

19953

PyObject * obj1 = 0 ;

19954

char * kwnames[] = {

19955

(char *) "self",(char *) "t", NULL

19956

};

19957

19958

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;

19959

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

19960

if (!SWIG_IsOK(res1)) {

19961

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetText" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

19962

}

19963

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

19964

{

19965

arg2 = wxString_in_helper(obj1);

19966

if (arg2 == NULL) SWIG_fail;

19967

temp2 = true;

19968

}

19969

{

19970

PyThreadState* __tstate = wxPyBeginAllowThreads();

19971

(arg1)->SetText((wxString const &)*arg2);

19972

wxPyEndAllowThreads(__tstate);

19973

if (PyErr_Occurred()) SWIG_fail;

19974

}

19975

resultobj = SWIG_Py_Void();

19976

{

19977

if (temp2)

19978

delete arg2;

19979

}

19980

return resultobj;

19981

fail:

19982

{

19983

if (temp2)

19984

delete arg2;

19985

}

19986

return NULL;

19987

}

19988

19989

19990

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19991

PyObject *resultobj = 0;

19992

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

19993

int arg2 ;

19994

void *argp1 = 0 ;

19995

int res1 = 0 ;

19996

int val2 ;

19997

int ecode2 = 0 ;

19998

PyObject * obj0 = 0 ;

19999

PyObject * obj1 = 0 ;

20000

char * kwnames[] = {

20001

(char *) "self",(char *) "len", NULL

20002

};

20003

20004

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetLength",kwnames,&obj0,&obj1)) SWIG_fail;

20005

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20006

if (!SWIG_IsOK(res1)) {

20007

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetLength" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20008

}

20009

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20010

ecode2 = SWIG_AsVal_int(obj1, &val2);

20011

if (!SWIG_IsOK(ecode2)) {

20012

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetLength" "', expected argument " "2"" of type '" "int""'");

20013

}

20014

arg2 = static_cast< int >(val2);

20015

{

20016

PyThreadState* __tstate = wxPyBeginAllowThreads();

20017

(arg1)->SetLength(arg2);

20018

wxPyEndAllowThreads(__tstate);

20019

if (PyErr_Occurred()) SWIG_fail;

20020

}

20021

resultobj = SWIG_Py_Void();

20022

return resultobj;

20023

fail:

20024

return NULL;

20025

}

20026

20027

20028

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetLinesAdded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20029

PyObject *resultobj = 0;

20030

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20031

int arg2 ;

20032

void *argp1 = 0 ;

20033

int res1 = 0 ;

20034

int val2 ;

20035

int ecode2 = 0 ;

20036

PyObject * obj0 = 0 ;

20037

PyObject * obj1 = 0 ;

20038

char * kwnames[] = {

20039

(char *) "self",(char *) "num", NULL

20040

};

20041

20042

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetLinesAdded",kwnames,&obj0,&obj1)) SWIG_fail;

20043

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20044

if (!SWIG_IsOK(res1)) {

20045

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetLinesAdded" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20046

}

20047

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20048

ecode2 = SWIG_AsVal_int(obj1, &val2);

20049

if (!SWIG_IsOK(ecode2)) {

20050

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetLinesAdded" "', expected argument " "2"" of type '" "int""'");

20051

}

20052

arg2 = static_cast< int >(val2);

20053

{

20054

PyThreadState* __tstate = wxPyBeginAllowThreads();

20055

(arg1)->SetLinesAdded(arg2);

20056

wxPyEndAllowThreads(__tstate);

20057

if (PyErr_Occurred()) SWIG_fail;

20058

}

20059

resultobj = SWIG_Py_Void();

20060

return resultobj;

20061

fail:

20062

return NULL;

20063

}

20064

20065

20066

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20067

PyObject *resultobj = 0;

20068

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20069

int arg2 ;

20070

void *argp1 = 0 ;

20071

int res1 = 0 ;

20072

int val2 ;

20073

int ecode2 = 0 ;

20074

PyObject * obj0 = 0 ;

20075

PyObject * obj1 = 0 ;

20076

char * kwnames[] = {

20077

(char *) "self",(char *) "val", NULL

20078

};

20079

20080

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetLine",kwnames,&obj0,&obj1)) SWIG_fail;

20081

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20082

if (!SWIG_IsOK(res1)) {

20083

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetLine" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20084

}

20085

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20086

ecode2 = SWIG_AsVal_int(obj1, &val2);

20087

if (!SWIG_IsOK(ecode2)) {

20088

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetLine" "', expected argument " "2"" of type '" "int""'");

20089

}

20090

arg2 = static_cast< int >(val2);

20091

{

20092

PyThreadState* __tstate = wxPyBeginAllowThreads();

20093

(arg1)->SetLine(arg2);

20094

wxPyEndAllowThreads(__tstate);

20095

if (PyErr_Occurred()) SWIG_fail;

20096

}

20097

resultobj = SWIG_Py_Void();

20098

return resultobj;

20099

fail:

20100

return NULL;

20101

}

20102

20103

20104

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetFoldLevelNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20105

PyObject *resultobj = 0;

20106

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20107

int arg2 ;

20108

void *argp1 = 0 ;

20109

int res1 = 0 ;

20110

int val2 ;

20111

int ecode2 = 0 ;

20112

PyObject * obj0 = 0 ;

20113

PyObject * obj1 = 0 ;

20114

char * kwnames[] = {

20115

(char *) "self",(char *) "val", NULL

20116

};

20117

20118

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetFoldLevelNow",kwnames,&obj0,&obj1)) SWIG_fail;

20119

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20120

if (!SWIG_IsOK(res1)) {

20121

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetFoldLevelNow" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20122

}

20123

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20124

ecode2 = SWIG_AsVal_int(obj1, &val2);

20125

if (!SWIG_IsOK(ecode2)) {

20126

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetFoldLevelNow" "', expected argument " "2"" of type '" "int""'");

20127

}

20128

arg2 = static_cast< int >(val2);

20129

{

20130

PyThreadState* __tstate = wxPyBeginAllowThreads();

20131

(arg1)->SetFoldLevelNow(arg2);

20132

wxPyEndAllowThreads(__tstate);

20133

if (PyErr_Occurred()) SWIG_fail;

20134

}

20135

resultobj = SWIG_Py_Void();

20136

return resultobj;

20137

fail:

20138

return NULL;

20139

}

20140

20141

20142

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetFoldLevelPrev(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20143

PyObject *resultobj = 0;

20144

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20145

int arg2 ;

20146

void *argp1 = 0 ;

20147

int res1 = 0 ;

20148

int val2 ;

20149

int ecode2 = 0 ;

20150

PyObject * obj0 = 0 ;

20151

PyObject * obj1 = 0 ;

20152

char * kwnames[] = {

20153

(char *) "self",(char *) "val", NULL

20154

};

20155

20156

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetFoldLevelPrev",kwnames,&obj0,&obj1)) SWIG_fail;

20157

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20158

if (!SWIG_IsOK(res1)) {

20159

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetFoldLevelPrev" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20160

}

20161

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20162

ecode2 = SWIG_AsVal_int(obj1, &val2);

20163

if (!SWIG_IsOK(ecode2)) {

20164

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetFoldLevelPrev" "', expected argument " "2"" of type '" "int""'");

20165

}

20166

arg2 = static_cast< int >(val2);

20167

{

20168

PyThreadState* __tstate = wxPyBeginAllowThreads();

20169

(arg1)->SetFoldLevelPrev(arg2);

20170

wxPyEndAllowThreads(__tstate);

20171

if (PyErr_Occurred()) SWIG_fail;

20172

}

20173

resultobj = SWIG_Py_Void();

20174

return resultobj;

20175

fail:

20176

return NULL;

20177

}

20178

20179

20180

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20181

PyObject *resultobj = 0;

20182

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20183

int arg2 ;

20184

void *argp1 = 0 ;

20185

int res1 = 0 ;

20186

int val2 ;

20187

int ecode2 = 0 ;

20188

PyObject * obj0 = 0 ;

20189

PyObject * obj1 = 0 ;

20190

char * kwnames[] = {

20191

(char *) "self",(char *) "val", NULL

20192

};

20193

20194

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;

20195

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20196

if (!SWIG_IsOK(res1)) {

20197

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetMargin" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20198

}

20199

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20200

ecode2 = SWIG_AsVal_int(obj1, &val2);

20201

if (!SWIG_IsOK(ecode2)) {

20202

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetMargin" "', expected argument " "2"" of type '" "int""'");

20203

}

20204

arg2 = static_cast< int >(val2);

20205

{

20206

PyThreadState* __tstate = wxPyBeginAllowThreads();

20207

(arg1)->SetMargin(arg2);

20208

wxPyEndAllowThreads(__tstate);

20209

if (PyErr_Occurred()) SWIG_fail;

20210

}

20211

resultobj = SWIG_Py_Void();

20212

return resultobj;

20213

fail:

20214

return NULL;

20215

}

20216

20217

20218

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20219

PyObject *resultobj = 0;

20220

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20221

int arg2 ;

20222

void *argp1 = 0 ;

20223

int res1 = 0 ;

20224

int val2 ;

20225

int ecode2 = 0 ;

20226

PyObject * obj0 = 0 ;

20227

PyObject * obj1 = 0 ;

20228

char * kwnames[] = {

20229

(char *) "self",(char *) "val", NULL

20230

};

20231

20232

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetMessage",kwnames,&obj0,&obj1)) SWIG_fail;

20233

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20234

if (!SWIG_IsOK(res1)) {

20235

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetMessage" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20236

}

20237

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20238

ecode2 = SWIG_AsVal_int(obj1, &val2);

20239

if (!SWIG_IsOK(ecode2)) {

20240

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetMessage" "', expected argument " "2"" of type '" "int""'");

20241

}

20242

arg2 = static_cast< int >(val2);

20243

{

20244

PyThreadState* __tstate = wxPyBeginAllowThreads();

20245

(arg1)->SetMessage(arg2);

20246

wxPyEndAllowThreads(__tstate);

20247

if (PyErr_Occurred()) SWIG_fail;

20248

}

20249

resultobj = SWIG_Py_Void();

20250

return resultobj;

20251

fail:

20252

return NULL;

20253

}

20254

20255

20256

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetWParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20257

PyObject *resultobj = 0;

20258

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20259

int arg2 ;

20260

void *argp1 = 0 ;

20261

int res1 = 0 ;

20262

int val2 ;

20263

int ecode2 = 0 ;

20264

PyObject * obj0 = 0 ;

20265

PyObject * obj1 = 0 ;

20266

char * kwnames[] = {

20267

(char *) "self",(char *) "val", NULL

20268

};

20269

20270

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetWParam",kwnames,&obj0,&obj1)) SWIG_fail;

20271

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20272

if (!SWIG_IsOK(res1)) {

20273

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetWParam" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20274

}

20275

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20276

ecode2 = SWIG_AsVal_int(obj1, &val2);

20277

if (!SWIG_IsOK(ecode2)) {

20278

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetWParam" "', expected argument " "2"" of type '" "int""'");

20279

}

20280

arg2 = static_cast< int >(val2);

20281

{

20282

PyThreadState* __tstate = wxPyBeginAllowThreads();

20283

(arg1)->SetWParam(arg2);

20284

wxPyEndAllowThreads(__tstate);

20285

if (PyErr_Occurred()) SWIG_fail;

20286

}

20287

resultobj = SWIG_Py_Void();

20288

return resultobj;

20289

fail:

20290

return NULL;

20291

}

20292

20293

20294

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetLParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20295

PyObject *resultobj = 0;

20296

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20297

int arg2 ;

20298

void *argp1 = 0 ;

20299

int res1 = 0 ;

20300

int val2 ;

20301

int ecode2 = 0 ;

20302

PyObject * obj0 = 0 ;

20303

PyObject * obj1 = 0 ;

20304

char * kwnames[] = {

20305

(char *) "self",(char *) "val", NULL

20306

};

20307

20308

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetLParam",kwnames,&obj0,&obj1)) SWIG_fail;

20309

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20310

if (!SWIG_IsOK(res1)) {

20311

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetLParam" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20312

}

20313

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20314

ecode2 = SWIG_AsVal_int(obj1, &val2);

20315

if (!SWIG_IsOK(ecode2)) {

20316

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetLParam" "', expected argument " "2"" of type '" "int""'");

20317

}

20318

arg2 = static_cast< int >(val2);

20319

{

20320

PyThreadState* __tstate = wxPyBeginAllowThreads();

20321

(arg1)->SetLParam(arg2);

20322

wxPyEndAllowThreads(__tstate);

20323

if (PyErr_Occurred()) SWIG_fail;

20324

}

20325

resultobj = SWIG_Py_Void();

20326

return resultobj;

20327

fail:

20328

return NULL;

20329

}

20330

20331

20332

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetListType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20333

PyObject *resultobj = 0;

20334

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20335

int arg2 ;

20336

void *argp1 = 0 ;

20337

int res1 = 0 ;

20338

int val2 ;

20339

int ecode2 = 0 ;

20340

PyObject * obj0 = 0 ;

20341

PyObject * obj1 = 0 ;

20342

char * kwnames[] = {

20343

(char *) "self",(char *) "val", NULL

20344

};

20345

20346

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetListType",kwnames,&obj0,&obj1)) SWIG_fail;

20347

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20348

if (!SWIG_IsOK(res1)) {

20349

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetListType" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20350

}

20351

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20352

ecode2 = SWIG_AsVal_int(obj1, &val2);

20353

if (!SWIG_IsOK(ecode2)) {

20354

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetListType" "', expected argument " "2"" of type '" "int""'");

20355

}

20356

arg2 = static_cast< int >(val2);

20357

{

20358

PyThreadState* __tstate = wxPyBeginAllowThreads();

20359

(arg1)->SetListType(arg2);

20360

wxPyEndAllowThreads(__tstate);

20361

if (PyErr_Occurred()) SWIG_fail;

20362

}

20363

resultobj = SWIG_Py_Void();

20364

return resultobj;

20365

fail:

20366

return NULL;

20367

}

20368

20369

20370

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20371

PyObject *resultobj = 0;

20372

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20373

int arg2 ;

20374

void *argp1 = 0 ;

20375

int res1 = 0 ;

20376

int val2 ;

20377

int ecode2 = 0 ;

20378

PyObject * obj0 = 0 ;

20379

PyObject * obj1 = 0 ;

20380

char * kwnames[] = {

20381

(char *) "self",(char *) "val", NULL

20382

};

20383

20384

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetX",kwnames,&obj0,&obj1)) SWIG_fail;

20385

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20386

if (!SWIG_IsOK(res1)) {

20387

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetX" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20388

}

20389

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20390

ecode2 = SWIG_AsVal_int(obj1, &val2);

20391

if (!SWIG_IsOK(ecode2)) {

20392

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetX" "', expected argument " "2"" of type '" "int""'");

20393

}

20394

arg2 = static_cast< int >(val2);

20395

{

20396

PyThreadState* __tstate = wxPyBeginAllowThreads();

20397

(arg1)->SetX(arg2);

20398

wxPyEndAllowThreads(__tstate);

20399

if (PyErr_Occurred()) SWIG_fail;

20400

}

20401

resultobj = SWIG_Py_Void();

20402

return resultobj;

20403

fail:

20404

return NULL;

20405

}

20406

20407

20408

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20409

PyObject *resultobj = 0;

20410

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20411

int arg2 ;

20412

void *argp1 = 0 ;

20413

int res1 = 0 ;

20414

int val2 ;

20415

int ecode2 = 0 ;

20416

PyObject * obj0 = 0 ;

20417

PyObject * obj1 = 0 ;

20418

char * kwnames[] = {

20419

(char *) "self",(char *) "val", NULL

20420

};

20421

20422

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetY",kwnames,&obj0,&obj1)) SWIG_fail;

20423

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20424

if (!SWIG_IsOK(res1)) {

20425

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetY" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20426

}

20427

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20428

ecode2 = SWIG_AsVal_int(obj1, &val2);

20429

if (!SWIG_IsOK(ecode2)) {

20430

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetY" "', expected argument " "2"" of type '" "int""'");

20431

}

20432

arg2 = static_cast< int >(val2);

20433

{

20434

PyThreadState* __tstate = wxPyBeginAllowThreads();

20435

(arg1)->SetY(arg2);

20436

wxPyEndAllowThreads(__tstate);

20437

if (PyErr_Occurred()) SWIG_fail;

20438

}

20439

resultobj = SWIG_Py_Void();

20440

return resultobj;

20441

fail:

20442

return NULL;

20443

}

20444

20445

20446

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetDragText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20447

PyObject *resultobj = 0;

20448

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20449

wxString *arg2 = 0 ;

20450

void *argp1 = 0 ;

20451

int res1 = 0 ;

20452

bool temp2 = false ;

20453

PyObject * obj0 = 0 ;

20454

PyObject * obj1 = 0 ;

20455

char * kwnames[] = {

20456

(char *) "self",(char *) "val", NULL

20457

};

20458

20459

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetDragText",kwnames,&obj0,&obj1)) SWIG_fail;

20460

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20461

if (!SWIG_IsOK(res1)) {

20462

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetDragText" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20463

}

20464

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20465

{

20466

arg2 = wxString_in_helper(obj1);

20467

if (arg2 == NULL) SWIG_fail;

20468

temp2 = true;

20469

}

20470

{

20471

PyThreadState* __tstate = wxPyBeginAllowThreads();

20472

(arg1)->SetDragText((wxString const &)*arg2);

20473

wxPyEndAllowThreads(__tstate);

20474

if (PyErr_Occurred()) SWIG_fail;

20475

}

20476

resultobj = SWIG_Py_Void();

20477

{

20478

if (temp2)

20479

delete arg2;

20480

}

20481

return resultobj;

20482

fail:

20483

{

20484

if (temp2)

20485

delete arg2;

20486

}

20487

return NULL;

20488

}

20489

20490

20491

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetDragAllowMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20492

PyObject *resultobj = 0;

20493

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20494

bool arg2 ;

20495

void *argp1 = 0 ;

20496

int res1 = 0 ;

20497

bool val2 ;

20498

int ecode2 = 0 ;

20499

PyObject * obj0 = 0 ;

20500

PyObject * obj1 = 0 ;

20501

char * kwnames[] = {

20502

(char *) "self",(char *) "val", NULL

20503

};

20504

20505

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetDragAllowMove",kwnames,&obj0,&obj1)) SWIG_fail;

20506

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20507

if (!SWIG_IsOK(res1)) {

20508

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetDragAllowMove" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20509

}

20510

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20511

ecode2 = SWIG_AsVal_bool(obj1, &val2);

20512

if (!SWIG_IsOK(ecode2)) {

20513

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetDragAllowMove" "', expected argument " "2"" of type '" "bool""'");

20514

}

20515

arg2 = static_cast< bool >(val2);

20516

{

20517

PyThreadState* __tstate = wxPyBeginAllowThreads();

20518

(arg1)->SetDragAllowMove(arg2);

20519

wxPyEndAllowThreads(__tstate);

20520

if (PyErr_Occurred()) SWIG_fail;

20521

}

20522

resultobj = SWIG_Py_Void();

20523

return resultobj;

20524

fail:

20525

return NULL;

20526

}

20527

20528

20529

SWIGINTERN PyObject *_wrap_StyledTextEvent_SetDragResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20530

PyObject *resultobj = 0;

20531

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20532

wxDragResult arg2 ;

20533

void *argp1 = 0 ;

20534

int res1 = 0 ;

20535

int val2 ;

20536

int ecode2 = 0 ;

20537

PyObject * obj0 = 0 ;

20538

PyObject * obj1 = 0 ;

20539

char * kwnames[] = {

20540

(char *) "self",(char *) "val", NULL

20541

};

20542

20543

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StyledTextEvent_SetDragResult",kwnames,&obj0,&obj1)) SWIG_fail;

20544

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20545

if (!SWIG_IsOK(res1)) {

20546

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_SetDragResult" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

20547

}

20548

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20549

ecode2 = SWIG_AsVal_int(obj1, &val2);

20550

if (!SWIG_IsOK(ecode2)) {

20551

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StyledTextEvent_SetDragResult" "', expected argument " "2"" of type '" "wxDragResult""'");

20552

}

20553

arg2 = static_cast< wxDragResult >(val2);

20554

{

20555

PyThreadState* __tstate = wxPyBeginAllowThreads();

20556

(arg1)->SetDragResult(arg2);

20557

wxPyEndAllowThreads(__tstate);

20558

if (PyErr_Occurred()) SWIG_fail;

20559

}

20560

resultobj = SWIG_Py_Void();

20561

return resultobj;

20562

fail:

20563

return NULL;

20564

}

20565

20566

20567

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20568

PyObject *resultobj = 0;

20569

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20570

int result;

20571

void *argp1 = 0 ;

20572

int res1 = 0 ;

20573

PyObject *swig_obj[1] ;

20574

20575

if (!args) SWIG_fail;

20576

swig_obj[0] = args;

20577

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20578

if (!SWIG_IsOK(res1)) {

20579

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetPosition" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20580

}

20581

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20582

{

20583

PyThreadState* __tstate = wxPyBeginAllowThreads();

20584

result = (int)((wxStyledTextEvent const *)arg1)->GetPosition();

20585

wxPyEndAllowThreads(__tstate);

20586

if (PyErr_Occurred()) SWIG_fail;

20587

}

20588

resultobj = SWIG_From_int(static_cast< int >(result));

20589

return resultobj;

20590

fail:

20591

return NULL;

20592

}

20593

20594

20595

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20596

PyObject *resultobj = 0;

20597

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20598

int result;

20599

void *argp1 = 0 ;

20600

int res1 = 0 ;

20601

PyObject *swig_obj[1] ;

20602

20603

if (!args) SWIG_fail;

20604

swig_obj[0] = args;

20605

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20606

if (!SWIG_IsOK(res1)) {

20607

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetKey" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20608

}

20609

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20610

{

20611

PyThreadState* __tstate = wxPyBeginAllowThreads();

20612

result = (int)((wxStyledTextEvent const *)arg1)->GetKey();

20613

wxPyEndAllowThreads(__tstate);

20614

if (PyErr_Occurred()) SWIG_fail;

20615

}

20616

resultobj = SWIG_From_int(static_cast< int >(result));

20617

return resultobj;

20618

fail:

20619

return NULL;

20620

}

20621

20622

20623

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20624

PyObject *resultobj = 0;

20625

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20626

int result;

20627

void *argp1 = 0 ;

20628

int res1 = 0 ;

20629

PyObject *swig_obj[1] ;

20630

20631

if (!args) SWIG_fail;

20632

swig_obj[0] = args;

20633

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20634

if (!SWIG_IsOK(res1)) {

20635

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetModifiers" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20636

}

20637

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20638

{

20639

PyThreadState* __tstate = wxPyBeginAllowThreads();

20640

result = (int)((wxStyledTextEvent const *)arg1)->GetModifiers();

20641

wxPyEndAllowThreads(__tstate);

20642

if (PyErr_Occurred()) SWIG_fail;

20643

}

20644

resultobj = SWIG_From_int(static_cast< int >(result));

20645

return resultobj;

20646

fail:

20647

return NULL;

20648

}

20649

20650

20651

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetModificationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20652

PyObject *resultobj = 0;

20653

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20654

int result;

20655

void *argp1 = 0 ;

20656

int res1 = 0 ;

20657

PyObject *swig_obj[1] ;

20658

20659

if (!args) SWIG_fail;

20660

swig_obj[0] = args;

20661

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20662

if (!SWIG_IsOK(res1)) {

20663

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetModificationType" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20664

}

20665

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20666

{

20667

PyThreadState* __tstate = wxPyBeginAllowThreads();

20668

result = (int)((wxStyledTextEvent const *)arg1)->GetModificationType();

20669

wxPyEndAllowThreads(__tstate);

20670

if (PyErr_Occurred()) SWIG_fail;

20671

}

20672

resultobj = SWIG_From_int(static_cast< int >(result));

20673

return resultobj;

20674

fail:

20675

return NULL;

20676

}

20677

20678

20679

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20680

PyObject *resultobj = 0;

20681

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20682

wxString result;

20683

void *argp1 = 0 ;

20684

int res1 = 0 ;

20685

PyObject *swig_obj[1] ;

20686

20687

if (!args) SWIG_fail;

20688

swig_obj[0] = args;

20689

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20690

if (!SWIG_IsOK(res1)) {

20691

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetText" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20692

}

20693

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20694

{

20695

PyThreadState* __tstate = wxPyBeginAllowThreads();

20696

result = ((wxStyledTextEvent const *)arg1)->GetText();

20697

wxPyEndAllowThreads(__tstate);

20698

if (PyErr_Occurred()) SWIG_fail;

20699

}

20700

{

20701

#if wxUSE_UNICODE

20702

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

20703

#else

20704

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

20705

#endif

20706

}

20707

return resultobj;

20708

fail:

20709

return NULL;

20710

}

20711

20712

20713

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20714

PyObject *resultobj = 0;

20715

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20716

int result;

20717

void *argp1 = 0 ;

20718

int res1 = 0 ;

20719

PyObject *swig_obj[1] ;

20720

20721

if (!args) SWIG_fail;

20722

swig_obj[0] = args;

20723

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20724

if (!SWIG_IsOK(res1)) {

20725

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetLength" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20726

}

20727

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20728

{

20729

PyThreadState* __tstate = wxPyBeginAllowThreads();

20730

result = (int)((wxStyledTextEvent const *)arg1)->GetLength();

20731

wxPyEndAllowThreads(__tstate);

20732

if (PyErr_Occurred()) SWIG_fail;

20733

}

20734

resultobj = SWIG_From_int(static_cast< int >(result));

20735

return resultobj;

20736

fail:

20737

return NULL;

20738

}

20739

20740

20741

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetLinesAdded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20742

PyObject *resultobj = 0;

20743

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20744

int result;

20745

void *argp1 = 0 ;

20746

int res1 = 0 ;

20747

PyObject *swig_obj[1] ;

20748

20749

if (!args) SWIG_fail;

20750

swig_obj[0] = args;

20751

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20752

if (!SWIG_IsOK(res1)) {

20753

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetLinesAdded" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20754

}

20755

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20756

{

20757

PyThreadState* __tstate = wxPyBeginAllowThreads();

20758

result = (int)((wxStyledTextEvent const *)arg1)->GetLinesAdded();

20759

wxPyEndAllowThreads(__tstate);

20760

if (PyErr_Occurred()) SWIG_fail;

20761

}

20762

resultobj = SWIG_From_int(static_cast< int >(result));

20763

return resultobj;

20764

fail:

20765

return NULL;

20766

}

20767

20768

20769

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20770

PyObject *resultobj = 0;

20771

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20772

int result;

20773

void *argp1 = 0 ;

20774

int res1 = 0 ;

20775

PyObject *swig_obj[1] ;

20776

20777

if (!args) SWIG_fail;

20778

swig_obj[0] = args;

20779

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20780

if (!SWIG_IsOK(res1)) {

20781

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetLine" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20782

}

20783

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20784

{

20785

PyThreadState* __tstate = wxPyBeginAllowThreads();

20786

result = (int)((wxStyledTextEvent const *)arg1)->GetLine();

20787

wxPyEndAllowThreads(__tstate);

20788

if (PyErr_Occurred()) SWIG_fail;

20789

}

20790

resultobj = SWIG_From_int(static_cast< int >(result));

20791

return resultobj;

20792

fail:

20793

return NULL;

20794

}

20795

20796

20797

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetFoldLevelNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20798

PyObject *resultobj = 0;

20799

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20800

int result;

20801

void *argp1 = 0 ;

20802

int res1 = 0 ;

20803

PyObject *swig_obj[1] ;

20804

20805

if (!args) SWIG_fail;

20806

swig_obj[0] = args;

20807

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20808

if (!SWIG_IsOK(res1)) {

20809

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetFoldLevelNow" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20810

}

20811

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20812

{

20813

PyThreadState* __tstate = wxPyBeginAllowThreads();

20814

result = (int)((wxStyledTextEvent const *)arg1)->GetFoldLevelNow();

20815

wxPyEndAllowThreads(__tstate);

20816

if (PyErr_Occurred()) SWIG_fail;

20817

}

20818

resultobj = SWIG_From_int(static_cast< int >(result));

20819

return resultobj;

20820

fail:

20821

return NULL;

20822

}

20823

20824

20825

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetFoldLevelPrev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20826

PyObject *resultobj = 0;

20827

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20828

int result;

20829

void *argp1 = 0 ;

20830

int res1 = 0 ;

20831

PyObject *swig_obj[1] ;

20832

20833

if (!args) SWIG_fail;

20834

swig_obj[0] = args;

20835

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20836

if (!SWIG_IsOK(res1)) {

20837

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetFoldLevelPrev" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20838

}

20839

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20840

{

20841

PyThreadState* __tstate = wxPyBeginAllowThreads();

20842

result = (int)((wxStyledTextEvent const *)arg1)->GetFoldLevelPrev();

20843

wxPyEndAllowThreads(__tstate);

20844

if (PyErr_Occurred()) SWIG_fail;

20845

}

20846

resultobj = SWIG_From_int(static_cast< int >(result));

20847

return resultobj;

20848

fail:

20849

return NULL;

20850

}

20851

20852

20853

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20854

PyObject *resultobj = 0;

20855

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20856

int result;

20857

void *argp1 = 0 ;

20858

int res1 = 0 ;

20859

PyObject *swig_obj[1] ;

20860

20861

if (!args) SWIG_fail;

20862

swig_obj[0] = args;

20863

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20864

if (!SWIG_IsOK(res1)) {

20865

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetMargin" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20866

}

20867

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20868

{

20869

PyThreadState* __tstate = wxPyBeginAllowThreads();

20870

result = (int)((wxStyledTextEvent const *)arg1)->GetMargin();

20871

wxPyEndAllowThreads(__tstate);

20872

if (PyErr_Occurred()) SWIG_fail;

20873

}

20874

resultobj = SWIG_From_int(static_cast< int >(result));

20875

return resultobj;

20876

fail:

20877

return NULL;

20878

}

20879

20880

20881

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20882

PyObject *resultobj = 0;

20883

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20884

int result;

20885

void *argp1 = 0 ;

20886

int res1 = 0 ;

20887

PyObject *swig_obj[1] ;

20888

20889

if (!args) SWIG_fail;

20890

swig_obj[0] = args;

20891

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20892

if (!SWIG_IsOK(res1)) {

20893

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetMessage" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20894

}

20895

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20896

{

20897

PyThreadState* __tstate = wxPyBeginAllowThreads();

20898

result = (int)((wxStyledTextEvent const *)arg1)->GetMessage();

20899

wxPyEndAllowThreads(__tstate);

20900

if (PyErr_Occurred()) SWIG_fail;

20901

}

20902

resultobj = SWIG_From_int(static_cast< int >(result));

20903

return resultobj;

20904

fail:

20905

return NULL;

20906

}

20907

20908

20909

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetWParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20910

PyObject *resultobj = 0;

20911

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20912

int result;

20913

void *argp1 = 0 ;

20914

int res1 = 0 ;

20915

PyObject *swig_obj[1] ;

20916

20917

if (!args) SWIG_fail;

20918

swig_obj[0] = args;

20919

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20920

if (!SWIG_IsOK(res1)) {

20921

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetWParam" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20922

}

20923

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20924

{

20925

PyThreadState* __tstate = wxPyBeginAllowThreads();

20926

result = (int)((wxStyledTextEvent const *)arg1)->GetWParam();

20927

wxPyEndAllowThreads(__tstate);

20928

if (PyErr_Occurred()) SWIG_fail;

20929

}

20930

resultobj = SWIG_From_int(static_cast< int >(result));

20931

return resultobj;

20932

fail:

20933

return NULL;

20934

}

20935

20936

20937

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetLParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20938

PyObject *resultobj = 0;

20939

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20940

int result;

20941

void *argp1 = 0 ;

20942

int res1 = 0 ;

20943

PyObject *swig_obj[1] ;

20944

20945

if (!args) SWIG_fail;

20946

swig_obj[0] = args;

20947

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20948

if (!SWIG_IsOK(res1)) {

20949

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetLParam" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20950

}

20951

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20952

{

20953

PyThreadState* __tstate = wxPyBeginAllowThreads();

20954

result = (int)((wxStyledTextEvent const *)arg1)->GetLParam();

20955

wxPyEndAllowThreads(__tstate);

20956

if (PyErr_Occurred()) SWIG_fail;

20957

}

20958

resultobj = SWIG_From_int(static_cast< int >(result));

20959

return resultobj;

20960

fail:

20961

return NULL;

20962

}

20963

20964

20965

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetListType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20966

PyObject *resultobj = 0;

20967

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20968

int result;

20969

void *argp1 = 0 ;

20970

int res1 = 0 ;

20971

PyObject *swig_obj[1] ;

20972

20973

if (!args) SWIG_fail;

20974

swig_obj[0] = args;

20975

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

20976

if (!SWIG_IsOK(res1)) {

20977

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetListType" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

20978

}

20979

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

20980

{

20981

PyThreadState* __tstate = wxPyBeginAllowThreads();

20982

result = (int)((wxStyledTextEvent const *)arg1)->GetListType();

20983

wxPyEndAllowThreads(__tstate);

20984

if (PyErr_Occurred()) SWIG_fail;

20985

}

20986

resultobj = SWIG_From_int(static_cast< int >(result));

20987

return resultobj;

20988

fail:

20989

return NULL;

20990

}

20991

20992

20993

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20994

PyObject *resultobj = 0;

20995

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

20996

int result;

20997

void *argp1 = 0 ;

20998

int res1 = 0 ;

20999

PyObject *swig_obj[1] ;

21000

21001

if (!args) SWIG_fail;

21002

swig_obj[0] = args;

21003

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

21004

if (!SWIG_IsOK(res1)) {

21005

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetX" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

21006

}

21007

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

21008

{

21009

PyThreadState* __tstate = wxPyBeginAllowThreads();

21010

result = (int)((wxStyledTextEvent const *)arg1)->GetX();

21011

wxPyEndAllowThreads(__tstate);

21012

if (PyErr_Occurred()) SWIG_fail;

21013

}

21014

resultobj = SWIG_From_int(static_cast< int >(result));

21015

return resultobj;

21016

fail:

21017

return NULL;

21018

}

21019

21020

21021

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21022

PyObject *resultobj = 0;

21023

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

21024

int result;

21025

void *argp1 = 0 ;

21026

int res1 = 0 ;

21027

PyObject *swig_obj[1] ;

21028

21029

if (!args) SWIG_fail;

21030

swig_obj[0] = args;

21031

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

21032

if (!SWIG_IsOK(res1)) {

21033

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetY" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

21034

}

21035

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

21036

{

21037

PyThreadState* __tstate = wxPyBeginAllowThreads();

21038

result = (int)((wxStyledTextEvent const *)arg1)->GetY();

21039

wxPyEndAllowThreads(__tstate);

21040

if (PyErr_Occurred()) SWIG_fail;

21041

}

21042

resultobj = SWIG_From_int(static_cast< int >(result));

21043

return resultobj;

21044

fail:

21045

return NULL;

21046

}

21047

21048

21049

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetDragText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21050

PyObject *resultobj = 0;

21051

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

21052

wxString result;

21053

void *argp1 = 0 ;

21054

int res1 = 0 ;

21055

PyObject *swig_obj[1] ;

21056

21057

if (!args) SWIG_fail;

21058

swig_obj[0] = args;

21059

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

21060

if (!SWIG_IsOK(res1)) {

21061

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetDragText" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

21062

}

21063

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

21064

{

21065

PyThreadState* __tstate = wxPyBeginAllowThreads();

21066

result = (arg1)->GetDragText();

21067

wxPyEndAllowThreads(__tstate);

21068

if (PyErr_Occurred()) SWIG_fail;

21069

}

21070

{

21071

#if wxUSE_UNICODE

21072

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

21073

#else

21074

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

21075

#endif

21076

}

21077

return resultobj;

21078

fail:

21079

return NULL;

21080

}

21081

21082

21083

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetDragAllowMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21084

PyObject *resultobj = 0;

21085

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

21086

bool result;

21087

void *argp1 = 0 ;

21088

int res1 = 0 ;

21089

PyObject *swig_obj[1] ;

21090

21091

if (!args) SWIG_fail;

21092

swig_obj[0] = args;

21093

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

21094

if (!SWIG_IsOK(res1)) {

21095

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetDragAllowMove" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

21096

}

21097

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

21098

{

21099

PyThreadState* __tstate = wxPyBeginAllowThreads();

21100

result = (bool)(arg1)->GetDragAllowMove();

21101

wxPyEndAllowThreads(__tstate);

21102

if (PyErr_Occurred()) SWIG_fail;

21103

}

21104

{

21105

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21106

}

21107

return resultobj;

21108

fail:

21109

return NULL;

21110

}

21111

21112

21113

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetDragResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21114

PyObject *resultobj = 0;

21115

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

21116

wxDragResult result;

21117

void *argp1 = 0 ;

21118

int res1 = 0 ;

21119

PyObject *swig_obj[1] ;

21120

21121

if (!args) SWIG_fail;

21122

swig_obj[0] = args;

21123

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

21124

if (!SWIG_IsOK(res1)) {

21125

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetDragResult" "', expected argument " "1"" of type '" "wxStyledTextEvent *""'");

21126

}

21127

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

21128

{

21129

PyThreadState* __tstate = wxPyBeginAllowThreads();

21130

result = (wxDragResult)(arg1)->GetDragResult();

21131

wxPyEndAllowThreads(__tstate);

21132

if (PyErr_Occurred()) SWIG_fail;

21133

}

21134

resultobj = SWIG_From_int(static_cast< int >(result));

21135

return resultobj;

21136

fail:

21137

return NULL;

21138

}

21139

21140

21141

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetShift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21142

PyObject *resultobj = 0;

21143

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

21144

bool result;

21145

void *argp1 = 0 ;

21146

int res1 = 0 ;

21147

PyObject *swig_obj[1] ;

21148

21149

if (!args) SWIG_fail;

21150

swig_obj[0] = args;

21151

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

21152

if (!SWIG_IsOK(res1)) {

21153

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetShift" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

21154

}

21155

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

21156

{

21157

PyThreadState* __tstate = wxPyBeginAllowThreads();

21158

result = (bool)((wxStyledTextEvent const *)arg1)->GetShift();

21159

wxPyEndAllowThreads(__tstate);

21160

if (PyErr_Occurred()) SWIG_fail;

21161

}

21162

{

21163

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21164

}

21165

return resultobj;

21166

fail:

21167

return NULL;

21168

}

21169

21170

21171

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21172

PyObject *resultobj = 0;

21173

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

21174

bool result;

21175

void *argp1 = 0 ;

21176

int res1 = 0 ;

21177

PyObject *swig_obj[1] ;

21178

21179

if (!args) SWIG_fail;

21180

swig_obj[0] = args;

21181

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

21182

if (!SWIG_IsOK(res1)) {

21183

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetControl" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

21184

}

21185

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

21186

{

21187

PyThreadState* __tstate = wxPyBeginAllowThreads();

21188

result = (bool)((wxStyledTextEvent const *)arg1)->GetControl();

21189

wxPyEndAllowThreads(__tstate);

21190

if (PyErr_Occurred()) SWIG_fail;

21191

}

21192

{

21193

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21194

}

21195

return resultobj;

21196

fail:

21197

return NULL;

21198

}

21199

21200

21201

SWIGINTERN PyObject *_wrap_StyledTextEvent_GetAlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21202

PyObject *resultobj = 0;

21203

wxStyledTextEvent *arg1 = (wxStyledTextEvent *) 0 ;

21204

bool result;

21205

void *argp1 = 0 ;

21206

int res1 = 0 ;

21207

PyObject *swig_obj[1] ;

21208

21209

if (!args) SWIG_fail;

21210

swig_obj[0] = args;

21211

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStyledTextEvent, 0 | 0 );

21212

if (!SWIG_IsOK(res1)) {

21213

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StyledTextEvent_GetAlt" "', expected argument " "1"" of type '" "wxStyledTextEvent const *""'");

21214

}

21215

arg1 = reinterpret_cast< wxStyledTextEvent * >(argp1);

21216

{

21217

PyThreadState* __tstate = wxPyBeginAllowThreads();

21218

result = (bool)((wxStyledTextEvent const *)arg1)->GetAlt();

21219

wxPyEndAllowThreads(__tstate);

21220

if (PyErr_Occurred()) SWIG_fail;

21221

}

21222

{

21223

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21224

}

21225

return resultobj;

21226

fail:

21227

return NULL;

21228

}

21229

21230

21231

SWIGINTERN PyObject *StyledTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21232

PyObject *obj;

21233

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

21234

SWIG_TypeNewClientData(SWIGTYPE_p_wxStyledTextEvent, SWIG_NewClientData(obj));

21235

return SWIG_Py_Void();

21236

}

21237

21238

SWIGINTERN PyObject *StyledTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21239

return SWIG_Python_InitShadowInstance(args);

21240

}

21241

21242

static PyMethodDef SwigMethods[] = {

21243

{ (char *)"new_StyledTextCtrl", (PyCFunction) _wrap_new_StyledTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},

21244

{ (char *)"new_PreStyledTextCtrl", (PyCFunction)_wrap_new_PreStyledTextCtrl, METH_NOARGS, NULL},

21245

{ (char *)"StyledTextCtrl_Create", (PyCFunction) _wrap_StyledTextCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},

21246

{ (char *)"StyledTextCtrl_AddText", (PyCFunction) _wrap_StyledTextCtrl_AddText, METH_VARARGS | METH_KEYWORDS, NULL},

21247

{ (char *)"StyledTextCtrl_AddStyledText", (PyCFunction) _wrap_StyledTextCtrl_AddStyledText, METH_VARARGS | METH_KEYWORDS, NULL},

21248

{ (char *)"StyledTextCtrl_InsertText", (PyCFunction) _wrap_StyledTextCtrl_InsertText, METH_VARARGS | METH_KEYWORDS, NULL},

21249

{ (char *)"StyledTextCtrl_ClearAll", (PyCFunction)_wrap_StyledTextCtrl_ClearAll, METH_O, NULL},

21250

{ (char *)"StyledTextCtrl_ClearDocumentStyle", (PyCFunction)_wrap_StyledTextCtrl_ClearDocumentStyle, METH_O, NULL},

21251

{ (char *)"StyledTextCtrl_GetLength", (PyCFunction)_wrap_StyledTextCtrl_GetLength, METH_O, NULL},

21252

{ (char *)"StyledTextCtrl_GetCharAt", (PyCFunction) _wrap_StyledTextCtrl_GetCharAt, METH_VARARGS | METH_KEYWORDS, NULL},

21253

{ (char *)"StyledTextCtrl_GetCurrentPos", (PyCFunction)_wrap_StyledTextCtrl_GetCurrentPos, METH_O, NULL},

21254

{ (char *)"StyledTextCtrl_GetAnchor", (PyCFunction)_wrap_StyledTextCtrl_GetAnchor, METH_O, NULL},

21255

{ (char *)"StyledTextCtrl_GetStyleAt", (PyCFunction) _wrap_StyledTextCtrl_GetStyleAt, METH_VARARGS | METH_KEYWORDS, NULL},

21256

{ (char *)"StyledTextCtrl_Redo", (PyCFunction)_wrap_StyledTextCtrl_Redo, METH_O, NULL},

21257

{ (char *)"StyledTextCtrl_SetUndoCollection", (PyCFunction) _wrap_StyledTextCtrl_SetUndoCollection, METH_VARARGS | METH_KEYWORDS, NULL},

21258

{ (char *)"StyledTextCtrl_SelectAll", (PyCFunction)_wrap_StyledTextCtrl_SelectAll, METH_O, NULL},

21259

{ (char *)"StyledTextCtrl_SetSavePoint", (PyCFunction)_wrap_StyledTextCtrl_SetSavePoint, METH_O, NULL},

21260

{ (char *)"StyledTextCtrl_GetStyledText", (PyCFunction) _wrap_StyledTextCtrl_GetStyledText, METH_VARARGS | METH_KEYWORDS, NULL},

21261

{ (char *)"StyledTextCtrl_CanRedo", (PyCFunction)_wrap_StyledTextCtrl_CanRedo, METH_O, NULL},

21262

{ (char *)"StyledTextCtrl_MarkerLineFromHandle", (PyCFunction) _wrap_StyledTextCtrl_MarkerLineFromHandle, METH_VARARGS | METH_KEYWORDS, NULL},

21263

{ (char *)"StyledTextCtrl_MarkerDeleteHandle", (PyCFunction) _wrap_StyledTextCtrl_MarkerDeleteHandle, METH_VARARGS | METH_KEYWORDS, NULL},

21264

{ (char *)"StyledTextCtrl_GetUndoCollection", (PyCFunction)_wrap_StyledTextCtrl_GetUndoCollection, METH_O, NULL},

21265

{ (char *)"StyledTextCtrl_GetViewWhiteSpace", (PyCFunction)_wrap_StyledTextCtrl_GetViewWhiteSpace, METH_O, NULL},

21266

{ (char *)"StyledTextCtrl_SetViewWhiteSpace", (PyCFunction) _wrap_StyledTextCtrl_SetViewWhiteSpace, METH_VARARGS | METH_KEYWORDS, NULL},

21267

{ (char *)"StyledTextCtrl_PositionFromPoint", (PyCFunction) _wrap_StyledTextCtrl_PositionFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},

21268

{ (char *)"StyledTextCtrl_PositionFromPointClose", (PyCFunction) _wrap_StyledTextCtrl_PositionFromPointClose, METH_VARARGS | METH_KEYWORDS, NULL},

21269

{ (char *)"StyledTextCtrl_GotoLine", (PyCFunction) _wrap_StyledTextCtrl_GotoLine, METH_VARARGS | METH_KEYWORDS, NULL},

21270

{ (char *)"StyledTextCtrl_GotoPos", (PyCFunction) _wrap_StyledTextCtrl_GotoPos, METH_VARARGS | METH_KEYWORDS, NULL},

21271

{ (char *)"StyledTextCtrl_SetAnchor", (PyCFunction) _wrap_StyledTextCtrl_SetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},

21272

{ (char *)"StyledTextCtrl_GetCurLine", (PyCFunction)_wrap_StyledTextCtrl_GetCurLine, METH_O, NULL},

21273

{ (char *)"StyledTextCtrl_GetEndStyled", (PyCFunction)_wrap_StyledTextCtrl_GetEndStyled, METH_O, NULL},

21274

{ (char *)"StyledTextCtrl_ConvertEOLs", (PyCFunction) _wrap_StyledTextCtrl_ConvertEOLs, METH_VARARGS | METH_KEYWORDS, NULL},

21275

{ (char *)"StyledTextCtrl_GetEOLMode", (PyCFunction)_wrap_StyledTextCtrl_GetEOLMode, METH_O, NULL},

21276

{ (char *)"StyledTextCtrl_SetEOLMode", (PyCFunction) _wrap_StyledTextCtrl_SetEOLMode, METH_VARARGS | METH_KEYWORDS, NULL},

21277

{ (char *)"StyledTextCtrl_StartStyling", (PyCFunction) _wrap_StyledTextCtrl_StartStyling, METH_VARARGS | METH_KEYWORDS, NULL},

21278

{ (char *)"StyledTextCtrl_SetStyling", (PyCFunction) _wrap_StyledTextCtrl_SetStyling, METH_VARARGS | METH_KEYWORDS, NULL},

21279

{ (char *)"StyledTextCtrl_GetBufferedDraw", (PyCFunction)_wrap_StyledTextCtrl_GetBufferedDraw, METH_O, NULL},

21280

{ (char *)"StyledTextCtrl_SetBufferedDraw", (PyCFunction) _wrap_StyledTextCtrl_SetBufferedDraw, METH_VARARGS | METH_KEYWORDS, NULL},

21281

{ (char *)"StyledTextCtrl_SetTabWidth", (PyCFunction) _wrap_StyledTextCtrl_SetTabWidth, METH_VARARGS | METH_KEYWORDS, NULL},

21282

{ (char *)"StyledTextCtrl_GetTabWidth", (PyCFunction)_wrap_StyledTextCtrl_GetTabWidth, METH_O, NULL},

21283

{ (char *)"StyledTextCtrl_SetCodePage", (PyCFunction) _wrap_StyledTextCtrl_SetCodePage, METH_VARARGS | METH_KEYWORDS, NULL},

21284

{ (char *)"StyledTextCtrl_MarkerDefine", (PyCFunction) _wrap_StyledTextCtrl_MarkerDefine, METH_VARARGS | METH_KEYWORDS, NULL},

21285

{ (char *)"StyledTextCtrl_MarkerSetForeground", (PyCFunction) _wrap_StyledTextCtrl_MarkerSetForeground, METH_VARARGS | METH_KEYWORDS, NULL},

21286

{ (char *)"StyledTextCtrl_MarkerSetBackground", (PyCFunction) _wrap_StyledTextCtrl_MarkerSetBackground, METH_VARARGS | METH_KEYWORDS, NULL},

21287

{ (char *)"StyledTextCtrl_MarkerAdd", (PyCFunction) _wrap_StyledTextCtrl_MarkerAdd, METH_VARARGS | METH_KEYWORDS, NULL},

21288

{ (char *)"StyledTextCtrl_MarkerDelete", (PyCFunction) _wrap_StyledTextCtrl_MarkerDelete, METH_VARARGS | METH_KEYWORDS, NULL},

21289

{ (char *)"StyledTextCtrl_MarkerDeleteAll", (PyCFunction) _wrap_StyledTextCtrl_MarkerDeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},

21290

{ (char *)"StyledTextCtrl_MarkerGet", (PyCFunction) _wrap_StyledTextCtrl_MarkerGet, METH_VARARGS | METH_KEYWORDS, NULL},

21291

{ (char *)"StyledTextCtrl_MarkerNext", (PyCFunction) _wrap_StyledTextCtrl_MarkerNext, METH_VARARGS | METH_KEYWORDS, NULL},

21292

{ (char *)"StyledTextCtrl_MarkerPrevious", (PyCFunction) _wrap_StyledTextCtrl_MarkerPrevious, METH_VARARGS | METH_KEYWORDS, NULL},

21293

{ (char *)"StyledTextCtrl_MarkerDefineBitmap", (PyCFunction) _wrap_StyledTextCtrl_MarkerDefineBitmap, METH_VARARGS | METH_KEYWORDS, NULL},

21294

{ (char *)"StyledTextCtrl_MarkerAddSet", (PyCFunction) _wrap_StyledTextCtrl_MarkerAddSet, METH_VARARGS | METH_KEYWORDS, NULL},

21295

{ (char *)"StyledTextCtrl_MarkerSetAlpha", (PyCFunction) _wrap_StyledTextCtrl_MarkerSetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},

21296

{ (char *)"StyledTextCtrl_SetMarginType", (PyCFunction) _wrap_StyledTextCtrl_SetMarginType, METH_VARARGS | METH_KEYWORDS, NULL},

21297

{ (char *)"StyledTextCtrl_GetMarginType", (PyCFunction) _wrap_StyledTextCtrl_GetMarginType, METH_VARARGS | METH_KEYWORDS, NULL},

21298

{ (char *)"StyledTextCtrl_SetMarginWidth", (PyCFunction) _wrap_StyledTextCtrl_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},

21299

{ (char *)"StyledTextCtrl_GetMarginWidth", (PyCFunction) _wrap_StyledTextCtrl_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},

21300

{ (char *)"StyledTextCtrl_SetMarginMask", (PyCFunction) _wrap_StyledTextCtrl_SetMarginMask, METH_VARARGS | METH_KEYWORDS, NULL},

21301

{ (char *)"StyledTextCtrl_GetMarginMask", (PyCFunction) _wrap_StyledTextCtrl_GetMarginMask, METH_VARARGS | METH_KEYWORDS, NULL},

21302

{ (char *)"StyledTextCtrl_SetMarginSensitive", (PyCFunction) _wrap_StyledTextCtrl_SetMarginSensitive, METH_VARARGS | METH_KEYWORDS, NULL},

21303

{ (char *)"StyledTextCtrl_GetMarginSensitive", (PyCFunction) _wrap_StyledTextCtrl_GetMarginSensitive, METH_VARARGS | METH_KEYWORDS, NULL},

21304

{ (char *)"StyledTextCtrl_StyleClearAll", (PyCFunction)_wrap_StyledTextCtrl_StyleClearAll, METH_O, NULL},

21305

{ (char *)"StyledTextCtrl_StyleSetForeground", (PyCFunction) _wrap_StyledTextCtrl_StyleSetForeground, METH_VARARGS | METH_KEYWORDS, NULL},

21306

{ (char *)"StyledTextCtrl_StyleSetBackground", (PyCFunction) _wrap_StyledTextCtrl_StyleSetBackground, METH_VARARGS | METH_KEYWORDS, NULL},

21307

{ (char *)"StyledTextCtrl_StyleSetBold", (PyCFunction) _wrap_StyledTextCtrl_StyleSetBold, METH_VARARGS | METH_KEYWORDS, NULL},

21308

{ (char *)"StyledTextCtrl_StyleSetItalic", (PyCFunction) _wrap_StyledTextCtrl_StyleSetItalic, METH_VARARGS | METH_KEYWORDS, NULL},

21309

{ (char *)"StyledTextCtrl_StyleSetSize", (PyCFunction) _wrap_StyledTextCtrl_StyleSetSize, METH_VARARGS | METH_KEYWORDS, NULL},

21310

{ (char *)"StyledTextCtrl_StyleSetFaceName", (PyCFunction) _wrap_StyledTextCtrl_StyleSetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},

21311

{ (char *)"StyledTextCtrl_StyleSetEOLFilled", (PyCFunction) _wrap_StyledTextCtrl_StyleSetEOLFilled, METH_VARARGS | METH_KEYWORDS, NULL},

21312

{ (char *)"StyledTextCtrl_StyleResetDefault", (PyCFunction)_wrap_StyledTextCtrl_StyleResetDefault, METH_O, NULL},

21313

{ (char *)"StyledTextCtrl_StyleSetUnderline", (PyCFunction) _wrap_StyledTextCtrl_StyleSetUnderline, METH_VARARGS | METH_KEYWORDS, NULL},

21314

{ (char *)"StyledTextCtrl_StyleSetCase", (PyCFunction) _wrap_StyledTextCtrl_StyleSetCase, METH_VARARGS | METH_KEYWORDS, NULL},

21315

{ (char *)"StyledTextCtrl_StyleSetHotSpot", (PyCFunction) _wrap_StyledTextCtrl_StyleSetHotSpot, METH_VARARGS | METH_KEYWORDS, NULL},

21316

{ (char *)"StyledTextCtrl_SetSelForeground", (PyCFunction) _wrap_StyledTextCtrl_SetSelForeground, METH_VARARGS | METH_KEYWORDS, NULL},

21317

{ (char *)"StyledTextCtrl_SetSelBackground", (PyCFunction) _wrap_StyledTextCtrl_SetSelBackground, METH_VARARGS | METH_KEYWORDS, NULL},

21318

{ (char *)"StyledTextCtrl_GetSelAlpha", (PyCFunction)_wrap_StyledTextCtrl_GetSelAlpha, METH_O, NULL},

21319

{ (char *)"StyledTextCtrl_SetSelAlpha", (PyCFunction) _wrap_StyledTextCtrl_SetSelAlpha, METH_VARARGS | METH_KEYWORDS, NULL},

21320

{ (char *)"StyledTextCtrl_SetCaretForeground", (PyCFunction) _wrap_StyledTextCtrl_SetCaretForeground, METH_VARARGS | METH_KEYWORDS, NULL},

21321

{ (char *)"StyledTextCtrl_CmdKeyAssign", (PyCFunction) _wrap_StyledTextCtrl_CmdKeyAssign, METH_VARARGS | METH_KEYWORDS, NULL},

21322

{ (char *)"StyledTextCtrl_CmdKeyClear", (PyCFunction) _wrap_StyledTextCtrl_CmdKeyClear, METH_VARARGS | METH_KEYWORDS, NULL},

21323

{ (char *)"StyledTextCtrl_CmdKeyClearAll", (PyCFunction)_wrap_StyledTextCtrl_CmdKeyClearAll, METH_O, NULL},

21324

{ (char *)"StyledTextCtrl_SetStyleBytes", (PyCFunction) _wrap_StyledTextCtrl_SetStyleBytes, METH_VARARGS | METH_KEYWORDS, NULL},

21325

{ (char *)"StyledTextCtrl_StyleSetVisible", (PyCFunction) _wrap_StyledTextCtrl_StyleSetVisible, METH_VARARGS | METH_KEYWORDS, NULL},

21326

{ (char *)"StyledTextCtrl_GetCaretPeriod", (PyCFunction)_wrap_StyledTextCtrl_GetCaretPeriod, METH_O, NULL},

21327

{ (char *)"StyledTextCtrl_SetCaretPeriod", (PyCFunction) _wrap_StyledTextCtrl_SetCaretPeriod, METH_VARARGS | METH_KEYWORDS, NULL},

21328

{ (char *)"StyledTextCtrl_SetWordChars", (PyCFunction) _wrap_StyledTextCtrl_SetWordChars, METH_VARARGS | METH_KEYWORDS, NULL},

21329

{ (char *)"StyledTextCtrl_BeginUndoAction", (PyCFunction)_wrap_StyledTextCtrl_BeginUndoAction, METH_O, NULL},

21330

{ (char *)"StyledTextCtrl_EndUndoAction", (PyCFunction)_wrap_StyledTextCtrl_EndUndoAction, METH_O, NULL},

21331

{ (char *)"StyledTextCtrl_IndicatorSetStyle", (PyCFunction) _wrap_StyledTextCtrl_IndicatorSetStyle, METH_VARARGS | METH_KEYWORDS, NULL},

21332

{ (char *)"StyledTextCtrl_IndicatorGetStyle", (PyCFunction) _wrap_StyledTextCtrl_IndicatorGetStyle, METH_VARARGS | METH_KEYWORDS, NULL},

21333

{ (char *)"StyledTextCtrl_IndicatorSetForeground", (PyCFunction) _wrap_StyledTextCtrl_IndicatorSetForeground, METH_VARARGS | METH_KEYWORDS, NULL},

21334

{ (char *)"StyledTextCtrl_IndicatorGetForeground", (PyCFunction) _wrap_StyledTextCtrl_IndicatorGetForeground, METH_VARARGS | METH_KEYWORDS, NULL},

21335

{ (char *)"StyledTextCtrl_SetWhitespaceForeground", (PyCFunction) _wrap_StyledTextCtrl_SetWhitespaceForeground, METH_VARARGS | METH_KEYWORDS, NULL},

21336

{ (char *)"StyledTextCtrl_SetWhitespaceBackground", (PyCFunction) _wrap_StyledTextCtrl_SetWhitespaceBackground, METH_VARARGS | METH_KEYWORDS, NULL},

21337

{ (char *)"StyledTextCtrl_SetStyleBits", (PyCFunction) _wrap_StyledTextCtrl_SetStyleBits, METH_VARARGS | METH_KEYWORDS, NULL},

21338

{ (char *)"StyledTextCtrl_GetStyleBits", (PyCFunction)_wrap_StyledTextCtrl_GetStyleBits, METH_O, NULL},

21339

{ (char *)"StyledTextCtrl_SetLineState", (PyCFunction) _wrap_StyledTextCtrl_SetLineState, METH_VARARGS | METH_KEYWORDS, NULL},

21340

{ (char *)"StyledTextCtrl_GetLineState", (PyCFunction) _wrap_StyledTextCtrl_GetLineState, METH_VARARGS | METH_KEYWORDS, NULL},

21341

{ (char *)"StyledTextCtrl_GetMaxLineState", (PyCFunction)_wrap_StyledTextCtrl_GetMaxLineState, METH_O, NULL},

21342

{ (char *)"StyledTextCtrl_GetCaretLineVisible", (PyCFunction)_wrap_StyledTextCtrl_GetCaretLineVisible, METH_O, NULL},

21343

{ (char *)"StyledTextCtrl_SetCaretLineVisible", (PyCFunction) _wrap_StyledTextCtrl_SetCaretLineVisible, METH_VARARGS | METH_KEYWORDS, NULL},

21344

{ (char *)"StyledTextCtrl_GetCaretLineBackground", (PyCFunction)_wrap_StyledTextCtrl_GetCaretLineBackground, METH_O, NULL},

21345

{ (char *)"StyledTextCtrl_SetCaretLineBackground", (PyCFunction) _wrap_StyledTextCtrl_SetCaretLineBackground, METH_VARARGS | METH_KEYWORDS, NULL},

21346

{ (char *)"StyledTextCtrl_StyleSetChangeable", (PyCFunction) _wrap_StyledTextCtrl_StyleSetChangeable, METH_VARARGS | METH_KEYWORDS, NULL},

21347

{ (char *)"StyledTextCtrl_AutoCompShow", (PyCFunction) _wrap_StyledTextCtrl_AutoCompShow, METH_VARARGS | METH_KEYWORDS, NULL},

21348

{ (char *)"StyledTextCtrl_AutoCompCancel", (PyCFunction)_wrap_StyledTextCtrl_AutoCompCancel, METH_O, NULL},

21349

{ (char *)"StyledTextCtrl_AutoCompActive", (PyCFunction)_wrap_StyledTextCtrl_AutoCompActive, METH_O, NULL},

21350

{ (char *)"StyledTextCtrl_AutoCompPosStart", (PyCFunction)_wrap_StyledTextCtrl_AutoCompPosStart, METH_O, NULL},

21351

{ (char *)"StyledTextCtrl_AutoCompComplete", (PyCFunction)_wrap_StyledTextCtrl_AutoCompComplete, METH_O, NULL},

21352

{ (char *)"StyledTextCtrl_AutoCompStops", (PyCFunction) _wrap_StyledTextCtrl_AutoCompStops, METH_VARARGS | METH_KEYWORDS, NULL},

21353

{ (char *)"StyledTextCtrl_AutoCompSetSeparator", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSetSeparator, METH_VARARGS | METH_KEYWORDS, NULL},

21354

{ (char *)"StyledTextCtrl_AutoCompGetSeparator", (PyCFunction)_wrap_StyledTextCtrl_AutoCompGetSeparator, METH_O, NULL},

21355

{ (char *)"StyledTextCtrl_AutoCompSelect", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSelect, METH_VARARGS | METH_KEYWORDS, NULL},

21356

{ (char *)"StyledTextCtrl_AutoCompSetCancelAtStart", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSetCancelAtStart, METH_VARARGS | METH_KEYWORDS, NULL},

21357

{ (char *)"StyledTextCtrl_AutoCompGetCancelAtStart", (PyCFunction)_wrap_StyledTextCtrl_AutoCompGetCancelAtStart, METH_O, NULL},

21358

{ (char *)"StyledTextCtrl_AutoCompSetFillUps", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSetFillUps, METH_VARARGS | METH_KEYWORDS, NULL},

21359

{ (char *)"StyledTextCtrl_AutoCompSetChooseSingle", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSetChooseSingle, METH_VARARGS | METH_KEYWORDS, NULL},

21360

{ (char *)"StyledTextCtrl_AutoCompGetChooseSingle", (PyCFunction)_wrap_StyledTextCtrl_AutoCompGetChooseSingle, METH_O, NULL},

21361

{ (char *)"StyledTextCtrl_AutoCompSetIgnoreCase", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSetIgnoreCase, METH_VARARGS | METH_KEYWORDS, NULL},

21362

{ (char *)"StyledTextCtrl_AutoCompGetIgnoreCase", (PyCFunction)_wrap_StyledTextCtrl_AutoCompGetIgnoreCase, METH_O, NULL},

21363

{ (char *)"StyledTextCtrl_UserListShow", (PyCFunction) _wrap_StyledTextCtrl_UserListShow, METH_VARARGS | METH_KEYWORDS, NULL},

21364

{ (char *)"StyledTextCtrl_AutoCompSetAutoHide", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSetAutoHide, METH_VARARGS | METH_KEYWORDS, NULL},

21365

{ (char *)"StyledTextCtrl_AutoCompGetAutoHide", (PyCFunction)_wrap_StyledTextCtrl_AutoCompGetAutoHide, METH_O, NULL},

21366

{ (char *)"StyledTextCtrl_AutoCompSetDropRestOfWord", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSetDropRestOfWord, METH_VARARGS | METH_KEYWORDS, NULL},

21367

{ (char *)"StyledTextCtrl_AutoCompGetDropRestOfWord", (PyCFunction)_wrap_StyledTextCtrl_AutoCompGetDropRestOfWord, METH_O, NULL},

21368

{ (char *)"StyledTextCtrl_RegisterImage", (PyCFunction) _wrap_StyledTextCtrl_RegisterImage, METH_VARARGS | METH_KEYWORDS, NULL},

21369

{ (char *)"StyledTextCtrl_ClearRegisteredImages", (PyCFunction)_wrap_StyledTextCtrl_ClearRegisteredImages, METH_O, NULL},

21370

{ (char *)"StyledTextCtrl_AutoCompGetTypeSeparator", (PyCFunction)_wrap_StyledTextCtrl_AutoCompGetTypeSeparator, METH_O, NULL},

21371

{ (char *)"StyledTextCtrl_AutoCompSetTypeSeparator", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSetTypeSeparator, METH_VARARGS | METH_KEYWORDS, NULL},

21372

{ (char *)"StyledTextCtrl_AutoCompSetMaxWidth", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},

21373

{ (char *)"StyledTextCtrl_AutoCompGetMaxWidth", (PyCFunction)_wrap_StyledTextCtrl_AutoCompGetMaxWidth, METH_O, NULL},

21374

{ (char *)"StyledTextCtrl_AutoCompSetMaxHeight", (PyCFunction) _wrap_StyledTextCtrl_AutoCompSetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},

21375

{ (char *)"StyledTextCtrl_AutoCompGetMaxHeight", (PyCFunction)_wrap_StyledTextCtrl_AutoCompGetMaxHeight, METH_O, NULL},

21376

{ (char *)"StyledTextCtrl_SetIndent", (PyCFunction) _wrap_StyledTextCtrl_SetIndent, METH_VARARGS | METH_KEYWORDS, NULL},

21377

{ (char *)"StyledTextCtrl_GetIndent", (PyCFunction)_wrap_StyledTextCtrl_GetIndent, METH_O, NULL},

21378

{ (char *)"StyledTextCtrl_SetUseTabs", (PyCFunction) _wrap_StyledTextCtrl_SetUseTabs, METH_VARARGS | METH_KEYWORDS, NULL},

21379

{ (char *)"StyledTextCtrl_GetUseTabs", (PyCFunction)_wrap_StyledTextCtrl_GetUseTabs, METH_O, NULL},

21380

{ (char *)"StyledTextCtrl_SetLineIndentation", (PyCFunction) _wrap_StyledTextCtrl_SetLineIndentation, METH_VARARGS | METH_KEYWORDS, NULL},

21381

{ (char *)"StyledTextCtrl_GetLineIndentation", (PyCFunction) _wrap_StyledTextCtrl_GetLineIndentation, METH_VARARGS | METH_KEYWORDS, NULL},

21382

{ (char *)"StyledTextCtrl_GetLineIndentPosition", (PyCFunction) _wrap_StyledTextCtrl_GetLineIndentPosition, METH_VARARGS | METH_KEYWORDS, NULL},

21383

{ (char *)"StyledTextCtrl_GetColumn", (PyCFunction) _wrap_StyledTextCtrl_GetColumn, METH_VARARGS | METH_KEYWORDS, NULL},

21384

{ (char *)"StyledTextCtrl_SetUseHorizontalScrollBar", (PyCFunction) _wrap_StyledTextCtrl_SetUseHorizontalScrollBar, METH_VARARGS | METH_KEYWORDS, NULL},

21385

{ (char *)"StyledTextCtrl_GetUseHorizontalScrollBar", (PyCFunction)_wrap_StyledTextCtrl_GetUseHorizontalScrollBar, METH_O, NULL},

21386

{ (char *)"StyledTextCtrl_SetIndentationGuides", (PyCFunction) _wrap_StyledTextCtrl_SetIndentationGuides, METH_VARARGS | METH_KEYWORDS, NULL},

21387

{ (char *)"StyledTextCtrl_GetIndentationGuides", (PyCFunction)_wrap_StyledTextCtrl_GetIndentationGuides, METH_O, NULL},

21388

{ (char *)"StyledTextCtrl_SetHighlightGuide", (PyCFunction) _wrap_StyledTextCtrl_SetHighlightGuide, METH_VARARGS | METH_KEYWORDS, NULL},

21389

{ (char *)"StyledTextCtrl_GetHighlightGuide", (PyCFunction)_wrap_StyledTextCtrl_GetHighlightGuide, METH_O, NULL},

21390

{ (char *)"StyledTextCtrl_GetLineEndPosition", (PyCFunction) _wrap_StyledTextCtrl_GetLineEndPosition, METH_VARARGS | METH_KEYWORDS, NULL},

21391

{ (char *)"StyledTextCtrl_GetCodePage", (PyCFunction)_wrap_StyledTextCtrl_GetCodePage, METH_O, NULL},

21392

{ (char *)"StyledTextCtrl_GetCaretForeground", (PyCFunction)_wrap_StyledTextCtrl_GetCaretForeground, METH_O, NULL},

21393

{ (char *)"StyledTextCtrl_GetReadOnly", (PyCFunction)_wrap_StyledTextCtrl_GetReadOnly, METH_O, NULL},

21394

{ (char *)"StyledTextCtrl_SetCurrentPos", (PyCFunction) _wrap_StyledTextCtrl_SetCurrentPos, METH_VARARGS | METH_KEYWORDS, NULL},

21395

{ (char *)"StyledTextCtrl_SetSelectionStart", (PyCFunction) _wrap_StyledTextCtrl_SetSelectionStart, METH_VARARGS | METH_KEYWORDS, NULL},

21396

{ (char *)"StyledTextCtrl_GetSelectionStart", (PyCFunction)_wrap_StyledTextCtrl_GetSelectionStart, METH_O, NULL},

21397

{ (char *)"StyledTextCtrl_SetSelectionEnd", (PyCFunction) _wrap_StyledTextCtrl_SetSelectionEnd, METH_VARARGS | METH_KEYWORDS, NULL},

21398

{ (char *)"StyledTextCtrl_GetSelectionEnd", (PyCFunction)_wrap_StyledTextCtrl_GetSelectionEnd, METH_O, NULL},

21399

{ (char *)"StyledTextCtrl_SetPrintMagnification", (PyCFunction) _wrap_StyledTextCtrl_SetPrintMagnification, METH_VARARGS | METH_KEYWORDS, NULL},

21400

{ (char *)"StyledTextCtrl_GetPrintMagnification", (PyCFunction)_wrap_StyledTextCtrl_GetPrintMagnification, METH_O, NULL},

21401

{ (char *)"StyledTextCtrl_SetPrintColourMode", (PyCFunction) _wrap_StyledTextCtrl_SetPrintColourMode, METH_VARARGS | METH_KEYWORDS, NULL},

21402

{ (char *)"StyledTextCtrl_GetPrintColourMode", (PyCFunction)_wrap_StyledTextCtrl_GetPrintColourMode, METH_O, NULL},

21403

{ (char *)"StyledTextCtrl_FindText", (PyCFunction) _wrap_StyledTextCtrl_FindText, METH_VARARGS | METH_KEYWORDS, NULL},

21404

{ (char *)"StyledTextCtrl_FormatRange", (PyCFunction) _wrap_StyledTextCtrl_FormatRange, METH_VARARGS | METH_KEYWORDS, NULL},

21405

{ (char *)"StyledTextCtrl_GetFirstVisibleLine", (PyCFunction)_wrap_StyledTextCtrl_GetFirstVisibleLine, METH_O, NULL},

21406

{ (char *)"StyledTextCtrl_GetLine", (PyCFunction) _wrap_StyledTextCtrl_GetLine, METH_VARARGS | METH_KEYWORDS, NULL},

21407

{ (char *)"StyledTextCtrl_GetLineCount", (PyCFunction)_wrap_StyledTextCtrl_GetLineCount, METH_O, NULL},

21408

{ (char *)"StyledTextCtrl_SetMarginLeft", (PyCFunction) _wrap_StyledTextCtrl_SetMarginLeft, METH_VARARGS | METH_KEYWORDS, NULL},

21409

{ (char *)"StyledTextCtrl_GetMarginLeft", (PyCFunction)_wrap_StyledTextCtrl_GetMarginLeft, METH_O, NULL},

21410

{ (char *)"StyledTextCtrl_SetMarginRight", (PyCFunction) _wrap_StyledTextCtrl_SetMarginRight, METH_VARARGS | METH_KEYWORDS, NULL},

21411

{ (char *)"StyledTextCtrl_GetMarginRight", (PyCFunction)_wrap_StyledTextCtrl_GetMarginRight, METH_O, NULL},

21412

{ (char *)"StyledTextCtrl_GetModify", (PyCFunction)_wrap_StyledTextCtrl_GetModify, METH_O, NULL},

21413

{ (char *)"StyledTextCtrl_SetSelection", (PyCFunction) _wrap_StyledTextCtrl_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},

21414

{ (char *)"StyledTextCtrl_GetSelectedText", (PyCFunction)_wrap_StyledTextCtrl_GetSelectedText, METH_O, NULL},

21415

{ (char *)"StyledTextCtrl_GetTextRange", (PyCFunction) _wrap_StyledTextCtrl_GetTextRange, METH_VARARGS | METH_KEYWORDS, NULL},

21416

{ (char *)"StyledTextCtrl_HideSelection", (PyCFunction) _wrap_StyledTextCtrl_HideSelection, METH_VARARGS | METH_KEYWORDS, NULL},

21417

{ (char *)"StyledTextCtrl_LineFromPosition", (PyCFunction) _wrap_StyledTextCtrl_LineFromPosition, METH_VARARGS | METH_KEYWORDS, NULL},

21418

{ (char *)"StyledTextCtrl_PositionFromLine", (PyCFunction) _wrap_StyledTextCtrl_PositionFromLine, METH_VARARGS | METH_KEYWORDS, NULL},

21419

{ (char *)"StyledTextCtrl_LineScroll", (PyCFunction) _wrap_StyledTextCtrl_LineScroll, METH_VARARGS | METH_KEYWORDS, NULL},

21420

{ (char *)"StyledTextCtrl_EnsureCaretVisible", (PyCFunction)_wrap_StyledTextCtrl_EnsureCaretVisible, METH_O, NULL},

21421

{ (char *)"StyledTextCtrl_ReplaceSelection", (PyCFunction) _wrap_StyledTextCtrl_ReplaceSelection, METH_VARARGS | METH_KEYWORDS, NULL},

21422

{ (char *)"StyledTextCtrl_SetReadOnly", (PyCFunction) _wrap_StyledTextCtrl_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},

21423

{ (char *)"StyledTextCtrl_CanPaste", (PyCFunction)_wrap_StyledTextCtrl_CanPaste, METH_O, NULL},

21424

{ (char *)"StyledTextCtrl_CanUndo", (PyCFunction)_wrap_StyledTextCtrl_CanUndo, METH_O, NULL},

21425

{ (char *)"StyledTextCtrl_EmptyUndoBuffer", (PyCFunction)_wrap_StyledTextCtrl_EmptyUndoBuffer, METH_O, NULL},

21426

{ (char *)"StyledTextCtrl_Undo", (PyCFunction)_wrap_StyledTextCtrl_Undo, METH_O, NULL},

21427

{ (char *)"StyledTextCtrl_Cut", (PyCFunction)_wrap_StyledTextCtrl_Cut, METH_O, NULL},

21428

{ (char *)"StyledTextCtrl_Copy", (PyCFunction)_wrap_StyledTextCtrl_Copy, METH_O, NULL},

21429

{ (char *)"StyledTextCtrl_Paste", (PyCFunction)_wrap_StyledTextCtrl_Paste, METH_O, NULL},

21430

{ (char *)"StyledTextCtrl_Clear", (PyCFunction)_wrap_StyledTextCtrl_Clear, METH_O, NULL},

21431

{ (char *)"StyledTextCtrl_SetText", (PyCFunction) _wrap_StyledTextCtrl_SetText, METH_VARARGS | METH_KEYWORDS, NULL},

21432

{ (char *)"StyledTextCtrl_GetText", (PyCFunction)_wrap_StyledTextCtrl_GetText, METH_O, NULL},

21433

{ (char *)"StyledTextCtrl_GetTextLength", (PyCFunction)_wrap_StyledTextCtrl_GetTextLength, METH_O, NULL},

21434

{ (char *)"StyledTextCtrl_SetOvertype", (PyCFunction) _wrap_StyledTextCtrl_SetOvertype, METH_VARARGS | METH_KEYWORDS, NULL},

21435

{ (char *)"StyledTextCtrl_GetOvertype", (PyCFunction)_wrap_StyledTextCtrl_GetOvertype, METH_O, NULL},

21436

{ (char *)"StyledTextCtrl_SetCaretWidth", (PyCFunction) _wrap_StyledTextCtrl_SetCaretWidth, METH_VARARGS | METH_KEYWORDS, NULL},

21437

{ (char *)"StyledTextCtrl_GetCaretWidth", (PyCFunction)_wrap_StyledTextCtrl_GetCaretWidth, METH_O, NULL},

21438

{ (char *)"StyledTextCtrl_SetTargetStart", (PyCFunction) _wrap_StyledTextCtrl_SetTargetStart, METH_VARARGS | METH_KEYWORDS, NULL},

21439

{ (char *)"StyledTextCtrl_GetTargetStart", (PyCFunction)_wrap_StyledTextCtrl_GetTargetStart, METH_O, NULL},

21440

{ (char *)"StyledTextCtrl_SetTargetEnd", (PyCFunction) _wrap_StyledTextCtrl_SetTargetEnd, METH_VARARGS | METH_KEYWORDS, NULL},

21441

{ (char *)"StyledTextCtrl_GetTargetEnd", (PyCFunction)_wrap_StyledTextCtrl_GetTargetEnd, METH_O, NULL},

21442

{ (char *)"StyledTextCtrl_ReplaceTarget", (PyCFunction) _wrap_StyledTextCtrl_ReplaceTarget, METH_VARARGS | METH_KEYWORDS, NULL},

21443

{ (char *)"StyledTextCtrl_ReplaceTargetRE", (PyCFunction) _wrap_StyledTextCtrl_ReplaceTargetRE, METH_VARARGS | METH_KEYWORDS, NULL},

21444

{ (char *)"StyledTextCtrl_SearchInTarget", (PyCFunction) _wrap_StyledTextCtrl_SearchInTarget, METH_VARARGS | METH_KEYWORDS, NULL},

21445

{ (char *)"StyledTextCtrl_SetSearchFlags", (PyCFunction) _wrap_StyledTextCtrl_SetSearchFlags, METH_VARARGS | METH_KEYWORDS, NULL},

21446

{ (char *)"StyledTextCtrl_GetSearchFlags", (PyCFunction)_wrap_StyledTextCtrl_GetSearchFlags, METH_O, NULL},

21447

{ (char *)"StyledTextCtrl_CallTipShow", (PyCFunction) _wrap_StyledTextCtrl_CallTipShow, METH_VARARGS | METH_KEYWORDS, NULL},

21448

{ (char *)"StyledTextCtrl_CallTipCancel", (PyCFunction)_wrap_StyledTextCtrl_CallTipCancel, METH_O, NULL},

21449

{ (char *)"StyledTextCtrl_CallTipActive", (PyCFunction)_wrap_StyledTextCtrl_CallTipActive, METH_O, NULL},

21450

{ (char *)"StyledTextCtrl_CallTipPosAtStart", (PyCFunction)_wrap_StyledTextCtrl_CallTipPosAtStart, METH_O, NULL},

21451

{ (char *)"StyledTextCtrl_CallTipSetHighlight", (PyCFunction) _wrap_StyledTextCtrl_CallTipSetHighlight, METH_VARARGS | METH_KEYWORDS, NULL},

21452

{ (char *)"StyledTextCtrl_CallTipSetBackground", (PyCFunction) _wrap_StyledTextCtrl_CallTipSetBackground, METH_VARARGS | METH_KEYWORDS, NULL},

21453

{ (char *)"StyledTextCtrl_CallTipSetForeground", (PyCFunction) _wrap_StyledTextCtrl_CallTipSetForeground, METH_VARARGS | METH_KEYWORDS, NULL},

21454

{ (char *)"StyledTextCtrl_CallTipSetForegroundHighlight", (PyCFunction) _wrap_StyledTextCtrl_CallTipSetForegroundHighlight, METH_VARARGS | METH_KEYWORDS, NULL},

21455

{ (char *)"StyledTextCtrl_CallTipUseStyle", (PyCFunction) _wrap_StyledTextCtrl_CallTipUseStyle, METH_VARARGS | METH_KEYWORDS, NULL},

21456

{ (char *)"StyledTextCtrl_VisibleFromDocLine", (PyCFunction) _wrap_StyledTextCtrl_VisibleFromDocLine, METH_VARARGS | METH_KEYWORDS, NULL},

21457

{ (char *)"StyledTextCtrl_DocLineFromVisible", (PyCFunction) _wrap_StyledTextCtrl_DocLineFromVisible, METH_VARARGS | METH_KEYWORDS, NULL},

21458

{ (char *)"StyledTextCtrl_WrapCount", (PyCFunction) _wrap_StyledTextCtrl_WrapCount, METH_VARARGS | METH_KEYWORDS, NULL},

21459

{ (char *)"StyledTextCtrl_SetFoldLevel", (PyCFunction) _wrap_StyledTextCtrl_SetFoldLevel, METH_VARARGS | METH_KEYWORDS, NULL},

21460

{ (char *)"StyledTextCtrl_GetFoldLevel", (PyCFunction) _wrap_StyledTextCtrl_GetFoldLevel, METH_VARARGS | METH_KEYWORDS, NULL},

21461

{ (char *)"StyledTextCtrl_GetLastChild", (PyCFunction) _wrap_StyledTextCtrl_GetLastChild, METH_VARARGS | METH_KEYWORDS, NULL},

21462

{ (char *)"StyledTextCtrl_GetFoldParent", (PyCFunction) _wrap_StyledTextCtrl_GetFoldParent, METH_VARARGS | METH_KEYWORDS, NULL},

21463

{ (char *)"StyledTextCtrl_ShowLines", (PyCFunction) _wrap_StyledTextCtrl_ShowLines, METH_VARARGS | METH_KEYWORDS, NULL},

21464

{ (char *)"StyledTextCtrl_HideLines", (PyCFunction) _wrap_StyledTextCtrl_HideLines, METH_VARARGS | METH_KEYWORDS, NULL},

21465

{ (char *)"StyledTextCtrl_GetLineVisible", (PyCFunction) _wrap_StyledTextCtrl_GetLineVisible, METH_VARARGS | METH_KEYWORDS, NULL},

21466

{ (char *)"StyledTextCtrl_SetFoldExpanded", (PyCFunction) _wrap_StyledTextCtrl_SetFoldExpanded, METH_VARARGS | METH_KEYWORDS, NULL},

21467

{ (char *)"StyledTextCtrl_GetFoldExpanded", (PyCFunction) _wrap_StyledTextCtrl_GetFoldExpanded, METH_VARARGS | METH_KEYWORDS, NULL},

21468

{ (char *)"StyledTextCtrl_ToggleFold", (PyCFunction) _wrap_StyledTextCtrl_ToggleFold, METH_VARARGS | METH_KEYWORDS, NULL},

21469

{ (char *)"StyledTextCtrl_EnsureVisible", (PyCFunction) _wrap_StyledTextCtrl_EnsureVisible, METH_VARARGS | METH_KEYWORDS, NULL},

21470

{ (char *)"StyledTextCtrl_SetFoldFlags", (PyCFunction) _wrap_StyledTextCtrl_SetFoldFlags, METH_VARARGS | METH_KEYWORDS, NULL},

21471

{ (char *)"StyledTextCtrl_EnsureVisibleEnforcePolicy", (PyCFunction) _wrap_StyledTextCtrl_EnsureVisibleEnforcePolicy, METH_VARARGS | METH_KEYWORDS, NULL},

21472

{ (char *)"StyledTextCtrl_SetTabIndents", (PyCFunction) _wrap_StyledTextCtrl_SetTabIndents, METH_VARARGS | METH_KEYWORDS, NULL},

21473

{ (char *)"StyledTextCtrl_GetTabIndents", (PyCFunction)_wrap_StyledTextCtrl_GetTabIndents, METH_O, NULL},

21474

{ (char *)"StyledTextCtrl_SetBackSpaceUnIndents", (PyCFunction) _wrap_StyledTextCtrl_SetBackSpaceUnIndents, METH_VARARGS | METH_KEYWORDS, NULL},

21475

{ (char *)"StyledTextCtrl_GetBackSpaceUnIndents", (PyCFunction)_wrap_StyledTextCtrl_GetBackSpaceUnIndents, METH_O, NULL},

21476

{ (char *)"StyledTextCtrl_SetMouseDwellTime", (PyCFunction) _wrap_StyledTextCtrl_SetMouseDwellTime, METH_VARARGS | METH_KEYWORDS, NULL},

21477

{ (char *)"StyledTextCtrl_GetMouseDwellTime", (PyCFunction)_wrap_StyledTextCtrl_GetMouseDwellTime, METH_O, NULL},

21478

{ (char *)"StyledTextCtrl_WordStartPosition", (PyCFunction) _wrap_StyledTextCtrl_WordStartPosition, METH_VARARGS | METH_KEYWORDS, NULL},

21479

{ (char *)"StyledTextCtrl_WordEndPosition", (PyCFunction) _wrap_StyledTextCtrl_WordEndPosition, METH_VARARGS | METH_KEYWORDS, NULL},

21480

{ (char *)"StyledTextCtrl_SetWrapMode", (PyCFunction) _wrap_StyledTextCtrl_SetWrapMode, METH_VARARGS | METH_KEYWORDS, NULL},

21481

{ (char *)"StyledTextCtrl_GetWrapMode", (PyCFunction)_wrap_StyledTextCtrl_GetWrapMode, METH_O, NULL},

21482

{ (char *)"StyledTextCtrl_SetWrapVisualFlags", (PyCFunction) _wrap_StyledTextCtrl_SetWrapVisualFlags, METH_VARARGS | METH_KEYWORDS, NULL},

21483

{ (char *)"StyledTextCtrl_GetWrapVisualFlags", (PyCFunction)_wrap_StyledTextCtrl_GetWrapVisualFlags, METH_O, NULL},

21484

{ (char *)"StyledTextCtrl_SetWrapVisualFlagsLocation", (PyCFunction) _wrap_StyledTextCtrl_SetWrapVisualFlagsLocation, METH_VARARGS | METH_KEYWORDS, NULL},

21485

{ (char *)"StyledTextCtrl_GetWrapVisualFlagsLocation", (PyCFunction)_wrap_StyledTextCtrl_GetWrapVisualFlagsLocation, METH_O, NULL},

21486

{ (char *)"StyledTextCtrl_SetWrapStartIndent", (PyCFunction) _wrap_StyledTextCtrl_SetWrapStartIndent, METH_VARARGS | METH_KEYWORDS, NULL},

21487

{ (char *)"StyledTextCtrl_GetWrapStartIndent", (PyCFunction)_wrap_StyledTextCtrl_GetWrapStartIndent, METH_O, NULL},

21488

{ (char *)"StyledTextCtrl_SetLayoutCache", (PyCFunction) _wrap_StyledTextCtrl_SetLayoutCache, METH_VARARGS | METH_KEYWORDS, NULL},

21489

{ (char *)"StyledTextCtrl_GetLayoutCache", (PyCFunction)_wrap_StyledTextCtrl_GetLayoutCache, METH_O, NULL},

21490

{ (char *)"StyledTextCtrl_SetScrollWidth", (PyCFunction) _wrap_StyledTextCtrl_SetScrollWidth, METH_VARARGS | METH_KEYWORDS, NULL},

21491

{ (char *)"StyledTextCtrl_GetScrollWidth", (PyCFunction)_wrap_StyledTextCtrl_GetScrollWidth, METH_O, NULL},

21492

{ (char *)"StyledTextCtrl_TextWidth", (PyCFunction) _wrap_StyledTextCtrl_TextWidth, METH_VARARGS | METH_KEYWORDS, NULL},

21493

{ (char *)"StyledTextCtrl_SetEndAtLastLine", (PyCFunction) _wrap_StyledTextCtrl_SetEndAtLastLine, METH_VARARGS | METH_KEYWORDS, NULL},

21494

{ (char *)"StyledTextCtrl_GetEndAtLastLine", (PyCFunction)_wrap_StyledTextCtrl_GetEndAtLastLine, METH_O, NULL},

21495

{ (char *)"StyledTextCtrl_TextHeight", (PyCFunction) _wrap_StyledTextCtrl_TextHeight, METH_VARARGS | METH_KEYWORDS, NULL},

21496

{ (char *)"StyledTextCtrl_SetUseVerticalScrollBar", (PyCFunction) _wrap_StyledTextCtrl_SetUseVerticalScrollBar, METH_VARARGS | METH_KEYWORDS, NULL},

21497

{ (char *)"StyledTextCtrl_GetUseVerticalScrollBar", (PyCFunction)_wrap_StyledTextCtrl_GetUseVerticalScrollBar, METH_O, NULL},

21498

{ (char *)"StyledTextCtrl_AppendText", (PyCFunction) _wrap_StyledTextCtrl_AppendText, METH_VARARGS | METH_KEYWORDS, NULL},

21499

{ (char *)"StyledTextCtrl_GetTwoPhaseDraw", (PyCFunction)_wrap_StyledTextCtrl_GetTwoPhaseDraw, METH_O, NULL},

21500

{ (char *)"StyledTextCtrl_SetTwoPhaseDraw", (PyCFunction) _wrap_StyledTextCtrl_SetTwoPhaseDraw, METH_VARARGS | METH_KEYWORDS, NULL},

21501

{ (char *)"StyledTextCtrl_TargetFromSelection", (PyCFunction)_wrap_StyledTextCtrl_TargetFromSelection, METH_O, NULL},

21502

{ (char *)"StyledTextCtrl_LinesJoin", (PyCFunction)_wrap_StyledTextCtrl_LinesJoin, METH_O, NULL},

21503

{ (char *)"StyledTextCtrl_LinesSplit", (PyCFunction) _wrap_StyledTextCtrl_LinesSplit, METH_VARARGS | METH_KEYWORDS, NULL},

21504

{ (char *)"StyledTextCtrl_SetFoldMarginColour", (PyCFunction) _wrap_StyledTextCtrl_SetFoldMarginColour, METH_VARARGS | METH_KEYWORDS, NULL},

21505

{ (char *)"StyledTextCtrl_SetFoldMarginHiColour", (PyCFunction) _wrap_StyledTextCtrl_SetFoldMarginHiColour, METH_VARARGS | METH_KEYWORDS, NULL},

21506

{ (char *)"StyledTextCtrl_LineDown", (PyCFunction)_wrap_StyledTextCtrl_LineDown, METH_O, NULL},

21507

{ (char *)"StyledTextCtrl_LineDownExtend", (PyCFunction)_wrap_StyledTextCtrl_LineDownExtend, METH_O, NULL},

21508

{ (char *)"StyledTextCtrl_LineUp", (PyCFunction)_wrap_StyledTextCtrl_LineUp, METH_O, NULL},

21509

{ (char *)"StyledTextCtrl_LineUpExtend", (PyCFunction)_wrap_StyledTextCtrl_LineUpExtend, METH_O, NULL},

21510

{ (char *)"StyledTextCtrl_CharLeft", (PyCFunction)_wrap_StyledTextCtrl_CharLeft, METH_O, NULL},

21511

{ (char *)"StyledTextCtrl_CharLeftExtend", (PyCFunction)_wrap_StyledTextCtrl_CharLeftExtend, METH_O, NULL},

21512

{ (char *)"StyledTextCtrl_CharRight", (PyCFunction)_wrap_StyledTextCtrl_CharRight, METH_O, NULL},

21513

{ (char *)"StyledTextCtrl_CharRightExtend", (PyCFunction)_wrap_StyledTextCtrl_CharRightExtend, METH_O, NULL},

21514

{ (char *)"StyledTextCtrl_WordLeft", (PyCFunction)_wrap_StyledTextCtrl_WordLeft, METH_O, NULL},

21515

{ (char *)"StyledTextCtrl_WordLeftExtend", (PyCFunction)_wrap_StyledTextCtrl_WordLeftExtend, METH_O, NULL},

21516

{ (char *)"StyledTextCtrl_WordRight", (PyCFunction)_wrap_StyledTextCtrl_WordRight, METH_O, NULL},

21517

{ (char *)"StyledTextCtrl_WordRightExtend", (PyCFunction)_wrap_StyledTextCtrl_WordRightExtend, METH_O, NULL},

21518

{ (char *)"StyledTextCtrl_Home", (PyCFunction)_wrap_StyledTextCtrl_Home, METH_O, NULL},

21519

{ (char *)"StyledTextCtrl_HomeExtend", (PyCFunction)_wrap_StyledTextCtrl_HomeExtend, METH_O, NULL},

21520

{ (char *)"StyledTextCtrl_LineEnd", (PyCFunction)_wrap_StyledTextCtrl_LineEnd, METH_O, NULL},

21521

{ (char *)"StyledTextCtrl_LineEndExtend", (PyCFunction)_wrap_StyledTextCtrl_LineEndExtend, METH_O, NULL},

21522

{ (char *)"StyledTextCtrl_DocumentStart", (PyCFunction)_wrap_StyledTextCtrl_DocumentStart, METH_O, NULL},

21523

{ (char *)"StyledTextCtrl_DocumentStartExtend", (PyCFunction)_wrap_StyledTextCtrl_DocumentStartExtend, METH_O, NULL},

21524

{ (char *)"StyledTextCtrl_DocumentEnd", (PyCFunction)_wrap_StyledTextCtrl_DocumentEnd, METH_O, NULL},

21525

{ (char *)"StyledTextCtrl_DocumentEndExtend", (PyCFunction)_wrap_StyledTextCtrl_DocumentEndExtend, METH_O, NULL},

21526

{ (char *)"StyledTextCtrl_PageUp", (PyCFunction)_wrap_StyledTextCtrl_PageUp, METH_O, NULL},

21527

{ (char *)"StyledTextCtrl_PageUpExtend", (PyCFunction)_wrap_StyledTextCtrl_PageUpExtend, METH_O, NULL},

21528

{ (char *)"StyledTextCtrl_PageDown", (PyCFunction)_wrap_StyledTextCtrl_PageDown, METH_O, NULL},

21529

{ (char *)"StyledTextCtrl_PageDownExtend", (PyCFunction)_wrap_StyledTextCtrl_PageDownExtend, METH_O, NULL},

21530

{ (char *)"StyledTextCtrl_EditToggleOvertype", (PyCFunction)_wrap_StyledTextCtrl_EditToggleOvertype, METH_O, NULL},

21531

{ (char *)"StyledTextCtrl_Cancel", (PyCFunction)_wrap_StyledTextCtrl_Cancel, METH_O, NULL},

21532

{ (char *)"StyledTextCtrl_DeleteBack", (PyCFunction)_wrap_StyledTextCtrl_DeleteBack, METH_O, NULL},

21533

{ (char *)"StyledTextCtrl_Tab", (PyCFunction)_wrap_StyledTextCtrl_Tab, METH_O, NULL},

21534

{ (char *)"StyledTextCtrl_BackTab", (PyCFunction)_wrap_StyledTextCtrl_BackTab, METH_O, NULL},

21535

{ (char *)"StyledTextCtrl_NewLine", (PyCFunction)_wrap_StyledTextCtrl_NewLine, METH_O, NULL},

21536

{ (char *)"StyledTextCtrl_FormFeed", (PyCFunction)_wrap_StyledTextCtrl_FormFeed, METH_O, NULL},

21537

{ (char *)"StyledTextCtrl_VCHome", (PyCFunction)_wrap_StyledTextCtrl_VCHome, METH_O, NULL},

21538

{ (char *)"StyledTextCtrl_VCHomeExtend", (PyCFunction)_wrap_StyledTextCtrl_VCHomeExtend, METH_O, NULL},

21539

{ (char *)"StyledTextCtrl_ZoomIn", (PyCFunction)_wrap_StyledTextCtrl_ZoomIn, METH_O, NULL},

21540

{ (char *)"StyledTextCtrl_ZoomOut", (PyCFunction)_wrap_StyledTextCtrl_ZoomOut, METH_O, NULL},

21541

{ (char *)"StyledTextCtrl_DelWordLeft", (PyCFunction)_wrap_StyledTextCtrl_DelWordLeft, METH_O, NULL},

21542

{ (char *)"StyledTextCtrl_DelWordRight", (PyCFunction)_wrap_StyledTextCtrl_DelWordRight, METH_O, NULL},

21543

{ (char *)"StyledTextCtrl_LineCut", (PyCFunction)_wrap_StyledTextCtrl_LineCut, METH_O, NULL},

21544

{ (char *)"StyledTextCtrl_LineDelete", (PyCFunction)_wrap_StyledTextCtrl_LineDelete, METH_O, NULL},

21545

{ (char *)"StyledTextCtrl_LineTranspose", (PyCFunction)_wrap_StyledTextCtrl_LineTranspose, METH_O, NULL},

21546

{ (char *)"StyledTextCtrl_LineDuplicate", (PyCFunction)_wrap_StyledTextCtrl_LineDuplicate, METH_O, NULL},

21547

{ (char *)"StyledTextCtrl_LowerCase", (PyCFunction)_wrap_StyledTextCtrl_LowerCase, METH_O, NULL},

21548

{ (char *)"StyledTextCtrl_UpperCase", (PyCFunction)_wrap_StyledTextCtrl_UpperCase, METH_O, NULL},

21549

{ (char *)"StyledTextCtrl_LineScrollDown", (PyCFunction)_wrap_StyledTextCtrl_LineScrollDown, METH_O, NULL},

21550

{ (char *)"StyledTextCtrl_LineScrollUp", (PyCFunction)_wrap_StyledTextCtrl_LineScrollUp, METH_O, NULL},

21551

{ (char *)"StyledTextCtrl_DeleteBackNotLine", (PyCFunction)_wrap_StyledTextCtrl_DeleteBackNotLine, METH_O, NULL},

21552

{ (char *)"StyledTextCtrl_HomeDisplay", (PyCFunction)_wrap_StyledTextCtrl_HomeDisplay, METH_O, NULL},

21553

{ (char *)"StyledTextCtrl_HomeDisplayExtend", (PyCFunction)_wrap_StyledTextCtrl_HomeDisplayExtend, METH_O, NULL},

21554

{ (char *)"StyledTextCtrl_LineEndDisplay", (PyCFunction)_wrap_StyledTextCtrl_LineEndDisplay, METH_O, NULL},

21555

{ (char *)"StyledTextCtrl_LineEndDisplayExtend", (PyCFunction)_wrap_StyledTextCtrl_LineEndDisplayExtend, METH_O, NULL},

21556

{ (char *)"StyledTextCtrl_HomeWrap", (PyCFunction)_wrap_StyledTextCtrl_HomeWrap, METH_O, NULL},

21557

{ (char *)"StyledTextCtrl_HomeWrapExtend", (PyCFunction)_wrap_StyledTextCtrl_HomeWrapExtend, METH_O, NULL},

21558

{ (char *)"StyledTextCtrl_LineEndWrap", (PyCFunction)_wrap_StyledTextCtrl_LineEndWrap, METH_O, NULL},

21559

{ (char *)"StyledTextCtrl_LineEndWrapExtend", (PyCFunction)_wrap_StyledTextCtrl_LineEndWrapExtend, METH_O, NULL},

21560

{ (char *)"StyledTextCtrl_VCHomeWrap", (PyCFunction)_wrap_StyledTextCtrl_VCHomeWrap, METH_O, NULL},

21561

{ (char *)"StyledTextCtrl_VCHomeWrapExtend", (PyCFunction)_wrap_StyledTextCtrl_VCHomeWrapExtend, METH_O, NULL},

21562

{ (char *)"StyledTextCtrl_LineCopy", (PyCFunction)_wrap_StyledTextCtrl_LineCopy, METH_O, NULL},

21563

{ (char *)"StyledTextCtrl_MoveCaretInsideView", (PyCFunction)_wrap_StyledTextCtrl_MoveCaretInsideView, METH_O, NULL},

21564

{ (char *)"StyledTextCtrl_LineLength", (PyCFunction) _wrap_StyledTextCtrl_LineLength, METH_VARARGS | METH_KEYWORDS, NULL},

21565

{ (char *)"StyledTextCtrl_BraceHighlight", (PyCFunction) _wrap_StyledTextCtrl_BraceHighlight, METH_VARARGS | METH_KEYWORDS, NULL},

21566

{ (char *)"StyledTextCtrl_BraceBadLight", (PyCFunction) _wrap_StyledTextCtrl_BraceBadLight, METH_VARARGS | METH_KEYWORDS, NULL},

21567

{ (char *)"StyledTextCtrl_BraceMatch", (PyCFunction) _wrap_StyledTextCtrl_BraceMatch, METH_VARARGS | METH_KEYWORDS, NULL},

21568

{ (char *)"StyledTextCtrl_GetViewEOL", (PyCFunction)_wrap_StyledTextCtrl_GetViewEOL, METH_O, NULL},

21569

{ (char *)"StyledTextCtrl_SetViewEOL", (PyCFunction) _wrap_StyledTextCtrl_SetViewEOL, METH_VARARGS | METH_KEYWORDS, NULL},

21570

{ (char *)"StyledTextCtrl_GetDocPointer", (PyCFunction)_wrap_StyledTextCtrl_GetDocPointer, METH_O, NULL},

21571

{ (char *)"StyledTextCtrl_SetDocPointer", (PyCFunction) _wrap_StyledTextCtrl_SetDocPointer, METH_VARARGS | METH_KEYWORDS, NULL},

21572

{ (char *)"StyledTextCtrl_SetModEventMask", (PyCFunction) _wrap_StyledTextCtrl_SetModEventMask, METH_VARARGS | METH_KEYWORDS, NULL},

21573

{ (char *)"StyledTextCtrl_GetEdgeColumn", (PyCFunction)_wrap_StyledTextCtrl_GetEdgeColumn, METH_O, NULL},

21574

{ (char *)"StyledTextCtrl_SetEdgeColumn", (PyCFunction) _wrap_StyledTextCtrl_SetEdgeColumn, METH_VARARGS | METH_KEYWORDS, NULL},

21575

{ (char *)"StyledTextCtrl_GetEdgeMode", (PyCFunction)_wrap_StyledTextCtrl_GetEdgeMode, METH_O, NULL},

21576

{ (char *)"StyledTextCtrl_SetEdgeMode", (PyCFunction) _wrap_StyledTextCtrl_SetEdgeMode, METH_VARARGS | METH_KEYWORDS, NULL},

21577

{ (char *)"StyledTextCtrl_GetEdgeColour", (PyCFunction)_wrap_StyledTextCtrl_GetEdgeColour, METH_O, NULL},

21578

{ (char *)"StyledTextCtrl_SetEdgeColour", (PyCFunction) _wrap_StyledTextCtrl_SetEdgeColour, METH_VARARGS | METH_KEYWORDS, NULL},

21579

{ (char *)"StyledTextCtrl_SearchAnchor", (PyCFunction)_wrap_StyledTextCtrl_SearchAnchor, METH_O, NULL},

21580

{ (char *)"StyledTextCtrl_SearchNext", (PyCFunction) _wrap_StyledTextCtrl_SearchNext, METH_VARARGS | METH_KEYWORDS, NULL},

21581

{ (char *)"StyledTextCtrl_SearchPrev", (PyCFunction) _wrap_StyledTextCtrl_SearchPrev, METH_VARARGS | METH_KEYWORDS, NULL},

21582

{ (char *)"StyledTextCtrl_LinesOnScreen", (PyCFunction)_wrap_StyledTextCtrl_LinesOnScreen, METH_O, NULL},

21583

{ (char *)"StyledTextCtrl_UsePopUp", (PyCFunction) _wrap_StyledTextCtrl_UsePopUp, METH_VARARGS | METH_KEYWORDS, NULL},

21584

{ (char *)"StyledTextCtrl_SelectionIsRectangle", (PyCFunction)_wrap_StyledTextCtrl_SelectionIsRectangle, METH_O, NULL},

21585

{ (char *)"StyledTextCtrl_SetZoom", (PyCFunction) _wrap_StyledTextCtrl_SetZoom, METH_VARARGS | METH_KEYWORDS, NULL},

21586

{ (char *)"StyledTextCtrl_GetZoom", (PyCFunction)_wrap_StyledTextCtrl_GetZoom, METH_O, NULL},

21587

{ (char *)"StyledTextCtrl_CreateDocument", (PyCFunction)_wrap_StyledTextCtrl_CreateDocument, METH_O, NULL},

21588

{ (char *)"StyledTextCtrl_AddRefDocument", (PyCFunction) _wrap_StyledTextCtrl_AddRefDocument, METH_VARARGS | METH_KEYWORDS, NULL},

21589

{ (char *)"StyledTextCtrl_ReleaseDocument", (PyCFunction) _wrap_StyledTextCtrl_ReleaseDocument, METH_VARARGS | METH_KEYWORDS, NULL},

21590

{ (char *)"StyledTextCtrl_GetModEventMask", (PyCFunction)_wrap_StyledTextCtrl_GetModEventMask, METH_O, NULL},

21591

{ (char *)"StyledTextCtrl_SetSTCFocus", (PyCFunction) _wrap_StyledTextCtrl_SetSTCFocus, METH_VARARGS | METH_KEYWORDS, NULL},

21592

{ (char *)"StyledTextCtrl_GetSTCFocus", (PyCFunction)_wrap_StyledTextCtrl_GetSTCFocus, METH_O, NULL},

21593

{ (char *)"StyledTextCtrl_SetStatus", (PyCFunction) _wrap_StyledTextCtrl_SetStatus, METH_VARARGS | METH_KEYWORDS, NULL},

21594

{ (char *)"StyledTextCtrl_GetStatus", (PyCFunction)_wrap_StyledTextCtrl_GetStatus, METH_O, NULL},

21595

{ (char *)"StyledTextCtrl_SetMouseDownCaptures", (PyCFunction) _wrap_StyledTextCtrl_SetMouseDownCaptures, METH_VARARGS | METH_KEYWORDS, NULL},

21596

{ (char *)"StyledTextCtrl_GetMouseDownCaptures", (PyCFunction)_wrap_StyledTextCtrl_GetMouseDownCaptures, METH_O, NULL},

21597

{ (char *)"StyledTextCtrl_SetSTCCursor", (PyCFunction) _wrap_StyledTextCtrl_SetSTCCursor, METH_VARARGS | METH_KEYWORDS, NULL},

21598

{ (char *)"StyledTextCtrl_GetSTCCursor", (PyCFunction)_wrap_StyledTextCtrl_GetSTCCursor, METH_O, NULL},

21599

{ (char *)"StyledTextCtrl_SetControlCharSymbol", (PyCFunction) _wrap_StyledTextCtrl_SetControlCharSymbol, METH_VARARGS | METH_KEYWORDS, NULL},

21600

{ (char *)"StyledTextCtrl_GetControlCharSymbol", (PyCFunction)_wrap_StyledTextCtrl_GetControlCharSymbol, METH_O, NULL},

21601

{ (char *)"StyledTextCtrl_WordPartLeft", (PyCFunction)_wrap_StyledTextCtrl_WordPartLeft, METH_O, NULL},

21602

{ (char *)"StyledTextCtrl_WordPartLeftExtend", (PyCFunction)_wrap_StyledTextCtrl_WordPartLeftExtend, METH_O, NULL},

21603

{ (char *)"StyledTextCtrl_WordPartRight", (PyCFunction)_wrap_StyledTextCtrl_WordPartRight, METH_O, NULL},

21604

{ (char *)"StyledTextCtrl_WordPartRightExtend", (PyCFunction)_wrap_StyledTextCtrl_WordPartRightExtend, METH_O, NULL},

21605

{ (char *)"StyledTextCtrl_SetVisiblePolicy", (PyCFunction) _wrap_StyledTextCtrl_SetVisiblePolicy, METH_VARARGS | METH_KEYWORDS, NULL},

21606

{ (char *)"StyledTextCtrl_DelLineLeft", (PyCFunction)_wrap_StyledTextCtrl_DelLineLeft, METH_O, NULL},

21607

{ (char *)"StyledTextCtrl_DelLineRight", (PyCFunction)_wrap_StyledTextCtrl_DelLineRight, METH_O, NULL},

21608

{ (char *)"StyledTextCtrl_SetXOffset", (PyCFunction) _wrap_StyledTextCtrl_SetXOffset, METH_VARARGS | METH_KEYWORDS, NULL},

21609

{ (char *)"StyledTextCtrl_GetXOffset", (PyCFunction)_wrap_StyledTextCtrl_GetXOffset, METH_O, NULL},

21610

{ (char *)"StyledTextCtrl_ChooseCaretX", (PyCFunction)_wrap_StyledTextCtrl_ChooseCaretX, METH_O, NULL},

21611

{ (char *)"StyledTextCtrl_SetXCaretPolicy", (PyCFunction) _wrap_StyledTextCtrl_SetXCaretPolicy, METH_VARARGS | METH_KEYWORDS, NULL},

21612

{ (char *)"StyledTextCtrl_SetYCaretPolicy", (PyCFunction) _wrap_StyledTextCtrl_SetYCaretPolicy, METH_VARARGS | METH_KEYWORDS, NULL},

21613

{ (char *)"StyledTextCtrl_SetPrintWrapMode", (PyCFunction) _wrap_StyledTextCtrl_SetPrintWrapMode, METH_VARARGS | METH_KEYWORDS, NULL},

21614

{ (char *)"StyledTextCtrl_GetPrintWrapMode", (PyCFunction)_wrap_StyledTextCtrl_GetPrintWrapMode, METH_O, NULL},

21615

{ (char *)"StyledTextCtrl_SetHotspotActiveForeground", (PyCFunction) _wrap_StyledTextCtrl_SetHotspotActiveForeground, METH_VARARGS | METH_KEYWORDS, NULL},

21616

{ (char *)"StyledTextCtrl_SetHotspotActiveBackground", (PyCFunction) _wrap_StyledTextCtrl_SetHotspotActiveBackground, METH_VARARGS | METH_KEYWORDS, NULL},

21617

{ (char *)"StyledTextCtrl_SetHotspotActiveUnderline", (PyCFunction) _wrap_StyledTextCtrl_SetHotspotActiveUnderline, METH_VARARGS | METH_KEYWORDS, NULL},

21618

{ (char *)"StyledTextCtrl_SetHotspotSingleLine", (PyCFunction) _wrap_StyledTextCtrl_SetHotspotSingleLine, METH_VARARGS | METH_KEYWORDS, NULL},

21619

{ (char *)"StyledTextCtrl_ParaDown", (PyCFunction)_wrap_StyledTextCtrl_ParaDown, METH_O, NULL},

21620

{ (char *)"StyledTextCtrl_ParaDownExtend", (PyCFunction)_wrap_StyledTextCtrl_ParaDownExtend, METH_O, NULL},

21621

{ (char *)"StyledTextCtrl_ParaUp", (PyCFunction)_wrap_StyledTextCtrl_ParaUp, METH_O, NULL},

21622

{ (char *)"StyledTextCtrl_ParaUpExtend", (PyCFunction)_wrap_StyledTextCtrl_ParaUpExtend, METH_O, NULL},

21623

{ (char *)"StyledTextCtrl_PositionBefore", (PyCFunction) _wrap_StyledTextCtrl_PositionBefore, METH_VARARGS | METH_KEYWORDS, NULL},

21624

{ (char *)"StyledTextCtrl_PositionAfter", (PyCFunction) _wrap_StyledTextCtrl_PositionAfter, METH_VARARGS | METH_KEYWORDS, NULL},

21625

{ (char *)"StyledTextCtrl_CopyRange", (PyCFunction) _wrap_StyledTextCtrl_CopyRange, METH_VARARGS | METH_KEYWORDS, NULL},

21626

{ (char *)"StyledTextCtrl_CopyText", (PyCFunction) _wrap_StyledTextCtrl_CopyText, METH_VARARGS | METH_KEYWORDS, NULL},

21627

{ (char *)"StyledTextCtrl_SetSelectionMode", (PyCFunction) _wrap_StyledTextCtrl_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},

21628

{ (char *)"StyledTextCtrl_GetSelectionMode", (PyCFunction)_wrap_StyledTextCtrl_GetSelectionMode, METH_O, NULL},

21629

{ (char *)"StyledTextCtrl_GetLineSelStartPosition", (PyCFunction) _wrap_StyledTextCtrl_GetLineSelStartPosition, METH_VARARGS | METH_KEYWORDS, NULL},

21630

{ (char *)"StyledTextCtrl_GetLineSelEndPosition", (PyCFunction) _wrap_StyledTextCtrl_GetLineSelEndPosition, METH_VARARGS | METH_KEYWORDS, NULL},

21631

{ (char *)"StyledTextCtrl_LineDownRectExtend", (PyCFunction)_wrap_StyledTextCtrl_LineDownRectExtend, METH_O, NULL},

21632

{ (char *)"StyledTextCtrl_LineUpRectExtend", (PyCFunction)_wrap_StyledTextCtrl_LineUpRectExtend, METH_O, NULL},

21633

{ (char *)"StyledTextCtrl_CharLeftRectExtend", (PyCFunction)_wrap_StyledTextCtrl_CharLeftRectExtend, METH_O, NULL},

21634

{ (char *)"StyledTextCtrl_CharRightRectExtend", (PyCFunction)_wrap_StyledTextCtrl_CharRightRectExtend, METH_O, NULL},

21635

{ (char *)"StyledTextCtrl_HomeRectExtend", (PyCFunction)_wrap_StyledTextCtrl_HomeRectExtend, METH_O, NULL},

21636

{ (char *)"StyledTextCtrl_VCHomeRectExtend", (PyCFunction)_wrap_StyledTextCtrl_VCHomeRectExtend, METH_O, NULL},

21637

{ (char *)"StyledTextCtrl_LineEndRectExtend", (PyCFunction)_wrap_StyledTextCtrl_LineEndRectExtend, METH_O, NULL},

21638

{ (char *)"StyledTextCtrl_PageUpRectExtend", (PyCFunction)_wrap_StyledTextCtrl_PageUpRectExtend, METH_O, NULL},

21639

{ (char *)"StyledTextCtrl_PageDownRectExtend", (PyCFunction)_wrap_StyledTextCtrl_PageDownRectExtend, METH_O, NULL},

21640

{ (char *)"StyledTextCtrl_StutteredPageUp", (PyCFunction)_wrap_StyledTextCtrl_StutteredPageUp, METH_O, NULL},

21641

{ (char *)"StyledTextCtrl_StutteredPageUpExtend", (PyCFunction)_wrap_StyledTextCtrl_StutteredPageUpExtend, METH_O, NULL},

21642

{ (char *)"StyledTextCtrl_StutteredPageDown", (PyCFunction)_wrap_StyledTextCtrl_StutteredPageDown, METH_O, NULL},

21643

{ (char *)"StyledTextCtrl_StutteredPageDownExtend", (PyCFunction)_wrap_StyledTextCtrl_StutteredPageDownExtend, METH_O, NULL},

21644

{ (char *)"StyledTextCtrl_WordLeftEnd", (PyCFunction)_wrap_StyledTextCtrl_WordLeftEnd, METH_O, NULL},

21645

{ (char *)"StyledTextCtrl_WordLeftEndExtend", (PyCFunction)_wrap_StyledTextCtrl_WordLeftEndExtend, METH_O, NULL},

21646

{ (char *)"StyledTextCtrl_WordRightEnd", (PyCFunction)_wrap_StyledTextCtrl_WordRightEnd, METH_O, NULL},

21647

{ (char *)"StyledTextCtrl_WordRightEndExtend", (PyCFunction)_wrap_StyledTextCtrl_WordRightEndExtend, METH_O, NULL},

21648

{ (char *)"StyledTextCtrl_SetWhitespaceChars", (PyCFunction) _wrap_StyledTextCtrl_SetWhitespaceChars, METH_VARARGS | METH_KEYWORDS, NULL},

21649

{ (char *)"StyledTextCtrl_SetCharsDefault", (PyCFunction)_wrap_StyledTextCtrl_SetCharsDefault, METH_O, NULL},

21650

{ (char *)"StyledTextCtrl_AutoCompGetCurrent", (PyCFunction)_wrap_StyledTextCtrl_AutoCompGetCurrent, METH_O, NULL},

21651

{ (char *)"StyledTextCtrl_Allocate", (PyCFunction) _wrap_StyledTextCtrl_Allocate, METH_VARARGS | METH_KEYWORDS, NULL},

21652

{ (char *)"StyledTextCtrl_FindColumn", (PyCFunction) _wrap_StyledTextCtrl_FindColumn, METH_VARARGS | METH_KEYWORDS, NULL},

21653

{ (char *)"StyledTextCtrl_GetCaretSticky", (PyCFunction)_wrap_StyledTextCtrl_GetCaretSticky, METH_O, NULL},

21654

{ (char *)"StyledTextCtrl_SetCaretSticky", (PyCFunction) _wrap_StyledTextCtrl_SetCaretSticky, METH_VARARGS | METH_KEYWORDS, NULL},

21655

{ (char *)"StyledTextCtrl_ToggleCaretSticky", (PyCFunction)_wrap_StyledTextCtrl_ToggleCaretSticky, METH_O, NULL},

21656

{ (char *)"StyledTextCtrl_SetPasteConvertEndings", (PyCFunction) _wrap_StyledTextCtrl_SetPasteConvertEndings, METH_VARARGS | METH_KEYWORDS, NULL},

21657

{ (char *)"StyledTextCtrl_GetPasteConvertEndings", (PyCFunction)_wrap_StyledTextCtrl_GetPasteConvertEndings, METH_O, NULL},

21658

{ (char *)"StyledTextCtrl_SelectionDuplicate", (PyCFunction)_wrap_StyledTextCtrl_SelectionDuplicate, METH_O, NULL},

21659

{ (char *)"StyledTextCtrl_SetCaretLineBackAlpha", (PyCFunction) _wrap_StyledTextCtrl_SetCaretLineBackAlpha, METH_VARARGS | METH_KEYWORDS, NULL},

21660

{ (char *)"StyledTextCtrl_GetCaretLineBackAlpha", (PyCFunction)_wrap_StyledTextCtrl_GetCaretLineBackAlpha, METH_O, NULL},

21661

{ (char *)"StyledTextCtrl_StartRecord", (PyCFunction)_wrap_StyledTextCtrl_StartRecord, METH_O, NULL},

21662

{ (char *)"StyledTextCtrl_StopRecord", (PyCFunction)_wrap_StyledTextCtrl_StopRecord, METH_O, NULL},

21663

{ (char *)"StyledTextCtrl_SetLexer", (PyCFunction) _wrap_StyledTextCtrl_SetLexer, METH_VARARGS | METH_KEYWORDS, NULL},

21664

{ (char *)"StyledTextCtrl_GetLexer", (PyCFunction)_wrap_StyledTextCtrl_GetLexer, METH_O, NULL},

21665

{ (char *)"StyledTextCtrl_Colourise", (PyCFunction) _wrap_StyledTextCtrl_Colourise, METH_VARARGS | METH_KEYWORDS, NULL},

21666

{ (char *)"StyledTextCtrl_SetProperty", (PyCFunction) _wrap_StyledTextCtrl_SetProperty, METH_VARARGS | METH_KEYWORDS, NULL},

21667

{ (char *)"StyledTextCtrl_SetKeyWords", (PyCFunction) _wrap_StyledTextCtrl_SetKeyWords, METH_VARARGS | METH_KEYWORDS, NULL},

21668

{ (char *)"StyledTextCtrl_SetLexerLanguage", (PyCFunction) _wrap_StyledTextCtrl_SetLexerLanguage, METH_VARARGS | METH_KEYWORDS, NULL},

21669

{ (char *)"StyledTextCtrl_GetProperty", (PyCFunction) _wrap_StyledTextCtrl_GetProperty, METH_VARARGS | METH_KEYWORDS, NULL},

21670

{ (char *)"StyledTextCtrl_GetPropertyExpanded", (PyCFunction) _wrap_StyledTextCtrl_GetPropertyExpanded, METH_VARARGS | METH_KEYWORDS, NULL},

21671

{ (char *)"StyledTextCtrl_GetPropertyInt", (PyCFunction) _wrap_StyledTextCtrl_GetPropertyInt, METH_VARARGS | METH_KEYWORDS, NULL},

21672

{ (char *)"StyledTextCtrl_GetStyleBitsNeeded", (PyCFunction)_wrap_StyledTextCtrl_GetStyleBitsNeeded, METH_O, NULL},

21673

{ (char *)"StyledTextCtrl_GetCurrentLine", (PyCFunction)_wrap_StyledTextCtrl_GetCurrentLine, METH_O, NULL},

21674

{ (char *)"StyledTextCtrl_StyleSetSpec", (PyCFunction) _wrap_StyledTextCtrl_StyleSetSpec, METH_VARARGS | METH_KEYWORDS, NULL},

21675

{ (char *)"StyledTextCtrl_StyleSetFont", (PyCFunction) _wrap_StyledTextCtrl_StyleSetFont, METH_VARARGS | METH_KEYWORDS, NULL},

21676

{ (char *)"StyledTextCtrl_StyleSetFontAttr", (PyCFunction) _wrap_StyledTextCtrl_StyleSetFontAttr, METH_VARARGS | METH_KEYWORDS, NULL},

21677

{ (char *)"StyledTextCtrl_StyleSetCharacterSet", (PyCFunction) _wrap_StyledTextCtrl_StyleSetCharacterSet, METH_VARARGS | METH_KEYWORDS, NULL},

21678

{ (char *)"StyledTextCtrl_StyleSetFontEncoding", (PyCFunction) _wrap_StyledTextCtrl_StyleSetFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},

21679

{ (char *)"StyledTextCtrl_CmdKeyExecute", (PyCFunction) _wrap_StyledTextCtrl_CmdKeyExecute, METH_VARARGS | METH_KEYWORDS, NULL},

21680

{ (char *)"StyledTextCtrl_SetMargins", (PyCFunction) _wrap_StyledTextCtrl_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},

21681

{ (char *)"StyledTextCtrl_GetSelection", (PyCFunction)_wrap_StyledTextCtrl_GetSelection, METH_O, NULL},

21682

{ (char *)"StyledTextCtrl_PointFromPosition", (PyCFunction) _wrap_StyledTextCtrl_PointFromPosition, METH_VARARGS | METH_KEYWORDS, NULL},

21683

{ (char *)"StyledTextCtrl_ScrollToLine", (PyCFunction) _wrap_StyledTextCtrl_ScrollToLine, METH_VARARGS | METH_KEYWORDS, NULL},

21684

{ (char *)"StyledTextCtrl_ScrollToColumn", (PyCFunction) _wrap_StyledTextCtrl_ScrollToColumn, METH_VARARGS | METH_KEYWORDS, NULL},

21685

{ (char *)"StyledTextCtrl_SendMsg", (PyCFunction) _wrap_StyledTextCtrl_SendMsg, METH_VARARGS | METH_KEYWORDS, NULL},

21686

{ (char *)"StyledTextCtrl_SetVScrollBar", (PyCFunction) _wrap_StyledTextCtrl_SetVScrollBar, METH_VARARGS | METH_KEYWORDS, NULL},

21687

{ (char *)"StyledTextCtrl_SetHScrollBar", (PyCFunction) _wrap_StyledTextCtrl_SetHScrollBar, METH_VARARGS | METH_KEYWORDS, NULL},

21688

{ (char *)"StyledTextCtrl_GetLastKeydownProcessed", (PyCFunction)_wrap_StyledTextCtrl_GetLastKeydownProcessed, METH_O, NULL},

21689

{ (char *)"StyledTextCtrl_SetLastKeydownProcessed", (PyCFunction) _wrap_StyledTextCtrl_SetLastKeydownProcessed, METH_VARARGS | METH_KEYWORDS, NULL},

21690

{ (char *)"StyledTextCtrl_SaveFile", (PyCFunction) _wrap_StyledTextCtrl_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},

21691

{ (char *)"StyledTextCtrl_LoadFile", (PyCFunction) _wrap_StyledTextCtrl_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},

21692

{ (char *)"StyledTextCtrl_DoDragOver", (PyCFunction) _wrap_StyledTextCtrl_DoDragOver, METH_VARARGS | METH_KEYWORDS, NULL},

21693

{ (char *)"StyledTextCtrl_DoDropText", (PyCFunction) _wrap_StyledTextCtrl_DoDropText, METH_VARARGS | METH_KEYWORDS, NULL},

21694

{ (char *)"StyledTextCtrl_SetUseAntiAliasing", (PyCFunction) _wrap_StyledTextCtrl_SetUseAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},

21695

{ (char *)"StyledTextCtrl_GetUseAntiAliasing", (PyCFunction)_wrap_StyledTextCtrl_GetUseAntiAliasing, METH_O, NULL},

21696

{ (char *)"StyledTextCtrl_AddTextRaw", (PyCFunction) _wrap_StyledTextCtrl_AddTextRaw, METH_VARARGS | METH_KEYWORDS, NULL},

21697

{ (char *)"StyledTextCtrl_InsertTextRaw", (PyCFunction) _wrap_StyledTextCtrl_InsertTextRaw, METH_VARARGS | METH_KEYWORDS, NULL},

21698

{ (char *)"StyledTextCtrl_GetCurLineRaw", (PyCFunction)_wrap_StyledTextCtrl_GetCurLineRaw, METH_O, NULL},

21699

{ (char *)"StyledTextCtrl_GetLineRaw", (PyCFunction) _wrap_StyledTextCtrl_GetLineRaw, METH_VARARGS | METH_KEYWORDS, NULL},

21700

{ (char *)"StyledTextCtrl_GetSelectedTextRaw", (PyCFunction)_wrap_StyledTextCtrl_GetSelectedTextRaw, METH_O, NULL},

21701

{ (char *)"StyledTextCtrl_GetTextRangeRaw", (PyCFunction) _wrap_StyledTextCtrl_GetTextRangeRaw, METH_VARARGS | METH_KEYWORDS, NULL},

21702

{ (char *)"StyledTextCtrl_SetTextRaw", (PyCFunction) _wrap_StyledTextCtrl_SetTextRaw, METH_VARARGS | METH_KEYWORDS, NULL},

21703

{ (char *)"StyledTextCtrl_GetTextRaw", (PyCFunction)_wrap_StyledTextCtrl_GetTextRaw, METH_O, NULL},

21704

{ (char *)"StyledTextCtrl_AppendTextRaw", (PyCFunction) _wrap_StyledTextCtrl_AppendTextRaw, METH_VARARGS | METH_KEYWORDS, NULL},

21705

{ (char *)"StyledTextCtrl_swigregister", StyledTextCtrl_swigregister, METH_VARARGS, NULL},

21706

{ (char *)"StyledTextCtrl_swiginit", StyledTextCtrl_swiginit, METH_VARARGS, NULL},

21707

{ (char *)"new_StyledTextEvent", (PyCFunction) _wrap_new_StyledTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},

21708

{ (char *)"delete_StyledTextEvent", (PyCFunction)_wrap_delete_StyledTextEvent, METH_O, NULL},

21709

{ (char *)"StyledTextEvent_SetPosition", (PyCFunction) _wrap_StyledTextEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},

21710

{ (char *)"StyledTextEvent_SetKey", (PyCFunction) _wrap_StyledTextEvent_SetKey, METH_VARARGS | METH_KEYWORDS, NULL},

21711

{ (char *)"StyledTextEvent_SetModifiers", (PyCFunction) _wrap_StyledTextEvent_SetModifiers, METH_VARARGS | METH_KEYWORDS, NULL},

21712

{ (char *)"StyledTextEvent_SetModificationType", (PyCFunction) _wrap_StyledTextEvent_SetModificationType, METH_VARARGS | METH_KEYWORDS, NULL},

21713

{ (char *)"StyledTextEvent_SetText", (PyCFunction) _wrap_StyledTextEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},

21714

{ (char *)"StyledTextEvent_SetLength", (PyCFunction) _wrap_StyledTextEvent_SetLength, METH_VARARGS | METH_KEYWORDS, NULL},

21715

{ (char *)"StyledTextEvent_SetLinesAdded", (PyCFunction) _wrap_StyledTextEvent_SetLinesAdded, METH_VARARGS | METH_KEYWORDS, NULL},

21716

{ (char *)"StyledTextEvent_SetLine", (PyCFunction) _wrap_StyledTextEvent_SetLine, METH_VARARGS | METH_KEYWORDS, NULL},

21717

{ (char *)"StyledTextEvent_SetFoldLevelNow", (PyCFunction) _wrap_StyledTextEvent_SetFoldLevelNow, METH_VARARGS | METH_KEYWORDS, NULL},

21718

{ (char *)"StyledTextEvent_SetFoldLevelPrev", (PyCFunction) _wrap_StyledTextEvent_SetFoldLevelPrev, METH_VARARGS | METH_KEYWORDS, NULL},

21719

{ (char *)"StyledTextEvent_SetMargin", (PyCFunction) _wrap_StyledTextEvent_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},

21720

{ (char *)"StyledTextEvent_SetMessage", (PyCFunction) _wrap_StyledTextEvent_SetMessage, METH_VARARGS | METH_KEYWORDS, NULL},

21721

{ (char *)"StyledTextEvent_SetWParam", (PyCFunction) _wrap_StyledTextEvent_SetWParam, METH_VARARGS | METH_KEYWORDS, NULL},

21722

{ (char *)"StyledTextEvent_SetLParam", (PyCFunction) _wrap_StyledTextEvent_SetLParam, METH_VARARGS | METH_KEYWORDS, NULL},

21723

{ (char *)"StyledTextEvent_SetListType", (PyCFunction) _wrap_StyledTextEvent_SetListType, METH_VARARGS | METH_KEYWORDS, NULL},

21724

{ (char *)"StyledTextEvent_SetX", (PyCFunction) _wrap_StyledTextEvent_SetX, METH_VARARGS | METH_KEYWORDS, NULL},

21725

{ (char *)"StyledTextEvent_SetY", (PyCFunction) _wrap_StyledTextEvent_SetY, METH_VARARGS | METH_KEYWORDS, NULL},

21726

{ (char *)"StyledTextEvent_SetDragText", (PyCFunction) _wrap_StyledTextEvent_SetDragText, METH_VARARGS | METH_KEYWORDS, NULL},

21727

{ (char *)"StyledTextEvent_SetDragAllowMove", (PyCFunction) _wrap_StyledTextEvent_SetDragAllowMove, METH_VARARGS | METH_KEYWORDS, NULL},

21728

{ (char *)"StyledTextEvent_SetDragResult", (PyCFunction) _wrap_StyledTextEvent_SetDragResult, METH_VARARGS | METH_KEYWORDS, NULL},

21729

{ (char *)"StyledTextEvent_GetPosition", (PyCFunction)_wrap_StyledTextEvent_GetPosition, METH_O, NULL},

21730

{ (char *)"StyledTextEvent_GetKey", (PyCFunction)_wrap_StyledTextEvent_GetKey, METH_O, NULL},

21731

{ (char *)"StyledTextEvent_GetModifiers", (PyCFunction)_wrap_StyledTextEvent_GetModifiers, METH_O, NULL},

21732

{ (char *)"StyledTextEvent_GetModificationType", (PyCFunction)_wrap_StyledTextEvent_GetModificationType, METH_O, NULL},

21733

{ (char *)"StyledTextEvent_GetText", (PyCFunction)_wrap_StyledTextEvent_GetText, METH_O, NULL},

21734

{ (char *)"StyledTextEvent_GetLength", (PyCFunction)_wrap_StyledTextEvent_GetLength, METH_O, NULL},

21735

{ (char *)"StyledTextEvent_GetLinesAdded", (PyCFunction)_wrap_StyledTextEvent_GetLinesAdded, METH_O, NULL},

21736

{ (char *)"StyledTextEvent_GetLine", (PyCFunction)_wrap_StyledTextEvent_GetLine, METH_O, NULL},

21737

{ (char *)"StyledTextEvent_GetFoldLevelNow", (PyCFunction)_wrap_StyledTextEvent_GetFoldLevelNow, METH_O, NULL},

21738

{ (char *)"StyledTextEvent_GetFoldLevelPrev", (PyCFunction)_wrap_StyledTextEvent_GetFoldLevelPrev, METH_O, NULL},

21739

{ (char *)"StyledTextEvent_GetMargin", (PyCFunction)_wrap_StyledTextEvent_GetMargin, METH_O, NULL},

21740

{ (char *)"StyledTextEvent_GetMessage", (PyCFunction)_wrap_StyledTextEvent_GetMessage, METH_O, NULL},

21741

{ (char *)"StyledTextEvent_GetWParam", (PyCFunction)_wrap_StyledTextEvent_GetWParam, METH_O, NULL},

21742

{ (char *)"StyledTextEvent_GetLParam", (PyCFunction)_wrap_StyledTextEvent_GetLParam, METH_O, NULL},

21743

{ (char *)"StyledTextEvent_GetListType", (PyCFunction)_wrap_StyledTextEvent_GetListType, METH_O, NULL},

21744

{ (char *)"StyledTextEvent_GetX", (PyCFunction)_wrap_StyledTextEvent_GetX, METH_O, NULL},

21745

{ (char *)"StyledTextEvent_GetY", (PyCFunction)_wrap_StyledTextEvent_GetY, METH_O, NULL},

21746

{ (char *)"StyledTextEvent_GetDragText", (PyCFunction)_wrap_StyledTextEvent_GetDragText, METH_O, NULL},

21747

{ (char *)"StyledTextEvent_GetDragAllowMove", (PyCFunction)_wrap_StyledTextEvent_GetDragAllowMove, METH_O, NULL},

21748

{ (char *)"StyledTextEvent_GetDragResult", (PyCFunction)_wrap_StyledTextEvent_GetDragResult, METH_O, NULL},

21749

{ (char *)"StyledTextEvent_GetShift", (PyCFunction)_wrap_StyledTextEvent_GetShift, METH_O, NULL},

21750

{ (char *)"StyledTextEvent_GetControl", (PyCFunction)_wrap_StyledTextEvent_GetControl, METH_O, NULL},

21751

{ (char *)"StyledTextEvent_GetAlt", (PyCFunction)_wrap_StyledTextEvent_GetAlt, METH_O, NULL},

21752

{ (char *)"StyledTextEvent_swigregister", StyledTextEvent_swigregister, METH_VARARGS, NULL},

21753

{ (char *)"StyledTextEvent_swiginit", StyledTextEvent_swiginit, METH_VARARGS, NULL},

21754

{ NULL, NULL, 0, NULL }

21755

};

21756

21757

21758

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

21759

21760

static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {

21761

return (void *)((wxObject *) ((wxLayoutConstraints *) x));

21762

}

21763

static void *_p_wxSizerItemTo_p_wxObject(void *x) {

21764

return (void *)((wxObject *) ((wxSizerItem *) x));

21765

}

21766

static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {

21767

return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));

21768

}

21769

static void *_p_wxScrollEventTo_p_wxObject(void *x) {

21770

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));

21771

}

21772

static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {

21773

return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));

21774

}

21775

static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {

21776

return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));

21777

}

21778

static void *_p_wxBoxSizerTo_p_wxObject(void *x) {

21779

return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));

21780

}

21781

static void *_p_wxSizerTo_p_wxObject(void *x) {

21782

return (void *)((wxObject *) ((wxSizer *) x));

21783

}

21784

static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {

21785

return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));

21786

}

21787

static void *_p_wxFileHistoryTo_p_wxObject(void *x) {

21788

return (void *)((wxObject *) ((wxFileHistory *) x));

21789

}

21790

static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {

21791

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));

21792

}

21793

static void *_p_wxEventTo_p_wxObject(void *x) {

21794

return (void *)((wxObject *) ((wxEvent *) x));

21795

}

21796

static void *_p_wxGridSizerTo_p_wxObject(void *x) {

21797

return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));

21798

}

21799

static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {

21800

return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));

21801

}

21802

static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {

21803

return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));

21804

}

21805

static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {

21806

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));

21807

}

21808

static void *_p_wxPaintEventTo_p_wxObject(void *x) {

21809

return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));

21810

}

21811

static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {

21812

return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));

21813

}

21814

static void *_p_wxStyledTextEventTo_p_wxObject(void *x) {

21815

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxStyledTextEvent *) x));

21816

}

21817

static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {

21818

return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));

21819

}

21820

static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {

21821

return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));

21822

}

21823

static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {

21824

return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));

21825

}

21826

static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {

21827

return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));

21828

}

21829

static void *_p_wxControlTo_p_wxObject(void *x) {

21830

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));

21831

}

21832

static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {

21833

return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));

21834

}

21835

static void *_p_wxTimerEventTo_p_wxObject(void *x) {

21836

return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));

21837

}

21838

static void *_p_wxPowerEventTo_p_wxObject(void *x) {

21839

return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));

21840

}

21841

static void *_p_wxFSFileTo_p_wxObject(void *x) {

21842

return (void *)((wxObject *) ((wxFSFile *) x));

21843

}

21844

static void *_p_wxClipboardTo_p_wxObject(void *x) {

21845

return (void *)((wxObject *) ((wxClipboard *) x));

21846

}

21847

static void *_p_wxPySizerTo_p_wxObject(void *x) {

21848

return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));

21849

}

21850

static void *_p_wxStyledTextCtrlTo_p_wxObject(void *x) {

21851

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxStyledTextCtrl *) x));

21852

}

21853

static void *_p_wxPyEventTo_p_wxObject(void *x) {

21854

return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));

21855

}

21856

static void *_p_wxNotifyEventTo_p_wxObject(void *x) {

21857

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));

21858

}

21859

static void *_p_wxShowEventTo_p_wxObject(void *x) {

21860

return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));

21861

}

21862

static void *_p_wxToolTipTo_p_wxObject(void *x) {

21863

return (void *)((wxObject *) ((wxToolTip *) x));

21864

}

21865

static void *_p_wxMenuItemTo_p_wxObject(void *x) {

21866

return (void *)((wxObject *) ((wxMenuItem *) x));

21867

}

21868

static void *_p_wxDateEventTo_p_wxObject(void *x) {

21869

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));

21870

}

21871

static void *_p_wxIdleEventTo_p_wxObject(void *x) {

21872

return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));

21873

}

21874

static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {

21875

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));

21876

}

21877

static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {

21878

return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));

21879

}

21880

static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {

21881

return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));

21882

}

21883

static void *_p_wxIconizeEventTo_p_wxObject(void *x) {

21884

return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));

21885

}

21886

static void *_p_wxActivateEventTo_p_wxObject(void *x) {

21887

return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));

21888

}

21889

static void *_p_wxSizeEventTo_p_wxObject(void *x) {

21890

return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));

21891

}

21892

static void *_p_wxMoveEventTo_p_wxObject(void *x) {

21893

return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));

21894

}

21895

static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {

21896

return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));

21897

}

21898

static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {

21899

return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));

21900

}

21901

static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {

21902

return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));

21903

}

21904

static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {

21905

return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));

21906

}

21907

static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {

21908

return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));

21909

}

21910

static void *_p_wxANIHandlerTo_p_wxObject(void *x) {

21911

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));

21912

}

21913

static void *_p_wxCURHandlerTo_p_wxObject(void *x) {

21914

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));

21915

}

21916

static void *_p_wxICOHandlerTo_p_wxObject(void *x) {

21917

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));

21918

}

21919

static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {

21920

return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));

21921

}

21922

static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {

21923

return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));

21924

}

21925

static void *_p_wxImageHandlerTo_p_wxObject(void *x) {

21926

return (void *)((wxObject *) ((wxImageHandler *) x));

21927

}

21928

static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {

21929

return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));

21930

}

21931

static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {

21932

return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));

21933

}

21934

static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {

21935

return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));

21936

}

21937

static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {

21938

return (void *)((wxObject *) ((wxEvtHandler *) x));

21939

}

21940

static void *_p_wxPyEvtHandlerTo_p_wxObject(void *x) {

21941

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyEvtHandler *) x));

21942

}

21943

static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {

21944

return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));

21945

}

21946

static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {

21947

return (void *)((wxObject *) ((wxAcceleratorTable *) x));

21948

}

21949

static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {

21950

return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));

21951

}

21952

static void *_p_wxImageTo_p_wxObject(void *x) {

21953

return (void *)((wxObject *) ((wxImage *) x));

21954

}

21955

static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {

21956

return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));

21957

}

21958

static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {

21959

return (void *)((wxObject *) ((wxSystemOptions *) x));

21960

}

21961

static void *_p_wxJoystickEventTo_p_wxObject(void *x) {

21962

return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));

21963

}

21964

static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {

21965

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));

21966

}

21967

static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {

21968

return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));

21969

}

21970

static void *_p_wxKeyEventTo_p_wxObject(void *x) {

21971

return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));

21972

}

21973

static void *_p_wxWindowTo_p_wxObject(void *x) {

21974

return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));

21975

}

21976

static void *_p_wxMenuTo_p_wxObject(void *x) {

21977

return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));

21978

}

21979

static void *_p_wxMenuBarTo_p_wxObject(void *x) {

21980

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));

21981

}

21982

static void *_p_wxPyProcessTo_p_wxObject(void *x) {

21983

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));

21984

}

21985

static void *_p_wxFileSystemTo_p_wxObject(void *x) {

21986

return (void *)((wxObject *) ((wxFileSystem *) x));

21987

}

21988

static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {

21989

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));

21990

}

21991

static void *_p_wxMenuEventTo_p_wxObject(void *x) {

21992

return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));

21993

}

21994

static void *_p_wxPyAppTo_p_wxObject(void *x) {

21995

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));

21996

}

21997

static void *_p_wxCloseEventTo_p_wxObject(void *x) {

21998

return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));

21999

}

22000

static void *_p_wxMouseEventTo_p_wxObject(void *x) {

22001

return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));

22002

}

22003

static void *_p_wxEraseEventTo_p_wxObject(void *x) {

22004

return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));

22005

}

22006

static void *_p_wxBusyInfoTo_p_wxObject(void *x) {

22007

return (void *)((wxObject *) ((wxBusyInfo *) x));

22008

}

22009

static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {

22010

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));

22011

}

22012

static void *_p_wxCommandEventTo_p_wxObject(void *x) {

22013

return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));

22014

}

22015

static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {

22016

return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));

22017

}

22018

static void *_p_wxFocusEventTo_p_wxObject(void *x) {

22019

return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));

22020

}

22021

static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {

22022

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));

22023

}

22024

static void *_p_wxProcessEventTo_p_wxObject(void *x) {

22025

return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));

22026

}

22027

static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {

22028

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));

22029

}

22030

static void *_p_wxPyValidatorTo_p_wxObject(void *x) {

22031

return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));

22032

}

22033

static void *_p_wxValidatorTo_p_wxObject(void *x) {

22034

return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));

22035

}

22036

static void *_p_wxPyTimerTo_p_wxObject(void *x) {

22037

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));

22038

}

22039

static void *_p_wxControlTo_p_wxWindow(void *x) {

22040

return (void *)((wxWindow *) ((wxControl *) x));

22041

}

22042

static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {

22043

return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));

22044

}

22045

static void *_p_wxStyledTextCtrlTo_p_wxWindow(void *x) {

22046

return (void *)((wxWindow *) (wxControl *) ((wxStyledTextCtrl *) x));

22047

}

22048

static void *_p_wxMenuBarTo_p_wxWindow(void *x) {

22049

return (void *)((wxWindow *) ((wxMenuBar *) x));

22050

}

22051

static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {

22052

return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));

22053

}

22054

static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {

22055

return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));

22056

}

22057

static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {

22058

return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));

22059

}

22060

static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {

22061

return (void *)((wxCommandEvent *) ((wxDateEvent *) x));

22062

}

22063

static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {

22064

return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));

22065

}

22066

static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {

22067

return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));

22068

}

22069

static void *_p_wxStyledTextEventTo_p_wxCommandEvent(void *x) {

22070

return (void *)((wxCommandEvent *) ((wxStyledTextEvent *) x));

22071

}

22072

static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {

22073

return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));

22074

}

22075

static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {

22076

return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));

22077

}

22078

static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {

22079

return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));

22080

}

22081

static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {

22082

return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));

22083

}

22084

static void *_p_wxControlTo_p_wxEvtHandler(void *x) {

22085

return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));

22086

}

22087

static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {

22088

return (void *)((wxEvtHandler *) ((wxWindow *) x));

22089

}

22090

static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {

22091

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));

22092

}

22093

static void *_p_wxPyEvtHandlerTo_p_wxEvtHandler(void *x) {

22094

return (void *)((wxEvtHandler *) ((wxPyEvtHandler *) x));

22095

}

22096

static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {

22097

return (void *)((wxEvtHandler *) ((wxPyApp *) x));

22098

}

22099

static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {

22100

return (void *)((wxEvtHandler *) ((wxPyTimer *) x));

22101

}

22102

static void *_p_wxStyledTextCtrlTo_p_wxEvtHandler(void *x) {

22103

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxStyledTextCtrl *) x));

22104

}

22105

static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {

22106

return (void *)((wxEvtHandler *) ((wxValidator *) x));

22107

}

22108

static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {

22109

return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));

22110

}

22111

static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {

22112

return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));

22113

}

22114

static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {

22115

return (void *)((wxEvtHandler *) ((wxMenu *) x));

22116

}

22117

static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {

22118

return (void *)((wxEvtHandler *) ((wxPyProcess *) x));

22119

}

22120

static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {

22121

return (void *)((wxControl *) ((wxControlWithItems *) x));

22122

}

22123

static void *_p_wxStyledTextCtrlTo_p_wxControl(void *x) {

22124

return (void *)((wxControl *) ((wxStyledTextCtrl *) x));

22125

}

22126

static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {

22127

return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));

22128

}

22129

static void *_p_wxMenuEventTo_p_wxEvent(void *x) {

22130

return (void *)((wxEvent *) ((wxMenuEvent *) x));

22131

}

22132

static void *_p_wxCloseEventTo_p_wxEvent(void *x) {

22133

return (void *)((wxEvent *) ((wxCloseEvent *) x));

22134

}

22135

static void *_p_wxMouseEventTo_p_wxEvent(void *x) {

22136

return (void *)((wxEvent *) ((wxMouseEvent *) x));

22137

}

22138

static void *_p_wxEraseEventTo_p_wxEvent(void *x) {

22139

return (void *)((wxEvent *) ((wxEraseEvent *) x));

22140

}

22141

static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {

22142

return (void *)((wxEvent *) ((wxSetCursorEvent *) x));

22143

}

22144

static void *_p_wxTimerEventTo_p_wxEvent(void *x) {

22145

return (void *)((wxEvent *) ((wxTimerEvent *) x));

22146

}

22147

static void *_p_wxPowerEventTo_p_wxEvent(void *x) {

22148

return (void *)((wxEvent *) ((wxPowerEvent *) x));

22149

}

22150

static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {

22151

return (void *)((wxEvent *) ((wxInitDialogEvent *) x));

22152

}

22153

static void *_p_wxScrollEventTo_p_wxEvent(void *x) {

22154

return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));

22155

}

22156

static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {

22157

return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));

22158

}

22159

static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {

22160

return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));

22161

}

22162

static void *_p_wxPyEventTo_p_wxEvent(void *x) {

22163

return (void *)((wxEvent *) ((wxPyEvent *) x));

22164

}

22165

static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {

22166

return (void *)((wxEvent *) ((wxJoystickEvent *) x));

22167

}

22168

static void *_p_wxIdleEventTo_p_wxEvent(void *x) {

22169

return (void *)((wxEvent *) ((wxIdleEvent *) x));

22170

}

22171

static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {

22172

return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));

22173

}

22174

static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {

22175

return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));

22176

}

22177

static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {

22178

return (void *)((wxEvent *) ((wxMaximizeEvent *) x));

22179

}

22180

static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {

22181

return (void *)((wxEvent *) ((wxIconizeEvent *) x));

22182

}

22183

static void *_p_wxActivateEventTo_p_wxEvent(void *x) {

22184

return (void *)((wxEvent *) ((wxActivateEvent *) x));

22185

}

22186

static void *_p_wxSizeEventTo_p_wxEvent(void *x) {

22187

return (void *)((wxEvent *) ((wxSizeEvent *) x));

22188

}

22189

static void *_p_wxMoveEventTo_p_wxEvent(void *x) {

22190

return (void *)((wxEvent *) ((wxMoveEvent *) x));

22191

}

22192

static void *_p_wxDateEventTo_p_wxEvent(void *x) {

22193

return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));

22194

}

22195

static void *_p_wxPaintEventTo_p_wxEvent(void *x) {

22196

return (void *)((wxEvent *) ((wxPaintEvent *) x));

22197

}

22198

static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {

22199

return (void *)((wxEvent *) ((wxNcPaintEvent *) x));

22200

}

22201

static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {

22202

return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));

22203

}

22204

static void *_p_wxStyledTextEventTo_p_wxEvent(void *x) {

22205

return (void *)((wxEvent *) (wxCommandEvent *) ((wxStyledTextEvent *) x));

22206

}

22207

static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {

22208

return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));

22209

}

22210

static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {

22211

return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));

22212

}

22213

static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {

22214

return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));

22215

}

22216

static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {

22217

return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));

22218

}

22219

static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {

22220

return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));

22221

}

22222

static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {

22223

return (void *)((wxEvent *) ((wxDropFilesEvent *) x));

22224

}

22225

static void *_p_wxFocusEventTo_p_wxEvent(void *x) {

22226

return (void *)((wxEvent *) ((wxFocusEvent *) x));

22227

}

22228

static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {

22229

return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));

22230

}

22231

static void *_p_wxProcessEventTo_p_wxEvent(void *x) {

22232

return (void *)((wxEvent *) ((wxProcessEvent *) x));

22233

}

22234

static void *_p_wxShowEventTo_p_wxEvent(void *x) {

22235

return (void *)((wxEvent *) ((wxShowEvent *) x));

22236

}

22237

static void *_p_wxCommandEventTo_p_wxEvent(void *x) {

22238

return (void *)((wxEvent *) ((wxCommandEvent *) x));

22239

}

22240

static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {

22241

return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));

22242

}

22243

static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {

22244

return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));

22245

}

22246

static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {

22247

return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));

22248

}

22249

static void *_p_wxKeyEventTo_p_wxEvent(void *x) {

22250

return (void *)((wxEvent *) ((wxKeyEvent *) x));

22251

}

22252

static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {

22253

return (void *)((wxEvent *) ((wxScrollWinEvent *) x));

22254

}

22255

static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};

22256

static swig_type_info _swigt__p_double = {"_p_double", "double *|wxDouble *", 0, 0, (void*)0, 0};

22257

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};

22258

static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};

22259

static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};

22260

static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};

22261

static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};

22262

static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};

22263

static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};

22264

static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};

22265

static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};

22266

static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};

22267

static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};

22268

static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};

22269

static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};

22270

static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};

22271

static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};

22272

static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};

22273

static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};

22274

static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};

22275

static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};

22276

static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};

22277

static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};

22278

static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};

22279

static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};

22280

static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};

22281

static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};

22282

static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};

22283

static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};

22284

static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};

22285

static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};

22286

static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", 0, 0, 0, 0, 0};

22287

static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", 0, 0, 0, 0, 0};

22288

static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};

22289

static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};

22290

static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};

22291

static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", 0, 0, 0, 0, 0};

22292

static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};

22293

static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};

22294

static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};

22295

static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};

22296

static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};

22297

static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};

22298

static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};

22299

static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};

22300

static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};

22301

static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};

22302

static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};

22303

static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};

22304

static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};

22305

static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};

22306

static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};

22307

static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", 0, 0, 0, 0, 0};

22308

static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};

22309

static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};

22310

static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};

22311

static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};

22312

static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};

22313

static swig_type_info _swigt__p_wxPyEvtHandler = {"_p_wxPyEvtHandler", 0, 0, 0, 0, 0};

22314

static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};

22315

static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", 0, 0, 0, 0, 0};

22316

static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};

22317

static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};

22318

static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};

22319

static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};

22320

static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", 0, 0, 0, 0, 0};

22321

static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};

22322

static swig_type_info _swigt__p_wxIntPtr = {"_p_wxIntPtr", "wxIntPtr *", 0, 0, (void*)0, 0};

22323

static swig_type_info _swigt__p_wxMemoryBuffer = {"_p_wxMemoryBuffer", "wxMemoryBuffer *", 0, 0, (void*)0, 0};

22324

static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};

22325

static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};

22326

static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};

22327

static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};

22328

static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};

22329

static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};

22330

static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};

22331

static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};

22332

static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};

22333

static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", 0, 0, 0, 0, 0};

22334

static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};

22335

static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};

22336

static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};

22337

static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", 0, 0, 0, 0, 0};

22338

static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};

22339

static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", 0, 0, 0, 0, 0};

22340

static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};

22341

static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};

22342

static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};

22343

static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};

22344

static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};

22345

static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};

22346

static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};

22347

static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};

22348

static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};

22349

static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};

22350

static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};

22351

static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};

22352

static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};

22353

static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};

22354

static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};

22355

static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};

22356

static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};

22357

static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};

22358

static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", 0, 0, 0, 0, 0};

22359

static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};

22360

static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", 0, 0, 0, 0, 0};

22361

static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};

22362

static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};

22363

static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};

22364

static swig_type_info _swigt__p_wxScrollBar = {"_p_wxScrollBar", "wxScrollBar *", 0, 0, (void*)0, 0};

22365

static swig_type_info _swigt__p_wxStyledTextCtrl = {"_p_wxStyledTextCtrl", "wxStyledTextCtrl *", 0, 0, (void*)0, 0};

22366

static swig_type_info _swigt__p_wxStyledTextEvent = {"_p_wxStyledTextEvent", "wxStyledTextEvent *", 0, 0, (void*)0, 0};

22367

static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};

22368

22369

static swig_type_info *swig_type_initial[] = {

22370

&_swigt__p_char,

22371

&_swigt__p_double,

22372

&_swigt__p_form_ops_t,

22373

&_swigt__p_int,

22374

&_swigt__p_unsigned_char,

22375

&_swigt__p_unsigned_int,

22376

&_swigt__p_unsigned_long,

22377

&_swigt__p_void,

22378

&_swigt__p_wxANIHandler,

22379

&_swigt__p_wxAcceleratorTable,

22380

&_swigt__p_wxActivateEvent,

22381

&_swigt__p_wxBMPHandler,

22382

&_swigt__p_wxBitmap,

22383

&_swigt__p_wxBoxSizer,

22384

&_swigt__p_wxBusyInfo,

22385

&_swigt__p_wxCURHandler,

22386

&_swigt__p_wxChildFocusEvent,

22387

&_swigt__p_wxClipboard,

22388

&_swigt__p_wxClipboardTextEvent,

22389

&_swigt__p_wxCloseEvent,

22390

&_swigt__p_wxColour,

22391

&_swigt__p_wxCommandEvent,

22392

&_swigt__p_wxContextMenuEvent,

22393

&_swigt__p_wxControl,

22394

&_swigt__p_wxControlWithItems,

22395

&_swigt__p_wxDC,

22396

&_swigt__p_wxDateEvent,

22397

&_swigt__p_wxDisplayChangedEvent,

22398

&_swigt__p_wxDropFilesEvent,

22399

&_swigt__p_wxDuplexMode,

22400

&_swigt__p_wxEraseEvent,

22401

&_swigt__p_wxEvent,

22402

&_swigt__p_wxEvtHandler,

22403

&_swigt__p_wxFSFile,

22404

&_swigt__p_wxFileHistory,

22405

&_swigt__p_wxFileSystem,

22406

&_swigt__p_wxFlexGridSizer,

22407

&_swigt__p_wxFocusEvent,

22408

&_swigt__p_wxFont,

22409

&_swigt__p_wxGBSizerItem,

22410

&_swigt__p_wxGIFHandler,

22411

&_swigt__p_wxGridBagSizer,

22412

&_swigt__p_wxGridSizer,

22413

&_swigt__p_wxICOHandler,

22414

&_swigt__p_wxIconizeEvent,

22415

&_swigt__p_wxIdleEvent,

22416

&_swigt__p_wxImage,

22417

&_swigt__p_wxImageHandler,

22418

&_swigt__p_wxIndividualLayoutConstraint,

22419

&_swigt__p_wxInitDialogEvent,

22420

&_swigt__p_wxIntPtr,

22421

&_swigt__p_wxJPEGHandler,

22422

&_swigt__p_wxJoystickEvent,

22423

&_swigt__p_wxKeyEvent,

22424

&_swigt__p_wxLayoutConstraints,

22425

&_swigt__p_wxMaximizeEvent,

22426

&_swigt__p_wxMemoryBuffer,

22427

&_swigt__p_wxMenu,

22428

&_swigt__p_wxMenuBar,

22429

&_swigt__p_wxMenuEvent,

22430

&_swigt__p_wxMenuItem,

22431

&_swigt__p_wxMouseCaptureChangedEvent,

22432

&_swigt__p_wxMouseCaptureLostEvent,

22433

&_swigt__p_wxMouseEvent,

22434

&_swigt__p_wxMoveEvent,

22435

&_swigt__p_wxNavigationKeyEvent,

22436

&_swigt__p_wxNcPaintEvent,

22437

&_swigt__p_wxNotifyEvent,

22438

&_swigt__p_wxObject,

22439

&_swigt__p_wxPCXHandler,

22440

&_swigt__p_wxPNGHandler,

22441

&_swigt__p_wxPNMHandler,

22442

&_swigt__p_wxPaintEvent,

22443

&_swigt__p_wxPaletteChangedEvent,

22444

&_swigt__p_wxPaperSize,

22445

&_swigt__p_wxPoint,

22446

&_swigt__p_wxPowerEvent,

22447

&_swigt__p_wxProcessEvent,

22448

&_swigt__p_wxPyApp,

22449

&_swigt__p_wxPyCommandEvent,

22450

&_swigt__p_wxPyEvent,

22451

&_swigt__p_wxPyEvtHandler,

22452

&_swigt__p_wxPyImageHandler,

22453

&_swigt__p_wxPyProcess,

22454

&_swigt__p_wxPySizer,

22455

&_swigt__p_wxPyTimer,

22456

&_swigt__p_wxPyValidator,

22457

&_swigt__p_wxQueryNewPaletteEvent,

22458

&_swigt__p_wxRect,

22459

&_swigt__p_wxScrollBar,

22460

&_swigt__p_wxScrollEvent,

22461

&_swigt__p_wxScrollWinEvent,

22462

&_swigt__p_wxSetCursorEvent,

22463

&_swigt__p_wxShowEvent,

22464

&_swigt__p_wxSizeEvent,

22465

&_swigt__p_wxSizer,

22466

&_swigt__p_wxSizerItem,

22467

&_swigt__p_wxStaticBoxSizer,

22468

&_swigt__p_wxStdDialogButtonSizer,

22469

&_swigt__p_wxStyledTextCtrl,

22470

&_swigt__p_wxStyledTextEvent,

22471

&_swigt__p_wxSysColourChangedEvent,

22472

&_swigt__p_wxSystemOptions,

22473

&_swigt__p_wxTGAHandler,

22474

&_swigt__p_wxTIFFHandler,

22475

&_swigt__p_wxTimerEvent,

22476

&_swigt__p_wxToolTip,

22477

&_swigt__p_wxUpdateUIEvent,

22478

&_swigt__p_wxValidator,

22479

&_swigt__p_wxWindow,

22480

&_swigt__p_wxWindowCreateEvent,

22481

&_swigt__p_wxWindowDestroyEvent,

22482

&_swigt__p_wxXPMHandler,

22483

};

22484

22485

static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};

22486

static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};

22487

static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};

22488

static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};

22489

static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};

22490

static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};

22491

static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};

22492

static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};

22493

static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};

22494

static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};

22495

static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};

22496

static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};

22497

static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};

22498

static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};

22499

static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};

22500

static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};

22501

static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};

22502

static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};

22503

static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};

22504

static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};

22505

static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxStyledTextEvent, _p_wxStyledTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};

22506

static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};

22507

static swig_cast_info _swigc__p_wxControl[] = { {&_swigt__p_wxControl, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxControl, 0, 0}, {&_swigt__p_wxStyledTextCtrl, _p_wxStyledTextCtrlTo_p_wxControl, 0, 0},{0, 0, 0, 0}};

22508

static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};

22509

static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};

22510

static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};

22511

static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};

22512

static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};

22513

static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};

22514

static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};

22515

static swig_cast_info _swigc__p_wxTimerEvent[] = {{&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};

22516

static swig_cast_info _swigc__p_wxPowerEvent[] = {{&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};

22517

static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};

22518

static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};

22519

static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};

22520

static swig_cast_info _swigc__p_wxJoystickEvent[] = {{&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};

22521

static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};

22522

static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};

22523

static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};

22524

static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};

22525

static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};

22526

static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};

22527

static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};

22528

static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};

22529

static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};

22530

static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

22531

static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

22532

static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

22533

static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

22534

static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};

22535

static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};

22536

static swig_cast_info _swigc__p_wxProcessEvent[] = {{&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};

22537

static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};

22538

static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};

22539

static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};

22540

static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};

22541

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_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_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_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_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_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_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_wxStyledTextEvent, _p_wxStyledTextEventTo_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_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_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_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}};

22542

static swig_cast_info _swigc__p_wxPyEvtHandler[] = {{&_swigt__p_wxPyEvtHandler, 0, 0, 0},{0, 0, 0, 0}};

22543

static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};

22544

static swig_cast_info _swigc__p_wxPyTimer[] = {{&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};

22545

static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};

22546

static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};

22547

static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};

22548

static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};

22549

static swig_cast_info _swigc__p_wxPyProcess[] = {{&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};

22550

static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxStyledTextCtrl, _p_wxStyledTextCtrlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyEvtHandler, _p_wxPyEvtHandlerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_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}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};

22551

static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};

22552

static swig_cast_info _swigc__p_wxIntPtr[] = { {&_swigt__p_wxIntPtr, 0, 0, 0},{0, 0, 0, 0}};

22553

static swig_cast_info _swigc__p_wxMemoryBuffer[] = { {&_swigt__p_wxMemoryBuffer, 0, 0, 0},{0, 0, 0, 0}};

22554

static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};

22555

static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};

22556

static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};

22557

static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};

22558

static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};

22559

static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};

22560

static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};

22561

static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};

22562

static swig_cast_info _swigc__p_wxFileHistory[] = {{&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};

22563

static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};

22564

static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};

22565

static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};

22566

static swig_cast_info _swigc__p_wxClipboard[] = {{&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};

22567

static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};

22568

static swig_cast_info _swigc__p_wxToolTip[] = {{&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};

22569

static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};

22570

static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};

22571

static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};

22572

static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};

22573

static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};

22574

static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};

22575

static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};

22576

static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};

22577

static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};

22578

static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};

22579

static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};

22580

static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};

22581

static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};

22582

static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};

22583

static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};

22584

static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};

22585

static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};

22586

static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};

22587

static swig_cast_info _swigc__p_wxSystemOptions[] = {{&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};

22588

static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};

22589

static swig_cast_info _swigc__p_wxBusyInfo[] = {{&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};

22590

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_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxStyledTextEvent, _p_wxStyledTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStyledTextCtrl, _p_wxStyledTextCtrlTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_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_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_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_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_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_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_wxPyProcess, _p_wxPyProcessTo_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_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_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}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};

22591

static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};

22592

static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};

22593

static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};

22594

static swig_cast_info _swigc__p_wxScrollBar[] = { {&_swigt__p_wxScrollBar, 0, 0, 0},{0, 0, 0, 0}};

22595

static swig_cast_info _swigc__p_wxStyledTextCtrl[] = { {&_swigt__p_wxStyledTextCtrl, 0, 0, 0},{0, 0, 0, 0}};

22596

static swig_cast_info _swigc__p_wxStyledTextEvent[] = { {&_swigt__p_wxStyledTextEvent, 0, 0, 0},{0, 0, 0, 0}};

22597

static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStyledTextCtrl, _p_wxStyledTextCtrlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};

22598

22599

static swig_cast_info *swig_cast_initial[] = {

22600

_swigc__p_char,

22601

_swigc__p_double,

22602

_swigc__p_form_ops_t,

22603

_swigc__p_int,

22604

_swigc__p_unsigned_char,

22605

_swigc__p_unsigned_int,

22606

_swigc__p_unsigned_long,

22607

_swigc__p_void,

22608

_swigc__p_wxANIHandler,

22609

_swigc__p_wxAcceleratorTable,

22610

_swigc__p_wxActivateEvent,

22611

_swigc__p_wxBMPHandler,

22612

_swigc__p_wxBitmap,

22613

_swigc__p_wxBoxSizer,

22614

_swigc__p_wxBusyInfo,

22615

_swigc__p_wxCURHandler,

22616

_swigc__p_wxChildFocusEvent,

22617

_swigc__p_wxClipboard,

22618

_swigc__p_wxClipboardTextEvent,

22619

_swigc__p_wxCloseEvent,

22620

_swigc__p_wxColour,

22621

_swigc__p_wxCommandEvent,

22622

_swigc__p_wxContextMenuEvent,

22623

_swigc__p_wxControl,

22624

_swigc__p_wxControlWithItems,

22625

_swigc__p_wxDC,

22626

_swigc__p_wxDateEvent,

22627

_swigc__p_wxDisplayChangedEvent,

22628

_swigc__p_wxDropFilesEvent,

22629

_swigc__p_wxDuplexMode,

22630

_swigc__p_wxEraseEvent,

22631

_swigc__p_wxEvent,

22632

_swigc__p_wxEvtHandler,

22633

_swigc__p_wxFSFile,

22634

_swigc__p_wxFileHistory,

22635

_swigc__p_wxFileSystem,

22636

_swigc__p_wxFlexGridSizer,

22637

_swigc__p_wxFocusEvent,

22638

_swigc__p_wxFont,

22639

_swigc__p_wxGBSizerItem,

22640

_swigc__p_wxGIFHandler,

22641

_swigc__p_wxGridBagSizer,

22642

_swigc__p_wxGridSizer,

22643

_swigc__p_wxICOHandler,

22644

_swigc__p_wxIconizeEvent,

22645

_swigc__p_wxIdleEvent,

22646

_swigc__p_wxImage,

22647

_swigc__p_wxImageHandler,

22648

_swigc__p_wxIndividualLayoutConstraint,

22649

_swigc__p_wxInitDialogEvent,

22650

_swigc__p_wxIntPtr,

22651

_swigc__p_wxJPEGHandler,

22652

_swigc__p_wxJoystickEvent,

22653

_swigc__p_wxKeyEvent,

22654

_swigc__p_wxLayoutConstraints,

22655

_swigc__p_wxMaximizeEvent,

22656

_swigc__p_wxMemoryBuffer,

22657

_swigc__p_wxMenu,

22658

_swigc__p_wxMenuBar,

22659

_swigc__p_wxMenuEvent,

22660

_swigc__p_wxMenuItem,

22661

_swigc__p_wxMouseCaptureChangedEvent,

22662

_swigc__p_wxMouseCaptureLostEvent,

22663

_swigc__p_wxMouseEvent,

22664

_swigc__p_wxMoveEvent,

22665

_swigc__p_wxNavigationKeyEvent,

22666

_swigc__p_wxNcPaintEvent,

22667

_swigc__p_wxNotifyEvent,

22668

_swigc__p_wxObject,

22669

_swigc__p_wxPCXHandler,

22670

_swigc__p_wxPNGHandler,

22671

_swigc__p_wxPNMHandler,

22672

_swigc__p_wxPaintEvent,

22673

_swigc__p_wxPaletteChangedEvent,

22674

_swigc__p_wxPaperSize,

22675

_swigc__p_wxPoint,

22676

_swigc__p_wxPowerEvent,

22677

_swigc__p_wxProcessEvent,

22678

_swigc__p_wxPyApp,

22679

_swigc__p_wxPyCommandEvent,

22680

_swigc__p_wxPyEvent,

22681

_swigc__p_wxPyEvtHandler,

22682

_swigc__p_wxPyImageHandler,

22683

_swigc__p_wxPyProcess,

22684

_swigc__p_wxPySizer,

22685

_swigc__p_wxPyTimer,

22686

_swigc__p_wxPyValidator,

22687

_swigc__p_wxQueryNewPaletteEvent,

22688

_swigc__p_wxRect,

22689

_swigc__p_wxScrollBar,

22690

_swigc__p_wxScrollEvent,

22691

_swigc__p_wxScrollWinEvent,

22692

_swigc__p_wxSetCursorEvent,

22693

_swigc__p_wxShowEvent,

22694

_swigc__p_wxSizeEvent,

22695

_swigc__p_wxSizer,

22696

_swigc__p_wxSizerItem,

22697

_swigc__p_wxStaticBoxSizer,

22698

_swigc__p_wxStdDialogButtonSizer,

22699

_swigc__p_wxStyledTextCtrl,

22700

_swigc__p_wxStyledTextEvent,

22701

_swigc__p_wxSysColourChangedEvent,

22702

_swigc__p_wxSystemOptions,

22703

_swigc__p_wxTGAHandler,

22704

_swigc__p_wxTIFFHandler,

22705

_swigc__p_wxTimerEvent,

22706

_swigc__p_wxToolTip,

22707

_swigc__p_wxUpdateUIEvent,

22708

_swigc__p_wxValidator,

22709

_swigc__p_wxWindow,

22710

_swigc__p_wxWindowCreateEvent,

22711

_swigc__p_wxWindowDestroyEvent,

22712

_swigc__p_wxXPMHandler,

22713

};

22714

22715

22716

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

22717

22718

static swig_const_info swig_const_table[] = {

22719

{0, 0, 0, 0.0, 0, 0}};

22720

22721

#ifdef __cplusplus

22722

}

22723

#endif

22724

/* -----------------------------------------------------------------------------

22725

* Type initialization:

22726

* This problem is tough by the requirement that no dynamic

22727

* memory is used. Also, since swig_type_info structures store pointers to

22728

* swig_cast_info structures and swig_cast_info structures store pointers back

22729

* to swig_type_info structures, we need some lookup code at initialization.

22730

* The idea is that swig generates all the structures that are needed.

22731

* The runtime then collects these partially filled structures.

22732

* The SWIG_InitializeModule function takes these initial arrays out of

22733

* swig_module, and does all the lookup, filling in the swig_module.types

22734

* array with the correct data and linking the correct swig_cast_info

22735

* structures together.

22736

*

22737

* The generated swig_type_info structures are assigned staticly to an initial

22738

* array. We just loop though that array, and handle each type individually.

22739

* First we lookup if this type has been already loaded, and if so, use the

22740

* loaded structure instead of the generated one. Then we have to fill in the

22741

* cast linked list. The cast data is initially stored in something like a

22742

* two-dimensional array. Each row corresponds to a type (there are the same

22743

* number of rows as there are in the swig_type_initial array). Each entry in

22744

* a column is one of the swig_cast_info structures for that type.

22745

* The cast_initial array is actually an array of arrays, because each row has

22746

* a variable number of columns. So to actually build the cast linked list,

22747

* we find the array of casts associated with the type, and loop through it

22748

* adding the casts to the list. The one last trick we need to do is making

22749

* sure the type pointer in the swig_cast_info struct is correct.

22750

*

22751

* First off, we lookup the cast->type name to see if it is already loaded.

22752

* There are three cases to handle:

22753

* 1) If the cast->type has already been loaded AND the type we are adding

22754

* casting info to has not been loaded (it is in this module), THEN we

22755

* replace the cast->type pointer with the type pointer that has already

22756

* been loaded.

22757

* 2) If BOTH types (the one we are adding casting info to, and the

22758

* cast->type) are loaded, THEN the cast info has already been loaded by

22759

* the previous module so we just ignore it.

22760

* 3) Finally, if cast->type has not already been loaded, then we add that

22761

* swig_cast_info to the linked list (because the cast->type) pointer will

22762

* be correct.

22763

* ----------------------------------------------------------------------------- */

22764

22765

#ifdef __cplusplus

22766

extern "C" {

22767

#if 0

22768

} /* c-mode */

22769

#endif

22770

#endif

22771

22772

#if 0

22773

#define SWIGRUNTIME_DEBUG

22774

#endif

22775

22776

SWIGRUNTIME void

22777

SWIG_InitializeModule(void *clientdata) {

22778

size_t i;

22779

swig_module_info *module_head;

22780

static int init_run = 0;

22781

22782

clientdata = clientdata;

22783

22784

if (init_run) return;

22785

init_run = 1;

22786

22787

/* Initialize the swig_module */

22788

swig_module.type_initial = swig_type_initial;

22789

swig_module.cast_initial = swig_cast_initial;

22790

22791

/* Try and load any already created modules */

22792

module_head = SWIG_GetModule(clientdata);

22793

if (module_head) {

22794

swig_module.next = module_head->next;

22795

module_head->next = &swig_module;

22796

} else {

22797

/* This is the first module loaded */

22798

swig_module.next = &swig_module;

22799

SWIG_SetModule(clientdata, &swig_module);

22800

}

22801

22802

/* Now work on filling in swig_module.types */

22803

#ifdef SWIGRUNTIME_DEBUG

22804

printf("SWIG_InitializeModule: size %d\n", swig_module.size);

22805

#endif

22806

for (i = 0; i < swig_module.size; ++i) {

22807

swig_type_info *type = 0;

22808

swig_type_info *ret;

22809

swig_cast_info *cast;

22810

22811

#ifdef SWIGRUNTIME_DEBUG

22812

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

22813

#endif

22814

22815

/* if there is another module already loaded */

22816

if (swig_module.next != &swig_module) {

22817

type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);

22818

}

22819

if (type) {

22820

/* Overwrite clientdata field */

22821

#ifdef SWIGRUNTIME_DEBUG

22822

printf("SWIG_InitializeModule: found type %s\n", type->name);

22823

#endif

22824

if (swig_module.type_initial[i]->clientdata) {

22825

type->clientdata = swig_module.type_initial[i]->clientdata;

22826

#ifdef SWIGRUNTIME_DEBUG

22827

printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);

22828

#endif

22829

}

22830

} else {

22831

type = swig_module.type_initial[i];

22832

}

22833

22834

/* Insert casting types */

22835

cast = swig_module.cast_initial[i];

22836

while (cast->type) {

22837

/* Don't need to add information already in the list */

22838

ret = 0;

22839

#ifdef SWIGRUNTIME_DEBUG

22840

printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);

22841

#endif

22842

if (swig_module.next != &swig_module) {

22843

ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);

22844

#ifdef SWIGRUNTIME_DEBUG

22845

if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);

22846

#endif

22847

}

22848

if (ret) {

22849

if (type == swig_module.type_initial[i]) {

22850

#ifdef SWIGRUNTIME_DEBUG

22851

printf("SWIG_InitializeModule: skip old type %s\n", ret->name);

22852

#endif

22853

cast->type = ret;

22854

ret = 0;

22855

} else {

22856

/* Check for casting already in the list */

22857

swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);

22858

#ifdef SWIGRUNTIME_DEBUG

22859

if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);

22860

#endif

22861

if (!ocast) ret = 0;

22862

}

22863

}

22864

22865

if (!ret) {

22866

#ifdef SWIGRUNTIME_DEBUG

22867

printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);

22868

#endif

22869

if (type->cast) {

22870

type->cast->prev = cast;

22871

cast->next = type->cast;

22872

}

22873

type->cast = cast;

22874

}

22875

cast++;

22876

}

22877

/* Set entry in modules->types array equal to the type */

22878

swig_module.types[i] = type;

22879

}

22880

swig_module.types[i] = 0;

22881

22882

#ifdef SWIGRUNTIME_DEBUG

22883

printf("**** SWIG_InitializeModule: Cast List ******\n");

22884

for (i = 0; i < swig_module.size; ++i) {

22885

int j = 0;

22886

swig_cast_info *cast = swig_module.cast_initial[i];

22887

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

22888

while (cast->type) {

22889

printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);

22890

cast++;

22891

++j;

22892

}

22893

printf("---- Total casts: %d\n",j);

22894

}

22895

printf("**** SWIG_InitializeModule: Cast List ******\n");

22896

#endif

22897

}

22898

22899

/* This function will propagate the clientdata field of type to

22900

* any new swig_type_info structures that have been added into the list

22901

* of equivalent types. It is like calling

22902

* SWIG_TypeClientData(type, clientdata) a second time.

22903

*/

22904

SWIGRUNTIME void

22905

SWIG_PropagateClientData(void) {

22906

size_t i;

22907

swig_cast_info *equiv;

22908

static int init_run = 0;

22909

22910

if (init_run) return;

22911

init_run = 1;

22912

22913

for (i = 0; i < swig_module.size; i++) {

22914

if (swig_module.types[i]->clientdata) {

22915

equiv = swig_module.types[i]->cast;

22916

while (equiv) {

22917

if (!equiv->converter) {

22918

if (equiv->type && !equiv->type->clientdata)

22919

SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);

22920

}

22921

equiv = equiv->next;

22922

}

22923

}

22924

}

22925

}

22926

22927

#ifdef __cplusplus

22928

#if 0

22929

{

22930

/* c-mode */

22931

#endif

22932

}

22933

#endif

22934

22935

22936

22937

#ifdef __cplusplus

22938

extern "C" {

22939

#endif

22940

22941

/* Python-specific SWIG API */

22942

#define SWIG_newvarlink() SWIG_Python_newvarlink()

22943

#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)

22944

#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)

22945

22946

/* -----------------------------------------------------------------------------

22947

* global variable support code.

22948

* ----------------------------------------------------------------------------- */

22949

22950

typedef struct swig_globalvar {

22951

char *name; /* Name of global variable */

22952

PyObject *(*get_attr)(void); /* Return the current value */

22953

int (*set_attr)(PyObject *); /* Set the value */

22954

struct swig_globalvar *next;

22955

} swig_globalvar;

22956

22957

typedef struct swig_varlinkobject {

22958

PyObject_HEAD

22959

swig_globalvar *vars;

22960

} swig_varlinkobject;

22961

22962

SWIGINTERN PyObject *

22963

swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {

22964

return PyString_FromString("<Swig global variables>");

22965

}

22966

22967

SWIGINTERN PyObject *

22968

swig_varlink_str(swig_varlinkobject *v) {

22969

PyObject *str = PyString_FromString("(");

22970

swig_globalvar *var;

22971

for (var = v->vars; var; var=var->next) {

22972

PyString_ConcatAndDel(&str,PyString_FromString(var->name));

22973

if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));

22974

}

22975

PyString_ConcatAndDel(&str,PyString_FromString(")"));

22976

return str;

22977

}

22978

22979

SWIGINTERN int

22980

swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {

22981

PyObject *str = swig_varlink_str(v);

22982

fprintf(fp,"Swig global variables ");

22983

fprintf(fp,"%s\n", PyString_AsString(str));

22984

Py_DECREF(str);

22985

return 0;

22986

}

22987

22988

SWIGINTERN void

22989

swig_varlink_dealloc(swig_varlinkobject *v) {

22990

swig_globalvar *var = v->vars;

22991

while (var) {

22992

swig_globalvar *n = var->next;

22993

free(var->name);

22994

free(var);

22995

var = n;

22996

}

22997

}

22998

22999

SWIGINTERN PyObject *

23000

swig_varlink_getattr(swig_varlinkobject *v, char *n) {

23001

PyObject *res = NULL;

23002

swig_globalvar *var = v->vars;

23003

while (var) {

23004

if (strcmp(var->name,n) == 0) {

23005

res = (*var->get_attr)();

23006

break;

23007

}

23008

var = var->next;

23009

}

23010

if (res == NULL && !PyErr_Occurred()) {

23011

PyErr_SetString(PyExc_NameError,"Unknown C global variable");

23012

}

23013

return res;

23014

}

23015

23016

SWIGINTERN int

23017

swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {

23018

int res = 1;

23019

swig_globalvar *var = v->vars;

23020

while (var) {

23021

if (strcmp(var->name,n) == 0) {

23022

res = (*var->set_attr)(p);

23023

break;

23024

}

23025

var = var->next;

23026

}

23027

if (res == 1 && !PyErr_Occurred()) {

23028

PyErr_SetString(PyExc_NameError,"Unknown C global variable");

23029

}

23030

return res;

23031

}

23032

23033

SWIGINTERN PyTypeObject*

23034

swig_varlink_type(void) {

23035

static char varlink__doc__[] = "Swig var link object";

23036

static PyTypeObject varlink_type;

23037

static int type_init = 0;

23038

if (!type_init) {

23039

const PyTypeObject tmp

23040

= {

23041

PyObject_HEAD_INIT(NULL)

23042

0, /* Number of items in variable part (ob_size) */

23043

(char *)"swigvarlink", /* Type name (tp_name) */

23044

sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */

23045

0, /* Itemsize (tp_itemsize) */

23046

(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */

23047

(printfunc) swig_varlink_print, /* Print (tp_print) */

23048

(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */

23049

(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */

23050

0, /* tp_compare */

23051

(reprfunc) swig_varlink_repr, /* tp_repr */

23052

0, /* tp_as_number */

23053

0, /* tp_as_sequence */

23054

0, /* tp_as_mapping */

23055

0, /* tp_hash */

23056

0, /* tp_call */

23057

(reprfunc)swig_varlink_str, /* tp_str */

23058

0, /* tp_getattro */

23059

0, /* tp_setattro */

23060

0, /* tp_as_buffer */

23061

0, /* tp_flags */

23062

varlink__doc__, /* tp_doc */

23063

0, /* tp_traverse */

23064

0, /* tp_clear */

23065

0, /* tp_richcompare */

23066

0, /* tp_weaklistoffset */

23067

#if PY_VERSION_HEX >= 0x02020000

23068

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */

23069

#endif

23070

#if PY_VERSION_HEX >= 0x02030000

23071

0, /* tp_del */

23072

#endif

23073

#ifdef COUNT_ALLOCS

23074

0,0,0,0 /* tp_alloc -> tp_next */

23075

#endif

23076

};

23077

varlink_type = tmp;

23078

varlink_type.ob_type = &PyType_Type;

23079

type_init = 1;

23080

}

23081

return &varlink_type;

23082

}

23083

23084

/* Create a variable linking object for use later */

23085

SWIGINTERN PyObject *

23086

SWIG_Python_newvarlink(void) {

23087

swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());

23088

if (result) {

23089

result->vars = 0;

23090

}

23091

return ((PyObject*) result);

23092

}

23093

23094

SWIGINTERN void

23095

SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {

23096

swig_varlinkobject *v = (swig_varlinkobject *) p;

23097

swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));

23098

if (gv) {

23099

size_t size = strlen(name)+1;

23100

gv->name = (char *)malloc(size);

23101

if (gv->name) {

23102

strncpy(gv->name,name,size);

23103

gv->get_attr = get_attr;

23104

gv->set_attr = set_attr;

23105

gv->next = v->vars;

23106

}

23107

}

23108

v->vars = gv;

23109

}

23110

23111

SWIGINTERN PyObject *

23112

SWIG_globals() {

23113

static PyObject *_SWIG_globals = 0;

23114

if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();

23115

return _SWIG_globals;

23116

}

23117

23118

/* -----------------------------------------------------------------------------

23119

* constants/methods manipulation

23120

* ----------------------------------------------------------------------------- */

23121

23122

/* Install Constants */

23123

SWIGINTERN void

23124

SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {

23125

PyObject *obj = 0;

23126

size_t i;

23127

for (i = 0; constants[i].type; ++i) {

23128

switch(constants[i].type) {

23129

case SWIG_PY_POINTER:

23130

obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);

23131

break;

23132

case SWIG_PY_BINARY:

23133

obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));

23134

break;

23135

default:

23136

obj = 0;

23137

break;

23138

}

23139

if (obj) {

23140

PyDict_SetItemString(d, constants[i].name, obj);

23141

Py_DECREF(obj);

23142

}

23143

}

23144

}

23145

23146

/* -----------------------------------------------------------------------------*/

23147

/* Fix SwigMethods to carry the callback ptrs when needed */

23148

/* -----------------------------------------------------------------------------*/

23149

23150

SWIGINTERN void

23151

SWIG_Python_FixMethods(PyMethodDef *methods,

23152

swig_const_info *const_table,

23153

swig_type_info **types,

23154

swig_type_info **types_initial) {

23155

size_t i;

23156

for (i = 0; methods[i].ml_name; ++i) {

23157

const char *c = methods[i].ml_doc;

23158

if (c && (c = strstr(c, "swig_ptr: "))) {

23159

int j;

23160

swig_const_info *ci = 0;

23161

const char *name = c + 10;

23162

for (j = 0; const_table[j].type; ++j) {

23163

if (strncmp(const_table[j].name, name,

23164

strlen(const_table[j].name)) == 0) {

23165

ci = &(const_table[j]);

23166

break;

23167

}

23168

}

23169

if (ci) {

23170

size_t shift = (ci->ptype) - types;

23171

swig_type_info *ty = types_initial[shift];

23172

size_t ldoc = (c - methods[i].ml_doc);

23173

size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;

23174

char *ndoc = (char*)malloc(ldoc + lptr + 10);

23175

if (ndoc) {

23176

char *buff = ndoc;

23177

void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;

23178

if (ptr) {

23179

strncpy(buff, methods[i].ml_doc, ldoc);

23180

buff += ldoc;

23181

strncpy(buff, "swig_ptr: ", 10);

23182

buff += 10;

23183

SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);

23184

methods[i].ml_doc = ndoc;

23185

}

23186

}

23187

}

23188

}

23189

}

23190

}

23191

23192

#ifdef __cplusplus

23193

}

23194

#endif

23195

23196

/* -----------------------------------------------------------------------------*

23197

* Partial Init method

23198

* -----------------------------------------------------------------------------*/

23199

23200

#ifdef __cplusplus

23201

extern "C"

23202

#endif

23203

SWIGEXPORT void SWIG_init(void) {

23204

PyObject *m, *d;

23205

23206

/* Fix SwigMethods to carry the callback ptrs when needed */

23207

SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);

23208

23209

m = Py_InitModule((char *) SWIG_name, SwigMethods);

23210

d = PyModule_GetDict(m);

23211

23212

SWIG_InitializeModule(0);

23213

SWIG_InstallConstants(d,swig_const_table);

23214

23215

23216

PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());

23217

SWIG_addvarlink(SWIG_globals(),(char*)"STCNameStr",STCNameStr_get, STCNameStr_set);

23218

SWIG_Python_SetConstant(d, "STC_USE_DND",SWIG_From_int(static_cast< int >(1)));

23219

SWIG_Python_SetConstant(d, "STC_USE_POPUP",SWIG_From_int(static_cast< int >(1)));

23220

SWIG_Python_SetConstant(d, "STC_INVALID_POSITION",SWIG_From_int(static_cast< int >(-1)));

23221

SWIG_Python_SetConstant(d, "STC_START",SWIG_From_int(static_cast< int >(2000)));

23222

SWIG_Python_SetConstant(d, "STC_OPTIONAL_START",SWIG_From_int(static_cast< int >(3000)));

23223

SWIG_Python_SetConstant(d, "STC_LEXER_START",SWIG_From_int(static_cast< int >(4000)));

23224

SWIG_Python_SetConstant(d, "STC_WS_INVISIBLE",SWIG_From_int(static_cast< int >(0)));

23225

SWIG_Python_SetConstant(d, "STC_WS_VISIBLEALWAYS",SWIG_From_int(static_cast< int >(1)));

23226

SWIG_Python_SetConstant(d, "STC_WS_VISIBLEAFTERINDENT",SWIG_From_int(static_cast< int >(2)));

23227

SWIG_Python_SetConstant(d, "STC_EOL_CRLF",SWIG_From_int(static_cast< int >(0)));

23228

SWIG_Python_SetConstant(d, "STC_EOL_CR",SWIG_From_int(static_cast< int >(1)));

23229

SWIG_Python_SetConstant(d, "STC_EOL_LF",SWIG_From_int(static_cast< int >(2)));

23230

SWIG_Python_SetConstant(d, "STC_CP_UTF8",SWIG_From_int(static_cast< int >(65001)));

23231

SWIG_Python_SetConstant(d, "STC_CP_DBCS",SWIG_From_int(static_cast< int >(1)));

23232

SWIG_Python_SetConstant(d, "STC_MARKER_MAX",SWIG_From_int(static_cast< int >(31)));

23233

SWIG_Python_SetConstant(d, "STC_MARK_CIRCLE",SWIG_From_int(static_cast< int >(0)));

23234

SWIG_Python_SetConstant(d, "STC_MARK_ROUNDRECT",SWIG_From_int(static_cast< int >(1)));

23235

SWIG_Python_SetConstant(d, "STC_MARK_ARROW",SWIG_From_int(static_cast< int >(2)));

23236

SWIG_Python_SetConstant(d, "STC_MARK_SMALLRECT",SWIG_From_int(static_cast< int >(3)));

23237

SWIG_Python_SetConstant(d, "STC_MARK_SHORTARROW",SWIG_From_int(static_cast< int >(4)));

23238

SWIG_Python_SetConstant(d, "STC_MARK_EMPTY",SWIG_From_int(static_cast< int >(5)));

23239

SWIG_Python_SetConstant(d, "STC_MARK_ARROWDOWN",SWIG_From_int(static_cast< int >(6)));

23240

SWIG_Python_SetConstant(d, "STC_MARK_MINUS",SWIG_From_int(static_cast< int >(7)));

23241

SWIG_Python_SetConstant(d, "STC_MARK_PLUS",SWIG_From_int(static_cast< int >(8)));

23242

SWIG_Python_SetConstant(d, "STC_MARK_VLINE",SWIG_From_int(static_cast< int >(9)));

23243

SWIG_Python_SetConstant(d, "STC_MARK_LCORNER",SWIG_From_int(static_cast< int >(10)));

23244

SWIG_Python_SetConstant(d, "STC_MARK_TCORNER",SWIG_From_int(static_cast< int >(11)));

23245

SWIG_Python_SetConstant(d, "STC_MARK_BOXPLUS",SWIG_From_int(static_cast< int >(12)));

23246

SWIG_Python_SetConstant(d, "STC_MARK_BOXPLUSCONNECTED",SWIG_From_int(static_cast< int >(13)));

23247

SWIG_Python_SetConstant(d, "STC_MARK_BOXMINUS",SWIG_From_int(static_cast< int >(14)));

23248

SWIG_Python_SetConstant(d, "STC_MARK_BOXMINUSCONNECTED",SWIG_From_int(static_cast< int >(15)));

23249

SWIG_Python_SetConstant(d, "STC_MARK_LCORNERCURVE",SWIG_From_int(static_cast< int >(16)));

23250

SWIG_Python_SetConstant(d, "STC_MARK_TCORNERCURVE",SWIG_From_int(static_cast< int >(17)));

23251

SWIG_Python_SetConstant(d, "STC_MARK_CIRCLEPLUS",SWIG_From_int(static_cast< int >(18)));

23252

SWIG_Python_SetConstant(d, "STC_MARK_CIRCLEPLUSCONNECTED",SWIG_From_int(static_cast< int >(19)));

23253

SWIG_Python_SetConstant(d, "STC_MARK_CIRCLEMINUS",SWIG_From_int(static_cast< int >(20)));

23254

SWIG_Python_SetConstant(d, "STC_MARK_CIRCLEMINUSCONNECTED",SWIG_From_int(static_cast< int >(21)));

23255

SWIG_Python_SetConstant(d, "STC_MARK_BACKGROUND",SWIG_From_int(static_cast< int >(22)));

23256

SWIG_Python_SetConstant(d, "STC_MARK_DOTDOTDOT",SWIG_From_int(static_cast< int >(23)));

23257

SWIG_Python_SetConstant(d, "STC_MARK_ARROWS",SWIG_From_int(static_cast< int >(24)));

23258

SWIG_Python_SetConstant(d, "STC_MARK_PIXMAP",SWIG_From_int(static_cast< int >(25)));

23259

SWIG_Python_SetConstant(d, "STC_MARK_FULLRECT",SWIG_From_int(static_cast< int >(26)));

23260

SWIG_Python_SetConstant(d, "STC_MARK_CHARACTER",SWIG_From_int(static_cast< int >(10000)));

23261

SWIG_Python_SetConstant(d, "STC_MARKNUM_FOLDEREND",SWIG_From_int(static_cast< int >(25)));

23262

SWIG_Python_SetConstant(d, "STC_MARKNUM_FOLDEROPENMID",SWIG_From_int(static_cast< int >(26)));

23263

SWIG_Python_SetConstant(d, "STC_MARKNUM_FOLDERMIDTAIL",SWIG_From_int(static_cast< int >(27)));

23264

SWIG_Python_SetConstant(d, "STC_MARKNUM_FOLDERTAIL",SWIG_From_int(static_cast< int >(28)));

23265

SWIG_Python_SetConstant(d, "STC_MARKNUM_FOLDERSUB",SWIG_From_int(static_cast< int >(29)));

23266

SWIG_Python_SetConstant(d, "STC_MARKNUM_FOLDER",SWIG_From_int(static_cast< int >(30)));

23267

SWIG_Python_SetConstant(d, "STC_MARKNUM_FOLDEROPEN",SWIG_From_int(static_cast< int >(31)));

23268

SWIG_Python_SetConstant(d, "STC_MASK_FOLDERS",SWIG_From_int(static_cast< int >(0xFE000000)));

23269

SWIG_Python_SetConstant(d, "STC_MARGIN_SYMBOL",SWIG_From_int(static_cast< int >(0)));

23270

SWIG_Python_SetConstant(d, "STC_MARGIN_NUMBER",SWIG_From_int(static_cast< int >(1)));

23271

SWIG_Python_SetConstant(d, "STC_MARGIN_BACK",SWIG_From_int(static_cast< int >(2)));

23272

SWIG_Python_SetConstant(d, "STC_MARGIN_FORE",SWIG_From_int(static_cast< int >(3)));

23273

SWIG_Python_SetConstant(d, "STC_STYLE_DEFAULT",SWIG_From_int(static_cast< int >(32)));

23274

SWIG_Python_SetConstant(d, "STC_STYLE_LINENUMBER",SWIG_From_int(static_cast< int >(33)));

23275

SWIG_Python_SetConstant(d, "STC_STYLE_BRACELIGHT",SWIG_From_int(static_cast< int >(34)));

23276

SWIG_Python_SetConstant(d, "STC_STYLE_BRACEBAD",SWIG_From_int(static_cast< int >(35)));

23277

SWIG_Python_SetConstant(d, "STC_STYLE_CONTROLCHAR",SWIG_From_int(static_cast< int >(36)));

23278

SWIG_Python_SetConstant(d, "STC_STYLE_INDENTGUIDE",SWIG_From_int(static_cast< int >(37)));

23279

SWIG_Python_SetConstant(d, "STC_STYLE_CALLTIP",SWIG_From_int(static_cast< int >(38)));

23280

SWIG_Python_SetConstant(d, "STC_STYLE_LASTPREDEFINED",SWIG_From_int(static_cast< int >(39)));

23281

SWIG_Python_SetConstant(d, "STC_STYLE_MAX",SWIG_From_int(static_cast< int >(127)));

23282

SWIG_Python_SetConstant(d, "STC_CHARSET_ANSI",SWIG_From_int(static_cast< int >(0)));

23283

SWIG_Python_SetConstant(d, "STC_CHARSET_DEFAULT",SWIG_From_int(static_cast< int >(1)));

23284

SWIG_Python_SetConstant(d, "STC_CHARSET_BALTIC",SWIG_From_int(static_cast< int >(186)));

23285

SWIG_Python_SetConstant(d, "STC_CHARSET_CHINESEBIG5",SWIG_From_int(static_cast< int >(136)));

23286

SWIG_Python_SetConstant(d, "STC_CHARSET_EASTEUROPE",SWIG_From_int(static_cast< int >(238)));

23287

SWIG_Python_SetConstant(d, "STC_CHARSET_GB2312",SWIG_From_int(static_cast< int >(134)));

23288

SWIG_Python_SetConstant(d, "STC_CHARSET_GREEK",SWIG_From_int(static_cast< int >(161)));

23289

SWIG_Python_SetConstant(d, "STC_CHARSET_HANGUL",SWIG_From_int(static_cast< int >(129)));

23290

SWIG_Python_SetConstant(d, "STC_CHARSET_MAC",SWIG_From_int(static_cast< int >(77)));

23291

SWIG_Python_SetConstant(d, "STC_CHARSET_OEM",SWIG_From_int(static_cast< int >(255)));

23292

SWIG_Python_SetConstant(d, "STC_CHARSET_RUSSIAN",SWIG_From_int(static_cast< int >(204)));

23293

SWIG_Python_SetConstant(d, "STC_CHARSET_CYRILLIC",SWIG_From_int(static_cast< int >(1251)));

23294

SWIG_Python_SetConstant(d, "STC_CHARSET_SHIFTJIS",SWIG_From_int(static_cast< int >(128)));

23295

SWIG_Python_SetConstant(d, "STC_CHARSET_SYMBOL",SWIG_From_int(static_cast< int >(2)));

23296

SWIG_Python_SetConstant(d, "STC_CHARSET_TURKISH",SWIG_From_int(static_cast< int >(162)));

23297

SWIG_Python_SetConstant(d, "STC_CHARSET_JOHAB",SWIG_From_int(static_cast< int >(130)));

23298

SWIG_Python_SetConstant(d, "STC_CHARSET_HEBREW",SWIG_From_int(static_cast< int >(177)));

23299

SWIG_Python_SetConstant(d, "STC_CHARSET_ARABIC",SWIG_From_int(static_cast< int >(178)));

23300

SWIG_Python_SetConstant(d, "STC_CHARSET_VIETNAMESE",SWIG_From_int(static_cast< int >(163)));

23301

SWIG_Python_SetConstant(d, "STC_CHARSET_THAI",SWIG_From_int(static_cast< int >(222)));

23302

SWIG_Python_SetConstant(d, "STC_CHARSET_8859_15",SWIG_From_int(static_cast< int >(1000)));

23303

SWIG_Python_SetConstant(d, "STC_CASE_MIXED",SWIG_From_int(static_cast< int >(0)));

23304

SWIG_Python_SetConstant(d, "STC_CASE_UPPER",SWIG_From_int(static_cast< int >(1)));

23305

SWIG_Python_SetConstant(d, "STC_CASE_LOWER",SWIG_From_int(static_cast< int >(2)));

23306

SWIG_Python_SetConstant(d, "STC_INDIC_MAX",SWIG_From_int(static_cast< int >(7)));

23307

SWIG_Python_SetConstant(d, "STC_INDIC_PLAIN",SWIG_From_int(static_cast< int >(0)));

23308

SWIG_Python_SetConstant(d, "STC_INDIC_SQUIGGLE",SWIG_From_int(static_cast< int >(1)));

23309

SWIG_Python_SetConstant(d, "STC_INDIC_TT",SWIG_From_int(static_cast< int >(2)));

23310

SWIG_Python_SetConstant(d, "STC_INDIC_DIAGONAL",SWIG_From_int(static_cast< int >(3)));

23311

SWIG_Python_SetConstant(d, "STC_INDIC_STRIKE",SWIG_From_int(static_cast< int >(4)));

23312

SWIG_Python_SetConstant(d, "STC_INDIC_HIDDEN",SWIG_From_int(static_cast< int >(5)));

23313

SWIG_Python_SetConstant(d, "STC_INDIC_BOX",SWIG_From_int(static_cast< int >(6)));

23314

SWIG_Python_SetConstant(d, "STC_INDIC_ROUNDBOX",SWIG_From_int(static_cast< int >(7)));

23315

SWIG_Python_SetConstant(d, "STC_INDIC0_MASK",SWIG_From_int(static_cast< int >(0x20)));

23316

SWIG_Python_SetConstant(d, "STC_INDIC1_MASK",SWIG_From_int(static_cast< int >(0x40)));

23317

SWIG_Python_SetConstant(d, "STC_INDIC2_MASK",SWIG_From_int(static_cast< int >(0x80)));

23318

SWIG_Python_SetConstant(d, "STC_INDICS_MASK",SWIG_From_int(static_cast< int >(0xE0)));

23319

SWIG_Python_SetConstant(d, "STC_PRINT_NORMAL",SWIG_From_int(static_cast< int >(0)));

23320

SWIG_Python_SetConstant(d, "STC_PRINT_INVERTLIGHT",SWIG_From_int(static_cast< int >(1)));

23321

SWIG_Python_SetConstant(d, "STC_PRINT_BLACKONWHITE",SWIG_From_int(static_cast< int >(2)));

23322

SWIG_Python_SetConstant(d, "STC_PRINT_COLOURONWHITE",SWIG_From_int(static_cast< int >(3)));

23323

SWIG_Python_SetConstant(d, "STC_PRINT_COLOURONWHITEDEFAULTBG",SWIG_From_int(static_cast< int >(4)));

23324

SWIG_Python_SetConstant(d, "STC_FIND_WHOLEWORD",SWIG_From_int(static_cast< int >(2)));

23325

SWIG_Python_SetConstant(d, "STC_FIND_MATCHCASE",SWIG_From_int(static_cast< int >(4)));

23326

SWIG_Python_SetConstant(d, "STC_FIND_WORDSTART",SWIG_From_int(static_cast< int >(0x00100000)));

23327

SWIG_Python_SetConstant(d, "STC_FIND_REGEXP",SWIG_From_int(static_cast< int >(0x00200000)));

23328

SWIG_Python_SetConstant(d, "STC_FIND_POSIX",SWIG_From_int(static_cast< int >(0x00400000)));

23329

SWIG_Python_SetConstant(d, "STC_FOLDLEVELBASE",SWIG_From_int(static_cast< int >(0x400)));

23330

SWIG_Python_SetConstant(d, "STC_FOLDLEVELWHITEFLAG",SWIG_From_int(static_cast< int >(0x1000)));

23331

SWIG_Python_SetConstant(d, "STC_FOLDLEVELHEADERFLAG",SWIG_From_int(static_cast< int >(0x2000)));

23332

SWIG_Python_SetConstant(d, "STC_FOLDLEVELBOXHEADERFLAG",SWIG_From_int(static_cast< int >(0x4000)));

23333

SWIG_Python_SetConstant(d, "STC_FOLDLEVELBOXFOOTERFLAG",SWIG_From_int(static_cast< int >(0x8000)));

23334

SWIG_Python_SetConstant(d, "STC_FOLDLEVELCONTRACTED",SWIG_From_int(static_cast< int >(0x10000)));

23335

SWIG_Python_SetConstant(d, "STC_FOLDLEVELUNINDENT",SWIG_From_int(static_cast< int >(0x20000)));

23336

SWIG_Python_SetConstant(d, "STC_FOLDLEVELNUMBERMASK",SWIG_From_int(static_cast< int >(0x0FFF)));

23337

SWIG_Python_SetConstant(d, "STC_FOLDFLAG_LINEBEFORE_EXPANDED",SWIG_From_int(static_cast< int >(0x0002)));

23338

SWIG_Python_SetConstant(d, "STC_FOLDFLAG_LINEBEFORE_CONTRACTED",SWIG_From_int(static_cast< int >(0x0004)));

23339

SWIG_Python_SetConstant(d, "STC_FOLDFLAG_LINEAFTER_EXPANDED",SWIG_From_int(static_cast< int >(0x0008)));

23340

SWIG_Python_SetConstant(d, "STC_FOLDFLAG_LINEAFTER_CONTRACTED",SWIG_From_int(static_cast< int >(0x0010)));

23341

SWIG_Python_SetConstant(d, "STC_FOLDFLAG_LEVELNUMBERS",SWIG_From_int(static_cast< int >(0x0040)));

23342

SWIG_Python_SetConstant(d, "STC_FOLDFLAG_BOX",SWIG_From_int(static_cast< int >(0x0001)));

23343

SWIG_Python_SetConstant(d, "STC_TIME_FOREVER",SWIG_From_int(static_cast< int >(10000000)));

23344

SWIG_Python_SetConstant(d, "STC_WRAP_NONE",SWIG_From_int(static_cast< int >(0)));

23345

SWIG_Python_SetConstant(d, "STC_WRAP_WORD",SWIG_From_int(static_cast< int >(1)));

23346

SWIG_Python_SetConstant(d, "STC_WRAP_CHAR",SWIG_From_int(static_cast< int >(2)));

23347

SWIG_Python_SetConstant(d, "STC_WRAPVISUALFLAG_NONE",SWIG_From_int(static_cast< int >(0x0000)));

23348

SWIG_Python_SetConstant(d, "STC_WRAPVISUALFLAG_END",SWIG_From_int(static_cast< int >(0x0001)));

23349

SWIG_Python_SetConstant(d, "STC_WRAPVISUALFLAG_START",SWIG_From_int(static_cast< int >(0x0002)));

23350

SWIG_Python_SetConstant(d, "STC_WRAPVISUALFLAGLOC_DEFAULT",SWIG_From_int(static_cast< int >(0x0000)));

23351

SWIG_Python_SetConstant(d, "STC_WRAPVISUALFLAGLOC_END_BY_TEXT",SWIG_From_int(static_cast< int >(0x0001)));

23352

SWIG_Python_SetConstant(d, "STC_WRAPVISUALFLAGLOC_START_BY_TEXT",SWIG_From_int(static_cast< int >(0x0002)));

23353

SWIG_Python_SetConstant(d, "STC_CACHE_NONE",SWIG_From_int(static_cast< int >(0)));

23354

SWIG_Python_SetConstant(d, "STC_CACHE_CARET",SWIG_From_int(static_cast< int >(1)));

23355

SWIG_Python_SetConstant(d, "STC_CACHE_PAGE",SWIG_From_int(static_cast< int >(2)));

23356

SWIG_Python_SetConstant(d, "STC_CACHE_DOCUMENT",SWIG_From_int(static_cast< int >(3)));

23357

SWIG_Python_SetConstant(d, "STC_EDGE_NONE",SWIG_From_int(static_cast< int >(0)));

23358

SWIG_Python_SetConstant(d, "STC_EDGE_LINE",SWIG_From_int(static_cast< int >(1)));

23359

SWIG_Python_SetConstant(d, "STC_EDGE_BACKGROUND",SWIG_From_int(static_cast< int >(2)));

23360

SWIG_Python_SetConstant(d, "STC_CURSORNORMAL",SWIG_From_int(static_cast< int >(-1)));

23361

SWIG_Python_SetConstant(d, "STC_CURSORWAIT",SWIG_From_int(static_cast< int >(4)));

23362

SWIG_Python_SetConstant(d, "STC_VISIBLE_SLOP",SWIG_From_int(static_cast< int >(0x01)));

23363

SWIG_Python_SetConstant(d, "STC_VISIBLE_STRICT",SWIG_From_int(static_cast< int >(0x04)));

23364

SWIG_Python_SetConstant(d, "STC_CARET_SLOP",SWIG_From_int(static_cast< int >(0x01)));

23365

SWIG_Python_SetConstant(d, "STC_CARET_STRICT",SWIG_From_int(static_cast< int >(0x04)));

23366

SWIG_Python_SetConstant(d, "STC_CARET_JUMPS",SWIG_From_int(static_cast< int >(0x10)));

23367

SWIG_Python_SetConstant(d, "STC_CARET_EVEN",SWIG_From_int(static_cast< int >(0x08)));

23368

SWIG_Python_SetConstant(d, "STC_SEL_STREAM",SWIG_From_int(static_cast< int >(0)));

23369

SWIG_Python_SetConstant(d, "STC_SEL_RECTANGLE",SWIG_From_int(static_cast< int >(1)));

23370

SWIG_Python_SetConstant(d, "STC_SEL_LINES",SWIG_From_int(static_cast< int >(2)));

23371

SWIG_Python_SetConstant(d, "STC_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(0)));

23372

SWIG_Python_SetConstant(d, "STC_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(255)));

23373

SWIG_Python_SetConstant(d, "STC_ALPHA_NOALPHA",SWIG_From_int(static_cast< int >(256)));

23374

SWIG_Python_SetConstant(d, "STC_KEYWORDSET_MAX",SWIG_From_int(static_cast< int >(8)));

23375

SWIG_Python_SetConstant(d, "STC_MOD_INSERTTEXT",SWIG_From_int(static_cast< int >(0x1)));

23376

SWIG_Python_SetConstant(d, "STC_MOD_DELETETEXT",SWIG_From_int(static_cast< int >(0x2)));

23377

SWIG_Python_SetConstant(d, "STC_MOD_CHANGESTYLE",SWIG_From_int(static_cast< int >(0x4)));

23378

SWIG_Python_SetConstant(d, "STC_MOD_CHANGEFOLD",SWIG_From_int(static_cast< int >(0x8)));

23379

SWIG_Python_SetConstant(d, "STC_PERFORMED_USER",SWIG_From_int(static_cast< int >(0x10)));

23380

SWIG_Python_SetConstant(d, "STC_PERFORMED_UNDO",SWIG_From_int(static_cast< int >(0x20)));

23381

SWIG_Python_SetConstant(d, "STC_PERFORMED_REDO",SWIG_From_int(static_cast< int >(0x40)));

23382

SWIG_Python_SetConstant(d, "STC_MULTISTEPUNDOREDO",SWIG_From_int(static_cast< int >(0x80)));

23383

SWIG_Python_SetConstant(d, "STC_LASTSTEPINUNDOREDO",SWIG_From_int(static_cast< int >(0x100)));

23384

SWIG_Python_SetConstant(d, "STC_MOD_CHANGEMARKER",SWIG_From_int(static_cast< int >(0x200)));

23385

SWIG_Python_SetConstant(d, "STC_MOD_BEFOREINSERT",SWIG_From_int(static_cast< int >(0x400)));

23386

SWIG_Python_SetConstant(d, "STC_MOD_BEFOREDELETE",SWIG_From_int(static_cast< int >(0x800)));

23387

SWIG_Python_SetConstant(d, "STC_MULTILINEUNDOREDO",SWIG_From_int(static_cast< int >(0x1000)));

23388

SWIG_Python_SetConstant(d, "STC_MODEVENTMASKALL",SWIG_From_int(static_cast< int >(0x1FFF)));

23389

SWIG_Python_SetConstant(d, "STC_KEY_DOWN",SWIG_From_int(static_cast< int >(300)));

23390

SWIG_Python_SetConstant(d, "STC_KEY_UP",SWIG_From_int(static_cast< int >(301)));

23391

SWIG_Python_SetConstant(d, "STC_KEY_LEFT",SWIG_From_int(static_cast< int >(302)));

23392

SWIG_Python_SetConstant(d, "STC_KEY_RIGHT",SWIG_From_int(static_cast< int >(303)));

23393

SWIG_Python_SetConstant(d, "STC_KEY_HOME",SWIG_From_int(static_cast< int >(304)));

23394

SWIG_Python_SetConstant(d, "STC_KEY_END",SWIG_From_int(static_cast< int >(305)));

23395

SWIG_Python_SetConstant(d, "STC_KEY_PRIOR",SWIG_From_int(static_cast< int >(306)));

23396

SWIG_Python_SetConstant(d, "STC_KEY_NEXT",SWIG_From_int(static_cast< int >(307)));

23397

SWIG_Python_SetConstant(d, "STC_KEY_DELETE",SWIG_From_int(static_cast< int >(308)));

23398

SWIG_Python_SetConstant(d, "STC_KEY_INSERT",SWIG_From_int(static_cast< int >(309)));

23399

SWIG_Python_SetConstant(d, "STC_KEY_ESCAPE",SWIG_From_int(static_cast< int >(7)));

23400

SWIG_Python_SetConstant(d, "STC_KEY_BACK",SWIG_From_int(static_cast< int >(8)));

23401

SWIG_Python_SetConstant(d, "STC_KEY_TAB",SWIG_From_int(static_cast< int >(9)));

23402

SWIG_Python_SetConstant(d, "STC_KEY_RETURN",SWIG_From_int(static_cast< int >(13)));

23403

SWIG_Python_SetConstant(d, "STC_KEY_ADD",SWIG_From_int(static_cast< int >(310)));

23404

SWIG_Python_SetConstant(d, "STC_KEY_SUBTRACT",SWIG_From_int(static_cast< int >(311)));

23405

SWIG_Python_SetConstant(d, "STC_KEY_DIVIDE",SWIG_From_int(static_cast< int >(312)));

23406

SWIG_Python_SetConstant(d, "STC_SCMOD_NORM",SWIG_From_int(static_cast< int >(0)));

23407

SWIG_Python_SetConstant(d, "STC_SCMOD_SHIFT",SWIG_From_int(static_cast< int >(1)));

23408

SWIG_Python_SetConstant(d, "STC_SCMOD_CTRL",SWIG_From_int(static_cast< int >(2)));

23409

SWIG_Python_SetConstant(d, "STC_SCMOD_ALT",SWIG_From_int(static_cast< int >(4)));

23410

SWIG_Python_SetConstant(d, "STC_LEX_CONTAINER",SWIG_From_int(static_cast< int >(0)));

23411

SWIG_Python_SetConstant(d, "STC_LEX_NULL",SWIG_From_int(static_cast< int >(1)));

23412

SWIG_Python_SetConstant(d, "STC_LEX_PYTHON",SWIG_From_int(static_cast< int >(2)));

23413

SWIG_Python_SetConstant(d, "STC_LEX_CPP",SWIG_From_int(static_cast< int >(3)));

23414

SWIG_Python_SetConstant(d, "STC_LEX_HTML",SWIG_From_int(static_cast< int >(4)));

23415

SWIG_Python_SetConstant(d, "STC_LEX_XML",SWIG_From_int(static_cast< int >(5)));

23416

SWIG_Python_SetConstant(d, "STC_LEX_PERL",SWIG_From_int(static_cast< int >(6)));

23417

SWIG_Python_SetConstant(d, "STC_LEX_SQL",SWIG_From_int(static_cast< int >(7)));

23418

SWIG_Python_SetConstant(d, "STC_LEX_VB",SWIG_From_int(static_cast< int >(8)));

23419

SWIG_Python_SetConstant(d, "STC_LEX_PROPERTIES",SWIG_From_int(static_cast< int >(9)));

23420

SWIG_Python_SetConstant(d, "STC_LEX_ERRORLIST",SWIG_From_int(static_cast< int >(10)));

23421

SWIG_Python_SetConstant(d, "STC_LEX_MAKEFILE",SWIG_From_int(static_cast< int >(11)));

23422

SWIG_Python_SetConstant(d, "STC_LEX_BATCH",SWIG_From_int(static_cast< int >(12)));

23423

SWIG_Python_SetConstant(d, "STC_LEX_XCODE",SWIG_From_int(static_cast< int >(13)));

23424

SWIG_Python_SetConstant(d, "STC_LEX_LATEX",SWIG_From_int(static_cast< int >(14)));

23425

SWIG_Python_SetConstant(d, "STC_LEX_LUA",SWIG_From_int(static_cast< int >(15)));

23426

SWIG_Python_SetConstant(d, "STC_LEX_DIFF",SWIG_From_int(static_cast< int >(16)));

23427

SWIG_Python_SetConstant(d, "STC_LEX_CONF",SWIG_From_int(static_cast< int >(17)));

23428

SWIG_Python_SetConstant(d, "STC_LEX_PASCAL",SWIG_From_int(static_cast< int >(18)));

23429

SWIG_Python_SetConstant(d, "STC_LEX_AVE",SWIG_From_int(static_cast< int >(19)));

23430

SWIG_Python_SetConstant(d, "STC_LEX_ADA",SWIG_From_int(static_cast< int >(20)));

23431

SWIG_Python_SetConstant(d, "STC_LEX_LISP",SWIG_From_int(static_cast< int >(21)));

23432

SWIG_Python_SetConstant(d, "STC_LEX_RUBY",SWIG_From_int(static_cast< int >(22)));

23433

SWIG_Python_SetConstant(d, "STC_LEX_EIFFEL",SWIG_From_int(static_cast< int >(23)));

23434

SWIG_Python_SetConstant(d, "STC_LEX_EIFFELKW",SWIG_From_int(static_cast< int >(24)));

23435

SWIG_Python_SetConstant(d, "STC_LEX_TCL",SWIG_From_int(static_cast< int >(25)));

23436

SWIG_Python_SetConstant(d, "STC_LEX_NNCRONTAB",SWIG_From_int(static_cast< int >(26)));

23437

SWIG_Python_SetConstant(d, "STC_LEX_BULLANT",SWIG_From_int(static_cast< int >(27)));

23438

SWIG_Python_SetConstant(d, "STC_LEX_VBSCRIPT",SWIG_From_int(static_cast< int >(28)));

23439

SWIG_Python_SetConstant(d, "STC_LEX_BAAN",SWIG_From_int(static_cast< int >(31)));

23440

SWIG_Python_SetConstant(d, "STC_LEX_MATLAB",SWIG_From_int(static_cast< int >(32)));

23441

SWIG_Python_SetConstant(d, "STC_LEX_SCRIPTOL",SWIG_From_int(static_cast< int >(33)));

23442

SWIG_Python_SetConstant(d, "STC_LEX_ASM",SWIG_From_int(static_cast< int >(34)));

23443

SWIG_Python_SetConstant(d, "STC_LEX_CPPNOCASE",SWIG_From_int(static_cast< int >(35)));

23444

SWIG_Python_SetConstant(d, "STC_LEX_FORTRAN",SWIG_From_int(static_cast< int >(36)));

23445

SWIG_Python_SetConstant(d, "STC_LEX_F77",SWIG_From_int(static_cast< int >(37)));

23446

SWIG_Python_SetConstant(d, "STC_LEX_CSS",SWIG_From_int(static_cast< int >(38)));

23447

SWIG_Python_SetConstant(d, "STC_LEX_POV",SWIG_From_int(static_cast< int >(39)));

23448

SWIG_Python_SetConstant(d, "STC_LEX_LOUT",SWIG_From_int(static_cast< int >(40)));

23449

SWIG_Python_SetConstant(d, "STC_LEX_ESCRIPT",SWIG_From_int(static_cast< int >(41)));

23450

SWIG_Python_SetConstant(d, "STC_LEX_PS",SWIG_From_int(static_cast< int >(42)));

23451

SWIG_Python_SetConstant(d, "STC_LEX_NSIS",SWIG_From_int(static_cast< int >(43)));

23452

SWIG_Python_SetConstant(d, "STC_LEX_MMIXAL",SWIG_From_int(static_cast< int >(44)));

23453

SWIG_Python_SetConstant(d, "STC_LEX_CLW",SWIG_From_int(static_cast< int >(45)));

23454

SWIG_Python_SetConstant(d, "STC_LEX_CLWNOCASE",SWIG_From_int(static_cast< int >(46)));

23455

SWIG_Python_SetConstant(d, "STC_LEX_LOT",SWIG_From_int(static_cast< int >(47)));

23456

SWIG_Python_SetConstant(d, "STC_LEX_YAML",SWIG_From_int(static_cast< int >(48)));

23457

SWIG_Python_SetConstant(d, "STC_LEX_TEX",SWIG_From_int(static_cast< int >(49)));

23458

SWIG_Python_SetConstant(d, "STC_LEX_METAPOST",SWIG_From_int(static_cast< int >(50)));

23459

SWIG_Python_SetConstant(d, "STC_LEX_POWERBASIC",SWIG_From_int(static_cast< int >(51)));

23460

SWIG_Python_SetConstant(d, "STC_LEX_FORTH",SWIG_From_int(static_cast< int >(52)));

23461

SWIG_Python_SetConstant(d, "STC_LEX_ERLANG",SWIG_From_int(static_cast< int >(53)));

23462

SWIG_Python_SetConstant(d, "STC_LEX_OCTAVE",SWIG_From_int(static_cast< int >(54)));

23463

SWIG_Python_SetConstant(d, "STC_LEX_MSSQL",SWIG_From_int(static_cast< int >(55)));

23464

SWIG_Python_SetConstant(d, "STC_LEX_VERILOG",SWIG_From_int(static_cast< int >(56)));

23465

SWIG_Python_SetConstant(d, "STC_LEX_KIX",SWIG_From_int(static_cast< int >(57)));

23466

SWIG_Python_SetConstant(d, "STC_LEX_GUI4CLI",SWIG_From_int(static_cast< int >(58)));

23467

SWIG_Python_SetConstant(d, "STC_LEX_SPECMAN",SWIG_From_int(static_cast< int >(59)));

23468

SWIG_Python_SetConstant(d, "STC_LEX_AU3",SWIG_From_int(static_cast< int >(60)));

23469

SWIG_Python_SetConstant(d, "STC_LEX_APDL",SWIG_From_int(static_cast< int >(61)));

23470

SWIG_Python_SetConstant(d, "STC_LEX_BASH",SWIG_From_int(static_cast< int >(62)));

23471

SWIG_Python_SetConstant(d, "STC_LEX_ASN1",SWIG_From_int(static_cast< int >(63)));

23472

SWIG_Python_SetConstant(d, "STC_LEX_VHDL",SWIG_From_int(static_cast< int >(64)));

23473

SWIG_Python_SetConstant(d, "STC_LEX_CAML",SWIG_From_int(static_cast< int >(65)));

23474

SWIG_Python_SetConstant(d, "STC_LEX_BLITZBASIC",SWIG_From_int(static_cast< int >(66)));

23475

SWIG_Python_SetConstant(d, "STC_LEX_PUREBASIC",SWIG_From_int(static_cast< int >(67)));

23476

SWIG_Python_SetConstant(d, "STC_LEX_HASKELL",SWIG_From_int(static_cast< int >(68)));

23477

SWIG_Python_SetConstant(d, "STC_LEX_PHPSCRIPT",SWIG_From_int(static_cast< int >(69)));

23478

SWIG_Python_SetConstant(d, "STC_LEX_TADS3",SWIG_From_int(static_cast< int >(70)));

23479

SWIG_Python_SetConstant(d, "STC_LEX_REBOL",SWIG_From_int(static_cast< int >(71)));

23480

SWIG_Python_SetConstant(d, "STC_LEX_SMALLTALK",SWIG_From_int(static_cast< int >(72)));

23481

SWIG_Python_SetConstant(d, "STC_LEX_FLAGSHIP",SWIG_From_int(static_cast< int >(73)));

23482

SWIG_Python_SetConstant(d, "STC_LEX_CSOUND",SWIG_From_int(static_cast< int >(74)));

23483

SWIG_Python_SetConstant(d, "STC_LEX_FREEBASIC",SWIG_From_int(static_cast< int >(75)));

23484

SWIG_Python_SetConstant(d, "STC_LEX_INNOSETUP",SWIG_From_int(static_cast< int >(76)));

23485

SWIG_Python_SetConstant(d, "STC_LEX_OPAL",SWIG_From_int(static_cast< int >(77)));

23486

SWIG_Python_SetConstant(d, "STC_LEX_SPICE",SWIG_From_int(static_cast< int >(78)));

23487

SWIG_Python_SetConstant(d, "STC_LEX_AUTOMATIC",SWIG_From_int(static_cast< int >(1000)));

23488

SWIG_Python_SetConstant(d, "STC_P_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23489

SWIG_Python_SetConstant(d, "STC_P_COMMENTLINE",SWIG_From_int(static_cast< int >(1)));

23490

SWIG_Python_SetConstant(d, "STC_P_NUMBER",SWIG_From_int(static_cast< int >(2)));

23491

SWIG_Python_SetConstant(d, "STC_P_STRING",SWIG_From_int(static_cast< int >(3)));

23492

SWIG_Python_SetConstant(d, "STC_P_CHARACTER",SWIG_From_int(static_cast< int >(4)));

23493

SWIG_Python_SetConstant(d, "STC_P_WORD",SWIG_From_int(static_cast< int >(5)));

23494

SWIG_Python_SetConstant(d, "STC_P_TRIPLE",SWIG_From_int(static_cast< int >(6)));

23495

SWIG_Python_SetConstant(d, "STC_P_TRIPLEDOUBLE",SWIG_From_int(static_cast< int >(7)));

23496

SWIG_Python_SetConstant(d, "STC_P_CLASSNAME",SWIG_From_int(static_cast< int >(8)));

23497

SWIG_Python_SetConstant(d, "STC_P_DEFNAME",SWIG_From_int(static_cast< int >(9)));

23498

SWIG_Python_SetConstant(d, "STC_P_OPERATOR",SWIG_From_int(static_cast< int >(10)));

23499

SWIG_Python_SetConstant(d, "STC_P_IDENTIFIER",SWIG_From_int(static_cast< int >(11)));

23500

SWIG_Python_SetConstant(d, "STC_P_COMMENTBLOCK",SWIG_From_int(static_cast< int >(12)));

23501

SWIG_Python_SetConstant(d, "STC_P_STRINGEOL",SWIG_From_int(static_cast< int >(13)));

23502

SWIG_Python_SetConstant(d, "STC_P_WORD2",SWIG_From_int(static_cast< int >(14)));

23503

SWIG_Python_SetConstant(d, "STC_P_DECORATOR",SWIG_From_int(static_cast< int >(15)));

23504

SWIG_Python_SetConstant(d, "STC_C_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23505

SWIG_Python_SetConstant(d, "STC_C_COMMENT",SWIG_From_int(static_cast< int >(1)));

23506

SWIG_Python_SetConstant(d, "STC_C_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

23507

SWIG_Python_SetConstant(d, "STC_C_COMMENTDOC",SWIG_From_int(static_cast< int >(3)));

23508

SWIG_Python_SetConstant(d, "STC_C_NUMBER",SWIG_From_int(static_cast< int >(4)));

23509

SWIG_Python_SetConstant(d, "STC_C_WORD",SWIG_From_int(static_cast< int >(5)));

23510

SWIG_Python_SetConstant(d, "STC_C_STRING",SWIG_From_int(static_cast< int >(6)));

23511

SWIG_Python_SetConstant(d, "STC_C_CHARACTER",SWIG_From_int(static_cast< int >(7)));

23512

SWIG_Python_SetConstant(d, "STC_C_UUID",SWIG_From_int(static_cast< int >(8)));

23513

SWIG_Python_SetConstant(d, "STC_C_PREPROCESSOR",SWIG_From_int(static_cast< int >(9)));

23514

SWIG_Python_SetConstant(d, "STC_C_OPERATOR",SWIG_From_int(static_cast< int >(10)));

23515

SWIG_Python_SetConstant(d, "STC_C_IDENTIFIER",SWIG_From_int(static_cast< int >(11)));

23516

SWIG_Python_SetConstant(d, "STC_C_STRINGEOL",SWIG_From_int(static_cast< int >(12)));

23517

SWIG_Python_SetConstant(d, "STC_C_VERBATIM",SWIG_From_int(static_cast< int >(13)));

23518

SWIG_Python_SetConstant(d, "STC_C_REGEX",SWIG_From_int(static_cast< int >(14)));

23519

SWIG_Python_SetConstant(d, "STC_C_COMMENTLINEDOC",SWIG_From_int(static_cast< int >(15)));

23520

SWIG_Python_SetConstant(d, "STC_C_WORD2",SWIG_From_int(static_cast< int >(16)));

23521

SWIG_Python_SetConstant(d, "STC_C_COMMENTDOCKEYWORD",SWIG_From_int(static_cast< int >(17)));

23522

SWIG_Python_SetConstant(d, "STC_C_COMMENTDOCKEYWORDERROR",SWIG_From_int(static_cast< int >(18)));

23523

SWIG_Python_SetConstant(d, "STC_C_GLOBALCLASS",SWIG_From_int(static_cast< int >(19)));

23524

SWIG_Python_SetConstant(d, "STC_TCL_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23525

SWIG_Python_SetConstant(d, "STC_TCL_COMMENT",SWIG_From_int(static_cast< int >(1)));

23526

SWIG_Python_SetConstant(d, "STC_TCL_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

23527

SWIG_Python_SetConstant(d, "STC_TCL_NUMBER",SWIG_From_int(static_cast< int >(3)));

23528

SWIG_Python_SetConstant(d, "STC_TCL_WORD_IN_QUOTE",SWIG_From_int(static_cast< int >(4)));

23529

SWIG_Python_SetConstant(d, "STC_TCL_IN_QUOTE",SWIG_From_int(static_cast< int >(5)));

23530

SWIG_Python_SetConstant(d, "STC_TCL_OPERATOR",SWIG_From_int(static_cast< int >(6)));

23531

SWIG_Python_SetConstant(d, "STC_TCL_IDENTIFIER",SWIG_From_int(static_cast< int >(7)));

23532

SWIG_Python_SetConstant(d, "STC_TCL_SUBSTITUTION",SWIG_From_int(static_cast< int >(8)));

23533

SWIG_Python_SetConstant(d, "STC_TCL_SUB_BRACE",SWIG_From_int(static_cast< int >(9)));

23534

SWIG_Python_SetConstant(d, "STC_TCL_MODIFIER",SWIG_From_int(static_cast< int >(10)));

23535

SWIG_Python_SetConstant(d, "STC_TCL_EXPAND",SWIG_From_int(static_cast< int >(11)));

23536

SWIG_Python_SetConstant(d, "STC_TCL_WORD",SWIG_From_int(static_cast< int >(12)));

23537

SWIG_Python_SetConstant(d, "STC_TCL_WORD2",SWIG_From_int(static_cast< int >(13)));

23538

SWIG_Python_SetConstant(d, "STC_TCL_WORD3",SWIG_From_int(static_cast< int >(14)));

23539

SWIG_Python_SetConstant(d, "STC_TCL_WORD4",SWIG_From_int(static_cast< int >(15)));

23540

SWIG_Python_SetConstant(d, "STC_TCL_WORD5",SWIG_From_int(static_cast< int >(16)));

23541

SWIG_Python_SetConstant(d, "STC_TCL_WORD6",SWIG_From_int(static_cast< int >(17)));

23542

SWIG_Python_SetConstant(d, "STC_TCL_WORD7",SWIG_From_int(static_cast< int >(18)));

23543

SWIG_Python_SetConstant(d, "STC_TCL_WORD8",SWIG_From_int(static_cast< int >(19)));

23544

SWIG_Python_SetConstant(d, "STC_TCL_COMMENT_BOX",SWIG_From_int(static_cast< int >(20)));

23545

SWIG_Python_SetConstant(d, "STC_TCL_BLOCK_COMMENT",SWIG_From_int(static_cast< int >(21)));

23546

SWIG_Python_SetConstant(d, "STC_H_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23547

SWIG_Python_SetConstant(d, "STC_H_TAG",SWIG_From_int(static_cast< int >(1)));

23548

SWIG_Python_SetConstant(d, "STC_H_TAGUNKNOWN",SWIG_From_int(static_cast< int >(2)));

23549

SWIG_Python_SetConstant(d, "STC_H_ATTRIBUTE",SWIG_From_int(static_cast< int >(3)));

23550

SWIG_Python_SetConstant(d, "STC_H_ATTRIBUTEUNKNOWN",SWIG_From_int(static_cast< int >(4)));

23551

SWIG_Python_SetConstant(d, "STC_H_NUMBER",SWIG_From_int(static_cast< int >(5)));

23552

SWIG_Python_SetConstant(d, "STC_H_DOUBLESTRING",SWIG_From_int(static_cast< int >(6)));

23553

SWIG_Python_SetConstant(d, "STC_H_SINGLESTRING",SWIG_From_int(static_cast< int >(7)));

23554

SWIG_Python_SetConstant(d, "STC_H_OTHER",SWIG_From_int(static_cast< int >(8)));

23555

SWIG_Python_SetConstant(d, "STC_H_COMMENT",SWIG_From_int(static_cast< int >(9)));

23556

SWIG_Python_SetConstant(d, "STC_H_ENTITY",SWIG_From_int(static_cast< int >(10)));

23557

SWIG_Python_SetConstant(d, "STC_H_TAGEND",SWIG_From_int(static_cast< int >(11)));

23558

SWIG_Python_SetConstant(d, "STC_H_XMLSTART",SWIG_From_int(static_cast< int >(12)));

23559

SWIG_Python_SetConstant(d, "STC_H_XMLEND",SWIG_From_int(static_cast< int >(13)));

23560

SWIG_Python_SetConstant(d, "STC_H_SCRIPT",SWIG_From_int(static_cast< int >(14)));

23561

SWIG_Python_SetConstant(d, "STC_H_ASP",SWIG_From_int(static_cast< int >(15)));

23562

SWIG_Python_SetConstant(d, "STC_H_ASPAT",SWIG_From_int(static_cast< int >(16)));

23563

SWIG_Python_SetConstant(d, "STC_H_CDATA",SWIG_From_int(static_cast< int >(17)));

23564

SWIG_Python_SetConstant(d, "STC_H_QUESTION",SWIG_From_int(static_cast< int >(18)));

23565

SWIG_Python_SetConstant(d, "STC_H_VALUE",SWIG_From_int(static_cast< int >(19)));

23566

SWIG_Python_SetConstant(d, "STC_H_XCCOMMENT",SWIG_From_int(static_cast< int >(20)));

23567

SWIG_Python_SetConstant(d, "STC_H_SGML_DEFAULT",SWIG_From_int(static_cast< int >(21)));

23568

SWIG_Python_SetConstant(d, "STC_H_SGML_COMMAND",SWIG_From_int(static_cast< int >(22)));

23569

SWIG_Python_SetConstant(d, "STC_H_SGML_1ST_PARAM",SWIG_From_int(static_cast< int >(23)));

23570

SWIG_Python_SetConstant(d, "STC_H_SGML_DOUBLESTRING",SWIG_From_int(static_cast< int >(24)));

23571

SWIG_Python_SetConstant(d, "STC_H_SGML_SIMPLESTRING",SWIG_From_int(static_cast< int >(25)));

23572

SWIG_Python_SetConstant(d, "STC_H_SGML_ERROR",SWIG_From_int(static_cast< int >(26)));

23573

SWIG_Python_SetConstant(d, "STC_H_SGML_SPECIAL",SWIG_From_int(static_cast< int >(27)));

23574

SWIG_Python_SetConstant(d, "STC_H_SGML_ENTITY",SWIG_From_int(static_cast< int >(28)));

23575

SWIG_Python_SetConstant(d, "STC_H_SGML_COMMENT",SWIG_From_int(static_cast< int >(29)));

23576

SWIG_Python_SetConstant(d, "STC_H_SGML_1ST_PARAM_COMMENT",SWIG_From_int(static_cast< int >(30)));

23577

SWIG_Python_SetConstant(d, "STC_H_SGML_BLOCK_DEFAULT",SWIG_From_int(static_cast< int >(31)));

23578

SWIG_Python_SetConstant(d, "STC_HJ_START",SWIG_From_int(static_cast< int >(40)));

23579

SWIG_Python_SetConstant(d, "STC_HJ_DEFAULT",SWIG_From_int(static_cast< int >(41)));

23580

SWIG_Python_SetConstant(d, "STC_HJ_COMMENT",SWIG_From_int(static_cast< int >(42)));

23581

SWIG_Python_SetConstant(d, "STC_HJ_COMMENTLINE",SWIG_From_int(static_cast< int >(43)));

23582

SWIG_Python_SetConstant(d, "STC_HJ_COMMENTDOC",SWIG_From_int(static_cast< int >(44)));

23583

SWIG_Python_SetConstant(d, "STC_HJ_NUMBER",SWIG_From_int(static_cast< int >(45)));

23584

SWIG_Python_SetConstant(d, "STC_HJ_WORD",SWIG_From_int(static_cast< int >(46)));

23585

SWIG_Python_SetConstant(d, "STC_HJ_KEYWORD",SWIG_From_int(static_cast< int >(47)));

23586

SWIG_Python_SetConstant(d, "STC_HJ_DOUBLESTRING",SWIG_From_int(static_cast< int >(48)));

23587

SWIG_Python_SetConstant(d, "STC_HJ_SINGLESTRING",SWIG_From_int(static_cast< int >(49)));

23588

SWIG_Python_SetConstant(d, "STC_HJ_SYMBOLS",SWIG_From_int(static_cast< int >(50)));

23589

SWIG_Python_SetConstant(d, "STC_HJ_STRINGEOL",SWIG_From_int(static_cast< int >(51)));

23590

SWIG_Python_SetConstant(d, "STC_HJ_REGEX",SWIG_From_int(static_cast< int >(52)));

23591

SWIG_Python_SetConstant(d, "STC_HJA_START",SWIG_From_int(static_cast< int >(55)));

23592

SWIG_Python_SetConstant(d, "STC_HJA_DEFAULT",SWIG_From_int(static_cast< int >(56)));

23593

SWIG_Python_SetConstant(d, "STC_HJA_COMMENT",SWIG_From_int(static_cast< int >(57)));

23594

SWIG_Python_SetConstant(d, "STC_HJA_COMMENTLINE",SWIG_From_int(static_cast< int >(58)));

23595

SWIG_Python_SetConstant(d, "STC_HJA_COMMENTDOC",SWIG_From_int(static_cast< int >(59)));

23596

SWIG_Python_SetConstant(d, "STC_HJA_NUMBER",SWIG_From_int(static_cast< int >(60)));

23597

SWIG_Python_SetConstant(d, "STC_HJA_WORD",SWIG_From_int(static_cast< int >(61)));

23598

SWIG_Python_SetConstant(d, "STC_HJA_KEYWORD",SWIG_From_int(static_cast< int >(62)));

23599

SWIG_Python_SetConstant(d, "STC_HJA_DOUBLESTRING",SWIG_From_int(static_cast< int >(63)));

23600

SWIG_Python_SetConstant(d, "STC_HJA_SINGLESTRING",SWIG_From_int(static_cast< int >(64)));

23601

SWIG_Python_SetConstant(d, "STC_HJA_SYMBOLS",SWIG_From_int(static_cast< int >(65)));

23602

SWIG_Python_SetConstant(d, "STC_HJA_STRINGEOL",SWIG_From_int(static_cast< int >(66)));

23603

SWIG_Python_SetConstant(d, "STC_HJA_REGEX",SWIG_From_int(static_cast< int >(67)));

23604

SWIG_Python_SetConstant(d, "STC_HB_START",SWIG_From_int(static_cast< int >(70)));

23605

SWIG_Python_SetConstant(d, "STC_HB_DEFAULT",SWIG_From_int(static_cast< int >(71)));

23606

SWIG_Python_SetConstant(d, "STC_HB_COMMENTLINE",SWIG_From_int(static_cast< int >(72)));

23607

SWIG_Python_SetConstant(d, "STC_HB_NUMBER",SWIG_From_int(static_cast< int >(73)));

23608

SWIG_Python_SetConstant(d, "STC_HB_WORD",SWIG_From_int(static_cast< int >(74)));

23609

SWIG_Python_SetConstant(d, "STC_HB_STRING",SWIG_From_int(static_cast< int >(75)));

23610

SWIG_Python_SetConstant(d, "STC_HB_IDENTIFIER",SWIG_From_int(static_cast< int >(76)));

23611

SWIG_Python_SetConstant(d, "STC_HB_STRINGEOL",SWIG_From_int(static_cast< int >(77)));

23612

SWIG_Python_SetConstant(d, "STC_HBA_START",SWIG_From_int(static_cast< int >(80)));

23613

SWIG_Python_SetConstant(d, "STC_HBA_DEFAULT",SWIG_From_int(static_cast< int >(81)));

23614

SWIG_Python_SetConstant(d, "STC_HBA_COMMENTLINE",SWIG_From_int(static_cast< int >(82)));

23615

SWIG_Python_SetConstant(d, "STC_HBA_NUMBER",SWIG_From_int(static_cast< int >(83)));

23616

SWIG_Python_SetConstant(d, "STC_HBA_WORD",SWIG_From_int(static_cast< int >(84)));

23617

SWIG_Python_SetConstant(d, "STC_HBA_STRING",SWIG_From_int(static_cast< int >(85)));

23618

SWIG_Python_SetConstant(d, "STC_HBA_IDENTIFIER",SWIG_From_int(static_cast< int >(86)));

23619

SWIG_Python_SetConstant(d, "STC_HBA_STRINGEOL",SWIG_From_int(static_cast< int >(87)));

23620

SWIG_Python_SetConstant(d, "STC_HP_START",SWIG_From_int(static_cast< int >(90)));

23621

SWIG_Python_SetConstant(d, "STC_HP_DEFAULT",SWIG_From_int(static_cast< int >(91)));

23622

SWIG_Python_SetConstant(d, "STC_HP_COMMENTLINE",SWIG_From_int(static_cast< int >(92)));

23623

SWIG_Python_SetConstant(d, "STC_HP_NUMBER",SWIG_From_int(static_cast< int >(93)));

23624

SWIG_Python_SetConstant(d, "STC_HP_STRING",SWIG_From_int(static_cast< int >(94)));

23625

SWIG_Python_SetConstant(d, "STC_HP_CHARACTER",SWIG_From_int(static_cast< int >(95)));

23626

SWIG_Python_SetConstant(d, "STC_HP_WORD",SWIG_From_int(static_cast< int >(96)));

23627

SWIG_Python_SetConstant(d, "STC_HP_TRIPLE",SWIG_From_int(static_cast< int >(97)));

23628

SWIG_Python_SetConstant(d, "STC_HP_TRIPLEDOUBLE",SWIG_From_int(static_cast< int >(98)));

23629

SWIG_Python_SetConstant(d, "STC_HP_CLASSNAME",SWIG_From_int(static_cast< int >(99)));

23630

SWIG_Python_SetConstant(d, "STC_HP_DEFNAME",SWIG_From_int(static_cast< int >(100)));

23631

SWIG_Python_SetConstant(d, "STC_HP_OPERATOR",SWIG_From_int(static_cast< int >(101)));

23632

SWIG_Python_SetConstant(d, "STC_HP_IDENTIFIER",SWIG_From_int(static_cast< int >(102)));

23633

SWIG_Python_SetConstant(d, "STC_HPHP_COMPLEX_VARIABLE",SWIG_From_int(static_cast< int >(104)));

23634

SWIG_Python_SetConstant(d, "STC_HPA_START",SWIG_From_int(static_cast< int >(105)));

23635

SWIG_Python_SetConstant(d, "STC_HPA_DEFAULT",SWIG_From_int(static_cast< int >(106)));

23636

SWIG_Python_SetConstant(d, "STC_HPA_COMMENTLINE",SWIG_From_int(static_cast< int >(107)));

23637

SWIG_Python_SetConstant(d, "STC_HPA_NUMBER",SWIG_From_int(static_cast< int >(108)));

23638

SWIG_Python_SetConstant(d, "STC_HPA_STRING",SWIG_From_int(static_cast< int >(109)));

23639

SWIG_Python_SetConstant(d, "STC_HPA_CHARACTER",SWIG_From_int(static_cast< int >(110)));

23640

SWIG_Python_SetConstant(d, "STC_HPA_WORD",SWIG_From_int(static_cast< int >(111)));

23641

SWIG_Python_SetConstant(d, "STC_HPA_TRIPLE",SWIG_From_int(static_cast< int >(112)));

23642

SWIG_Python_SetConstant(d, "STC_HPA_TRIPLEDOUBLE",SWIG_From_int(static_cast< int >(113)));

23643

SWIG_Python_SetConstant(d, "STC_HPA_CLASSNAME",SWIG_From_int(static_cast< int >(114)));

23644

SWIG_Python_SetConstant(d, "STC_HPA_DEFNAME",SWIG_From_int(static_cast< int >(115)));

23645

SWIG_Python_SetConstant(d, "STC_HPA_OPERATOR",SWIG_From_int(static_cast< int >(116)));

23646

SWIG_Python_SetConstant(d, "STC_HPA_IDENTIFIER",SWIG_From_int(static_cast< int >(117)));

23647

SWIG_Python_SetConstant(d, "STC_HPHP_DEFAULT",SWIG_From_int(static_cast< int >(118)));

23648

SWIG_Python_SetConstant(d, "STC_HPHP_HSTRING",SWIG_From_int(static_cast< int >(119)));

23649

SWIG_Python_SetConstant(d, "STC_HPHP_SIMPLESTRING",SWIG_From_int(static_cast< int >(120)));

23650

SWIG_Python_SetConstant(d, "STC_HPHP_WORD",SWIG_From_int(static_cast< int >(121)));

23651

SWIG_Python_SetConstant(d, "STC_HPHP_NUMBER",SWIG_From_int(static_cast< int >(122)));

23652

SWIG_Python_SetConstant(d, "STC_HPHP_VARIABLE",SWIG_From_int(static_cast< int >(123)));

23653

SWIG_Python_SetConstant(d, "STC_HPHP_COMMENT",SWIG_From_int(static_cast< int >(124)));

23654

SWIG_Python_SetConstant(d, "STC_HPHP_COMMENTLINE",SWIG_From_int(static_cast< int >(125)));

23655

SWIG_Python_SetConstant(d, "STC_HPHP_HSTRING_VARIABLE",SWIG_From_int(static_cast< int >(126)));

23656

SWIG_Python_SetConstant(d, "STC_HPHP_OPERATOR",SWIG_From_int(static_cast< int >(127)));

23657

SWIG_Python_SetConstant(d, "STC_PL_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23658

SWIG_Python_SetConstant(d, "STC_PL_ERROR",SWIG_From_int(static_cast< int >(1)));

23659

SWIG_Python_SetConstant(d, "STC_PL_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

23660

SWIG_Python_SetConstant(d, "STC_PL_POD",SWIG_From_int(static_cast< int >(3)));

23661

SWIG_Python_SetConstant(d, "STC_PL_NUMBER",SWIG_From_int(static_cast< int >(4)));

23662

SWIG_Python_SetConstant(d, "STC_PL_WORD",SWIG_From_int(static_cast< int >(5)));

23663

SWIG_Python_SetConstant(d, "STC_PL_STRING",SWIG_From_int(static_cast< int >(6)));

23664

SWIG_Python_SetConstant(d, "STC_PL_CHARACTER",SWIG_From_int(static_cast< int >(7)));

23665

SWIG_Python_SetConstant(d, "STC_PL_PUNCTUATION",SWIG_From_int(static_cast< int >(8)));

23666

SWIG_Python_SetConstant(d, "STC_PL_PREPROCESSOR",SWIG_From_int(static_cast< int >(9)));

23667

SWIG_Python_SetConstant(d, "STC_PL_OPERATOR",SWIG_From_int(static_cast< int >(10)));

23668

SWIG_Python_SetConstant(d, "STC_PL_IDENTIFIER",SWIG_From_int(static_cast< int >(11)));

23669

SWIG_Python_SetConstant(d, "STC_PL_SCALAR",SWIG_From_int(static_cast< int >(12)));

23670

SWIG_Python_SetConstant(d, "STC_PL_ARRAY",SWIG_From_int(static_cast< int >(13)));

23671

SWIG_Python_SetConstant(d, "STC_PL_HASH",SWIG_From_int(static_cast< int >(14)));

23672

SWIG_Python_SetConstant(d, "STC_PL_SYMBOLTABLE",SWIG_From_int(static_cast< int >(15)));

23673

SWIG_Python_SetConstant(d, "STC_PL_VARIABLE_INDEXER",SWIG_From_int(static_cast< int >(16)));

23674

SWIG_Python_SetConstant(d, "STC_PL_REGEX",SWIG_From_int(static_cast< int >(17)));

23675

SWIG_Python_SetConstant(d, "STC_PL_REGSUBST",SWIG_From_int(static_cast< int >(18)));

23676

SWIG_Python_SetConstant(d, "STC_PL_LONGQUOTE",SWIG_From_int(static_cast< int >(19)));

23677

SWIG_Python_SetConstant(d, "STC_PL_BACKTICKS",SWIG_From_int(static_cast< int >(20)));

23678

SWIG_Python_SetConstant(d, "STC_PL_DATASECTION",SWIG_From_int(static_cast< int >(21)));

23679

SWIG_Python_SetConstant(d, "STC_PL_HERE_DELIM",SWIG_From_int(static_cast< int >(22)));

23680

SWIG_Python_SetConstant(d, "STC_PL_HERE_Q",SWIG_From_int(static_cast< int >(23)));

23681

SWIG_Python_SetConstant(d, "STC_PL_HERE_QQ",SWIG_From_int(static_cast< int >(24)));

23682

SWIG_Python_SetConstant(d, "STC_PL_HERE_QX",SWIG_From_int(static_cast< int >(25)));

23683

SWIG_Python_SetConstant(d, "STC_PL_STRING_Q",SWIG_From_int(static_cast< int >(26)));

23684

SWIG_Python_SetConstant(d, "STC_PL_STRING_QQ",SWIG_From_int(static_cast< int >(27)));

23685

SWIG_Python_SetConstant(d, "STC_PL_STRING_QX",SWIG_From_int(static_cast< int >(28)));

23686

SWIG_Python_SetConstant(d, "STC_PL_STRING_QR",SWIG_From_int(static_cast< int >(29)));

23687

SWIG_Python_SetConstant(d, "STC_PL_STRING_QW",SWIG_From_int(static_cast< int >(30)));

23688

SWIG_Python_SetConstant(d, "STC_PL_POD_VERB",SWIG_From_int(static_cast< int >(31)));

23689

SWIG_Python_SetConstant(d, "STC_RB_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23690

SWIG_Python_SetConstant(d, "STC_RB_ERROR",SWIG_From_int(static_cast< int >(1)));

23691

SWIG_Python_SetConstant(d, "STC_RB_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

23692

SWIG_Python_SetConstant(d, "STC_RB_POD",SWIG_From_int(static_cast< int >(3)));

23693

SWIG_Python_SetConstant(d, "STC_RB_NUMBER",SWIG_From_int(static_cast< int >(4)));

23694

SWIG_Python_SetConstant(d, "STC_RB_WORD",SWIG_From_int(static_cast< int >(5)));

23695

SWIG_Python_SetConstant(d, "STC_RB_STRING",SWIG_From_int(static_cast< int >(6)));

23696

SWIG_Python_SetConstant(d, "STC_RB_CHARACTER",SWIG_From_int(static_cast< int >(7)));

23697

SWIG_Python_SetConstant(d, "STC_RB_CLASSNAME",SWIG_From_int(static_cast< int >(8)));

23698

SWIG_Python_SetConstant(d, "STC_RB_DEFNAME",SWIG_From_int(static_cast< int >(9)));

23699

SWIG_Python_SetConstant(d, "STC_RB_OPERATOR",SWIG_From_int(static_cast< int >(10)));

23700

SWIG_Python_SetConstant(d, "STC_RB_IDENTIFIER",SWIG_From_int(static_cast< int >(11)));

23701

SWIG_Python_SetConstant(d, "STC_RB_REGEX",SWIG_From_int(static_cast< int >(12)));

23702

SWIG_Python_SetConstant(d, "STC_RB_GLOBAL",SWIG_From_int(static_cast< int >(13)));

23703

SWIG_Python_SetConstant(d, "STC_RB_SYMBOL",SWIG_From_int(static_cast< int >(14)));

23704

SWIG_Python_SetConstant(d, "STC_RB_MODULE_NAME",SWIG_From_int(static_cast< int >(15)));

23705

SWIG_Python_SetConstant(d, "STC_RB_INSTANCE_VAR",SWIG_From_int(static_cast< int >(16)));

23706

SWIG_Python_SetConstant(d, "STC_RB_CLASS_VAR",SWIG_From_int(static_cast< int >(17)));

23707

SWIG_Python_SetConstant(d, "STC_RB_BACKTICKS",SWIG_From_int(static_cast< int >(18)));

23708

SWIG_Python_SetConstant(d, "STC_RB_DATASECTION",SWIG_From_int(static_cast< int >(19)));

23709

SWIG_Python_SetConstant(d, "STC_RB_HERE_DELIM",SWIG_From_int(static_cast< int >(20)));

23710

SWIG_Python_SetConstant(d, "STC_RB_HERE_Q",SWIG_From_int(static_cast< int >(21)));

23711

SWIG_Python_SetConstant(d, "STC_RB_HERE_QQ",SWIG_From_int(static_cast< int >(22)));

23712

SWIG_Python_SetConstant(d, "STC_RB_HERE_QX",SWIG_From_int(static_cast< int >(23)));

23713

SWIG_Python_SetConstant(d, "STC_RB_STRING_Q",SWIG_From_int(static_cast< int >(24)));

23714

SWIG_Python_SetConstant(d, "STC_RB_STRING_QQ",SWIG_From_int(static_cast< int >(25)));

23715

SWIG_Python_SetConstant(d, "STC_RB_STRING_QX",SWIG_From_int(static_cast< int >(26)));

23716

SWIG_Python_SetConstant(d, "STC_RB_STRING_QR",SWIG_From_int(static_cast< int >(27)));

23717

SWIG_Python_SetConstant(d, "STC_RB_STRING_QW",SWIG_From_int(static_cast< int >(28)));

23718

SWIG_Python_SetConstant(d, "STC_RB_WORD_DEMOTED",SWIG_From_int(static_cast< int >(29)));

23719

SWIG_Python_SetConstant(d, "STC_RB_STDIN",SWIG_From_int(static_cast< int >(30)));

23720

SWIG_Python_SetConstant(d, "STC_RB_STDOUT",SWIG_From_int(static_cast< int >(31)));

23721

SWIG_Python_SetConstant(d, "STC_RB_STDERR",SWIG_From_int(static_cast< int >(40)));

23722

SWIG_Python_SetConstant(d, "STC_RB_UPPER_BOUND",SWIG_From_int(static_cast< int >(41)));

23723

SWIG_Python_SetConstant(d, "STC_B_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23724

SWIG_Python_SetConstant(d, "STC_B_COMMENT",SWIG_From_int(static_cast< int >(1)));

23725

SWIG_Python_SetConstant(d, "STC_B_NUMBER",SWIG_From_int(static_cast< int >(2)));

23726

SWIG_Python_SetConstant(d, "STC_B_KEYWORD",SWIG_From_int(static_cast< int >(3)));

23727

SWIG_Python_SetConstant(d, "STC_B_STRING",SWIG_From_int(static_cast< int >(4)));

23728

SWIG_Python_SetConstant(d, "STC_B_PREPROCESSOR",SWIG_From_int(static_cast< int >(5)));

23729

SWIG_Python_SetConstant(d, "STC_B_OPERATOR",SWIG_From_int(static_cast< int >(6)));

23730

SWIG_Python_SetConstant(d, "STC_B_IDENTIFIER",SWIG_From_int(static_cast< int >(7)));

23731

SWIG_Python_SetConstant(d, "STC_B_DATE",SWIG_From_int(static_cast< int >(8)));

23732

SWIG_Python_SetConstant(d, "STC_B_STRINGEOL",SWIG_From_int(static_cast< int >(9)));

23733

SWIG_Python_SetConstant(d, "STC_B_KEYWORD2",SWIG_From_int(static_cast< int >(10)));

23734

SWIG_Python_SetConstant(d, "STC_B_KEYWORD3",SWIG_From_int(static_cast< int >(11)));

23735

SWIG_Python_SetConstant(d, "STC_B_KEYWORD4",SWIG_From_int(static_cast< int >(12)));

23736

SWIG_Python_SetConstant(d, "STC_B_CONSTANT",SWIG_From_int(static_cast< int >(13)));

23737

SWIG_Python_SetConstant(d, "STC_B_ASM",SWIG_From_int(static_cast< int >(14)));

23738

SWIG_Python_SetConstant(d, "STC_B_LABEL",SWIG_From_int(static_cast< int >(15)));

23739

SWIG_Python_SetConstant(d, "STC_B_ERROR",SWIG_From_int(static_cast< int >(16)));

23740

SWIG_Python_SetConstant(d, "STC_B_HEXNUMBER",SWIG_From_int(static_cast< int >(17)));

23741

SWIG_Python_SetConstant(d, "STC_B_BINNUMBER",SWIG_From_int(static_cast< int >(18)));

23742

SWIG_Python_SetConstant(d, "STC_PROPS_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23743

SWIG_Python_SetConstant(d, "STC_PROPS_COMMENT",SWIG_From_int(static_cast< int >(1)));

23744

SWIG_Python_SetConstant(d, "STC_PROPS_SECTION",SWIG_From_int(static_cast< int >(2)));

23745

SWIG_Python_SetConstant(d, "STC_PROPS_ASSIGNMENT",SWIG_From_int(static_cast< int >(3)));

23746

SWIG_Python_SetConstant(d, "STC_PROPS_DEFVAL",SWIG_From_int(static_cast< int >(4)));

23747

SWIG_Python_SetConstant(d, "STC_PROPS_KEY",SWIG_From_int(static_cast< int >(5)));

23748

SWIG_Python_SetConstant(d, "STC_L_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23749

SWIG_Python_SetConstant(d, "STC_L_COMMAND",SWIG_From_int(static_cast< int >(1)));

23750

SWIG_Python_SetConstant(d, "STC_L_TAG",SWIG_From_int(static_cast< int >(2)));

23751

SWIG_Python_SetConstant(d, "STC_L_MATH",SWIG_From_int(static_cast< int >(3)));

23752

SWIG_Python_SetConstant(d, "STC_L_COMMENT",SWIG_From_int(static_cast< int >(4)));

23753

SWIG_Python_SetConstant(d, "STC_LUA_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23754

SWIG_Python_SetConstant(d, "STC_LUA_COMMENT",SWIG_From_int(static_cast< int >(1)));

23755

SWIG_Python_SetConstant(d, "STC_LUA_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

23756

SWIG_Python_SetConstant(d, "STC_LUA_COMMENTDOC",SWIG_From_int(static_cast< int >(3)));

23757

SWIG_Python_SetConstant(d, "STC_LUA_NUMBER",SWIG_From_int(static_cast< int >(4)));

23758

SWIG_Python_SetConstant(d, "STC_LUA_WORD",SWIG_From_int(static_cast< int >(5)));

23759

SWIG_Python_SetConstant(d, "STC_LUA_STRING",SWIG_From_int(static_cast< int >(6)));

23760

SWIG_Python_SetConstant(d, "STC_LUA_CHARACTER",SWIG_From_int(static_cast< int >(7)));

23761

SWIG_Python_SetConstant(d, "STC_LUA_LITERALSTRING",SWIG_From_int(static_cast< int >(8)));

23762

SWIG_Python_SetConstant(d, "STC_LUA_PREPROCESSOR",SWIG_From_int(static_cast< int >(9)));

23763

SWIG_Python_SetConstant(d, "STC_LUA_OPERATOR",SWIG_From_int(static_cast< int >(10)));

23764

SWIG_Python_SetConstant(d, "STC_LUA_IDENTIFIER",SWIG_From_int(static_cast< int >(11)));

23765

SWIG_Python_SetConstant(d, "STC_LUA_STRINGEOL",SWIG_From_int(static_cast< int >(12)));

23766

SWIG_Python_SetConstant(d, "STC_LUA_WORD2",SWIG_From_int(static_cast< int >(13)));

23767

SWIG_Python_SetConstant(d, "STC_LUA_WORD3",SWIG_From_int(static_cast< int >(14)));

23768

SWIG_Python_SetConstant(d, "STC_LUA_WORD4",SWIG_From_int(static_cast< int >(15)));

23769

SWIG_Python_SetConstant(d, "STC_LUA_WORD5",SWIG_From_int(static_cast< int >(16)));

23770

SWIG_Python_SetConstant(d, "STC_LUA_WORD6",SWIG_From_int(static_cast< int >(17)));

23771

SWIG_Python_SetConstant(d, "STC_LUA_WORD7",SWIG_From_int(static_cast< int >(18)));

23772

SWIG_Python_SetConstant(d, "STC_LUA_WORD8",SWIG_From_int(static_cast< int >(19)));

23773

SWIG_Python_SetConstant(d, "STC_ERR_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23774

SWIG_Python_SetConstant(d, "STC_ERR_PYTHON",SWIG_From_int(static_cast< int >(1)));

23775

SWIG_Python_SetConstant(d, "STC_ERR_GCC",SWIG_From_int(static_cast< int >(2)));

23776

SWIG_Python_SetConstant(d, "STC_ERR_MS",SWIG_From_int(static_cast< int >(3)));

23777

SWIG_Python_SetConstant(d, "STC_ERR_CMD",SWIG_From_int(static_cast< int >(4)));

23778

SWIG_Python_SetConstant(d, "STC_ERR_BORLAND",SWIG_From_int(static_cast< int >(5)));

23779

SWIG_Python_SetConstant(d, "STC_ERR_PERL",SWIG_From_int(static_cast< int >(6)));

23780

SWIG_Python_SetConstant(d, "STC_ERR_NET",SWIG_From_int(static_cast< int >(7)));

23781

SWIG_Python_SetConstant(d, "STC_ERR_LUA",SWIG_From_int(static_cast< int >(8)));

23782

SWIG_Python_SetConstant(d, "STC_ERR_CTAG",SWIG_From_int(static_cast< int >(9)));

23783

SWIG_Python_SetConstant(d, "STC_ERR_DIFF_CHANGED",SWIG_From_int(static_cast< int >(10)));

23784

SWIG_Python_SetConstant(d, "STC_ERR_DIFF_ADDITION",SWIG_From_int(static_cast< int >(11)));

23785

SWIG_Python_SetConstant(d, "STC_ERR_DIFF_DELETION",SWIG_From_int(static_cast< int >(12)));

23786

SWIG_Python_SetConstant(d, "STC_ERR_DIFF_MESSAGE",SWIG_From_int(static_cast< int >(13)));

23787

SWIG_Python_SetConstant(d, "STC_ERR_PHP",SWIG_From_int(static_cast< int >(14)));

23788

SWIG_Python_SetConstant(d, "STC_ERR_ELF",SWIG_From_int(static_cast< int >(15)));

23789

SWIG_Python_SetConstant(d, "STC_ERR_IFC",SWIG_From_int(static_cast< int >(16)));

23790

SWIG_Python_SetConstant(d, "STC_ERR_IFORT",SWIG_From_int(static_cast< int >(17)));

23791

SWIG_Python_SetConstant(d, "STC_ERR_ABSF",SWIG_From_int(static_cast< int >(18)));

23792

SWIG_Python_SetConstant(d, "STC_ERR_TIDY",SWIG_From_int(static_cast< int >(19)));

23793

SWIG_Python_SetConstant(d, "STC_ERR_JAVA_STACK",SWIG_From_int(static_cast< int >(20)));

23794

SWIG_Python_SetConstant(d, "STC_BAT_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23795

SWIG_Python_SetConstant(d, "STC_BAT_COMMENT",SWIG_From_int(static_cast< int >(1)));

23796

SWIG_Python_SetConstant(d, "STC_BAT_WORD",SWIG_From_int(static_cast< int >(2)));

23797

SWIG_Python_SetConstant(d, "STC_BAT_LABEL",SWIG_From_int(static_cast< int >(3)));

23798

SWIG_Python_SetConstant(d, "STC_BAT_HIDE",SWIG_From_int(static_cast< int >(4)));

23799

SWIG_Python_SetConstant(d, "STC_BAT_COMMAND",SWIG_From_int(static_cast< int >(5)));

23800

SWIG_Python_SetConstant(d, "STC_BAT_IDENTIFIER",SWIG_From_int(static_cast< int >(6)));

23801

SWIG_Python_SetConstant(d, "STC_BAT_OPERATOR",SWIG_From_int(static_cast< int >(7)));

23802

SWIG_Python_SetConstant(d, "STC_MAKE_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23803

SWIG_Python_SetConstant(d, "STC_MAKE_COMMENT",SWIG_From_int(static_cast< int >(1)));

23804

SWIG_Python_SetConstant(d, "STC_MAKE_PREPROCESSOR",SWIG_From_int(static_cast< int >(2)));

23805

SWIG_Python_SetConstant(d, "STC_MAKE_IDENTIFIER",SWIG_From_int(static_cast< int >(3)));

23806

SWIG_Python_SetConstant(d, "STC_MAKE_OPERATOR",SWIG_From_int(static_cast< int >(4)));

23807

SWIG_Python_SetConstant(d, "STC_MAKE_TARGET",SWIG_From_int(static_cast< int >(5)));

23808

SWIG_Python_SetConstant(d, "STC_MAKE_IDEOL",SWIG_From_int(static_cast< int >(9)));

23809

SWIG_Python_SetConstant(d, "STC_DIFF_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23810

SWIG_Python_SetConstant(d, "STC_DIFF_COMMENT",SWIG_From_int(static_cast< int >(1)));

23811

SWIG_Python_SetConstant(d, "STC_DIFF_COMMAND",SWIG_From_int(static_cast< int >(2)));

23812

SWIG_Python_SetConstant(d, "STC_DIFF_HEADER",SWIG_From_int(static_cast< int >(3)));

23813

SWIG_Python_SetConstant(d, "STC_DIFF_POSITION",SWIG_From_int(static_cast< int >(4)));

23814

SWIG_Python_SetConstant(d, "STC_DIFF_DELETED",SWIG_From_int(static_cast< int >(5)));

23815

SWIG_Python_SetConstant(d, "STC_DIFF_ADDED",SWIG_From_int(static_cast< int >(6)));

23816

SWIG_Python_SetConstant(d, "STC_CONF_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23817

SWIG_Python_SetConstant(d, "STC_CONF_COMMENT",SWIG_From_int(static_cast< int >(1)));

23818

SWIG_Python_SetConstant(d, "STC_CONF_NUMBER",SWIG_From_int(static_cast< int >(2)));

23819

SWIG_Python_SetConstant(d, "STC_CONF_IDENTIFIER",SWIG_From_int(static_cast< int >(3)));

23820

SWIG_Python_SetConstant(d, "STC_CONF_EXTENSION",SWIG_From_int(static_cast< int >(4)));

23821

SWIG_Python_SetConstant(d, "STC_CONF_PARAMETER",SWIG_From_int(static_cast< int >(5)));

23822

SWIG_Python_SetConstant(d, "STC_CONF_STRING",SWIG_From_int(static_cast< int >(6)));

23823

SWIG_Python_SetConstant(d, "STC_CONF_OPERATOR",SWIG_From_int(static_cast< int >(7)));

23824

SWIG_Python_SetConstant(d, "STC_CONF_IP",SWIG_From_int(static_cast< int >(8)));

23825

SWIG_Python_SetConstant(d, "STC_CONF_DIRECTIVE",SWIG_From_int(static_cast< int >(9)));

23826

SWIG_Python_SetConstant(d, "STC_AVE_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23827

SWIG_Python_SetConstant(d, "STC_AVE_COMMENT",SWIG_From_int(static_cast< int >(1)));

23828

SWIG_Python_SetConstant(d, "STC_AVE_NUMBER",SWIG_From_int(static_cast< int >(2)));

23829

SWIG_Python_SetConstant(d, "STC_AVE_WORD",SWIG_From_int(static_cast< int >(3)));

23830

SWIG_Python_SetConstant(d, "STC_AVE_STRING",SWIG_From_int(static_cast< int >(6)));

23831

SWIG_Python_SetConstant(d, "STC_AVE_ENUM",SWIG_From_int(static_cast< int >(7)));

23832

SWIG_Python_SetConstant(d, "STC_AVE_STRINGEOL",SWIG_From_int(static_cast< int >(8)));

23833

SWIG_Python_SetConstant(d, "STC_AVE_IDENTIFIER",SWIG_From_int(static_cast< int >(9)));

23834

SWIG_Python_SetConstant(d, "STC_AVE_OPERATOR",SWIG_From_int(static_cast< int >(10)));

23835

SWIG_Python_SetConstant(d, "STC_AVE_WORD1",SWIG_From_int(static_cast< int >(11)));

23836

SWIG_Python_SetConstant(d, "STC_AVE_WORD2",SWIG_From_int(static_cast< int >(12)));

23837

SWIG_Python_SetConstant(d, "STC_AVE_WORD3",SWIG_From_int(static_cast< int >(13)));

23838

SWIG_Python_SetConstant(d, "STC_AVE_WORD4",SWIG_From_int(static_cast< int >(14)));

23839

SWIG_Python_SetConstant(d, "STC_AVE_WORD5",SWIG_From_int(static_cast< int >(15)));

23840

SWIG_Python_SetConstant(d, "STC_AVE_WORD6",SWIG_From_int(static_cast< int >(16)));

23841

SWIG_Python_SetConstant(d, "STC_ADA_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23842

SWIG_Python_SetConstant(d, "STC_ADA_WORD",SWIG_From_int(static_cast< int >(1)));

23843

SWIG_Python_SetConstant(d, "STC_ADA_IDENTIFIER",SWIG_From_int(static_cast< int >(2)));

23844

SWIG_Python_SetConstant(d, "STC_ADA_NUMBER",SWIG_From_int(static_cast< int >(3)));

23845

SWIG_Python_SetConstant(d, "STC_ADA_DELIMITER",SWIG_From_int(static_cast< int >(4)));

23846

SWIG_Python_SetConstant(d, "STC_ADA_CHARACTER",SWIG_From_int(static_cast< int >(5)));

23847

SWIG_Python_SetConstant(d, "STC_ADA_CHARACTEREOL",SWIG_From_int(static_cast< int >(6)));

23848

SWIG_Python_SetConstant(d, "STC_ADA_STRING",SWIG_From_int(static_cast< int >(7)));

23849

SWIG_Python_SetConstant(d, "STC_ADA_STRINGEOL",SWIG_From_int(static_cast< int >(8)));

23850

SWIG_Python_SetConstant(d, "STC_ADA_LABEL",SWIG_From_int(static_cast< int >(9)));

23851

SWIG_Python_SetConstant(d, "STC_ADA_COMMENTLINE",SWIG_From_int(static_cast< int >(10)));

23852

SWIG_Python_SetConstant(d, "STC_ADA_ILLEGAL",SWIG_From_int(static_cast< int >(11)));

23853

SWIG_Python_SetConstant(d, "STC_BAAN_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23854

SWIG_Python_SetConstant(d, "STC_BAAN_COMMENT",SWIG_From_int(static_cast< int >(1)));

23855

SWIG_Python_SetConstant(d, "STC_BAAN_COMMENTDOC",SWIG_From_int(static_cast< int >(2)));

23856

SWIG_Python_SetConstant(d, "STC_BAAN_NUMBER",SWIG_From_int(static_cast< int >(3)));

23857

SWIG_Python_SetConstant(d, "STC_BAAN_WORD",SWIG_From_int(static_cast< int >(4)));

23858

SWIG_Python_SetConstant(d, "STC_BAAN_STRING",SWIG_From_int(static_cast< int >(5)));

23859

SWIG_Python_SetConstant(d, "STC_BAAN_PREPROCESSOR",SWIG_From_int(static_cast< int >(6)));

23860

SWIG_Python_SetConstant(d, "STC_BAAN_OPERATOR",SWIG_From_int(static_cast< int >(7)));

23861

SWIG_Python_SetConstant(d, "STC_BAAN_IDENTIFIER",SWIG_From_int(static_cast< int >(8)));

23862

SWIG_Python_SetConstant(d, "STC_BAAN_STRINGEOL",SWIG_From_int(static_cast< int >(9)));

23863

SWIG_Python_SetConstant(d, "STC_BAAN_WORD2",SWIG_From_int(static_cast< int >(10)));

23864

SWIG_Python_SetConstant(d, "STC_LISP_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23865

SWIG_Python_SetConstant(d, "STC_LISP_COMMENT",SWIG_From_int(static_cast< int >(1)));

23866

SWIG_Python_SetConstant(d, "STC_LISP_NUMBER",SWIG_From_int(static_cast< int >(2)));

23867

SWIG_Python_SetConstant(d, "STC_LISP_KEYWORD",SWIG_From_int(static_cast< int >(3)));

23868

SWIG_Python_SetConstant(d, "STC_LISP_KEYWORD_KW",SWIG_From_int(static_cast< int >(4)));

23869

SWIG_Python_SetConstant(d, "STC_LISP_SYMBOL",SWIG_From_int(static_cast< int >(5)));

23870

SWIG_Python_SetConstant(d, "STC_LISP_STRING",SWIG_From_int(static_cast< int >(6)));

23871

SWIG_Python_SetConstant(d, "STC_LISP_STRINGEOL",SWIG_From_int(static_cast< int >(8)));

23872

SWIG_Python_SetConstant(d, "STC_LISP_IDENTIFIER",SWIG_From_int(static_cast< int >(9)));

23873

SWIG_Python_SetConstant(d, "STC_LISP_OPERATOR",SWIG_From_int(static_cast< int >(10)));

23874

SWIG_Python_SetConstant(d, "STC_LISP_SPECIAL",SWIG_From_int(static_cast< int >(11)));

23875

SWIG_Python_SetConstant(d, "STC_LISP_MULTI_COMMENT",SWIG_From_int(static_cast< int >(12)));

23876

SWIG_Python_SetConstant(d, "STC_EIFFEL_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23877

SWIG_Python_SetConstant(d, "STC_EIFFEL_COMMENTLINE",SWIG_From_int(static_cast< int >(1)));

23878

SWIG_Python_SetConstant(d, "STC_EIFFEL_NUMBER",SWIG_From_int(static_cast< int >(2)));

23879

SWIG_Python_SetConstant(d, "STC_EIFFEL_WORD",SWIG_From_int(static_cast< int >(3)));

23880

SWIG_Python_SetConstant(d, "STC_EIFFEL_STRING",SWIG_From_int(static_cast< int >(4)));

23881

SWIG_Python_SetConstant(d, "STC_EIFFEL_CHARACTER",SWIG_From_int(static_cast< int >(5)));

23882

SWIG_Python_SetConstant(d, "STC_EIFFEL_OPERATOR",SWIG_From_int(static_cast< int >(6)));

23883

SWIG_Python_SetConstant(d, "STC_EIFFEL_IDENTIFIER",SWIG_From_int(static_cast< int >(7)));

23884

SWIG_Python_SetConstant(d, "STC_EIFFEL_STRINGEOL",SWIG_From_int(static_cast< int >(8)));

23885

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23886

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_COMMENT",SWIG_From_int(static_cast< int >(1)));

23887

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_TASK",SWIG_From_int(static_cast< int >(2)));

23888

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_SECTION",SWIG_From_int(static_cast< int >(3)));

23889

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_KEYWORD",SWIG_From_int(static_cast< int >(4)));

23890

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_MODIFIER",SWIG_From_int(static_cast< int >(5)));

23891

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_ASTERISK",SWIG_From_int(static_cast< int >(6)));

23892

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_NUMBER",SWIG_From_int(static_cast< int >(7)));

23893

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_STRING",SWIG_From_int(static_cast< int >(8)));

23894

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_ENVIRONMENT",SWIG_From_int(static_cast< int >(9)));

23895

SWIG_Python_SetConstant(d, "STC_NNCRONTAB_IDENTIFIER",SWIG_From_int(static_cast< int >(10)));

23896

SWIG_Python_SetConstant(d, "STC_FORTH_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23897

SWIG_Python_SetConstant(d, "STC_FORTH_COMMENT",SWIG_From_int(static_cast< int >(1)));

23898

SWIG_Python_SetConstant(d, "STC_FORTH_COMMENT_ML",SWIG_From_int(static_cast< int >(2)));

23899

SWIG_Python_SetConstant(d, "STC_FORTH_IDENTIFIER",SWIG_From_int(static_cast< int >(3)));

23900

SWIG_Python_SetConstant(d, "STC_FORTH_CONTROL",SWIG_From_int(static_cast< int >(4)));

23901

SWIG_Python_SetConstant(d, "STC_FORTH_KEYWORD",SWIG_From_int(static_cast< int >(5)));

23902

SWIG_Python_SetConstant(d, "STC_FORTH_DEFWORD",SWIG_From_int(static_cast< int >(6)));

23903

SWIG_Python_SetConstant(d, "STC_FORTH_PREWORD1",SWIG_From_int(static_cast< int >(7)));

23904

SWIG_Python_SetConstant(d, "STC_FORTH_PREWORD2",SWIG_From_int(static_cast< int >(8)));

23905

SWIG_Python_SetConstant(d, "STC_FORTH_NUMBER",SWIG_From_int(static_cast< int >(9)));

23906

SWIG_Python_SetConstant(d, "STC_FORTH_STRING",SWIG_From_int(static_cast< int >(10)));

23907

SWIG_Python_SetConstant(d, "STC_FORTH_LOCALE",SWIG_From_int(static_cast< int >(11)));

23908

SWIG_Python_SetConstant(d, "STC_MATLAB_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23909

SWIG_Python_SetConstant(d, "STC_MATLAB_COMMENT",SWIG_From_int(static_cast< int >(1)));

23910

SWIG_Python_SetConstant(d, "STC_MATLAB_COMMAND",SWIG_From_int(static_cast< int >(2)));

23911

SWIG_Python_SetConstant(d, "STC_MATLAB_NUMBER",SWIG_From_int(static_cast< int >(3)));

23912

SWIG_Python_SetConstant(d, "STC_MATLAB_KEYWORD",SWIG_From_int(static_cast< int >(4)));

23913

SWIG_Python_SetConstant(d, "STC_MATLAB_STRING",SWIG_From_int(static_cast< int >(5)));

23914

SWIG_Python_SetConstant(d, "STC_MATLAB_OPERATOR",SWIG_From_int(static_cast< int >(6)));

23915

SWIG_Python_SetConstant(d, "STC_MATLAB_IDENTIFIER",SWIG_From_int(static_cast< int >(7)));

23916

SWIG_Python_SetConstant(d, "STC_MATLAB_DOUBLEQUOTESTRING",SWIG_From_int(static_cast< int >(8)));

23917

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23918

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_WHITE",SWIG_From_int(static_cast< int >(1)));

23919

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

23920

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_PERSISTENT",SWIG_From_int(static_cast< int >(3)));

23921

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_CSTYLE",SWIG_From_int(static_cast< int >(4)));

23922

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_COMMENTBLOCK",SWIG_From_int(static_cast< int >(5)));

23923

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_NUMBER",SWIG_From_int(static_cast< int >(6)));

23924

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_STRING",SWIG_From_int(static_cast< int >(7)));

23925

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_CHARACTER",SWIG_From_int(static_cast< int >(8)));

23926

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_STRINGEOL",SWIG_From_int(static_cast< int >(9)));

23927

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_KEYWORD",SWIG_From_int(static_cast< int >(10)));

23928

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_OPERATOR",SWIG_From_int(static_cast< int >(11)));

23929

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_IDENTIFIER",SWIG_From_int(static_cast< int >(12)));

23930

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_TRIPLE",SWIG_From_int(static_cast< int >(13)));

23931

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_CLASSNAME",SWIG_From_int(static_cast< int >(14)));

23932

SWIG_Python_SetConstant(d, "STC_SCRIPTOL_PREPROCESSOR",SWIG_From_int(static_cast< int >(15)));

23933

SWIG_Python_SetConstant(d, "STC_ASM_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23934

SWIG_Python_SetConstant(d, "STC_ASM_COMMENT",SWIG_From_int(static_cast< int >(1)));

23935

SWIG_Python_SetConstant(d, "STC_ASM_NUMBER",SWIG_From_int(static_cast< int >(2)));

23936

SWIG_Python_SetConstant(d, "STC_ASM_STRING",SWIG_From_int(static_cast< int >(3)));

23937

SWIG_Python_SetConstant(d, "STC_ASM_OPERATOR",SWIG_From_int(static_cast< int >(4)));

23938

SWIG_Python_SetConstant(d, "STC_ASM_IDENTIFIER",SWIG_From_int(static_cast< int >(5)));

23939

SWIG_Python_SetConstant(d, "STC_ASM_CPUINSTRUCTION",SWIG_From_int(static_cast< int >(6)));

23940

SWIG_Python_SetConstant(d, "STC_ASM_MATHINSTRUCTION",SWIG_From_int(static_cast< int >(7)));

23941

SWIG_Python_SetConstant(d, "STC_ASM_REGISTER",SWIG_From_int(static_cast< int >(8)));

23942

SWIG_Python_SetConstant(d, "STC_ASM_DIRECTIVE",SWIG_From_int(static_cast< int >(9)));

23943

SWIG_Python_SetConstant(d, "STC_ASM_DIRECTIVEOPERAND",SWIG_From_int(static_cast< int >(10)));

23944

SWIG_Python_SetConstant(d, "STC_ASM_COMMENTBLOCK",SWIG_From_int(static_cast< int >(11)));

23945

SWIG_Python_SetConstant(d, "STC_ASM_CHARACTER",SWIG_From_int(static_cast< int >(12)));

23946

SWIG_Python_SetConstant(d, "STC_ASM_STRINGEOL",SWIG_From_int(static_cast< int >(13)));

23947

SWIG_Python_SetConstant(d, "STC_ASM_EXTINSTRUCTION",SWIG_From_int(static_cast< int >(14)));

23948

SWIG_Python_SetConstant(d, "STC_F_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23949

SWIG_Python_SetConstant(d, "STC_F_COMMENT",SWIG_From_int(static_cast< int >(1)));

23950

SWIG_Python_SetConstant(d, "STC_F_NUMBER",SWIG_From_int(static_cast< int >(2)));

23951

SWIG_Python_SetConstant(d, "STC_F_STRING1",SWIG_From_int(static_cast< int >(3)));

23952

SWIG_Python_SetConstant(d, "STC_F_STRING2",SWIG_From_int(static_cast< int >(4)));

23953

SWIG_Python_SetConstant(d, "STC_F_STRINGEOL",SWIG_From_int(static_cast< int >(5)));

23954

SWIG_Python_SetConstant(d, "STC_F_OPERATOR",SWIG_From_int(static_cast< int >(6)));

23955

SWIG_Python_SetConstant(d, "STC_F_IDENTIFIER",SWIG_From_int(static_cast< int >(7)));

23956

SWIG_Python_SetConstant(d, "STC_F_WORD",SWIG_From_int(static_cast< int >(8)));

23957

SWIG_Python_SetConstant(d, "STC_F_WORD2",SWIG_From_int(static_cast< int >(9)));

23958

SWIG_Python_SetConstant(d, "STC_F_WORD3",SWIG_From_int(static_cast< int >(10)));

23959

SWIG_Python_SetConstant(d, "STC_F_PREPROCESSOR",SWIG_From_int(static_cast< int >(11)));

23960

SWIG_Python_SetConstant(d, "STC_F_OPERATOR2",SWIG_From_int(static_cast< int >(12)));

23961

SWIG_Python_SetConstant(d, "STC_F_LABEL",SWIG_From_int(static_cast< int >(13)));

23962

SWIG_Python_SetConstant(d, "STC_F_CONTINUATION",SWIG_From_int(static_cast< int >(14)));

23963

SWIG_Python_SetConstant(d, "STC_CSS_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23964

SWIG_Python_SetConstant(d, "STC_CSS_TAG",SWIG_From_int(static_cast< int >(1)));

23965

SWIG_Python_SetConstant(d, "STC_CSS_CLASS",SWIG_From_int(static_cast< int >(2)));

23966

SWIG_Python_SetConstant(d, "STC_CSS_PSEUDOCLASS",SWIG_From_int(static_cast< int >(3)));

23967

SWIG_Python_SetConstant(d, "STC_CSS_UNKNOWN_PSEUDOCLASS",SWIG_From_int(static_cast< int >(4)));

23968

SWIG_Python_SetConstant(d, "STC_CSS_OPERATOR",SWIG_From_int(static_cast< int >(5)));

23969

SWIG_Python_SetConstant(d, "STC_CSS_IDENTIFIER",SWIG_From_int(static_cast< int >(6)));

23970

SWIG_Python_SetConstant(d, "STC_CSS_UNKNOWN_IDENTIFIER",SWIG_From_int(static_cast< int >(7)));

23971

SWIG_Python_SetConstant(d, "STC_CSS_VALUE",SWIG_From_int(static_cast< int >(8)));

23972

SWIG_Python_SetConstant(d, "STC_CSS_COMMENT",SWIG_From_int(static_cast< int >(9)));

23973

SWIG_Python_SetConstant(d, "STC_CSS_ID",SWIG_From_int(static_cast< int >(10)));

23974

SWIG_Python_SetConstant(d, "STC_CSS_IMPORTANT",SWIG_From_int(static_cast< int >(11)));

23975

SWIG_Python_SetConstant(d, "STC_CSS_DIRECTIVE",SWIG_From_int(static_cast< int >(12)));

23976

SWIG_Python_SetConstant(d, "STC_CSS_DOUBLESTRING",SWIG_From_int(static_cast< int >(13)));

23977

SWIG_Python_SetConstant(d, "STC_CSS_SINGLESTRING",SWIG_From_int(static_cast< int >(14)));

23978

SWIG_Python_SetConstant(d, "STC_CSS_IDENTIFIER2",SWIG_From_int(static_cast< int >(15)));

23979

SWIG_Python_SetConstant(d, "STC_CSS_ATTRIBUTE",SWIG_From_int(static_cast< int >(16)));

23980

SWIG_Python_SetConstant(d, "STC_POV_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23981

SWIG_Python_SetConstant(d, "STC_POV_COMMENT",SWIG_From_int(static_cast< int >(1)));

23982

SWIG_Python_SetConstant(d, "STC_POV_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

23983

SWIG_Python_SetConstant(d, "STC_POV_NUMBER",SWIG_From_int(static_cast< int >(3)));

23984

SWIG_Python_SetConstant(d, "STC_POV_OPERATOR",SWIG_From_int(static_cast< int >(4)));

23985

SWIG_Python_SetConstant(d, "STC_POV_IDENTIFIER",SWIG_From_int(static_cast< int >(5)));

23986

SWIG_Python_SetConstant(d, "STC_POV_STRING",SWIG_From_int(static_cast< int >(6)));

23987

SWIG_Python_SetConstant(d, "STC_POV_STRINGEOL",SWIG_From_int(static_cast< int >(7)));

23988

SWIG_Python_SetConstant(d, "STC_POV_DIRECTIVE",SWIG_From_int(static_cast< int >(8)));

23989

SWIG_Python_SetConstant(d, "STC_POV_BADDIRECTIVE",SWIG_From_int(static_cast< int >(9)));

23990

SWIG_Python_SetConstant(d, "STC_POV_WORD2",SWIG_From_int(static_cast< int >(10)));

23991

SWIG_Python_SetConstant(d, "STC_POV_WORD3",SWIG_From_int(static_cast< int >(11)));

23992

SWIG_Python_SetConstant(d, "STC_POV_WORD4",SWIG_From_int(static_cast< int >(12)));

23993

SWIG_Python_SetConstant(d, "STC_POV_WORD5",SWIG_From_int(static_cast< int >(13)));

23994

SWIG_Python_SetConstant(d, "STC_POV_WORD6",SWIG_From_int(static_cast< int >(14)));

23995

SWIG_Python_SetConstant(d, "STC_POV_WORD7",SWIG_From_int(static_cast< int >(15)));

23996

SWIG_Python_SetConstant(d, "STC_POV_WORD8",SWIG_From_int(static_cast< int >(16)));

23997

SWIG_Python_SetConstant(d, "STC_LOUT_DEFAULT",SWIG_From_int(static_cast< int >(0)));

23998

SWIG_Python_SetConstant(d, "STC_LOUT_COMMENT",SWIG_From_int(static_cast< int >(1)));

23999

SWIG_Python_SetConstant(d, "STC_LOUT_NUMBER",SWIG_From_int(static_cast< int >(2)));

24000

SWIG_Python_SetConstant(d, "STC_LOUT_WORD",SWIG_From_int(static_cast< int >(3)));

24001

SWIG_Python_SetConstant(d, "STC_LOUT_WORD2",SWIG_From_int(static_cast< int >(4)));

24002

SWIG_Python_SetConstant(d, "STC_LOUT_WORD3",SWIG_From_int(static_cast< int >(5)));

24003

SWIG_Python_SetConstant(d, "STC_LOUT_WORD4",SWIG_From_int(static_cast< int >(6)));

24004

SWIG_Python_SetConstant(d, "STC_LOUT_STRING",SWIG_From_int(static_cast< int >(7)));

24005

SWIG_Python_SetConstant(d, "STC_LOUT_OPERATOR",SWIG_From_int(static_cast< int >(8)));

24006

SWIG_Python_SetConstant(d, "STC_LOUT_IDENTIFIER",SWIG_From_int(static_cast< int >(9)));

24007

SWIG_Python_SetConstant(d, "STC_LOUT_STRINGEOL",SWIG_From_int(static_cast< int >(10)));

24008

SWIG_Python_SetConstant(d, "STC_ESCRIPT_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24009

SWIG_Python_SetConstant(d, "STC_ESCRIPT_COMMENT",SWIG_From_int(static_cast< int >(1)));

24010

SWIG_Python_SetConstant(d, "STC_ESCRIPT_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

24011

SWIG_Python_SetConstant(d, "STC_ESCRIPT_COMMENTDOC",SWIG_From_int(static_cast< int >(3)));

24012

SWIG_Python_SetConstant(d, "STC_ESCRIPT_NUMBER",SWIG_From_int(static_cast< int >(4)));

24013

SWIG_Python_SetConstant(d, "STC_ESCRIPT_WORD",SWIG_From_int(static_cast< int >(5)));

24014

SWIG_Python_SetConstant(d, "STC_ESCRIPT_STRING",SWIG_From_int(static_cast< int >(6)));

24015

SWIG_Python_SetConstant(d, "STC_ESCRIPT_OPERATOR",SWIG_From_int(static_cast< int >(7)));

24016

SWIG_Python_SetConstant(d, "STC_ESCRIPT_IDENTIFIER",SWIG_From_int(static_cast< int >(8)));

24017

SWIG_Python_SetConstant(d, "STC_ESCRIPT_BRACE",SWIG_From_int(static_cast< int >(9)));

24018

SWIG_Python_SetConstant(d, "STC_ESCRIPT_WORD2",SWIG_From_int(static_cast< int >(10)));

24019

SWIG_Python_SetConstant(d, "STC_ESCRIPT_WORD3",SWIG_From_int(static_cast< int >(11)));

24020

SWIG_Python_SetConstant(d, "STC_PS_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24021

SWIG_Python_SetConstant(d, "STC_PS_COMMENT",SWIG_From_int(static_cast< int >(1)));

24022

SWIG_Python_SetConstant(d, "STC_PS_DSC_COMMENT",SWIG_From_int(static_cast< int >(2)));

24023

SWIG_Python_SetConstant(d, "STC_PS_DSC_VALUE",SWIG_From_int(static_cast< int >(3)));

24024

SWIG_Python_SetConstant(d, "STC_PS_NUMBER",SWIG_From_int(static_cast< int >(4)));

24025

SWIG_Python_SetConstant(d, "STC_PS_NAME",SWIG_From_int(static_cast< int >(5)));

24026

SWIG_Python_SetConstant(d, "STC_PS_KEYWORD",SWIG_From_int(static_cast< int >(6)));

24027

SWIG_Python_SetConstant(d, "STC_PS_LITERAL",SWIG_From_int(static_cast< int >(7)));

24028

SWIG_Python_SetConstant(d, "STC_PS_IMMEVAL",SWIG_From_int(static_cast< int >(8)));

24029

SWIG_Python_SetConstant(d, "STC_PS_PAREN_ARRAY",SWIG_From_int(static_cast< int >(9)));

24030

SWIG_Python_SetConstant(d, "STC_PS_PAREN_DICT",SWIG_From_int(static_cast< int >(10)));

24031

SWIG_Python_SetConstant(d, "STC_PS_PAREN_PROC",SWIG_From_int(static_cast< int >(11)));

24032

SWIG_Python_SetConstant(d, "STC_PS_TEXT",SWIG_From_int(static_cast< int >(12)));

24033

SWIG_Python_SetConstant(d, "STC_PS_HEXSTRING",SWIG_From_int(static_cast< int >(13)));

24034

SWIG_Python_SetConstant(d, "STC_PS_BASE85STRING",SWIG_From_int(static_cast< int >(14)));

24035

SWIG_Python_SetConstant(d, "STC_PS_BADSTRINGCHAR",SWIG_From_int(static_cast< int >(15)));

24036

SWIG_Python_SetConstant(d, "STC_NSIS_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24037

SWIG_Python_SetConstant(d, "STC_NSIS_COMMENT",SWIG_From_int(static_cast< int >(1)));

24038

SWIG_Python_SetConstant(d, "STC_NSIS_STRINGDQ",SWIG_From_int(static_cast< int >(2)));

24039

SWIG_Python_SetConstant(d, "STC_NSIS_STRINGLQ",SWIG_From_int(static_cast< int >(3)));

24040

SWIG_Python_SetConstant(d, "STC_NSIS_STRINGRQ",SWIG_From_int(static_cast< int >(4)));

24041

SWIG_Python_SetConstant(d, "STC_NSIS_FUNCTION",SWIG_From_int(static_cast< int >(5)));

24042

SWIG_Python_SetConstant(d, "STC_NSIS_VARIABLE",SWIG_From_int(static_cast< int >(6)));

24043

SWIG_Python_SetConstant(d, "STC_NSIS_LABEL",SWIG_From_int(static_cast< int >(7)));

24044

SWIG_Python_SetConstant(d, "STC_NSIS_USERDEFINED",SWIG_From_int(static_cast< int >(8)));

24045

SWIG_Python_SetConstant(d, "STC_NSIS_SECTIONDEF",SWIG_From_int(static_cast< int >(9)));

24046

SWIG_Python_SetConstant(d, "STC_NSIS_SUBSECTIONDEF",SWIG_From_int(static_cast< int >(10)));

24047

SWIG_Python_SetConstant(d, "STC_NSIS_IFDEFINEDEF",SWIG_From_int(static_cast< int >(11)));

24048

SWIG_Python_SetConstant(d, "STC_NSIS_MACRODEF",SWIG_From_int(static_cast< int >(12)));

24049

SWIG_Python_SetConstant(d, "STC_NSIS_STRINGVAR",SWIG_From_int(static_cast< int >(13)));

24050

SWIG_Python_SetConstant(d, "STC_NSIS_NUMBER",SWIG_From_int(static_cast< int >(14)));

24051

SWIG_Python_SetConstant(d, "STC_NSIS_SECTIONGROUP",SWIG_From_int(static_cast< int >(15)));

24052

SWIG_Python_SetConstant(d, "STC_NSIS_PAGEEX",SWIG_From_int(static_cast< int >(16)));

24053

SWIG_Python_SetConstant(d, "STC_NSIS_FUNCTIONDEF",SWIG_From_int(static_cast< int >(17)));

24054

SWIG_Python_SetConstant(d, "STC_NSIS_COMMENTBOX",SWIG_From_int(static_cast< int >(18)));

24055

SWIG_Python_SetConstant(d, "STC_MMIXAL_LEADWS",SWIG_From_int(static_cast< int >(0)));

24056

SWIG_Python_SetConstant(d, "STC_MMIXAL_COMMENT",SWIG_From_int(static_cast< int >(1)));

24057

SWIG_Python_SetConstant(d, "STC_MMIXAL_LABEL",SWIG_From_int(static_cast< int >(2)));

24058

SWIG_Python_SetConstant(d, "STC_MMIXAL_OPCODE",SWIG_From_int(static_cast< int >(3)));

24059

SWIG_Python_SetConstant(d, "STC_MMIXAL_OPCODE_PRE",SWIG_From_int(static_cast< int >(4)));

24060

SWIG_Python_SetConstant(d, "STC_MMIXAL_OPCODE_VALID",SWIG_From_int(static_cast< int >(5)));

24061

SWIG_Python_SetConstant(d, "STC_MMIXAL_OPCODE_UNKNOWN",SWIG_From_int(static_cast< int >(6)));

24062

SWIG_Python_SetConstant(d, "STC_MMIXAL_OPCODE_POST",SWIG_From_int(static_cast< int >(7)));

24063

SWIG_Python_SetConstant(d, "STC_MMIXAL_OPERANDS",SWIG_From_int(static_cast< int >(8)));

24064

SWIG_Python_SetConstant(d, "STC_MMIXAL_NUMBER",SWIG_From_int(static_cast< int >(9)));

24065

SWIG_Python_SetConstant(d, "STC_MMIXAL_REF",SWIG_From_int(static_cast< int >(10)));

24066

SWIG_Python_SetConstant(d, "STC_MMIXAL_CHAR",SWIG_From_int(static_cast< int >(11)));

24067

SWIG_Python_SetConstant(d, "STC_MMIXAL_STRING",SWIG_From_int(static_cast< int >(12)));

24068

SWIG_Python_SetConstant(d, "STC_MMIXAL_REGISTER",SWIG_From_int(static_cast< int >(13)));

24069

SWIG_Python_SetConstant(d, "STC_MMIXAL_HEX",SWIG_From_int(static_cast< int >(14)));

24070

SWIG_Python_SetConstant(d, "STC_MMIXAL_OPERATOR",SWIG_From_int(static_cast< int >(15)));

24071

SWIG_Python_SetConstant(d, "STC_MMIXAL_SYMBOL",SWIG_From_int(static_cast< int >(16)));

24072

SWIG_Python_SetConstant(d, "STC_MMIXAL_INCLUDE",SWIG_From_int(static_cast< int >(17)));

24073

SWIG_Python_SetConstant(d, "STC_CLW_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24074

SWIG_Python_SetConstant(d, "STC_CLW_LABEL",SWIG_From_int(static_cast< int >(1)));

24075

SWIG_Python_SetConstant(d, "STC_CLW_COMMENT",SWIG_From_int(static_cast< int >(2)));

24076

SWIG_Python_SetConstant(d, "STC_CLW_STRING",SWIG_From_int(static_cast< int >(3)));

24077

SWIG_Python_SetConstant(d, "STC_CLW_USER_IDENTIFIER",SWIG_From_int(static_cast< int >(4)));

24078

SWIG_Python_SetConstant(d, "STC_CLW_INTEGER_CONSTANT",SWIG_From_int(static_cast< int >(5)));

24079

SWIG_Python_SetConstant(d, "STC_CLW_REAL_CONSTANT",SWIG_From_int(static_cast< int >(6)));

24080

SWIG_Python_SetConstant(d, "STC_CLW_PICTURE_STRING",SWIG_From_int(static_cast< int >(7)));

24081

SWIG_Python_SetConstant(d, "STC_CLW_KEYWORD",SWIG_From_int(static_cast< int >(8)));

24082

SWIG_Python_SetConstant(d, "STC_CLW_COMPILER_DIRECTIVE",SWIG_From_int(static_cast< int >(9)));

24083

SWIG_Python_SetConstant(d, "STC_CLW_RUNTIME_EXPRESSIONS",SWIG_From_int(static_cast< int >(10)));

24084

SWIG_Python_SetConstant(d, "STC_CLW_BUILTIN_PROCEDURES_FUNCTION",SWIG_From_int(static_cast< int >(11)));

24085

SWIG_Python_SetConstant(d, "STC_CLW_STRUCTURE_DATA_TYPE",SWIG_From_int(static_cast< int >(12)));

24086

SWIG_Python_SetConstant(d, "STC_CLW_ATTRIBUTE",SWIG_From_int(static_cast< int >(13)));

24087

SWIG_Python_SetConstant(d, "STC_CLW_STANDARD_EQUATE",SWIG_From_int(static_cast< int >(14)));

24088

SWIG_Python_SetConstant(d, "STC_CLW_ERROR",SWIG_From_int(static_cast< int >(15)));

24089

SWIG_Python_SetConstant(d, "STC_CLW_DEPRECATED",SWIG_From_int(static_cast< int >(16)));

24090

SWIG_Python_SetConstant(d, "STC_LOT_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24091

SWIG_Python_SetConstant(d, "STC_LOT_HEADER",SWIG_From_int(static_cast< int >(1)));

24092

SWIG_Python_SetConstant(d, "STC_LOT_BREAK",SWIG_From_int(static_cast< int >(2)));

24093

SWIG_Python_SetConstant(d, "STC_LOT_SET",SWIG_From_int(static_cast< int >(3)));

24094

SWIG_Python_SetConstant(d, "STC_LOT_PASS",SWIG_From_int(static_cast< int >(4)));

24095

SWIG_Python_SetConstant(d, "STC_LOT_FAIL",SWIG_From_int(static_cast< int >(5)));

24096

SWIG_Python_SetConstant(d, "STC_LOT_ABORT",SWIG_From_int(static_cast< int >(6)));

24097

SWIG_Python_SetConstant(d, "STC_YAML_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24098

SWIG_Python_SetConstant(d, "STC_YAML_COMMENT",SWIG_From_int(static_cast< int >(1)));

24099

SWIG_Python_SetConstant(d, "STC_YAML_IDENTIFIER",SWIG_From_int(static_cast< int >(2)));

24100

SWIG_Python_SetConstant(d, "STC_YAML_KEYWORD",SWIG_From_int(static_cast< int >(3)));

24101

SWIG_Python_SetConstant(d, "STC_YAML_NUMBER",SWIG_From_int(static_cast< int >(4)));

24102

SWIG_Python_SetConstant(d, "STC_YAML_REFERENCE",SWIG_From_int(static_cast< int >(5)));

24103

SWIG_Python_SetConstant(d, "STC_YAML_DOCUMENT",SWIG_From_int(static_cast< int >(6)));

24104

SWIG_Python_SetConstant(d, "STC_YAML_TEXT",SWIG_From_int(static_cast< int >(7)));

24105

SWIG_Python_SetConstant(d, "STC_YAML_ERROR",SWIG_From_int(static_cast< int >(8)));

24106

SWIG_Python_SetConstant(d, "STC_TEX_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24107

SWIG_Python_SetConstant(d, "STC_TEX_SPECIAL",SWIG_From_int(static_cast< int >(1)));

24108

SWIG_Python_SetConstant(d, "STC_TEX_GROUP",SWIG_From_int(static_cast< int >(2)));

24109

SWIG_Python_SetConstant(d, "STC_TEX_SYMBOL",SWIG_From_int(static_cast< int >(3)));

24110

SWIG_Python_SetConstant(d, "STC_TEX_COMMAND",SWIG_From_int(static_cast< int >(4)));

24111

SWIG_Python_SetConstant(d, "STC_TEX_TEXT",SWIG_From_int(static_cast< int >(5)));

24112

SWIG_Python_SetConstant(d, "STC_METAPOST_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24113

SWIG_Python_SetConstant(d, "STC_METAPOST_SPECIAL",SWIG_From_int(static_cast< int >(1)));

24114

SWIG_Python_SetConstant(d, "STC_METAPOST_GROUP",SWIG_From_int(static_cast< int >(2)));

24115

SWIG_Python_SetConstant(d, "STC_METAPOST_SYMBOL",SWIG_From_int(static_cast< int >(3)));

24116

SWIG_Python_SetConstant(d, "STC_METAPOST_COMMAND",SWIG_From_int(static_cast< int >(4)));

24117

SWIG_Python_SetConstant(d, "STC_METAPOST_TEXT",SWIG_From_int(static_cast< int >(5)));

24118

SWIG_Python_SetConstant(d, "STC_METAPOST_EXTRA",SWIG_From_int(static_cast< int >(6)));

24119

SWIG_Python_SetConstant(d, "STC_ERLANG_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24120

SWIG_Python_SetConstant(d, "STC_ERLANG_COMMENT",SWIG_From_int(static_cast< int >(1)));

24121

SWIG_Python_SetConstant(d, "STC_ERLANG_VARIABLE",SWIG_From_int(static_cast< int >(2)));

24122

SWIG_Python_SetConstant(d, "STC_ERLANG_NUMBER",SWIG_From_int(static_cast< int >(3)));

24123

SWIG_Python_SetConstant(d, "STC_ERLANG_KEYWORD",SWIG_From_int(static_cast< int >(4)));

24124

SWIG_Python_SetConstant(d, "STC_ERLANG_STRING",SWIG_From_int(static_cast< int >(5)));

24125

SWIG_Python_SetConstant(d, "STC_ERLANG_OPERATOR",SWIG_From_int(static_cast< int >(6)));

24126

SWIG_Python_SetConstant(d, "STC_ERLANG_ATOM",SWIG_From_int(static_cast< int >(7)));

24127

SWIG_Python_SetConstant(d, "STC_ERLANG_FUNCTION_NAME",SWIG_From_int(static_cast< int >(8)));

24128

SWIG_Python_SetConstant(d, "STC_ERLANG_CHARACTER",SWIG_From_int(static_cast< int >(9)));

24129

SWIG_Python_SetConstant(d, "STC_ERLANG_MACRO",SWIG_From_int(static_cast< int >(10)));

24130

SWIG_Python_SetConstant(d, "STC_ERLANG_RECORD",SWIG_From_int(static_cast< int >(11)));

24131

SWIG_Python_SetConstant(d, "STC_ERLANG_SEPARATOR",SWIG_From_int(static_cast< int >(12)));

24132

SWIG_Python_SetConstant(d, "STC_ERLANG_NODE_NAME",SWIG_From_int(static_cast< int >(13)));

24133

SWIG_Python_SetConstant(d, "STC_ERLANG_UNKNOWN",SWIG_From_int(static_cast< int >(31)));

24134

SWIG_Python_SetConstant(d, "STC_MSSQL_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24135

SWIG_Python_SetConstant(d, "STC_MSSQL_COMMENT",SWIG_From_int(static_cast< int >(1)));

24136

SWIG_Python_SetConstant(d, "STC_MSSQL_LINE_COMMENT",SWIG_From_int(static_cast< int >(2)));

24137

SWIG_Python_SetConstant(d, "STC_MSSQL_NUMBER",SWIG_From_int(static_cast< int >(3)));

24138

SWIG_Python_SetConstant(d, "STC_MSSQL_STRING",SWIG_From_int(static_cast< int >(4)));

24139

SWIG_Python_SetConstant(d, "STC_MSSQL_OPERATOR",SWIG_From_int(static_cast< int >(5)));

24140

SWIG_Python_SetConstant(d, "STC_MSSQL_IDENTIFIER",SWIG_From_int(static_cast< int >(6)));

24141

SWIG_Python_SetConstant(d, "STC_MSSQL_VARIABLE",SWIG_From_int(static_cast< int >(7)));

24142

SWIG_Python_SetConstant(d, "STC_MSSQL_COLUMN_NAME",SWIG_From_int(static_cast< int >(8)));

24143

SWIG_Python_SetConstant(d, "STC_MSSQL_STATEMENT",SWIG_From_int(static_cast< int >(9)));

24144

SWIG_Python_SetConstant(d, "STC_MSSQL_DATATYPE",SWIG_From_int(static_cast< int >(10)));

24145

SWIG_Python_SetConstant(d, "STC_MSSQL_SYSTABLE",SWIG_From_int(static_cast< int >(11)));

24146

SWIG_Python_SetConstant(d, "STC_MSSQL_GLOBAL_VARIABLE",SWIG_From_int(static_cast< int >(12)));

24147

SWIG_Python_SetConstant(d, "STC_MSSQL_FUNCTION",SWIG_From_int(static_cast< int >(13)));

24148

SWIG_Python_SetConstant(d, "STC_MSSQL_STORED_PROCEDURE",SWIG_From_int(static_cast< int >(14)));

24149

SWIG_Python_SetConstant(d, "STC_MSSQL_DEFAULT_PREF_DATATYPE",SWIG_From_int(static_cast< int >(15)));

24150

SWIG_Python_SetConstant(d, "STC_MSSQL_COLUMN_NAME_2",SWIG_From_int(static_cast< int >(16)));

24151

SWIG_Python_SetConstant(d, "STC_V_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24152

SWIG_Python_SetConstant(d, "STC_V_COMMENT",SWIG_From_int(static_cast< int >(1)));

24153

SWIG_Python_SetConstant(d, "STC_V_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

24154

SWIG_Python_SetConstant(d, "STC_V_COMMENTLINEBANG",SWIG_From_int(static_cast< int >(3)));

24155

SWIG_Python_SetConstant(d, "STC_V_NUMBER",SWIG_From_int(static_cast< int >(4)));

24156

SWIG_Python_SetConstant(d, "STC_V_WORD",SWIG_From_int(static_cast< int >(5)));

24157

SWIG_Python_SetConstant(d, "STC_V_STRING",SWIG_From_int(static_cast< int >(6)));

24158

SWIG_Python_SetConstant(d, "STC_V_WORD2",SWIG_From_int(static_cast< int >(7)));

24159

SWIG_Python_SetConstant(d, "STC_V_WORD3",SWIG_From_int(static_cast< int >(8)));

24160

SWIG_Python_SetConstant(d, "STC_V_PREPROCESSOR",SWIG_From_int(static_cast< int >(9)));

24161

SWIG_Python_SetConstant(d, "STC_V_OPERATOR",SWIG_From_int(static_cast< int >(10)));

24162

SWIG_Python_SetConstant(d, "STC_V_IDENTIFIER",SWIG_From_int(static_cast< int >(11)));

24163

SWIG_Python_SetConstant(d, "STC_V_STRINGEOL",SWIG_From_int(static_cast< int >(12)));

24164

SWIG_Python_SetConstant(d, "STC_V_USER",SWIG_From_int(static_cast< int >(19)));

24165

SWIG_Python_SetConstant(d, "STC_KIX_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24166

SWIG_Python_SetConstant(d, "STC_KIX_COMMENT",SWIG_From_int(static_cast< int >(1)));

24167

SWIG_Python_SetConstant(d, "STC_KIX_STRING1",SWIG_From_int(static_cast< int >(2)));

24168

SWIG_Python_SetConstant(d, "STC_KIX_STRING2",SWIG_From_int(static_cast< int >(3)));

24169

SWIG_Python_SetConstant(d, "STC_KIX_NUMBER",SWIG_From_int(static_cast< int >(4)));

24170

SWIG_Python_SetConstant(d, "STC_KIX_VAR",SWIG_From_int(static_cast< int >(5)));

24171

SWIG_Python_SetConstant(d, "STC_KIX_MACRO",SWIG_From_int(static_cast< int >(6)));

24172

SWIG_Python_SetConstant(d, "STC_KIX_KEYWORD",SWIG_From_int(static_cast< int >(7)));

24173

SWIG_Python_SetConstant(d, "STC_KIX_FUNCTIONS",SWIG_From_int(static_cast< int >(8)));

24174

SWIG_Python_SetConstant(d, "STC_KIX_OPERATOR",SWIG_From_int(static_cast< int >(9)));

24175

SWIG_Python_SetConstant(d, "STC_KIX_IDENTIFIER",SWIG_From_int(static_cast< int >(31)));

24176

SWIG_Python_SetConstant(d, "STC_GC_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24177

SWIG_Python_SetConstant(d, "STC_GC_COMMENTLINE",SWIG_From_int(static_cast< int >(1)));

24178

SWIG_Python_SetConstant(d, "STC_GC_COMMENTBLOCK",SWIG_From_int(static_cast< int >(2)));

24179

SWIG_Python_SetConstant(d, "STC_GC_GLOBAL",SWIG_From_int(static_cast< int >(3)));

24180

SWIG_Python_SetConstant(d, "STC_GC_EVENT",SWIG_From_int(static_cast< int >(4)));

24181

SWIG_Python_SetConstant(d, "STC_GC_ATTRIBUTE",SWIG_From_int(static_cast< int >(5)));

24182

SWIG_Python_SetConstant(d, "STC_GC_CONTROL",SWIG_From_int(static_cast< int >(6)));

24183

SWIG_Python_SetConstant(d, "STC_GC_COMMAND",SWIG_From_int(static_cast< int >(7)));

24184

SWIG_Python_SetConstant(d, "STC_GC_STRING",SWIG_From_int(static_cast< int >(8)));

24185

SWIG_Python_SetConstant(d, "STC_GC_OPERATOR",SWIG_From_int(static_cast< int >(9)));

24186

SWIG_Python_SetConstant(d, "STC_SN_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24187

SWIG_Python_SetConstant(d, "STC_SN_CODE",SWIG_From_int(static_cast< int >(1)));

24188

SWIG_Python_SetConstant(d, "STC_SN_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

24189

SWIG_Python_SetConstant(d, "STC_SN_COMMENTLINEBANG",SWIG_From_int(static_cast< int >(3)));

24190

SWIG_Python_SetConstant(d, "STC_SN_NUMBER",SWIG_From_int(static_cast< int >(4)));

24191

SWIG_Python_SetConstant(d, "STC_SN_WORD",SWIG_From_int(static_cast< int >(5)));

24192

SWIG_Python_SetConstant(d, "STC_SN_STRING",SWIG_From_int(static_cast< int >(6)));

24193

SWIG_Python_SetConstant(d, "STC_SN_WORD2",SWIG_From_int(static_cast< int >(7)));

24194

SWIG_Python_SetConstant(d, "STC_SN_WORD3",SWIG_From_int(static_cast< int >(8)));

24195

SWIG_Python_SetConstant(d, "STC_SN_PREPROCESSOR",SWIG_From_int(static_cast< int >(9)));

24196

SWIG_Python_SetConstant(d, "STC_SN_OPERATOR",SWIG_From_int(static_cast< int >(10)));

24197

SWIG_Python_SetConstant(d, "STC_SN_IDENTIFIER",SWIG_From_int(static_cast< int >(11)));

24198

SWIG_Python_SetConstant(d, "STC_SN_STRINGEOL",SWIG_From_int(static_cast< int >(12)));

24199

SWIG_Python_SetConstant(d, "STC_SN_REGEXTAG",SWIG_From_int(static_cast< int >(13)));

24200

SWIG_Python_SetConstant(d, "STC_SN_SIGNAL",SWIG_From_int(static_cast< int >(14)));

24201

SWIG_Python_SetConstant(d, "STC_SN_USER",SWIG_From_int(static_cast< int >(19)));

24202

SWIG_Python_SetConstant(d, "STC_AU3_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24203

SWIG_Python_SetConstant(d, "STC_AU3_COMMENT",SWIG_From_int(static_cast< int >(1)));

24204

SWIG_Python_SetConstant(d, "STC_AU3_COMMENTBLOCK",SWIG_From_int(static_cast< int >(2)));

24205

SWIG_Python_SetConstant(d, "STC_AU3_NUMBER",SWIG_From_int(static_cast< int >(3)));

24206

SWIG_Python_SetConstant(d, "STC_AU3_FUNCTION",SWIG_From_int(static_cast< int >(4)));

24207

SWIG_Python_SetConstant(d, "STC_AU3_KEYWORD",SWIG_From_int(static_cast< int >(5)));

24208

SWIG_Python_SetConstant(d, "STC_AU3_MACRO",SWIG_From_int(static_cast< int >(6)));

24209

SWIG_Python_SetConstant(d, "STC_AU3_STRING",SWIG_From_int(static_cast< int >(7)));

24210

SWIG_Python_SetConstant(d, "STC_AU3_OPERATOR",SWIG_From_int(static_cast< int >(8)));

24211

SWIG_Python_SetConstant(d, "STC_AU3_VARIABLE",SWIG_From_int(static_cast< int >(9)));

24212

SWIG_Python_SetConstant(d, "STC_AU3_SENT",SWIG_From_int(static_cast< int >(10)));

24213

SWIG_Python_SetConstant(d, "STC_AU3_PREPROCESSOR",SWIG_From_int(static_cast< int >(11)));

24214

SWIG_Python_SetConstant(d, "STC_AU3_SPECIAL",SWIG_From_int(static_cast< int >(12)));

24215

SWIG_Python_SetConstant(d, "STC_AU3_EXPAND",SWIG_From_int(static_cast< int >(13)));

24216

SWIG_Python_SetConstant(d, "STC_AU3_COMOBJ",SWIG_From_int(static_cast< int >(14)));

24217

SWIG_Python_SetConstant(d, "STC_AU3_UDF",SWIG_From_int(static_cast< int >(15)));

24218

SWIG_Python_SetConstant(d, "STC_APDL_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24219

SWIG_Python_SetConstant(d, "STC_APDL_COMMENT",SWIG_From_int(static_cast< int >(1)));

24220

SWIG_Python_SetConstant(d, "STC_APDL_COMMENTBLOCK",SWIG_From_int(static_cast< int >(2)));

24221

SWIG_Python_SetConstant(d, "STC_APDL_NUMBER",SWIG_From_int(static_cast< int >(3)));

24222

SWIG_Python_SetConstant(d, "STC_APDL_STRING",SWIG_From_int(static_cast< int >(4)));

24223

SWIG_Python_SetConstant(d, "STC_APDL_OPERATOR",SWIG_From_int(static_cast< int >(5)));

24224

SWIG_Python_SetConstant(d, "STC_APDL_WORD",SWIG_From_int(static_cast< int >(6)));

24225

SWIG_Python_SetConstant(d, "STC_APDL_PROCESSOR",SWIG_From_int(static_cast< int >(7)));

24226

SWIG_Python_SetConstant(d, "STC_APDL_COMMAND",SWIG_From_int(static_cast< int >(8)));

24227

SWIG_Python_SetConstant(d, "STC_APDL_SLASHCOMMAND",SWIG_From_int(static_cast< int >(9)));

24228

SWIG_Python_SetConstant(d, "STC_APDL_STARCOMMAND",SWIG_From_int(static_cast< int >(10)));

24229

SWIG_Python_SetConstant(d, "STC_APDL_ARGUMENT",SWIG_From_int(static_cast< int >(11)));

24230

SWIG_Python_SetConstant(d, "STC_APDL_FUNCTION",SWIG_From_int(static_cast< int >(12)));

24231

SWIG_Python_SetConstant(d, "STC_SH_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24232

SWIG_Python_SetConstant(d, "STC_SH_ERROR",SWIG_From_int(static_cast< int >(1)));

24233

SWIG_Python_SetConstant(d, "STC_SH_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

24234

SWIG_Python_SetConstant(d, "STC_SH_NUMBER",SWIG_From_int(static_cast< int >(3)));

24235

SWIG_Python_SetConstant(d, "STC_SH_WORD",SWIG_From_int(static_cast< int >(4)));

24236

SWIG_Python_SetConstant(d, "STC_SH_STRING",SWIG_From_int(static_cast< int >(5)));

24237

SWIG_Python_SetConstant(d, "STC_SH_CHARACTER",SWIG_From_int(static_cast< int >(6)));

24238

SWIG_Python_SetConstant(d, "STC_SH_OPERATOR",SWIG_From_int(static_cast< int >(7)));

24239

SWIG_Python_SetConstant(d, "STC_SH_IDENTIFIER",SWIG_From_int(static_cast< int >(8)));

24240

SWIG_Python_SetConstant(d, "STC_SH_SCALAR",SWIG_From_int(static_cast< int >(9)));

24241

SWIG_Python_SetConstant(d, "STC_SH_PARAM",SWIG_From_int(static_cast< int >(10)));

24242

SWIG_Python_SetConstant(d, "STC_SH_BACKTICKS",SWIG_From_int(static_cast< int >(11)));

24243

SWIG_Python_SetConstant(d, "STC_SH_HERE_DELIM",SWIG_From_int(static_cast< int >(12)));

24244

SWIG_Python_SetConstant(d, "STC_SH_HERE_Q",SWIG_From_int(static_cast< int >(13)));

24245

SWIG_Python_SetConstant(d, "STC_ASN1_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24246

SWIG_Python_SetConstant(d, "STC_ASN1_COMMENT",SWIG_From_int(static_cast< int >(1)));

24247

SWIG_Python_SetConstant(d, "STC_ASN1_IDENTIFIER",SWIG_From_int(static_cast< int >(2)));

24248

SWIG_Python_SetConstant(d, "STC_ASN1_STRING",SWIG_From_int(static_cast< int >(3)));

24249

SWIG_Python_SetConstant(d, "STC_ASN1_OID",SWIG_From_int(static_cast< int >(4)));

24250

SWIG_Python_SetConstant(d, "STC_ASN1_SCALAR",SWIG_From_int(static_cast< int >(5)));

24251

SWIG_Python_SetConstant(d, "STC_ASN1_KEYWORD",SWIG_From_int(static_cast< int >(6)));

24252

SWIG_Python_SetConstant(d, "STC_ASN1_ATTRIBUTE",SWIG_From_int(static_cast< int >(7)));

24253

SWIG_Python_SetConstant(d, "STC_ASN1_DESCRIPTOR",SWIG_From_int(static_cast< int >(8)));

24254

SWIG_Python_SetConstant(d, "STC_ASN1_TYPE",SWIG_From_int(static_cast< int >(9)));

24255

SWIG_Python_SetConstant(d, "STC_ASN1_OPERATOR",SWIG_From_int(static_cast< int >(10)));

24256

SWIG_Python_SetConstant(d, "STC_VHDL_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24257

SWIG_Python_SetConstant(d, "STC_VHDL_COMMENT",SWIG_From_int(static_cast< int >(1)));

24258

SWIG_Python_SetConstant(d, "STC_VHDL_COMMENTLINEBANG",SWIG_From_int(static_cast< int >(2)));

24259

SWIG_Python_SetConstant(d, "STC_VHDL_NUMBER",SWIG_From_int(static_cast< int >(3)));

24260

SWIG_Python_SetConstant(d, "STC_VHDL_STRING",SWIG_From_int(static_cast< int >(4)));

24261

SWIG_Python_SetConstant(d, "STC_VHDL_OPERATOR",SWIG_From_int(static_cast< int >(5)));

24262

SWIG_Python_SetConstant(d, "STC_VHDL_IDENTIFIER",SWIG_From_int(static_cast< int >(6)));

24263

SWIG_Python_SetConstant(d, "STC_VHDL_STRINGEOL",SWIG_From_int(static_cast< int >(7)));

24264

SWIG_Python_SetConstant(d, "STC_VHDL_KEYWORD",SWIG_From_int(static_cast< int >(8)));

24265

SWIG_Python_SetConstant(d, "STC_VHDL_STDOPERATOR",SWIG_From_int(static_cast< int >(9)));

24266

SWIG_Python_SetConstant(d, "STC_VHDL_ATTRIBUTE",SWIG_From_int(static_cast< int >(10)));

24267

SWIG_Python_SetConstant(d, "STC_VHDL_STDFUNCTION",SWIG_From_int(static_cast< int >(11)));

24268

SWIG_Python_SetConstant(d, "STC_VHDL_STDPACKAGE",SWIG_From_int(static_cast< int >(12)));

24269

SWIG_Python_SetConstant(d, "STC_VHDL_STDTYPE",SWIG_From_int(static_cast< int >(13)));

24270

SWIG_Python_SetConstant(d, "STC_VHDL_USERWORD",SWIG_From_int(static_cast< int >(14)));

24271

SWIG_Python_SetConstant(d, "STC_CAML_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24272

SWIG_Python_SetConstant(d, "STC_CAML_IDENTIFIER",SWIG_From_int(static_cast< int >(1)));

24273

SWIG_Python_SetConstant(d, "STC_CAML_TAGNAME",SWIG_From_int(static_cast< int >(2)));

24274

SWIG_Python_SetConstant(d, "STC_CAML_KEYWORD",SWIG_From_int(static_cast< int >(3)));

24275

SWIG_Python_SetConstant(d, "STC_CAML_KEYWORD2",SWIG_From_int(static_cast< int >(4)));

24276

SWIG_Python_SetConstant(d, "STC_CAML_KEYWORD3",SWIG_From_int(static_cast< int >(5)));

24277

SWIG_Python_SetConstant(d, "STC_CAML_LINENUM",SWIG_From_int(static_cast< int >(6)));

24278

SWIG_Python_SetConstant(d, "STC_CAML_OPERATOR",SWIG_From_int(static_cast< int >(7)));

24279

SWIG_Python_SetConstant(d, "STC_CAML_NUMBER",SWIG_From_int(static_cast< int >(8)));

24280

SWIG_Python_SetConstant(d, "STC_CAML_CHAR",SWIG_From_int(static_cast< int >(9)));

24281

SWIG_Python_SetConstant(d, "STC_CAML_STRING",SWIG_From_int(static_cast< int >(11)));

24282

SWIG_Python_SetConstant(d, "STC_CAML_COMMENT",SWIG_From_int(static_cast< int >(12)));

24283

SWIG_Python_SetConstant(d, "STC_CAML_COMMENT1",SWIG_From_int(static_cast< int >(13)));

24284

SWIG_Python_SetConstant(d, "STC_CAML_COMMENT2",SWIG_From_int(static_cast< int >(14)));

24285

SWIG_Python_SetConstant(d, "STC_CAML_COMMENT3",SWIG_From_int(static_cast< int >(15)));

24286

SWIG_Python_SetConstant(d, "STC_HA_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24287

SWIG_Python_SetConstant(d, "STC_HA_IDENTIFIER",SWIG_From_int(static_cast< int >(1)));

24288

SWIG_Python_SetConstant(d, "STC_HA_KEYWORD",SWIG_From_int(static_cast< int >(2)));

24289

SWIG_Python_SetConstant(d, "STC_HA_NUMBER",SWIG_From_int(static_cast< int >(3)));

24290

SWIG_Python_SetConstant(d, "STC_HA_STRING",SWIG_From_int(static_cast< int >(4)));

24291

SWIG_Python_SetConstant(d, "STC_HA_CHARACTER",SWIG_From_int(static_cast< int >(5)));

24292

SWIG_Python_SetConstant(d, "STC_HA_CLASS",SWIG_From_int(static_cast< int >(6)));

24293

SWIG_Python_SetConstant(d, "STC_HA_MODULE",SWIG_From_int(static_cast< int >(7)));

24294

SWIG_Python_SetConstant(d, "STC_HA_CAPITAL",SWIG_From_int(static_cast< int >(8)));

24295

SWIG_Python_SetConstant(d, "STC_HA_DATA",SWIG_From_int(static_cast< int >(9)));

24296

SWIG_Python_SetConstant(d, "STC_HA_IMPORT",SWIG_From_int(static_cast< int >(10)));

24297

SWIG_Python_SetConstant(d, "STC_HA_OPERATOR",SWIG_From_int(static_cast< int >(11)));

24298

SWIG_Python_SetConstant(d, "STC_HA_INSTANCE",SWIG_From_int(static_cast< int >(12)));

24299

SWIG_Python_SetConstant(d, "STC_HA_COMMENTLINE",SWIG_From_int(static_cast< int >(13)));

24300

SWIG_Python_SetConstant(d, "STC_HA_COMMENTBLOCK",SWIG_From_int(static_cast< int >(14)));

24301

SWIG_Python_SetConstant(d, "STC_HA_COMMENTBLOCK2",SWIG_From_int(static_cast< int >(15)));

24302

SWIG_Python_SetConstant(d, "STC_HA_COMMENTBLOCK3",SWIG_From_int(static_cast< int >(16)));

24303

SWIG_Python_SetConstant(d, "STC_T3_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24304

SWIG_Python_SetConstant(d, "STC_T3_X_DEFAULT",SWIG_From_int(static_cast< int >(1)));

24305

SWIG_Python_SetConstant(d, "STC_T3_PREPROCESSOR",SWIG_From_int(static_cast< int >(2)));

24306

SWIG_Python_SetConstant(d, "STC_T3_BLOCK_COMMENT",SWIG_From_int(static_cast< int >(3)));

24307

SWIG_Python_SetConstant(d, "STC_T3_LINE_COMMENT",SWIG_From_int(static_cast< int >(4)));

24308

SWIG_Python_SetConstant(d, "STC_T3_OPERATOR",SWIG_From_int(static_cast< int >(5)));

24309

SWIG_Python_SetConstant(d, "STC_T3_KEYWORD",SWIG_From_int(static_cast< int >(6)));

24310

SWIG_Python_SetConstant(d, "STC_T3_NUMBER",SWIG_From_int(static_cast< int >(7)));

24311

SWIG_Python_SetConstant(d, "STC_T3_IDENTIFIER",SWIG_From_int(static_cast< int >(8)));

24312

SWIG_Python_SetConstant(d, "STC_T3_S_STRING",SWIG_From_int(static_cast< int >(9)));

24313

SWIG_Python_SetConstant(d, "STC_T3_D_STRING",SWIG_From_int(static_cast< int >(10)));

24314

SWIG_Python_SetConstant(d, "STC_T3_X_STRING",SWIG_From_int(static_cast< int >(11)));

24315

SWIG_Python_SetConstant(d, "STC_T3_LIB_DIRECTIVE",SWIG_From_int(static_cast< int >(12)));

24316

SWIG_Python_SetConstant(d, "STC_T3_MSG_PARAM",SWIG_From_int(static_cast< int >(13)));

24317

SWIG_Python_SetConstant(d, "STC_T3_HTML_TAG",SWIG_From_int(static_cast< int >(14)));

24318

SWIG_Python_SetConstant(d, "STC_T3_HTML_DEFAULT",SWIG_From_int(static_cast< int >(15)));

24319

SWIG_Python_SetConstant(d, "STC_T3_HTML_STRING",SWIG_From_int(static_cast< int >(16)));

24320

SWIG_Python_SetConstant(d, "STC_T3_USER1",SWIG_From_int(static_cast< int >(17)));

24321

SWIG_Python_SetConstant(d, "STC_T3_USER2",SWIG_From_int(static_cast< int >(18)));

24322

SWIG_Python_SetConstant(d, "STC_T3_USER3",SWIG_From_int(static_cast< int >(19)));

24323

SWIG_Python_SetConstant(d, "STC_REBOL_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24324

SWIG_Python_SetConstant(d, "STC_REBOL_COMMENTLINE",SWIG_From_int(static_cast< int >(1)));

24325

SWIG_Python_SetConstant(d, "STC_REBOL_COMMENTBLOCK",SWIG_From_int(static_cast< int >(2)));

24326

SWIG_Python_SetConstant(d, "STC_REBOL_PREFACE",SWIG_From_int(static_cast< int >(3)));

24327

SWIG_Python_SetConstant(d, "STC_REBOL_OPERATOR",SWIG_From_int(static_cast< int >(4)));

24328

SWIG_Python_SetConstant(d, "STC_REBOL_CHARACTER",SWIG_From_int(static_cast< int >(5)));

24329

SWIG_Python_SetConstant(d, "STC_REBOL_QUOTEDSTRING",SWIG_From_int(static_cast< int >(6)));

24330

SWIG_Python_SetConstant(d, "STC_REBOL_BRACEDSTRING",SWIG_From_int(static_cast< int >(7)));

24331

SWIG_Python_SetConstant(d, "STC_REBOL_NUMBER",SWIG_From_int(static_cast< int >(8)));

24332

SWIG_Python_SetConstant(d, "STC_REBOL_PAIR",SWIG_From_int(static_cast< int >(9)));

24333

SWIG_Python_SetConstant(d, "STC_REBOL_TUPLE",SWIG_From_int(static_cast< int >(10)));

24334

SWIG_Python_SetConstant(d, "STC_REBOL_BINARY",SWIG_From_int(static_cast< int >(11)));

24335

SWIG_Python_SetConstant(d, "STC_REBOL_MONEY",SWIG_From_int(static_cast< int >(12)));

24336

SWIG_Python_SetConstant(d, "STC_REBOL_ISSUE",SWIG_From_int(static_cast< int >(13)));

24337

SWIG_Python_SetConstant(d, "STC_REBOL_TAG",SWIG_From_int(static_cast< int >(14)));

24338

SWIG_Python_SetConstant(d, "STC_REBOL_FILE",SWIG_From_int(static_cast< int >(15)));

24339

SWIG_Python_SetConstant(d, "STC_REBOL_EMAIL",SWIG_From_int(static_cast< int >(16)));

24340

SWIG_Python_SetConstant(d, "STC_REBOL_URL",SWIG_From_int(static_cast< int >(17)));

24341

SWIG_Python_SetConstant(d, "STC_REBOL_DATE",SWIG_From_int(static_cast< int >(18)));

24342

SWIG_Python_SetConstant(d, "STC_REBOL_TIME",SWIG_From_int(static_cast< int >(19)));

24343

SWIG_Python_SetConstant(d, "STC_REBOL_IDENTIFIER",SWIG_From_int(static_cast< int >(20)));

24344

SWIG_Python_SetConstant(d, "STC_REBOL_WORD",SWIG_From_int(static_cast< int >(21)));

24345

SWIG_Python_SetConstant(d, "STC_REBOL_WORD2",SWIG_From_int(static_cast< int >(22)));

24346

SWIG_Python_SetConstant(d, "STC_REBOL_WORD3",SWIG_From_int(static_cast< int >(23)));

24347

SWIG_Python_SetConstant(d, "STC_REBOL_WORD4",SWIG_From_int(static_cast< int >(24)));

24348

SWIG_Python_SetConstant(d, "STC_REBOL_WORD5",SWIG_From_int(static_cast< int >(25)));

24349

SWIG_Python_SetConstant(d, "STC_REBOL_WORD6",SWIG_From_int(static_cast< int >(26)));

24350

SWIG_Python_SetConstant(d, "STC_REBOL_WORD7",SWIG_From_int(static_cast< int >(27)));

24351

SWIG_Python_SetConstant(d, "STC_REBOL_WORD8",SWIG_From_int(static_cast< int >(28)));

24352

SWIG_Python_SetConstant(d, "STC_SQL_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24353

SWIG_Python_SetConstant(d, "STC_SQL_COMMENT",SWIG_From_int(static_cast< int >(1)));

24354

SWIG_Python_SetConstant(d, "STC_SQL_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

24355

SWIG_Python_SetConstant(d, "STC_SQL_COMMENTDOC",SWIG_From_int(static_cast< int >(3)));

24356

SWIG_Python_SetConstant(d, "STC_SQL_NUMBER",SWIG_From_int(static_cast< int >(4)));

24357

SWIG_Python_SetConstant(d, "STC_SQL_WORD",SWIG_From_int(static_cast< int >(5)));

24358

SWIG_Python_SetConstant(d, "STC_SQL_STRING",SWIG_From_int(static_cast< int >(6)));

24359

SWIG_Python_SetConstant(d, "STC_SQL_CHARACTER",SWIG_From_int(static_cast< int >(7)));

24360

SWIG_Python_SetConstant(d, "STC_SQL_SQLPLUS",SWIG_From_int(static_cast< int >(8)));

24361

SWIG_Python_SetConstant(d, "STC_SQL_SQLPLUS_PROMPT",SWIG_From_int(static_cast< int >(9)));

24362

SWIG_Python_SetConstant(d, "STC_SQL_OPERATOR",SWIG_From_int(static_cast< int >(10)));

24363

SWIG_Python_SetConstant(d, "STC_SQL_IDENTIFIER",SWIG_From_int(static_cast< int >(11)));

24364

SWIG_Python_SetConstant(d, "STC_SQL_SQLPLUS_COMMENT",SWIG_From_int(static_cast< int >(13)));

24365

SWIG_Python_SetConstant(d, "STC_SQL_COMMENTLINEDOC",SWIG_From_int(static_cast< int >(15)));

24366

SWIG_Python_SetConstant(d, "STC_SQL_WORD2",SWIG_From_int(static_cast< int >(16)));

24367

SWIG_Python_SetConstant(d, "STC_SQL_COMMENTDOCKEYWORD",SWIG_From_int(static_cast< int >(17)));

24368

SWIG_Python_SetConstant(d, "STC_SQL_COMMENTDOCKEYWORDERROR",SWIG_From_int(static_cast< int >(18)));

24369

SWIG_Python_SetConstant(d, "STC_SQL_USER1",SWIG_From_int(static_cast< int >(19)));

24370

SWIG_Python_SetConstant(d, "STC_SQL_USER2",SWIG_From_int(static_cast< int >(20)));

24371

SWIG_Python_SetConstant(d, "STC_SQL_USER3",SWIG_From_int(static_cast< int >(21)));

24372

SWIG_Python_SetConstant(d, "STC_SQL_USER4",SWIG_From_int(static_cast< int >(22)));

24373

SWIG_Python_SetConstant(d, "STC_SQL_QUOTEDIDENTIFIER",SWIG_From_int(static_cast< int >(23)));

24374

SWIG_Python_SetConstant(d, "STC_ST_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24375

SWIG_Python_SetConstant(d, "STC_ST_STRING",SWIG_From_int(static_cast< int >(1)));

24376

SWIG_Python_SetConstant(d, "STC_ST_NUMBER",SWIG_From_int(static_cast< int >(2)));

24377

SWIG_Python_SetConstant(d, "STC_ST_COMMENT",SWIG_From_int(static_cast< int >(3)));

24378

SWIG_Python_SetConstant(d, "STC_ST_SYMBOL",SWIG_From_int(static_cast< int >(4)));

24379

SWIG_Python_SetConstant(d, "STC_ST_BINARY",SWIG_From_int(static_cast< int >(5)));

24380

SWIG_Python_SetConstant(d, "STC_ST_BOOL",SWIG_From_int(static_cast< int >(6)));

24381

SWIG_Python_SetConstant(d, "STC_ST_SELF",SWIG_From_int(static_cast< int >(7)));

24382

SWIG_Python_SetConstant(d, "STC_ST_SUPER",SWIG_From_int(static_cast< int >(8)));

24383

SWIG_Python_SetConstant(d, "STC_ST_NIL",SWIG_From_int(static_cast< int >(9)));

24384

SWIG_Python_SetConstant(d, "STC_ST_GLOBAL",SWIG_From_int(static_cast< int >(10)));

24385

SWIG_Python_SetConstant(d, "STC_ST_RETURN",SWIG_From_int(static_cast< int >(11)));

24386

SWIG_Python_SetConstant(d, "STC_ST_SPECIAL",SWIG_From_int(static_cast< int >(12)));

24387

SWIG_Python_SetConstant(d, "STC_ST_KWSEND",SWIG_From_int(static_cast< int >(13)));

24388

SWIG_Python_SetConstant(d, "STC_ST_ASSIGN",SWIG_From_int(static_cast< int >(14)));

24389

SWIG_Python_SetConstant(d, "STC_ST_CHARACTER",SWIG_From_int(static_cast< int >(15)));

24390

SWIG_Python_SetConstant(d, "STC_ST_SPEC_SEL",SWIG_From_int(static_cast< int >(16)));

24391

SWIG_Python_SetConstant(d, "STC_FS_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24392

SWIG_Python_SetConstant(d, "STC_FS_COMMENT",SWIG_From_int(static_cast< int >(1)));

24393

SWIG_Python_SetConstant(d, "STC_FS_COMMENTLINE",SWIG_From_int(static_cast< int >(2)));

24394

SWIG_Python_SetConstant(d, "STC_FS_COMMENTDOC",SWIG_From_int(static_cast< int >(3)));

24395

SWIG_Python_SetConstant(d, "STC_FS_COMMENTLINEDOC",SWIG_From_int(static_cast< int >(4)));

24396

SWIG_Python_SetConstant(d, "STC_FS_COMMENTDOCKEYWORD",SWIG_From_int(static_cast< int >(5)));

24397

SWIG_Python_SetConstant(d, "STC_FS_COMMENTDOCKEYWORDERROR",SWIG_From_int(static_cast< int >(6)));

24398

SWIG_Python_SetConstant(d, "STC_FS_KEYWORD",SWIG_From_int(static_cast< int >(7)));

24399

SWIG_Python_SetConstant(d, "STC_FS_KEYWORD2",SWIG_From_int(static_cast< int >(8)));

24400

SWIG_Python_SetConstant(d, "STC_FS_KEYWORD3",SWIG_From_int(static_cast< int >(9)));

24401

SWIG_Python_SetConstant(d, "STC_FS_KEYWORD4",SWIG_From_int(static_cast< int >(10)));

24402

SWIG_Python_SetConstant(d, "STC_FS_NUMBER",SWIG_From_int(static_cast< int >(11)));

24403

SWIG_Python_SetConstant(d, "STC_FS_STRING",SWIG_From_int(static_cast< int >(12)));

24404

SWIG_Python_SetConstant(d, "STC_FS_PREPROCESSOR",SWIG_From_int(static_cast< int >(13)));

24405

SWIG_Python_SetConstant(d, "STC_FS_OPERATOR",SWIG_From_int(static_cast< int >(14)));

24406

SWIG_Python_SetConstant(d, "STC_FS_IDENTIFIER",SWIG_From_int(static_cast< int >(15)));

24407

SWIG_Python_SetConstant(d, "STC_FS_DATE",SWIG_From_int(static_cast< int >(16)));

24408

SWIG_Python_SetConstant(d, "STC_FS_STRINGEOL",SWIG_From_int(static_cast< int >(17)));

24409

SWIG_Python_SetConstant(d, "STC_FS_CONSTANT",SWIG_From_int(static_cast< int >(18)));

24410

SWIG_Python_SetConstant(d, "STC_FS_ASM",SWIG_From_int(static_cast< int >(19)));

24411

SWIG_Python_SetConstant(d, "STC_FS_LABEL",SWIG_From_int(static_cast< int >(20)));

24412

SWIG_Python_SetConstant(d, "STC_FS_ERROR",SWIG_From_int(static_cast< int >(21)));

24413

SWIG_Python_SetConstant(d, "STC_FS_HEXNUMBER",SWIG_From_int(static_cast< int >(22)));

24414

SWIG_Python_SetConstant(d, "STC_FS_BINNUMBER",SWIG_From_int(static_cast< int >(23)));

24415

SWIG_Python_SetConstant(d, "STC_CSOUND_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24416

SWIG_Python_SetConstant(d, "STC_CSOUND_COMMENT",SWIG_From_int(static_cast< int >(1)));

24417

SWIG_Python_SetConstant(d, "STC_CSOUND_NUMBER",SWIG_From_int(static_cast< int >(2)));

24418

SWIG_Python_SetConstant(d, "STC_CSOUND_OPERATOR",SWIG_From_int(static_cast< int >(3)));

24419

SWIG_Python_SetConstant(d, "STC_CSOUND_INSTR",SWIG_From_int(static_cast< int >(4)));

24420

SWIG_Python_SetConstant(d, "STC_CSOUND_IDENTIFIER",SWIG_From_int(static_cast< int >(5)));

24421

SWIG_Python_SetConstant(d, "STC_CSOUND_OPCODE",SWIG_From_int(static_cast< int >(6)));

24422

SWIG_Python_SetConstant(d, "STC_CSOUND_HEADERSTMT",SWIG_From_int(static_cast< int >(7)));

24423

SWIG_Python_SetConstant(d, "STC_CSOUND_USERKEYWORD",SWIG_From_int(static_cast< int >(8)));

24424

SWIG_Python_SetConstant(d, "STC_CSOUND_COMMENTBLOCK",SWIG_From_int(static_cast< int >(9)));

24425

SWIG_Python_SetConstant(d, "STC_CSOUND_PARAM",SWIG_From_int(static_cast< int >(10)));

24426

SWIG_Python_SetConstant(d, "STC_CSOUND_ARATE_VAR",SWIG_From_int(static_cast< int >(11)));

24427

SWIG_Python_SetConstant(d, "STC_CSOUND_KRATE_VAR",SWIG_From_int(static_cast< int >(12)));

24428

SWIG_Python_SetConstant(d, "STC_CSOUND_IRATE_VAR",SWIG_From_int(static_cast< int >(13)));

24429

SWIG_Python_SetConstant(d, "STC_CSOUND_GLOBAL_VAR",SWIG_From_int(static_cast< int >(14)));

24430

SWIG_Python_SetConstant(d, "STC_CSOUND_STRINGEOL",SWIG_From_int(static_cast< int >(15)));

24431

SWIG_Python_SetConstant(d, "STC_INNO_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24432

SWIG_Python_SetConstant(d, "STC_INNO_COMMENT",SWIG_From_int(static_cast< int >(1)));

24433

SWIG_Python_SetConstant(d, "STC_INNO_KEYWORD",SWIG_From_int(static_cast< int >(2)));

24434

SWIG_Python_SetConstant(d, "STC_INNO_PARAMETER",SWIG_From_int(static_cast< int >(3)));

24435

SWIG_Python_SetConstant(d, "STC_INNO_SECTION",SWIG_From_int(static_cast< int >(4)));

24436

SWIG_Python_SetConstant(d, "STC_INNO_PREPROC",SWIG_From_int(static_cast< int >(5)));

24437

SWIG_Python_SetConstant(d, "STC_INNO_PREPROC_INLINE",SWIG_From_int(static_cast< int >(6)));

24438

SWIG_Python_SetConstant(d, "STC_INNO_COMMENT_PASCAL",SWIG_From_int(static_cast< int >(7)));

24439

SWIG_Python_SetConstant(d, "STC_INNO_KEYWORD_PASCAL",SWIG_From_int(static_cast< int >(8)));

24440

SWIG_Python_SetConstant(d, "STC_INNO_KEYWORD_USER",SWIG_From_int(static_cast< int >(9)));

24441

SWIG_Python_SetConstant(d, "STC_INNO_STRING_DOUBLE",SWIG_From_int(static_cast< int >(10)));

24442

SWIG_Python_SetConstant(d, "STC_INNO_STRING_SINGLE",SWIG_From_int(static_cast< int >(11)));

24443

SWIG_Python_SetConstant(d, "STC_INNO_IDENTIFIER",SWIG_From_int(static_cast< int >(12)));

24444

SWIG_Python_SetConstant(d, "STC_OPAL_SPACE",SWIG_From_int(static_cast< int >(0)));

24445

SWIG_Python_SetConstant(d, "STC_OPAL_COMMENT_BLOCK",SWIG_From_int(static_cast< int >(1)));

24446

SWIG_Python_SetConstant(d, "STC_OPAL_COMMENT_LINE",SWIG_From_int(static_cast< int >(2)));

24447

SWIG_Python_SetConstant(d, "STC_OPAL_INTEGER",SWIG_From_int(static_cast< int >(3)));

24448

SWIG_Python_SetConstant(d, "STC_OPAL_KEYWORD",SWIG_From_int(static_cast< int >(4)));

24449

SWIG_Python_SetConstant(d, "STC_OPAL_SORT",SWIG_From_int(static_cast< int >(5)));

24450

SWIG_Python_SetConstant(d, "STC_OPAL_STRING",SWIG_From_int(static_cast< int >(6)));

24451

SWIG_Python_SetConstant(d, "STC_OPAL_PAR",SWIG_From_int(static_cast< int >(7)));

24452

SWIG_Python_SetConstant(d, "STC_OPAL_BOOL_CONST",SWIG_From_int(static_cast< int >(8)));

24453

SWIG_Python_SetConstant(d, "STC_OPAL_DEFAULT",SWIG_From_int(static_cast< int >(32)));

24454

SWIG_Python_SetConstant(d, "STC_SPICE_DEFAULT",SWIG_From_int(static_cast< int >(0)));

24455

SWIG_Python_SetConstant(d, "STC_SPICE_IDENTIFIER",SWIG_From_int(static_cast< int >(1)));

24456

SWIG_Python_SetConstant(d, "STC_SPICE_KEYWORD",SWIG_From_int(static_cast< int >(2)));

24457

SWIG_Python_SetConstant(d, "STC_SPICE_KEYWORD2",SWIG_From_int(static_cast< int >(3)));

24458

SWIG_Python_SetConstant(d, "STC_SPICE_KEYWORD3",SWIG_From_int(static_cast< int >(4)));

24459

SWIG_Python_SetConstant(d, "STC_SPICE_NUMBER",SWIG_From_int(static_cast< int >(5)));

24460

SWIG_Python_SetConstant(d, "STC_SPICE_DELIMITER",SWIG_From_int(static_cast< int >(6)));

24461

SWIG_Python_SetConstant(d, "STC_SPICE_VALUE",SWIG_From_int(static_cast< int >(7)));

24462

SWIG_Python_SetConstant(d, "STC_SPICE_COMMENTLINE",SWIG_From_int(static_cast< int >(8)));

24463

SWIG_Python_SetConstant(d, "STC_CMD_REDO",SWIG_From_int(static_cast< int >(2011)));

24464

SWIG_Python_SetConstant(d, "STC_CMD_SELECTALL",SWIG_From_int(static_cast< int >(2013)));

24465

SWIG_Python_SetConstant(d, "STC_CMD_UNDO",SWIG_From_int(static_cast< int >(2176)));

24466

SWIG_Python_SetConstant(d, "STC_CMD_CUT",SWIG_From_int(static_cast< int >(2177)));

24467

SWIG_Python_SetConstant(d, "STC_CMD_COPY",SWIG_From_int(static_cast< int >(2178)));

24468

SWIG_Python_SetConstant(d, "STC_CMD_PASTE",SWIG_From_int(static_cast< int >(2179)));

24469

SWIG_Python_SetConstant(d, "STC_CMD_CLEAR",SWIG_From_int(static_cast< int >(2180)));

24470

SWIG_Python_SetConstant(d, "STC_CMD_LINEDOWN",SWIG_From_int(static_cast< int >(2300)));

24471

SWIG_Python_SetConstant(d, "STC_CMD_LINEDOWNEXTEND",SWIG_From_int(static_cast< int >(2301)));

24472

SWIG_Python_SetConstant(d, "STC_CMD_LINEUP",SWIG_From_int(static_cast< int >(2302)));

24473

SWIG_Python_SetConstant(d, "STC_CMD_LINEUPEXTEND",SWIG_From_int(static_cast< int >(2303)));

24474

SWIG_Python_SetConstant(d, "STC_CMD_CHARLEFT",SWIG_From_int(static_cast< int >(2304)));

24475

SWIG_Python_SetConstant(d, "STC_CMD_CHARLEFTEXTEND",SWIG_From_int(static_cast< int >(2305)));

24476

SWIG_Python_SetConstant(d, "STC_CMD_CHARRIGHT",SWIG_From_int(static_cast< int >(2306)));

24477

SWIG_Python_SetConstant(d, "STC_CMD_CHARRIGHTEXTEND",SWIG_From_int(static_cast< int >(2307)));

24478

SWIG_Python_SetConstant(d, "STC_CMD_WORDLEFT",SWIG_From_int(static_cast< int >(2308)));

24479

SWIG_Python_SetConstant(d, "STC_CMD_WORDLEFTEXTEND",SWIG_From_int(static_cast< int >(2309)));

24480

SWIG_Python_SetConstant(d, "STC_CMD_WORDRIGHT",SWIG_From_int(static_cast< int >(2310)));

24481

SWIG_Python_SetConstant(d, "STC_CMD_WORDRIGHTEXTEND",SWIG_From_int(static_cast< int >(2311)));

24482

SWIG_Python_SetConstant(d, "STC_CMD_HOME",SWIG_From_int(static_cast< int >(2312)));

24483

SWIG_Python_SetConstant(d, "STC_CMD_HOMEEXTEND",SWIG_From_int(static_cast< int >(2313)));

24484

SWIG_Python_SetConstant(d, "STC_CMD_LINEEND",SWIG_From_int(static_cast< int >(2314)));

24485

SWIG_Python_SetConstant(d, "STC_CMD_LINEENDEXTEND",SWIG_From_int(static_cast< int >(2315)));

24486

SWIG_Python_SetConstant(d, "STC_CMD_DOCUMENTSTART",SWIG_From_int(static_cast< int >(2316)));

24487

SWIG_Python_SetConstant(d, "STC_CMD_DOCUMENTSTARTEXTEND",SWIG_From_int(static_cast< int >(2317)));

24488

SWIG_Python_SetConstant(d, "STC_CMD_DOCUMENTEND",SWIG_From_int(static_cast< int >(2318)));

24489

SWIG_Python_SetConstant(d, "STC_CMD_DOCUMENTENDEXTEND",SWIG_From_int(static_cast< int >(2319)));

24490

SWIG_Python_SetConstant(d, "STC_CMD_PAGEUP",SWIG_From_int(static_cast< int >(2320)));

24491

SWIG_Python_SetConstant(d, "STC_CMD_PAGEUPEXTEND",SWIG_From_int(static_cast< int >(2321)));

24492

SWIG_Python_SetConstant(d, "STC_CMD_PAGEDOWN",SWIG_From_int(static_cast< int >(2322)));

24493

SWIG_Python_SetConstant(d, "STC_CMD_PAGEDOWNEXTEND",SWIG_From_int(static_cast< int >(2323)));

24494

SWIG_Python_SetConstant(d, "STC_CMD_EDITTOGGLEOVERTYPE",SWIG_From_int(static_cast< int >(2324)));

24495

SWIG_Python_SetConstant(d, "STC_CMD_CANCEL",SWIG_From_int(static_cast< int >(2325)));

24496

SWIG_Python_SetConstant(d, "STC_CMD_DELETEBACK",SWIG_From_int(static_cast< int >(2326)));

24497

SWIG_Python_SetConstant(d, "STC_CMD_TAB",SWIG_From_int(static_cast< int >(2327)));

24498

SWIG_Python_SetConstant(d, "STC_CMD_BACKTAB",SWIG_From_int(static_cast< int >(2328)));

24499

SWIG_Python_SetConstant(d, "STC_CMD_NEWLINE",SWIG_From_int(static_cast< int >(2329)));

24500

SWIG_Python_SetConstant(d, "STC_CMD_FORMFEED",SWIG_From_int(static_cast< int >(2330)));

24501

SWIG_Python_SetConstant(d, "STC_CMD_VCHOME",SWIG_From_int(static_cast< int >(2331)));

24502

SWIG_Python_SetConstant(d, "STC_CMD_VCHOMEEXTEND",SWIG_From_int(static_cast< int >(2332)));

24503

SWIG_Python_SetConstant(d, "STC_CMD_ZOOMIN",SWIG_From_int(static_cast< int >(2333)));

24504

SWIG_Python_SetConstant(d, "STC_CMD_ZOOMOUT",SWIG_From_int(static_cast< int >(2334)));

24505

SWIG_Python_SetConstant(d, "STC_CMD_DELWORDLEFT",SWIG_From_int(static_cast< int >(2335)));

24506

SWIG_Python_SetConstant(d, "STC_CMD_DELWORDRIGHT",SWIG_From_int(static_cast< int >(2336)));

24507

SWIG_Python_SetConstant(d, "STC_CMD_LINECUT",SWIG_From_int(static_cast< int >(2337)));

24508

SWIG_Python_SetConstant(d, "STC_CMD_LINEDELETE",SWIG_From_int(static_cast< int >(2338)));

24509

SWIG_Python_SetConstant(d, "STC_CMD_LINETRANSPOSE",SWIG_From_int(static_cast< int >(2339)));

24510

SWIG_Python_SetConstant(d, "STC_CMD_LINEDUPLICATE",SWIG_From_int(static_cast< int >(2404)));

24511

SWIG_Python_SetConstant(d, "STC_CMD_LOWERCASE",SWIG_From_int(static_cast< int >(2340)));

24512

SWIG_Python_SetConstant(d, "STC_CMD_UPPERCASE",SWIG_From_int(static_cast< int >(2341)));

24513

SWIG_Python_SetConstant(d, "STC_CMD_LINESCROLLDOWN",SWIG_From_int(static_cast< int >(2342)));

24514

SWIG_Python_SetConstant(d, "STC_CMD_LINESCROLLUP",SWIG_From_int(static_cast< int >(2343)));

24515

SWIG_Python_SetConstant(d, "STC_CMD_DELETEBACKNOTLINE",SWIG_From_int(static_cast< int >(2344)));

24516

SWIG_Python_SetConstant(d, "STC_CMD_HOMEDISPLAY",SWIG_From_int(static_cast< int >(2345)));

24517

SWIG_Python_SetConstant(d, "STC_CMD_HOMEDISPLAYEXTEND",SWIG_From_int(static_cast< int >(2346)));

24518

SWIG_Python_SetConstant(d, "STC_CMD_LINEENDDISPLAY",SWIG_From_int(static_cast< int >(2347)));

24519

SWIG_Python_SetConstant(d, "STC_CMD_LINEENDDISPLAYEXTEND",SWIG_From_int(static_cast< int >(2348)));

24520

SWIG_Python_SetConstant(d, "STC_CMD_HOMEWRAP",SWIG_From_int(static_cast< int >(2349)));

24521

SWIG_Python_SetConstant(d, "STC_CMD_HOMEWRAPEXTEND",SWIG_From_int(static_cast< int >(2450)));

24522

SWIG_Python_SetConstant(d, "STC_CMD_LINEENDWRAP",SWIG_From_int(static_cast< int >(2451)));

24523

SWIG_Python_SetConstant(d, "STC_CMD_LINEENDWRAPEXTEND",SWIG_From_int(static_cast< int >(2452)));

24524

SWIG_Python_SetConstant(d, "STC_CMD_VCHOMEWRAP",SWIG_From_int(static_cast< int >(2453)));

24525

SWIG_Python_SetConstant(d, "STC_CMD_VCHOMEWRAPEXTEND",SWIG_From_int(static_cast< int >(2454)));

24526

SWIG_Python_SetConstant(d, "STC_CMD_LINECOPY",SWIG_From_int(static_cast< int >(2455)));

24527

SWIG_Python_SetConstant(d, "STC_CMD_WORDPARTLEFT",SWIG_From_int(static_cast< int >(2390)));

24528

SWIG_Python_SetConstant(d, "STC_CMD_WORDPARTLEFTEXTEND",SWIG_From_int(static_cast< int >(2391)));

24529

SWIG_Python_SetConstant(d, "STC_CMD_WORDPARTRIGHT",SWIG_From_int(static_cast< int >(2392)));

24530

SWIG_Python_SetConstant(d, "STC_CMD_WORDPARTRIGHTEXTEND",SWIG_From_int(static_cast< int >(2393)));

24531

SWIG_Python_SetConstant(d, "STC_CMD_DELLINELEFT",SWIG_From_int(static_cast< int >(2395)));

24532

SWIG_Python_SetConstant(d, "STC_CMD_DELLINERIGHT",SWIG_From_int(static_cast< int >(2396)));

24533

SWIG_Python_SetConstant(d, "STC_CMD_PARADOWN",SWIG_From_int(static_cast< int >(2413)));

24534

SWIG_Python_SetConstant(d, "STC_CMD_PARADOWNEXTEND",SWIG_From_int(static_cast< int >(2414)));

24535

SWIG_Python_SetConstant(d, "STC_CMD_PARAUP",SWIG_From_int(static_cast< int >(2415)));

24536

SWIG_Python_SetConstant(d, "STC_CMD_PARAUPEXTEND",SWIG_From_int(static_cast< int >(2416)));

24537

SWIG_Python_SetConstant(d, "STC_CMD_LINEDOWNRECTEXTEND",SWIG_From_int(static_cast< int >(2426)));

24538

SWIG_Python_SetConstant(d, "STC_CMD_LINEUPRECTEXTEND",SWIG_From_int(static_cast< int >(2427)));

24539

SWIG_Python_SetConstant(d, "STC_CMD_CHARLEFTRECTEXTEND",SWIG_From_int(static_cast< int >(2428)));

24540

SWIG_Python_SetConstant(d, "STC_CMD_CHARRIGHTRECTEXTEND",SWIG_From_int(static_cast< int >(2429)));

24541

SWIG_Python_SetConstant(d, "STC_CMD_HOMERECTEXTEND",SWIG_From_int(static_cast< int >(2430)));

24542

SWIG_Python_SetConstant(d, "STC_CMD_VCHOMERECTEXTEND",SWIG_From_int(static_cast< int >(2431)));

24543

SWIG_Python_SetConstant(d, "STC_CMD_LINEENDRECTEXTEND",SWIG_From_int(static_cast< int >(2432)));

24544

SWIG_Python_SetConstant(d, "STC_CMD_PAGEUPRECTEXTEND",SWIG_From_int(static_cast< int >(2433)));

24545

SWIG_Python_SetConstant(d, "STC_CMD_PAGEDOWNRECTEXTEND",SWIG_From_int(static_cast< int >(2434)));

24546

SWIG_Python_SetConstant(d, "STC_CMD_STUTTEREDPAGEUP",SWIG_From_int(static_cast< int >(2435)));

24547

SWIG_Python_SetConstant(d, "STC_CMD_STUTTEREDPAGEUPEXTEND",SWIG_From_int(static_cast< int >(2436)));

24548

SWIG_Python_SetConstant(d, "STC_CMD_STUTTEREDPAGEDOWN",SWIG_From_int(static_cast< int >(2437)));

24549

SWIG_Python_SetConstant(d, "STC_CMD_STUTTEREDPAGEDOWNEXTEND",SWIG_From_int(static_cast< int >(2438)));

24550

SWIG_Python_SetConstant(d, "STC_CMD_WORDLEFTEND",SWIG_From_int(static_cast< int >(2439)));

24551

SWIG_Python_SetConstant(d, "STC_CMD_WORDLEFTENDEXTEND",SWIG_From_int(static_cast< int >(2440)));

24552

SWIG_Python_SetConstant(d, "STC_CMD_WORDRIGHTEND",SWIG_From_int(static_cast< int >(2441)));

24553

SWIG_Python_SetConstant(d, "STC_CMD_WORDRIGHTENDEXTEND",SWIG_From_int(static_cast< int >(2442)));

24554

SWIG_Python_SetConstant(d, "wxEVT_STC_CHANGE",SWIG_From_int(static_cast< int >(wxEVT_STC_CHANGE)));

24555

SWIG_Python_SetConstant(d, "wxEVT_STC_STYLENEEDED",SWIG_From_int(static_cast< int >(wxEVT_STC_STYLENEEDED)));

24556

SWIG_Python_SetConstant(d, "wxEVT_STC_CHARADDED",SWIG_From_int(static_cast< int >(wxEVT_STC_CHARADDED)));

24557

SWIG_Python_SetConstant(d, "wxEVT_STC_SAVEPOINTREACHED",SWIG_From_int(static_cast< int >(wxEVT_STC_SAVEPOINTREACHED)));

24558

SWIG_Python_SetConstant(d, "wxEVT_STC_SAVEPOINTLEFT",SWIG_From_int(static_cast< int >(wxEVT_STC_SAVEPOINTLEFT)));

24559

SWIG_Python_SetConstant(d, "wxEVT_STC_ROMODIFYATTEMPT",SWIG_From_int(static_cast< int >(wxEVT_STC_ROMODIFYATTEMPT)));

24560

SWIG_Python_SetConstant(d, "wxEVT_STC_KEY",SWIG_From_int(static_cast< int >(wxEVT_STC_KEY)));

24561

SWIG_Python_SetConstant(d, "wxEVT_STC_DOUBLECLICK",SWIG_From_int(static_cast< int >(wxEVT_STC_DOUBLECLICK)));

24562

SWIG_Python_SetConstant(d, "wxEVT_STC_UPDATEUI",SWIG_From_int(static_cast< int >(wxEVT_STC_UPDATEUI)));

24563

SWIG_Python_SetConstant(d, "wxEVT_STC_MODIFIED",SWIG_From_int(static_cast< int >(wxEVT_STC_MODIFIED)));

24564

SWIG_Python_SetConstant(d, "wxEVT_STC_MACRORECORD",SWIG_From_int(static_cast< int >(wxEVT_STC_MACRORECORD)));

24565

SWIG_Python_SetConstant(d, "wxEVT_STC_MARGINCLICK",SWIG_From_int(static_cast< int >(wxEVT_STC_MARGINCLICK)));

24566

SWIG_Python_SetConstant(d, "wxEVT_STC_NEEDSHOWN",SWIG_From_int(static_cast< int >(wxEVT_STC_NEEDSHOWN)));

24567

SWIG_Python_SetConstant(d, "wxEVT_STC_PAINTED",SWIG_From_int(static_cast< int >(wxEVT_STC_PAINTED)));

24568

SWIG_Python_SetConstant(d, "wxEVT_STC_USERLISTSELECTION",SWIG_From_int(static_cast< int >(wxEVT_STC_USERLISTSELECTION)));

24569

SWIG_Python_SetConstant(d, "wxEVT_STC_URIDROPPED",SWIG_From_int(static_cast< int >(wxEVT_STC_URIDROPPED)));

24570

SWIG_Python_SetConstant(d, "wxEVT_STC_DWELLSTART",SWIG_From_int(static_cast< int >(wxEVT_STC_DWELLSTART)));

24571

SWIG_Python_SetConstant(d, "wxEVT_STC_DWELLEND",SWIG_From_int(static_cast< int >(wxEVT_STC_DWELLEND)));

24572

SWIG_Python_SetConstant(d, "wxEVT_STC_START_DRAG",SWIG_From_int(static_cast< int >(wxEVT_STC_START_DRAG)));

24573

SWIG_Python_SetConstant(d, "wxEVT_STC_DRAG_OVER",SWIG_From_int(static_cast< int >(wxEVT_STC_DRAG_OVER)));

24574

SWIG_Python_SetConstant(d, "wxEVT_STC_DO_DROP",SWIG_From_int(static_cast< int >(wxEVT_STC_DO_DROP)));

24575

SWIG_Python_SetConstant(d, "wxEVT_STC_ZOOM",SWIG_From_int(static_cast< int >(wxEVT_STC_ZOOM)));

24576

SWIG_Python_SetConstant(d, "wxEVT_STC_HOTSPOT_CLICK",SWIG_From_int(static_cast< int >(wxEVT_STC_HOTSPOT_CLICK)));

24577

SWIG_Python_SetConstant(d, "wxEVT_STC_HOTSPOT_DCLICK",SWIG_From_int(static_cast< int >(wxEVT_STC_HOTSPOT_DCLICK)));

24578

SWIG_Python_SetConstant(d, "wxEVT_STC_CALLTIP_CLICK",SWIG_From_int(static_cast< int >(wxEVT_STC_CALLTIP_CLICK)));

24579

SWIG_Python_SetConstant(d, "wxEVT_STC_AUTOCOMP_SELECTION",SWIG_From_int(static_cast< int >(wxEVT_STC_AUTOCOMP_SELECTION)));

24580

24581

24582

}

24583